@autoark-ai/eva-client-sdk-ts 0.0.2-dev

package/dist/browser.js

@@ -0,0 +1,939 @@
+// src/errors/errors.ts
+var EvaSdkError = class extends Error {
+  fatal;
+  source = "sdk";
+  constructor(message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "EvaSdkError";
+    this.fatal = options.fatal ?? true;
+  }
+};
+function ensureError(value, options = {}) {
+  if (value instanceof EvaSdkError) {
+    return value;
+  }
+  return new EvaSdkError(options.message ?? "SDK operation failed", {
+    fatal: options.fatal ?? true,
+    cause: value
+  });
+}
+
+// src/core/media/passthrough-aec.ts
+function createInstrumentedPassthroughAecProcessor() {
+  const stats = {
+    nearEndProcessed: 0,
+    farEndPushed: 0,
+    reset: 0,
+    released: 0
+  };
+  const farEndChunks = [];
+  const nearEndChunks = [];
+  return {
+    descriptor: {
+      id: "passthrough-aec"
+    },
+    stats,
+    farEndChunks,
+    nearEndChunks,
+    pushFarEnd(chunk) {
+      stats.farEndPushed += 1;
+      farEndChunks.push(chunk);
+    },
+    processNearEnd(chunk) {
+      stats.nearEndProcessed += 1;
+      nearEndChunks.push(chunk);
+      return chunk;
+    },
+    reset() {
+      stats.reset += 1;
+    },
+    release() {
+      stats.released += 1;
+    }
+  };
+}
+
+// src/facade/media/browser/streaming-pcm16.ts
+var StreamingPcm16Encoder = class {
+  sourceRate;
+  frameSamples = 0;
+  pendingSamples = [];
+  push(channels, sourceSampleRate) {
+    if (!Number.isFinite(sourceSampleRate) || sourceSampleRate <= 0) {
+      throw new RangeError("sourceSampleRate must be finite and positive");
+    }
+    if (channels.length === 0) {
+      return [];
+    }
+    if (this.sourceRate !== void 0 && this.sourceRate !== sourceSampleRate) {
+      throw new RangeError("sourceSampleRate cannot change while encoding");
+    }
+    this.sourceRate ??= sourceSampleRate;
+    this.frameSamples ||= Math.round(sourceSampleRate / 50);
+    this.pendingSamples.push(...downmix(channels));
+    return this.takeCompleteFrames();
+  }
+  flush() {
+    const frames = this.takeCompleteFrames();
+    const tail = this.pendingSamples.length > 0 ? [encodePcm16(this.pendingSamples.splice(0))] : [];
+    this.sourceRate = void 0;
+    this.frameSamples = 0;
+    return [...frames, ...tail];
+  }
+  takeCompleteFrames() {
+    const frames = [];
+    while (this.frameSamples > 0 && this.pendingSamples.length >= this.frameSamples) {
+      frames.push(encodePcm16(this.pendingSamples.splice(0, this.frameSamples)));
+    }
+    return frames;
+  }
+};
+function downmix(channels) {
+  const length = channels[0].length;
+  if (channels.some((channel) => channel.length !== length)) {
+    throw new RangeError("All source channels must contain the same number of samples");
+  }
+  const mono = new Float32Array(length);
+  for (let index = 0; index < length; index += 1) {
+    let sum = 0;
+    for (const channel of channels) {
+      sum += channel[index];
+    }
+    mono[index] = sum / channels.length;
+  }
+  return mono;
+}
+function encodePcm16(samples) {
+  const output = new Uint8Array(samples.length * 2);
+  const view = new DataView(output.buffer, output.byteOffset, output.byteLength);
+  for (let index = 0; index < samples.length; index += 1) {
+    const sample = Math.max(-1, Math.min(1, samples[index] ?? 0));
+    const value = sample < 0 ? Math.round(sample * 32768) : Math.round(sample * 32767);
+    view.setInt16(index * 2, value, true);
+  }
+  return output;
+}
+
+// src/facade/media/browser/audio-input.ts
+var WORKLET_NAME = "eva-audio-capture";
+var DEFAULT_MAX_BUFFERED_CHUNKS = 128;
+var WORKLET_SOURCE = `
+class EvaAudioCaptureProcessor extends AudioWorkletProcessor {
+  process(inputs) {
+    const input = inputs[0];
+    if (input && input.length > 0) {
+      const channels = input.map((channel) => new Float32Array(channel));
+      this.port.postMessage(channels, channels.map((channel) => channel.buffer));
+    }
+    return true;
+  }
+}
+registerProcessor("${WORKLET_NAME}", EvaAudioCaptureProcessor);
+`;
+function createBrowserAudioInputSource(options = {}) {
+  return createBrowserAudioInputSourceWithDependencies(options);
+}
+function createBrowserAudioInputSourceWithDependencies(options = {}, dependencies = {}) {
+  return new DefaultBrowserAudioInputSource(options, dependencies);
+}
+var DefaultBrowserAudioInputSource = class {
+  constructor(options, dependencies) {
+    this.options = options;
+    this.dependencies = dependencies;
+  }
+  options;
+  dependencies;
+  generation = 0;
+  session;
+  async start() {
+    const session = this.session ?? this.createSession();
+    await session.startPromise;
+  }
+  frames(signal) {
+    const session = this.session;
+    if (session === void 0) {
+      return failedAudioChunks(
+        new EvaSdkError("Browser audio input is not started", { fatal: true })
+      );
+    }
+    if (isAborted(signal)) {
+      return this.consumeAbortedSession(session);
+    }
+    if (session.consumerActive) {
+      return failedAudioChunks(
+        new EvaSdkError("Browser audio input already has an active consumer", { fatal: true })
+      );
+    }
+    session.consumerActive = true;
+    return this.consumeSession(session, signal);
+  }
+  async *consumeAbortedSession(session) {
+    await this.teardown(session);
+  }
+  async *consumeSession(session, signal) {
+    let resolveAbort;
+    let abortStop;
+    const aborted = new Promise((resolve) => {
+      resolveAbort = resolve;
+    });
+    const abort = () => {
+      abortStop = this.teardown(session);
+      resolveAbort?.();
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+    try {
+      await Promise.race([session.startPromise, aborted]);
+      if (session.failure !== void 0) {
+        throw session.failure;
+      }
+      if (isAborted(signal) || session.cancelled) {
+        return;
+      }
+      while (!isAborted(signal)) {
+        if (session.failure !== void 0) {
+          throw session.failure;
+        }
+        if (session.cancelled) {
+          return;
+        }
+        const next = await session.queue.next();
+        if (next.done) {
+          return;
+        }
+        yield next.value;
+      }
+    } finally {
+      signal?.removeEventListener("abort", abort);
+      session.consumerActive = false;
+      await (abortStop ?? this.teardown(session));
+    }
+  }
+  async stop() {
+    const session = this.session;
+    if (session !== void 0) {
+      await this.teardown(session);
+    }
+  }
+  createSession() {
+    let session;
+    let rejectCancellation;
+    const cancelled = new Promise((_resolve, reject) => {
+      rejectCancellation = reject;
+    });
+    const queue = new AsyncChunkQueue(
+      normalizeQueueLimit(this.options.maxBufferedChunks),
+      (error) => {
+        session.failure = error;
+        void this.teardown(session);
+      }
+    );
+    session = {
+      generation: ++this.generation,
+      queue,
+      encoder: new StreamingPcm16Encoder(),
+      startPromise: Promise.resolve(),
+      consumerActive: false,
+      cancelled: false,
+      rejectCancellation,
+      stream: void 0,
+      context: void 0,
+      sourceNode: void 0,
+      workletNode: void 0,
+      sampleRate: void 0,
+      ownedWorkletUrl: void 0
+    };
+    this.session = session;
+    session.startPromise = Promise.race([this.startSession(session), cancelled]);
+    void session.startPromise.catch(() => {
+    });
+    return session;
+  }
+  async startSession(session) {
+    try {
+      const stream = await mediaDevicesOf(this.dependencies).getUserMedia({
+        audio: {
+          autoGainControl: this.options.autoGainControl ?? true,
+          echoCancellation: this.options.echoCancellation ?? true,
+          noiseSuppression: this.options.noiseSuppression ?? true
+        }
+      });
+      if (!this.isCurrent(session)) {
+        stopTracks(stream);
+        throw stoppedError();
+      }
+      session.stream = stream;
+      const context = audioContextOf(this.dependencies);
+      session.context = context;
+      session.sampleRate = context.sampleRate;
+      this.throwIfNotCurrent(session);
+      const workletUrl = this.dependencies.workletModuleUrl ?? objectUrlOf(this.dependencies).create(WORKLET_SOURCE);
+      if (this.dependencies.workletModuleUrl === void 0) {
+        session.ownedWorkletUrl = workletUrl;
+      }
+      await context.audioWorklet.addModule(workletUrl);
+      this.throwIfNotCurrent(session);
+      const sourceNode = context.createMediaStreamSource(stream);
+      const workletNode = workletNodeOf(this.dependencies, context);
+      session.sourceNode = sourceNode;
+      session.workletNode = workletNode;
+      workletNode.port.onmessage = (event) => this.handleSamples(session, event.data);
+      sourceNode.connect(workletNode);
+      workletNode.connect(context.destination);
+      await context.resume();
+      this.throwIfNotCurrent(session);
+    } catch (error) {
+      const cancelled = session.cancelled || this.session !== session;
+      await this.teardown(session);
+      throw cancelled ? stoppedError() : ensureError(error, { message: "Browser audio input failed" });
+    }
+  }
+  throwIfNotCurrent(session) {
+    if (!this.isCurrent(session)) {
+      throw stoppedError();
+    }
+  }
+  isCurrent(session) {
+    return !session.cancelled && this.session === session;
+  }
+  handleSamples(session, value) {
+    if (!this.isCurrent(session) || !isFloat32Channels(value) || session.context === void 0 || session.sampleRate === void 0) {
+      return;
+    }
+    try {
+      if (session.context.sampleRate !== session.sampleRate) {
+        throw new RangeError("AudioContext sampleRate changed during capture");
+      }
+      for (const data of session.encoder.push(value, session.sampleRate)) {
+        session.queue.push({
+          data,
+          sampleRate: session.sampleRate,
+          channels: 1,
+          format: "pcm_s16le"
+        });
+      }
+    } catch (error) {
+      const failure = ensureError(error, { message: "Browser audio input encoding failed" });
+      session.failure = failure;
+      session.queue.fail(failure);
+      void this.teardown(session);
+    }
+  }
+  teardown(session) {
+    if (session.teardownPromise !== void 0) {
+      return session.teardownPromise;
+    }
+    session.cancelled = true;
+    session.rejectCancellation?.(stoppedError());
+    session.rejectCancellation = void 0;
+    session.queue.close();
+    if (this.session === session) {
+      this.session = void 0;
+    }
+    const workletNode = session.workletNode;
+    const sourceNode = session.sourceNode;
+    const stream = session.stream;
+    const context = session.context;
+    const ownedWorkletUrl = session.ownedWorkletUrl;
+    session.workletNode = void 0;
+    session.sourceNode = void 0;
+    session.stream = void 0;
+    session.context = void 0;
+    session.sampleRate = void 0;
+    session.ownedWorkletUrl = void 0;
+    session.teardownPromise = (async () => {
+      if (workletNode !== void 0) {
+        workletNode.port.onmessage = null;
+        workletNode.disconnect();
+      }
+      sourceNode?.disconnect();
+      if (stream !== void 0) {
+        stopTracks(stream);
+      }
+      await context?.close();
+      if (ownedWorkletUrl !== void 0) {
+        objectUrlOf(this.dependencies).revoke(ownedWorkletUrl);
+      }
+    })();
+    return session.teardownPromise;
+  }
+};
+function stoppedError() {
+  return new EvaSdkError("Browser audio input stopped", { fatal: true });
+}
+function isAborted(signal) {
+  return signal?.aborted === true;
+}
+function stopTracks(stream) {
+  for (const track of stream.getAudioTracks()) {
+    track.stop();
+  }
+}
+async function* failedAudioChunks(error) {
+  throw error;
+}
+var AsyncChunkQueue = class {
+  constructor(limit, onOverflow) {
+    this.limit = limit;
+    this.onOverflow = onOverflow;
+  }
+  limit;
+  onOverflow;
+  items = [];
+  waiters = [];
+  closed = false;
+  error;
+  push(chunk) {
+    if (this.closed || this.error !== void 0) {
+      return;
+    }
+    const waiter = this.waiters.shift();
+    if (waiter !== void 0) {
+      waiter.resolve({ done: false, value: chunk });
+      return;
+    }
+    if (this.items.length >= this.limit) {
+      const error = new EvaSdkError("Browser audio input buffer overflow", { fatal: true });
+      this.error = error;
+      this.items.length = 0;
+      for (const pending of this.waiters.splice(0)) {
+        pending.reject(this.error);
+      }
+      this.onOverflow(error);
+      return;
+    }
+    this.items.push(chunk);
+  }
+  fail(error) {
+    if (this.closed || this.error !== void 0) {
+      return;
+    }
+    this.error = error;
+    this.items.length = 0;
+    for (const waiter of this.waiters.splice(0)) {
+      waiter.reject(error);
+    }
+  }
+  next() {
+    if (this.error !== void 0) {
+      return Promise.reject(this.error);
+    }
+    const item = this.items.shift();
+    if (item !== void 0) {
+      return Promise.resolve({ done: false, value: item });
+    }
+    if (this.closed) {
+      return Promise.resolve({ done: true, value: void 0 });
+    }
+    return new Promise((resolve, reject) => this.waiters.push({ resolve, reject }));
+  }
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    if (this.error === void 0) {
+      for (const waiter of this.waiters.splice(0)) {
+        waiter.resolve({ done: true, value: void 0 });
+      }
+    }
+  }
+};
+function normalizeQueueLimit(value) {
+  if (value === void 0) {
+    return DEFAULT_MAX_BUFFERED_CHUNKS;
+  }
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new EvaSdkError("Browser audio input maxBufferedChunks must be a positive integer", {
+      fatal: true
+    });
+  }
+  return value;
+}
+function isFloat32Channels(value) {
+  return Array.isArray(value) && value.length > 0 && value.every((channel) => channel instanceof Float32Array);
+}
+function mediaDevicesOf(dependencies) {
+  const mediaDevices = dependencies.mediaDevices ?? globalThis.navigator?.mediaDevices;
+  if (mediaDevices === void 0) {
+    throw new EvaSdkError("Browser media devices unavailable", { fatal: true });
+  }
+  return mediaDevices;
+}
+function audioContextOf(dependencies) {
+  if (dependencies.audioContextFactory !== void 0) {
+    return dependencies.audioContextFactory();
+  }
+  if (typeof AudioContext === "undefined") {
+    throw new EvaSdkError("Browser AudioContext unavailable", { fatal: true });
+  }
+  return new AudioContext({ latencyHint: "interactive" });
+}
+function workletNodeOf(dependencies, context) {
+  if (dependencies.audioWorkletNodeFactory !== void 0) {
+    return dependencies.audioWorkletNodeFactory(context, WORKLET_NAME);
+  }
+  return new AudioWorkletNode(context, WORKLET_NAME);
+}
+function objectUrlOf(dependencies) {
+  return dependencies.objectUrl ?? {
+    create(source) {
+      return URL.createObjectURL(new Blob([source], { type: "text/javascript" }));
+    },
+    revoke(url) {
+      URL.revokeObjectURL(url);
+    }
+  };
+}
+
+// src/facade/media/browser/audio-output.ts
+function createBrowserAudioOutputSink() {
+  return createBrowserAudioOutputSinkWithDependencies();
+}
+function createBrowserAudioOutputSinkWithDependencies(dependencies = {}) {
+  return new DefaultBrowserAudioOutputSink(dependencies);
+}
+var DefaultBrowserAudioOutputSink = class {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+  dependencies;
+  context;
+  scheduledTime = 0;
+  active = /* @__PURE__ */ new Set();
+  drainWaiters = /* @__PURE__ */ new Set();
+  generation = 0;
+  stopped = false;
+  stopPromise;
+  async enqueue(chunk) {
+    if (this.stopped) {
+      throw new EvaSdkError("Browser audio output stopped", { fatal: true });
+    }
+    if (chunk.format !== "pcm_s16le") {
+      throw new EvaSdkError("Browser audio output requires pcm_s16le", { fatal: true });
+    }
+    const generation = this.generation;
+    let context;
+    try {
+      context = this.context ?? this.createContext();
+      await context.resume();
+      if (!this.isCurrent(generation, context)) {
+        return;
+      }
+      const samples = Math.floor(chunk.data.byteLength / 2 / chunk.channels);
+      if (samples === 0) {
+        return;
+      }
+      const buffer = context.createBuffer(1, samples, chunk.sampleRate);
+      decodePcm16Mono(chunk, buffer.getChannelData(0));
+      const source = context.createBufferSource();
+      source.buffer = buffer;
+      source.connect(context.destination);
+      source.onended = () => {
+        this.active.delete(source);
+        this.resolveDrainIfIdle();
+      };
+      const startTime = Math.max(context.currentTime, this.scheduledTime);
+      this.active.add(source);
+      try {
+        source.start(startTime);
+        this.scheduledTime = startTime + buffer.duration;
+      } catch (error) {
+        source.onended = null;
+        this.active.delete(source);
+        this.resolveDrainIfIdle();
+        throw error;
+      }
+    } catch (error) {
+      if (context !== void 0 && !this.isCurrent(generation, context)) {
+        return;
+      }
+      throw ensureError(error, { message: "Browser audio output failed" });
+    }
+  }
+  flush() {
+    this.generation += 1;
+    const context = this.context;
+    const sources = [...this.active];
+    this.active.clear();
+    let failure;
+    for (const source of sources) {
+      source.onended = null;
+      try {
+        source.stop(0);
+      } catch (error) {
+        failure ??= error;
+      }
+    }
+    this.scheduledTime = context?.currentTime ?? 0;
+    this.resolveDrainIfIdle();
+    if (failure !== void 0) {
+      throw ensureError(failure, { message: "Browser audio output flush failed" });
+    }
+  }
+  drain() {
+    if (this.active.size === 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => this.drainWaiters.add(resolve));
+  }
+  stop() {
+    this.stopPromise ??= this.stopOnce();
+    return this.stopPromise;
+  }
+  createContext() {
+    if (this.dependencies.audioContextFactory !== void 0) {
+      this.context = this.dependencies.audioContextFactory();
+      return this.context;
+    }
+    if (typeof AudioContext === "undefined") {
+      throw new EvaSdkError("Browser AudioContext unavailable", { fatal: true });
+    }
+    this.context = new AudioContext({ latencyHint: "interactive" });
+    return this.context;
+  }
+  resolveDrainIfIdle() {
+    if (this.active.size !== 0) {
+      return;
+    }
+    for (const resolve of this.drainWaiters) {
+      resolve();
+    }
+    this.drainWaiters.clear();
+  }
+  isCurrent(generation, context) {
+    return !this.stopped && generation === this.generation && context === this.context;
+  }
+  async stopOnce() {
+    this.stopped = true;
+    let failure;
+    try {
+      this.flush();
+    } catch (error) {
+      failure = error;
+    }
+    const context = this.context;
+    this.context = void 0;
+    this.scheduledTime = 0;
+    try {
+      await context?.close();
+    } catch (error) {
+      failure ??= error;
+    }
+    if (failure !== void 0) {
+      throw ensureError(failure, { message: "Browser audio output stop failed" });
+    }
+  }
+};
+function decodePcm16Mono(chunk, output) {
+  const view = new DataView(chunk.data.buffer, chunk.data.byteOffset, chunk.data.byteLength);
+  for (let sampleIndex = 0; sampleIndex < output.length; sampleIndex += 1) {
+    let sum = 0;
+    for (let channel = 0; channel < chunk.channels; channel += 1) {
+      const offset = (sampleIndex * chunk.channels + channel) * 2;
+      sum += view.getInt16(offset, true) / 32768;
+    }
+    output[sampleIndex] = sum / chunk.channels;
+  }
+}
+
+// src/facade/media/browser/camera.ts
+function createBrowserCameraSnapshotSource(options = {}) {
+  return createBrowserCameraSnapshotSourceWithDependencies(options);
+}
+function createBrowserCameraSnapshotSourceWithDependencies(options = {}, dependencies = {}) {
+  assertOptions(options);
+  return new DefaultBrowserCameraSnapshotSource(options, dependencies);
+}
+var DefaultBrowserCameraSnapshotSource = class {
+  constructor(options, dependencies) {
+    this.options = options;
+    this.dependencies = dependencies;
+  }
+  options;
+  dependencies;
+  generation = 0;
+  active;
+  pendingStart;
+  pendingCapture;
+  teardownPromise;
+  start(signal) {
+    if (signal.aborted) return Promise.reject(abortError());
+    if (this.active !== void 0 || this.pendingStart !== void 0 || this.teardownPromise !== void 0) {
+      return Promise.reject(new EvaSdkError("Browser camera session already exists", { fatal: true }));
+    }
+    const generation = ++this.generation;
+    const cancellation = cancellable();
+    const pending = {
+      generation,
+      cancelled: false,
+      cancel: cancellation.cancel,
+      cancellation: cancellation.promise,
+      underlying: Promise.resolve()
+    };
+    this.pendingStart = pending;
+    pending.underlying = this.acquire(pending).finally(() => {
+      if (this.pendingStart === pending) this.pendingStart = void 0;
+    });
+    void pending.underlying.catch(() => {
+    });
+    return raceWithSignalAndCancellation(
+      pending.underlying,
+      signal,
+      () => this.cancelStart(pending),
+      pending.cancellation
+    );
+  }
+  capture(signal) {
+    if (signal.aborted) return Promise.reject(abortError());
+    const active = this.active;
+    if (active === void 0) {
+      return Promise.reject(new EvaSdkError("Browser camera is not started", { fatal: true }));
+    }
+    if (this.pendingCapture !== void 0) {
+      return Promise.reject(new EvaSdkError("Browser camera capture is already in progress", {
+        fatal: true
+      }));
+    }
+    const cancellation = cancellable();
+    const pending = {
+      generation: active.generation,
+      cancelled: false,
+      cancel: cancellation.cancel,
+      cancellation: cancellation.promise,
+      underlying: Promise.resolve(snapshotPlaceholder())
+    };
+    this.pendingCapture = pending;
+    pending.underlying = this.captureFrame(active, pending).finally(() => {
+      if (this.pendingCapture === pending) this.pendingCapture = void 0;
+    });
+    void pending.underlying.catch(() => {
+    });
+    return raceWithSignalAndCancellation(
+      pending.underlying,
+      signal,
+      () => this.cancelCapture(pending),
+      pending.cancellation
+    );
+  }
+  stop() {
+    if (this.teardownPromise !== void 0) return this.teardownPromise;
+    const pendingStart = this.pendingStart;
+    const pendingCapture = this.pendingCapture;
+    const active = this.active;
+    this.generation += 1;
+    if (pendingStart !== void 0) this.cancelStart(pendingStart);
+    if (pendingCapture !== void 0) this.cancelCapture(pendingCapture);
+    this.active = void 0;
+    if (active !== void 0) releaseActive(active);
+    const teardown = (async () => {
+      await Promise.allSettled([
+        pendingStart?.underlying ?? Promise.resolve(),
+        pendingCapture?.underlying ?? Promise.resolve()
+      ]);
+      const lateActive = this.active;
+      if (lateActive !== void 0) {
+        this.active = void 0;
+        releaseActive(lateActive);
+      }
+    })();
+    this.teardownPromise = teardown.finally(() => {
+      if (this.teardownPromise === teardown || this.teardownPromise !== void 0) {
+        this.teardownPromise = void 0;
+      }
+    });
+    return this.teardownPromise;
+  }
+  async acquire(pending) {
+    const stream = await mediaDevicesOf2(this.dependencies).getUserMedia({
+      audio: false,
+      video: this.options.video ?? true
+    });
+    if (!this.isCurrentStart(pending)) {
+      stopVideoTracks(stream);
+      throw abortError();
+    }
+    const video = createVideoOf(this.dependencies);
+    video.srcObject = stream;
+    try {
+      await video.play();
+      await waitForVideoFrameOf(this.dependencies)(video);
+      if (!this.isCurrentStart(pending) || video.videoWidth <= 0 || video.videoHeight <= 0) {
+        throw abortError();
+      }
+      this.active = { generation: pending.generation, stream, video };
+    } catch (error) {
+      video.pause();
+      video.srcObject = null;
+      stopVideoTracks(stream);
+      throw error;
+    }
+  }
+  async captureFrame(active, pending) {
+    const width = active.video.videoWidth;
+    const height = active.video.videoHeight;
+    if (width <= 0 || height <= 0) {
+      throw new EvaSdkError("Browser camera frame is not ready", { fatal: true });
+    }
+    const canvas = createCanvasOf(this.dependencies);
+    canvas.width = width;
+    canvas.height = height;
+    canvas.drawImage(active.video, width, height);
+    const requestedMime = this.options.mimeType ?? "image/png";
+    const blob = await canvas.encode(
+      requestedMime,
+      requestedMime === "image/jpeg" ? this.options.jpegQuality : void 0
+    );
+    if (!this.isCurrentCapture(active, pending)) throw abortError();
+    const data = new Uint8Array(await blob.arrayBuffer());
+    if (!this.isCurrentCapture(active, pending)) throw abortError();
+    const mimeType = blob.type || requestedMime;
+    if (data.byteLength === 0 || mimeType !== "image/png" && mimeType !== "image/jpeg") {
+      throw new EvaSdkError("Browser camera produced invalid image data", { fatal: true });
+    }
+    return { data, mimeType, width, height };
+  }
+  cancelStart(pending) {
+    if (pending.cancelled) return;
+    pending.cancelled = true;
+    pending.cancel();
+  }
+  cancelCapture(pending) {
+    if (pending.cancelled) return;
+    pending.cancelled = true;
+    pending.cancel();
+  }
+  isCurrentStart(pending) {
+    return this.pendingStart === pending && !pending.cancelled && pending.generation === this.generation;
+  }
+  isCurrentCapture(active, pending) {
+    return this.active === active && this.pendingCapture === pending && !pending.cancelled && pending.generation === this.generation;
+  }
+};
+function assertOptions(options) {
+  if (options.jpegQuality !== void 0 && (!Number.isFinite(options.jpegQuality) || options.jpegQuality < 0 || options.jpegQuality > 1)) {
+    throw new EvaSdkError("Browser camera jpegQuality must be between 0 and 1", { fatal: true });
+  }
+}
+function mediaDevicesOf2(dependencies) {
+  const devices = dependencies.mediaDevices ?? navigator.mediaDevices;
+  if (devices === void 0) {
+    throw new EvaSdkError("Browser camera mediaDevices is unavailable", { fatal: true });
+  }
+  return devices;
+}
+function createVideoOf(dependencies) {
+  if (dependencies.createVideo !== void 0) return dependencies.createVideo();
+  const video = document.createElement("video");
+  video.autoplay = true;
+  video.muted = true;
+  video.playsInline = true;
+  return video;
+}
+function createCanvasOf(dependencies) {
+  if (dependencies.createCanvas !== void 0) return dependencies.createCanvas();
+  const canvas = document.createElement("canvas");
+  return {
+    get width() {
+      return canvas.width;
+    },
+    set width(value) {
+      canvas.width = value;
+    },
+    get height() {
+      return canvas.height;
+    },
+    set height(value) {
+      canvas.height = value;
+    },
+    drawImage(video, width, height) {
+      const context = canvas.getContext("2d");
+      if (context === null) {
+        throw new EvaSdkError("Browser camera canvas 2D context is unavailable", { fatal: true });
+      }
+      context.drawImage(video, 0, 0, width, height);
+    },
+    encode(type, quality) {
+      return new Promise((resolve, reject) => {
+        canvas.toBlob((blob) => {
+          if (blob === null) {
+            reject(new EvaSdkError("Browser camera image encoding failed", { fatal: true }));
+          } else {
+            resolve(blob);
+          }
+        }, type, quality);
+      });
+    }
+  };
+}
+function waitForVideoFrameOf(dependencies) {
+  if (dependencies.waitForVideoFrame !== void 0) return dependencies.waitForVideoFrame;
+  return async (video) => {
+    if (video.videoWidth > 0 && video.videoHeight > 0) return;
+    const element = video;
+    await new Promise((resolve, reject) => {
+      const ready = () => {
+        cleanup();
+        resolve();
+      };
+      const failed = () => {
+        cleanup();
+        reject(new EvaSdkError("Browser camera video failed", { fatal: true }));
+      };
+      const cleanup = () => {
+        element.removeEventListener("loadeddata", ready);
+        element.removeEventListener("canplay", ready);
+        element.removeEventListener("error", failed);
+      };
+      element.addEventListener("loadeddata", ready, { once: true });
+      element.addEventListener("canplay", ready, { once: true });
+      element.addEventListener("error", failed, { once: true });
+    });
+  };
+}
+function releaseActive(active) {
+  active.video.pause();
+  active.video.srcObject = null;
+  stopVideoTracks(active.stream);
+}
+function stopVideoTracks(stream) {
+  for (const track of stream.getVideoTracks()) track.stop();
+}
+function cancellable() {
+  let cancel;
+  const promise = new Promise((_resolve, reject) => {
+    cancel = () => reject(abortError());
+  });
+  void promise.catch(() => {
+  });
+  return { promise, cancel };
+}
+function raceWithSignalAndCancellation(work, signal, cancel, cancellation) {
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      cancel();
+      reject(abortError());
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    Promise.race([work, cancellation]).then(resolve, reject).finally(() => {
+      signal.removeEventListener("abort", onAbort);
+    }).catch(() => {
+    });
+  });
+}
+function abortError() {
+  return new DOMException("Browser camera operation aborted", "AbortError");
+}
+function snapshotPlaceholder() {
+  return { data: new Uint8Array([0]), mimeType: "image/png", width: 1, height: 1 };
+}
+
+// src/facade/media/browser/index.ts
+function createPassthroughAecProcessor() {
+  return createInstrumentedPassthroughAecProcessor();
+}
+export {
+  createBrowserAudioInputSource,
+  createBrowserAudioOutputSink,
+  createBrowserCameraSnapshotSource,
+  createPassthroughAecProcessor
+};