[Calling Web SDK] AudioEffects disposes raw stream twice after acquisition failure (1.43.1)

The report isolates updateAudioEffectsStatusManager in the installed @azure/communication-calling 1.43.1 bundle at node_modules/@azure/communication-calling/dist-esm/sdk.bundle.js; it also mentions the parameterized method in 1.46.1. Read that method’s catch path and common cleanup, then run the supplied reproduce.mjs scenarios. Done means an acquired client is disposed once after acquisition failure and the original acquisition diagnostic is preserved.

Summary

In @azure/communication-calling 1.43.1, the internal AudioEffects method
updateAudioEffectsStatusManager can dispose the same raw-stream client twice
when getMediaStream() rejects. The second disposal throws:

Error: Raw stream client is already disposed
    at ...checkDisposed
    at ...dispose
    at ...updateAudioEffectsStatusManager

This was observed during initialization in an embedded Windows Chromium test
browser when the UI reported unavailable camera/microphone access. Normal call
connection could still succeed after a browser permission response. This is not
a claim of a general call outage or a demonstrated cause of mid-call audio loss.
The original device-acquisition rejection reason/browser build was not captured.

Reproduction and scope

The following Node reproduction executes the unchanged method extracted from
the installed 1.43.1 SDK, with synthetic stream/device collaborators. The raw
stream collaborator models the SDK's non-idempotent disposal guard. This isolates
the method's cleanup control flow; it is not an end-to-end browser/media test.

In an empty directory, install @azure/[email protected], save the
following as reproduce.mjs, then run node reproduce.mjs:

import assert from 'node:assert/strict';
import { readFile } from 'node:fs/promises';
import vm from 'node:vm';

const source = await readFile(
  'node_modules/@azure/communication-calling/dist-esm/sdk.bundle.js', 'utf8');
const start = source.indexOf('async updateAudioEffectsStatusManager(){');
const end = source.indexOf('async initializeWasmVqeInStack(', start);
assert.ok(start > 0 && end > start);
const method = source.slice(start, end);
const initialize = vm.runInNewContext(
  `(${method.replace('async updateAudioEffectsStatusManager', 'async function')})`,
  {
    isVdi3Proxy: () => false,
    getBrowserInfo: () => ({ engine: 'Chrome' }),
    BrowserAudioEffectsHelper: class {},
  });

for (const scenario of ['valid-stream', 'acquisition-rejected', 'no-raw-stream']) {
  let disposed = false, disposeCalls = 0, settings;
  const stream = {
    getMediaStream: async () => {
      if (scenario === 'acquisition-rejected') {
        throw new Error('Synthetic device acquisition failure');
      }
      return { getAudioTracks: () => [{ getSettings: () => ({
        autoGainControl: false, noiseSuppression: false, echoCancellation: false,
      }) }] };
    },
    dispose: () => {
      disposeCalls++;
      if (disposed) throw new Error('Raw stream client is already disposed');
      disposed = true;
    },
  };
  const effects = {
    on: () => {}, setActiveEffects: value => { settings = value; },
    getActiveEffects: () => settings,
  };
  const device = {
    isWBMediaClient: false, getTsDeviceManager: () => ({}),
    getRawDeviceMediaStream: () => {
      if (scenario === 'no-raw-stream') throw new Error('Synthetic device absent');
      return stream;
    },
    callStackAudioEffectsStatusManager: effects,
  };
  let error = null;
  try {
    await initialize.call({
      streamInstance: { canStartEffects: true, source: { deviceManager: device } },
      _logger: { warn: () => {}, debug: () => {} },
    });
  } catch (caught) { error = caught.message; }
  console.log({ scenario, disposeCalls, error });
  assert.equal(disposeCalls, scenario === 'valid-stream' ? 1 :
    scenario === 'acquisition-rejected' ? 2 : 0);
  assert.equal(error, scenario === 'acquisition-rejected' ?
    'Raw stream client is already disposed' : null);
}

Actual

The catch path disposes the client; common code later disposes it again.

Expected

The SDK should clean up each acquired raw-stream client once, preserve the
device-acquisition diagnostic, and not introduce a second cleanup exception.

Version inspection

1.43.1 was exercised as above. Integrity-verified 1.46.1 package source was also
inspected and appears to retain the catch/common duplicate-disposal pattern in
the parameterized method. 1.46.1 was not executed in this reproduction. No
claim is made about 2.x behavior, and no SDK internals have been patched.

Could you confirm the supported fix/version or workaround that does not suppress
errors or bypass browser device permissions?

Reproduction signature: acs-web-audio-effects-double-dispose-1431.