@newgameplusinc/alpha-spatial-comms 1.0.1

package/dist/index.mjs

@@ -0,0 +1,3252 @@
+import { io } from 'socket.io-client';
+import { Device } from 'mediasoup-client';
+import * as tf from '@tensorflow/tfjs';
+import { StreamChat } from 'stream-chat';
+
+// src/index.ts
+
+// src/core/EventManager.ts
+function createEventBus() {
+  const listeners = /* @__PURE__ */ new Map();
+  function on(event, listener) {
+    let set = listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      listeners.set(event, set);
+    }
+    set.add(listener);
+  }
+  function off(event, listener) {
+    listeners.get(event)?.delete(listener);
+  }
+  function emit(event, ...args) {
+    listeners.get(event)?.forEach((fn) => fn(...args));
+  }
+  function removeAllListeners(event) {
+    if (event) {
+      listeners.delete(event);
+    } else {
+      listeners.clear();
+    }
+  }
+  return { on, off, emit, removeAllListeners };
+}
+function createMediasoupManager(socket) {
+  const device = new Device();
+  let sendTransport = null;
+  let recvTransport = null;
+  const producers = /* @__PURE__ */ new Map();
+  const consumers = /* @__PURE__ */ new Map();
+  let participantId = "";
+  let sendTransportState = "new";
+  let recvTransportState = "new";
+  let iceRestartAttempts = 0;
+  const MAX_ICE_RESTART_ATTEMPTS = 3;
+  const internalBus = createEventBus();
+  function emitTransportEvent(event, data) {
+    internalBus.emit(event, data);
+  }
+  async function loadDevice(routerRtpCapabilities) {
+    if (device.loaded) return;
+    await device.load({ routerRtpCapabilities });
+  }
+  function sendDeviceRtpCapabilities(pid) {
+    participantId = pid;
+    socket.emit("device-rtp-capabilities", {
+      participantId: pid,
+      rtpCapabilities: device.rtpCapabilities
+    });
+  }
+  function createWebRtcTransport(direction, pid) {
+    return new Promise((resolve, reject) => {
+      const handleTransportCreated = (data) => {
+        if (data.type === direction) {
+          socket.off("transport-created", handleTransportCreated);
+          if (data.error) return reject(new Error(data.error));
+          resolve(data.params);
+        }
+      };
+      socket.on("transport-created", handleTransportCreated);
+      socket.emit("create-transport", { direction, participantId: pid });
+      setTimeout(() => {
+        socket.off("transport-created", handleTransportCreated);
+        reject(new Error(`Timeout waiting for ${direction} transport`));
+      }, 1e4);
+    });
+  }
+  function attemptIceRestart(direction) {
+    if (iceRestartAttempts >= MAX_ICE_RESTART_ATTEMPTS) {
+      emitTransportEvent("transport-failed", {
+        direction,
+        reason: "max-ice-restarts"
+      });
+      return;
+    }
+    iceRestartAttempts++;
+    const transport = direction === "send" ? sendTransport : recvTransport;
+    if (!transport) return;
+    socket.emit(
+      "request-ice-restart",
+      { participantId, transportId: transport.id, direction },
+      async (response) => {
+        if (response.error) {
+          setTimeout(() => attemptIceRestart(direction), 2e3);
+          return;
+        }
+        if (response.iceParameters) {
+          try {
+            await transport.restartIce({ iceParameters: response.iceParameters });
+          } catch {
+            setTimeout(() => attemptIceRestart(direction), 2e3);
+          }
+        }
+      }
+    );
+  }
+  function connectSendTransport() {
+    sendTransport?.on(
+      "connect",
+      async ({ dtlsParameters }, callback, errback) => {
+        socket.emit(
+          "connect-transport",
+          { transportId: sendTransport.id, dtlsParameters },
+          (response) => {
+            if (response.error) {
+              errback(new Error(response.error));
+            } else {
+              callback();
+            }
+          }
+        );
+      }
+    );
+    sendTransport?.on(
+      "produce",
+      async ({
+        kind,
+        rtpParameters,
+        appData
+      }, callback, errback) => {
+        socket.emit(
+          "produce",
+          {
+            transportId: sendTransport.id,
+            kind,
+            rtpParameters,
+            appData
+          },
+          (response) => {
+            if (response.error) {
+              errback(new Error(response.error));
+            } else if (response.producerId) {
+              callback({ id: response.producerId });
+            }
+          }
+        );
+      }
+    );
+    sendTransport?.on("connectionstatechange", (state) => {
+      sendTransportState = state;
+      switch (state) {
+        case "connected":
+          iceRestartAttempts = 0;
+          emitTransportEvent("transport-connected", { direction: "send" });
+          break;
+        case "disconnected":
+          emitTransportEvent("transport-disconnected", { direction: "send" });
+          attemptIceRestart("send");
+          break;
+        case "failed":
+          producers.clear();
+          emitTransportEvent("transport-failed", { direction: "send" });
+          socket.emit("transport-failed", { participantId, direction: "send" });
+          break;
+        case "closed":
+          producers.clear();
+          emitTransportEvent("transport-closed", { direction: "send" });
+          break;
+        case "connecting":
+          emitTransportEvent("transport-connecting", { direction: "send" });
+          break;
+      }
+    });
+  }
+  function connectRecvTransport() {
+    recvTransport?.on(
+      "connect",
+      async ({ dtlsParameters }, callback, errback) => {
+        socket.emit(
+          "connect-transport",
+          { transportId: recvTransport.id, dtlsParameters },
+          (response) => {
+            if (response.error) {
+              errback(new Error(response.error));
+            } else {
+              callback();
+            }
+          }
+        );
+      }
+    );
+    recvTransport?.on("connectionstatechange", (state) => {
+      recvTransportState = state;
+      switch (state) {
+        case "connected":
+          iceRestartAttempts = 0;
+          emitTransportEvent("transport-connected", { direction: "recv" });
+          break;
+        case "disconnected":
+          emitTransportEvent("transport-disconnected", { direction: "recv" });
+          attemptIceRestart("recv");
+          break;
+        case "failed":
+          emitTransportEvent("transport-failed", { direction: "recv" });
+          socket.emit("transport-failed", { participantId, direction: "recv" });
+          break;
+        case "closed":
+          emitTransportEvent("transport-closed", { direction: "recv" });
+          break;
+        case "connecting":
+          emitTransportEvent("transport-connecting", { direction: "recv" });
+          break;
+      }
+    });
+  }
+  async function createSendTransport(pid) {
+    const params = await createWebRtcTransport("send", pid);
+    const { iceServers, ...transportParams } = params;
+    sendTransport = device.createSendTransport({
+      ...transportParams,
+      iceServers: iceServers || []
+    });
+    connectSendTransport();
+  }
+  async function createRecvTransport(pid) {
+    const params = await createWebRtcTransport("recv", pid);
+    const { iceServers, ...transportParams } = params;
+    recvTransport = device.createRecvTransport({
+      ...transportParams,
+      iceServers: iceServers || []
+    });
+    connectRecvTransport();
+  }
+  async function produce(track, appData) {
+    if (!sendTransport) throw new Error("Send transport not initialized");
+    const produceOptions = { track, appData };
+    const isScreenshare = appData?.isScreenshare === true;
+    if (track.kind === "video") {
+      if (isScreenshare) {
+        produceOptions.encodings = [
+          {
+            rid: "r0",
+            active: true,
+            maxBitrate: 5e5,
+            maxFramerate: 10,
+            scaleResolutionDownBy: 4
+          },
+          {
+            rid: "r1",
+            active: true,
+            maxBitrate: 15e5,
+            maxFramerate: 15,
+            scaleResolutionDownBy: 2
+          },
+          {
+            rid: "r2",
+            active: true,
+            maxBitrate: 3e6,
+            maxFramerate: 15,
+            scaleResolutionDownBy: 1
+          }
+        ];
+        produceOptions.codecOptions = { videoGoogleStartBitrate: 1500 };
+      } else {
+        produceOptions.encodings = [
+          {
+            rid: "r0",
+            active: true,
+            maxBitrate: 1e5,
+            scaleResolutionDownBy: 4
+          },
+          {
+            rid: "r1",
+            active: true,
+            maxBitrate: 3e5,
+            scaleResolutionDownBy: 2
+          },
+          {
+            rid: "r2",
+            active: true,
+            maxBitrate: 9e5,
+            scaleResolutionDownBy: 1
+          }
+        ];
+        produceOptions.codecOptions = { videoGoogleStartBitrate: 1e3 };
+      }
+    }
+    const producer = await sendTransport.produce(produceOptions);
+    producer.on("transportclose", () => {
+      producers.delete(producer.id);
+    });
+    producer.on("trackended", () => {
+      producer.close();
+      producers.delete(producer.id);
+    });
+    producers.set(producer.id, producer);
+    return producer;
+  }
+  async function consume(data) {
+    if (!recvTransport) throw new Error("Receive transport not set up");
+    const consumer = await recvTransport.consume({
+      id: data.consumerId,
+      producerId: data.producerId,
+      kind: data.kind,
+      rtpParameters: data.rtpParameters
+    });
+    consumer.on("transportclose", () => {
+      consumers.delete(consumer.id);
+    });
+    consumer.on("trackended", () => {
+      consumer.close();
+      consumers.delete(consumer.id);
+    });
+    consumers.set(consumer.id, consumer);
+    return { consumer, track: consumer.track };
+  }
+  async function resumeConsumer(consumerId) {
+    return new Promise((resolve, reject) => {
+      socket.emit(
+        "resume-consumer",
+        { consumerId, participantId },
+        (response) => {
+          if (response.error) {
+            reject(new Error(response.error));
+          } else {
+            resolve();
+          }
+        }
+      );
+    });
+  }
+  function getTransportStates() {
+    return { send: sendTransportState, recv: recvTransportState };
+  }
+  function getConsumers() {
+    return consumers;
+  }
+  function close() {
+    producers.forEach((p) => p.close());
+    consumers.forEach((c) => c.close());
+    if (sendTransport) sendTransport.close();
+    if (recvTransport) recvTransport.close();
+    producers.clear();
+    consumers.clear();
+  }
+  return {
+    loadDevice,
+    sendDeviceRtpCapabilities,
+    createSendTransport,
+    createRecvTransport,
+    produce,
+    consume,
+    resumeConsumer,
+    getTransportStates,
+    getConsumers,
+    close,
+    onTransportEvent: (event, listener) => internalBus.on(event, listener)
+  };
+}
+
+// src/channels/spatial/SpatialAudioTypes.ts
+var DEFAULT_SPATIAL_CONFIG = {
+  refDistance: 0.5,
+  // Full volume at 0.5m or closer
+  maxDistance: 15,
+  // Silent at 15m (audio cutoff at 15.1m+)
+  rolloffFactor: 1,
+  // Unused - we use quadratic falloff
+  unit: "auto"
+};
+
+// src/utils/spatial/distance-calc.ts
+function getDistanceBetween(a, b) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const dz = b.z - a.z;
+  return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}
+
+// src/utils/spatial/gain-calc.ts
+var DEFAULT_GAIN_CONFIG = {
+  minDistance: 0.5,
+  // Full volume at 0.5m or closer
+  maxDistance: 15
+  // Silent at 15m
+};
+function calculateLogarithmicGain(distance, config = {}) {
+  const { minDistance, maxDistance } = {
+    ...DEFAULT_GAIN_CONFIG,
+    ...config
+  };
+  if (distance >= maxDistance) return 0;
+  if (distance <= minDistance) return 100;
+  const range = maxDistance - minDistance;
+  const normalizedDistance = (distance - minDistance) / range;
+  const remainingRatio = 1 - normalizedDistance;
+  const gain = 100 * remainingRatio * remainingRatio * remainingRatio;
+  return Math.max(0, gain);
+}
+
+// src/utils/spatial/pan-calc.ts
+function calculateListenerRight(yawDegrees) {
+  const yawRad = yawDegrees * Math.PI / 180;
+  return {
+    x: Math.cos(yawRad),
+    z: -Math.sin(yawRad)
+  };
+}
+function calculatePanFromPositions(listenerPos, sourcePos, listenerRight) {
+  const vecToSource = {
+    x: sourcePos.x - listenerPos.x,
+    z: sourcePos.z - listenerPos.z
+  };
+  const dxLocal = vecToSource.x * listenerRight.x + vecToSource.z * listenerRight.z;
+  const listenerForward = { x: -listenerRight.z, z: listenerRight.x };
+  const dzLocal = vecToSource.x * listenerForward.x + vecToSource.z * listenerForward.z;
+  const angleToSource = Math.atan2(dxLocal, dzLocal);
+  const rawPanValue = Math.sin(angleToSource);
+  return rawPanValue;
+}
+
+// src/utils/spatial/head-position.ts
+var DEFAULT_HEAD_HEIGHT = 1.6;
+function computeHeadPosition(bodyPosition, headHeight = DEFAULT_HEAD_HEIGHT) {
+  return {
+    x: bodyPosition.x,
+    y: bodyPosition.y + headHeight,
+    z: bodyPosition.z
+  };
+}
+
+// src/utils/position/normalize.ts
+function normalizePositionUnits(position, unit = "auto") {
+  if (unit === "meters") {
+    return { ...position };
+  }
+  if (unit === "centimeters") {
+    return {
+      x: position.x / 100,
+      y: position.y / 100,
+      z: position.z / 100
+    };
+  }
+  const maxAxis = Math.max(
+    Math.abs(position.x),
+    Math.abs(position.y),
+    Math.abs(position.z)
+  );
+  if (maxAxis > 50) {
+    return {
+      x: position.x / 100,
+      y: position.y / 100,
+      z: position.z / 100
+    };
+  }
+  return { ...position };
+}
+
+// src/utils/position/snap.ts
+var SNAP_CONFIG = {
+  threshold: 0.3
+};
+function createPositionSnapCache(threshold = SNAP_CONFIG.threshold) {
+  const cache = /* @__PURE__ */ new Map();
+  function snap(position, id) {
+    const cached = cache.get(id);
+    if (!cached || cached.x === 0 && cached.y === 0 && cached.z === 0) {
+      cache.set(id, { ...position });
+      return position;
+    }
+    const dx = position.x - cached.x;
+    const dy = position.y - cached.y;
+    const dz = position.z - cached.z;
+    const movedDistance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    if (movedDistance > threshold) {
+      cache.set(id, { ...position });
+      return position;
+    }
+    return cached;
+  }
+  return {
+    snap,
+    clear: (id) => {
+      cache.delete(id);
+    },
+    clearAll: () => {
+      cache.clear();
+    }
+  };
+}
+
+// src/utils/smoothing/pan-smoothing.ts
+var DEFAULT_PAN_SMOOTHER_OPTIONS = {
+  smoothingFactor: 0.3,
+  changeThreshold: 0.02,
+  centerDeadZone: 0.03
+};
+function createPanSmoother(options = {}) {
+  const opts = { ...DEFAULT_PAN_SMOOTHER_OPTIONS, ...options };
+  const smoothedValues = /* @__PURE__ */ new Map();
+  const lastUpdateTime = /* @__PURE__ */ new Map();
+  function smooth(participantId, newPanValue) {
+    const previousPan = smoothedValues.get(participantId);
+    const now = Date.now();
+    const lastTime = lastUpdateTime.get(participantId) || 0;
+    const timeSinceLastUpdate = now - lastTime;
+    let targetPan = newPanValue;
+    if (Math.abs(newPanValue) < opts.centerDeadZone) {
+      targetPan = 0;
+    }
+    if (previousPan === void 0) {
+      smoothedValues.set(participantId, targetPan);
+      lastUpdateTime.set(participantId, now);
+      return targetPan;
+    }
+    const panChange = Math.abs(targetPan - previousPan);
+    if (panChange < opts.changeThreshold) {
+      return previousPan;
+    }
+    let effectiveSmoothingFactor = opts.smoothingFactor;
+    const signFlipped = previousPan > 0 && targetPan < 0 || previousPan < 0 && targetPan > 0;
+    const bothNearCenter = Math.abs(previousPan) < 0.15 && Math.abs(targetPan) < 0.15;
+    const isLikelyJitter = signFlipped && panChange > 1 && timeSinceLastUpdate < 60;
+    if (isLikelyJitter) {
+      effectiveSmoothingFactor = 0.7;
+    } else if (bothNearCenter) {
+      effectiveSmoothingFactor = Math.min(opts.smoothingFactor + 0.1, 0.5);
+    }
+    const smoothedPan = previousPan * effectiveSmoothingFactor + targetPan * (1 - effectiveSmoothingFactor);
+    const finalPan = Math.abs(smoothedPan) < opts.centerDeadZone ? 0 : smoothedPan;
+    smoothedValues.set(participantId, finalPan);
+    lastUpdateTime.set(participantId, now);
+    return finalPan;
+  }
+  function clear(participantId) {
+    smoothedValues.delete(participantId);
+    lastUpdateTime.delete(participantId);
+  }
+  function clearAll() {
+    smoothedValues.clear();
+    lastUpdateTime.clear();
+  }
+  return { smooth, clear, clearAll };
+}
+
+// src/utils/smoothing/gain-smoothing.ts
+function applyGainSmooth(gainNode, targetGain, audioContext, timeConstant = 0.1) {
+  try {
+    gainNode.gain.setTargetAtTime(
+      targetGain,
+      audioContext.currentTime,
+      timeConstant
+    );
+  } catch (err) {
+    gainNode.gain.value = targetGain;
+  }
+}
+function applyStereoPanSmooth(stereoPanner, panValue, audioContext, timeConstant = 0.05) {
+  try {
+    stereoPanner.pan.setTargetAtTime(
+      panValue,
+      audioContext.currentTime,
+      timeConstant
+    );
+  } catch (err) {
+    stereoPanner.pan.value = panValue;
+  }
+}
+var L2RegularizerCompat = class {
+  constructor(config) {
+    this.l2 = config?.l2 ?? 0;
+  }
+  apply(x) {
+    return tf.tidy(
+      () => tf.sum(tf.square(x)).mul(tf.scalar(this.l2))
+    );
+  }
+  getConfig() {
+    return { l2: this.l2 };
+  }
+};
+L2RegularizerCompat.className = "L2";
+tf.serialization.registerClass(L2RegularizerCompat);
+var _GRUCellResetAfterSupport = class _GRUCellResetAfterSupport extends tf.layers.Layer {
+  constructor(config) {
+    super(config);
+    this.dropoutMask = null;
+    this.recurrentDropoutMask = null;
+    this.units = config.units;
+    this.resetAfter = (config.resetAfter ?? config.reset_after) !== false;
+    this.useBiasFlag = (config.useBias ?? config.use_bias) !== false;
+    this.stateSize = this.units;
+    this.activationFn = _GRUCellResetAfterSupport.makeActivation(
+      config.activation || "tanh"
+    );
+    this.recurrentActivationFn = _GRUCellResetAfterSupport.makeActivation(
+      config.recurrentActivation ?? config.recurrent_activation ?? "sigmoid"
+      // Keras default (model.json uses 'sigmoid', NOT 'hardSigmoid')
+    );
+  }
+  build(inputShape) {
+    let shape;
+    if (Array.isArray(inputShape[0])) {
+      shape = inputShape[0];
+    } else {
+      shape = inputShape;
+    }
+    const inputDim = shape[shape.length - 1];
+    this.kernelW = this.addWeight(
+      "kernel",
+      [inputDim, this.units * 3],
+      "float32",
+      tf.initializers.glorotUniform({})
+    );
+    this.recurrentKernelW = this.addWeight(
+      "recurrent_kernel",
+      [this.units, this.units * 3],
+      "float32",
+      tf.initializers.orthogonal({})
+    );
+    if (this.useBiasFlag) {
+      const biasShape = this.resetAfter ? [2, this.units * 3] : [this.units * 3];
+      this.biasW = this.addWeight(
+        "bias",
+        biasShape,
+        "float32",
+        tf.initializers.zeros()
+      );
+    }
+    this.built = true;
+  }
+  call(inputs, _kwargs) {
+    return tf.tidy(() => {
+      const input = inputs[0];
+      const hPrev = inputs[1];
+      let matrixX = input.matMul(this.kernelW.read());
+      if (this.resetAfter) {
+        let bKernel = null;
+        let bRecurrent = null;
+        if (this.useBiasFlag && this.biasW) {
+          const b = this.biasW.read();
+          bKernel = b.slice([0, 0], [1, -1]).squeeze([0]);
+          bRecurrent = b.slice([1, 0], [1, -1]).squeeze([0]);
+        }
+        if (bKernel) matrixX = matrixX.add(bKernel);
+        const matrixInner = hPrev.matMul(this.recurrentKernelW.read());
+        const [xZ, xR, xH] = tf.split(matrixX, 3, matrixX.rank - 1);
+        const [iZ, iR, iH] = tf.split(matrixInner, 3, matrixInner.rank - 1);
+        let rZ = iZ, rR = iR, rH = iH;
+        if (bRecurrent) {
+          const [rbZ, rbR, rbH] = tf.split(bRecurrent, 3, 0);
+          rZ = iZ.add(rbZ);
+          rR = iR.add(rbR);
+          rH = iH.add(rbH);
+        }
+        const z = this.recurrentActivationFn(xZ.add(rZ));
+        const r = this.recurrentActivationFn(xR.add(rR));
+        const hh = this.activationFn(xH.add(r.mul(rH)));
+        const h = tf.add(tf.mul(z, hPrev), tf.mul(tf.sub(tf.scalar(1), z), hh));
+        return [h, h];
+      } else {
+        if (this.useBiasFlag && this.biasW) {
+          matrixX = matrixX.add(this.biasW.read());
+        }
+        const rk = this.recurrentKernelW.read();
+        const [rk1, rk2] = tf.split(
+          rk,
+          [2 * this.units, this.units],
+          rk.rank - 1
+        );
+        const matrixInner = hPrev.matMul(rk1);
+        const [xZ, xR, xH] = tf.split(matrixX, 3, matrixX.rank - 1);
+        const [recZ, recR] = tf.split(matrixInner, 2, matrixInner.rank - 1);
+        const z = this.recurrentActivationFn(xZ.add(recZ));
+        const r = this.recurrentActivationFn(xR.add(recR));
+        const recH = tf.mul(r, hPrev).matMul(rk2);
+        const hh = this.activationFn(xH.add(recH));
+        const h = tf.add(tf.mul(z, hPrev), tf.mul(tf.sub(tf.scalar(1), z), hh));
+        return [h, h];
+      }
+    });
+  }
+  static makeActivation(name) {
+    switch (name.toLowerCase()) {
+      case "tanh":
+        return (x) => x.tanh();
+      case "sigmoid":
+        return (x) => x.sigmoid();
+      case "hardsigmoid":
+      case "hard_sigmoid":
+        return (x) => tf.clipByValue(x.mul(tf.scalar(0.2)).add(tf.scalar(0.5)), 0, 1);
+      case "relu":
+        return (x) => x.relu();
+      case "linear":
+        return (x) => x;
+      default:
+        return (x) => x.sigmoid();
+    }
+  }
+  getConfig() {
+    return {
+      ...super.getConfig(),
+      units: this.units,
+      useBias: this.useBiasFlag,
+      resetAfter: this.resetAfter
+    };
+  }
+};
+// Must match TF.js serialization class name
+_GRUCellResetAfterSupport.className = "GRUCell";
+var GRUCellResetAfterSupport = _GRUCellResetAfterSupport;
+tf.serialization.registerClass(GRUCellResetAfterSupport);
+var GRULayerWithResetAfter = class {
+  static fromConfig(_cls, config) {
+    const layerName = config.name;
+    const cell = new GRUCellResetAfterSupport({
+      ...config,
+      name: `gru_cell`,
+      // → weights: "gru_96/gru_cell/kernel" ✅
+      // Normalise keys: Keras JSON is snake_case; TF.js internals are camelCase
+      useBias: config.useBias ?? config.use_bias ?? true,
+      recurrentActivation: config.recurrentActivation ?? config.recurrent_activation ?? "sigmoid",
+      resetAfter: (config.resetAfter ?? config.reset_after) !== false,
+      returnSequences: config.returnSequences ?? config.return_sequences ?? false
+    });
+    return tf.layers.rnn({
+      cell,
+      returnSequences: config.returnSequences ?? config.return_sequences ?? false,
+      returnState: config.returnState ?? config.return_state ?? false,
+      goBackwards: config.goBackwards ?? config.go_backwards ?? false,
+      stateful: config.stateful ?? false,
+      unroll: config.unroll ?? false,
+      // Always use float32 — model.json exports dtype as a Keras Policy object
+      // (e.g. {class_name:"Policy", config:{name:"mixed_float16"}}) which TF.js
+      // cannot use as a DataType string. Weights are float32 anyway (UINT8 quantized
+      // with original_dtype=float32), so float32 is always correct here.
+      dtype: "float32",
+      name: layerName
+      // e.g. "gru_96" — RNN layer keeps this name
+    });
+  }
+};
+GRULayerWithResetAfter.className = "GRU";
+tf.serialization.registerClass(GRULayerWithResetAfter);
+var WEBRTC_SAMPLE_RATE = 48e3;
+function createMLNoiseSuppressor() {
+  const instance = new MLNoiseSuppressor();
+  return {
+    initialize: (url) => instance.initialize(url),
+    isReady: () => instance.isReady(),
+    getModelConfig: () => instance.getModelConfig(),
+    getInfo: () => instance.getInfo(),
+    computeGainsFromFeatures: (f, s, n, p) => instance.computeGainsFromFeatures(f, s, n, p),
+    clearParticipantSmoothingState: (id) => instance.clearParticipantSmoothingState(id),
+    processAudioSync: (buf) => instance.processAudioSync(buf),
+    reset: () => instance.reset(),
+    dispose: () => instance.dispose()
+  };
+}
+var MLNoiseSuppressor = class _MLNoiseSuppressor {
+  constructor() {
+    this.model = null;
+    this.config = null;
+    this.normStats = null;
+    this.isInitialized = false;
+    // Temporal smoothing state — per-participant to avoid cross-participant corruption
+    // when multiple async computeGainsFromFeatures() calls run concurrently.
+    this.prevMaskMap = /* @__PURE__ */ new Map();
+    // Faster smoothing: 0.70 means 30% of new value per frame (~3 frames to stabilise).
+    // Old 0.92 was too slow — first speech frame had smoothed max≈0.08 which fell below
+    // the isSpeechFrame threshold and silenced the first ~200ms of every utterance.
+    this.SMOOTHING_ALPHA = 0.7;
+    // Mel filterbank cache (built once, reused every frame)
+    this.melFilterbank = null;
+    // ── Google Meet-style ring buffer architecture ─────────────────────────────
+    // Process audio in exact hop_length (80 sample) steps at 16kHz.
+    // Each hop: STFT → apply cached FFT gains → ISTFT → OLA.
+    // Model runs async, updates cachedFftGains after each inference.
+    // Audio thread cost: ~2ms. Model inference: async, never blocks.
+    // Persistent input ring buffer (16kHz) — accumulates samples across callbacks.
+    this.inRing = new Float32Array(8192);
+    this.inRingLen = 0;
+    // OLA accumulator (16kHz) — each hop's ISTFT output is overlap-added here.
+    this.outAccum = new Float32Array(16384);
+    this.outNorm = new Float32Array(16384);
+    // sum of hann² for normalisation
+    // Per-FFT-bin gains from last completed async inference.
+    // All-ones until first inference completes → transparent passthrough.
+    this.cachedFftGains = null;
+    this.inferenceInFlight = false;
+    // Hann window cache (allocated once per N_FFT)
+    this.hannWinCache = null;
+    // Rolling mel frame history — seq_len frames of mel features for model input.
+    this.melFrameHistory = [];
+    // Resampling state (for 16kHz models)
+    this.needsResampling = false;
+    this.resampleRatio = 1;
+    // WEBRTC_SAMPLE_RATE / model.sample_rate
+    // Legacy fields (kept for isReady / reset API compatibility)
+    this.lastComplexFrames = [];
+    this.VOICE_FUNDAMENTAL_MIN = 80;
+    this.VOICE_FUNDAMENTAL_MAX = 500;
+    this.frameCounter = 0;
+    this.skipFrames = 0;
+    this.lastProcessedOutput = null;
+    this.processingTimes = [];
+    this.MAX_PROCESSING_TIME_MS = 42;
+  }
+  /**
+   * Initialize ML model for noise suppression
+   * @param modelUrl Path to model.json file
+   */
+  async initialize(modelUrl) {
+    try {
+      try {
+        await tf.setBackend("cpu");
+      } catch {
+        await tf.setBackend("webgl");
+      }
+      await tf.ready();
+      console.log(
+        `[MLNoiseSuppressor] TF.js backend ready: ${tf.getBackend()}`
+      );
+      const baseUrlForWeights = modelUrl.split("?")[0].replace(/model\.json$/, "");
+      const [modelJsonResp, binResp] = await Promise.all([
+        fetch(modelUrl),
+        fetch(`${baseUrlForWeights}group1-shard1of1.bin`)
+      ]);
+      const modelJsonData = await modelJsonResp.json();
+      const weightData = await binResp.arrayBuffer();
+      const remappedWeightSpecs = modelJsonData.weightsManifest[0].weights.map(
+        (w) => ({ ...w, name: w.name.replace("/gru_cell/", "/") })
+      );
+      this.model = await tf.loadLayersModel(
+        tf.io.fromMemory({
+          modelTopology: modelJsonData.modelTopology,
+          weightSpecs: remappedWeightSpecs,
+          weightData,
+          format: modelJsonData.format,
+          generatedBy: modelJsonData.generatedBy,
+          convertedBy: modelJsonData.convertedBy
+        })
+      );
+      console.log(
+        `[MLNoiseSuppressor] Model loaded \u2014 ${this.model.countParams().toLocaleString()} params | backend: ${tf.getBackend()} | url: ${modelUrl}`
+      );
+      const baseUrl = modelUrl.substring(0, modelUrl.lastIndexOf("/"));
+      const configResponse = await fetch(`${baseUrl}/model_config.json`);
+      this.config = await configResponse.json();
+      try {
+        const normResponse = await fetch(`${baseUrl}/normalization_stats.json`);
+        this.normStats = await normResponse.json();
+        console.log(
+          `[MLNoiseSuppressor] Normalization stats loaded \u2014 mean: ${this.normStats.mean.toFixed(4)}, std: ${this.normStats.std.toFixed(4)}`
+        );
+      } catch (e) {
+        console.warn(
+          `[MLNoiseSuppressor] normalization_stats.json not found, using defaults (mean=0, std=1)`
+        );
+        this.normStats = { mean: 0, std: 1 };
+      }
+      const modelSampleRate = this.config.sample_rate || 48e3;
+      if (modelSampleRate !== WEBRTC_SAMPLE_RATE) {
+        this.needsResampling = true;
+        this.resampleRatio = WEBRTC_SAMPLE_RATE / modelSampleRate;
+        console.log(
+          `[MLNoiseSuppressor] Resampling enabled: ${WEBRTC_SAMPLE_RATE}Hz \u2192 ${modelSampleRate}Hz (ratio: ${this.resampleRatio})`
+        );
+      } else {
+        this.needsResampling = false;
+        this.resampleRatio = 1;
+      }
+      const seqLen = this.config.sequence_length || 8;
+      const nMels = this.config.n_mels || 40;
+      console.log(
+        `[MLNoiseSuppressor] Warming up model (${seqLen} \xD7 ${nMels})...`
+      );
+      const warmupInput = tf.zeros([1, seqLen, nMels]);
+      for (let w = 0; w < 3; w++) {
+        const warmupOut = this.model.predict(warmupInput);
+        warmupOut.dataSync();
+        warmupOut.dispose();
+      }
+      warmupInput.dispose();
+      const diagInput = tf.fill([1, seqLen, nMels], 0.5);
+      const diagOut = this.model.predict(diagInput);
+      const diagData = new Float32Array(await diagOut.dataSync());
+      const diagMax = Math.max(...Array.from(diagData));
+      const diagMin = Math.min(...Array.from(diagData));
+      diagOut.dispose();
+      diagInput.dispose();
+      console.log(
+        `[MLNoiseSuppressor] \u26A0\uFE0F Weight check (input=0.5): output max=${diagMax.toFixed(4)} min=${diagMin.toFixed(4)} \u2014 ${diagMax > 0.01 ? "\u2705 weights LOADED" : "\u274C weights NOT loaded (all-zero output)"}`
+      );
+      console.log(
+        `[MLNoiseSuppressor] \u{1F4CB} TF.js weight variable names (${this.model.weights.length} total):`
+      );
+      this.model.weights.forEach((w, i) => {
+        const vals = w.read().dataSync();
+        const wMax = Math.max(...Array.from(vals).slice(0, 20));
+        const wMin = Math.min(...Array.from(vals).slice(0, 20));
+        console.log(
+          `  [${i}] ${w.name}  shape=${JSON.stringify(w.shape)}  val_range=[${wMin.toFixed(4)}, ${wMax.toFixed(4)}]${Math.abs(wMax) < 1e-6 && Math.abs(wMin) < 1e-6 ? " \u2190 \u274C ALL ZEROS (not loaded!)" : ""}`
+        );
+      });
+      console.log(`[MLNoiseSuppressor] Warmup done`);
+      this.isInitialized = true;
+      console.log(`[MLNoiseSuppressor] \u2705 Ready \u2014 noise suppression is ACTIVE`);
+      console.log(
+        `[MLNoiseSuppressor] Config: ${modelSampleRate}Hz, ${this.config.n_mels} mels, n_fft=${this.config.n_fft || 2048}`
+      );
+    } catch (error) {
+      console.error(`[MLNoiseSuppressor] \u274C Initialization failed:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Google Meet-style ring buffer noise suppression.
+   *
+   * Trains / Google Meet process audio in exact hop_length steps (80 samples = 5ms @ 16kHz).
+   * Each step:
+   *   1. Extract one STFT frame (n_fft=512) with Hann window — zero-pad if near end
+   *   2. Apply cached per-FFT-bin gains (from last async inference) → ISTFT
+   *   3. Overlap-add into persistent output ring buffer
+   *   4. Fire async inference (non-blocking) to update gains for next steps
+   *
+   * Audio thread cost: ~2ms (pure JS STFT + OLA).
+   * Model cost: async, never blocks audio thread.
+   * Mask staleness: ≤1 hop (5ms) — imperceptible for noise suppression.
+   */
+  processAudioSync(inputBuffer) {
+    if (!this.isInitialized || !this.model || !this.config) {
+      return inputBuffer;
+    }
+    const N_FFT = this.config.n_fft || 512;
+    const HOP = this.config.hop_length || 80;
+    const N_MELS = this.config.n_mels || 40;
+    const SEQ_LEN = this.config.sequence_length || 8;
+    const bins = N_FFT / 2 + 1;
+    if (!this.hannWinCache || this.hannWinCache.length !== N_FFT) {
+      this.hannWinCache = new Float32Array(N_FFT);
+      for (let i = 0; i < N_FFT; i++)
+        this.hannWinCache[i] = 0.5 * (1 - Math.cos(2 * Math.PI * i / (N_FFT - 1)));
+    }
+    const hann = this.hannWinCache;
+    try {
+      const in16 = this.needsResampling ? this.downsample(inputBuffer, this.resampleRatio) : inputBuffer;
+      if (this.inRingLen + in16.length > this.inRing.length) {
+        const grown = new Float32Array(
+          Math.max((this.inRingLen + in16.length) * 2, 8192)
+        );
+        grown.set(this.inRing.subarray(0, this.inRingLen));
+        this.inRing = grown;
+      }
+      this.inRing.set(in16, this.inRingLen);
+      this.inRingLen += in16.length;
+      const maxOut = this.inRingLen + N_FFT;
+      if (maxOut > this.outAccum.length) {
+        const g1 = new Float32Array(maxOut * 2);
+        g1.set(this.outAccum);
+        this.outAccum = g1;
+        const g2 = new Float32Array(maxOut * 2);
+        g2.set(this.outNorm);
+        this.outNorm = g2;
+      }
+      let offset = 0;
+      while (offset + HOP <= this.inRingLen) {
+        const frame = new Float32Array(N_FFT);
+        for (let i = 0; i < N_FFT; i++) {
+          const idx = offset + i;
+          frame[i] = (idx < this.inRingLen ? this.inRing[idx] : 0) * hann[i];
+        }
+        const { real: fR, imag: fI } = _MLNoiseSuppressor.fftForward(frame);
+        const power = new Float32Array(bins);
+        for (let k = 0; k < bins; k++) power[k] = fR[k] * fR[k] + fI[k] * fI[k];
+        const melFrame = this.computeMelFrame(power, N_MELS);
+        this.melFrameHistory.push(melFrame);
+        if (this.melFrameHistory.length > SEQ_LEN)
+          this.melFrameHistory = this.melFrameHistory.slice(-SEQ_LEN);
+        const gains = this.cachedFftGains ?? new Float32Array(bins).fill(1);
+        const mR = new Float32Array(N_FFT);
+        const mI = new Float32Array(N_FFT);
+        for (let k = 0; k < bins; k++) {
+          mR[k] = fR[k] * gains[k];
+          mI[k] = fI[k] * gains[k];
+          if (k > 0 && k < N_FFT / 2) {
+            mR[N_FFT - k] = mR[k];
+            mI[N_FFT - k] = -mI[k];
+          }
+        }
+        const recon = _MLNoiseSuppressor.ifftFromComplex(mR, mI);
+        for (let i = 0; i < N_FFT; i++) {
+          const pos = offset + i;
+          this.outAccum[pos] += recon[i] * hann[i];
+          this.outNorm[pos] += hann[i] * hann[i];
+        }
+        if (!this.inferenceInFlight) {
+          this.runInferenceAsync(this.melFrameHistory.slice(), SEQ_LEN, N_MELS);
+        }
+        offset += HOP;
+      }
+      const out16 = new Float32Array(in16.length);
+      const ready2 = Math.min(in16.length, offset);
+      for (let i = 0; i < ready2; i++) {
+        out16[i] = this.outNorm[i] > 1e-10 ? this.outAccum[i] / this.outNorm[i] : in16[i];
+      }
+      for (let i = ready2; i < in16.length; i++) out16[i] = in16[i];
+      this.inRing.copyWithin(0, offset);
+      this.inRingLen -= offset;
+      this.outAccum.copyWithin(0, offset);
+      this.outNorm.copyWithin(0, offset);
+      this.outAccum.fill(0, this.inRingLen + N_FFT);
+      this.outNorm.fill(0, this.inRingLen + N_FFT);
+      return this.needsResampling ? this.upsample(out16, this.resampleRatio, inputBuffer.length) : out16;
+    } catch {
+      return inputBuffer;
+    }
+  }
+  /**
+   * Compute mel-spectrogram features for one STFT frame.
+   * Matches training pipeline: power_to_db(ref=max) → (db+80)/80 clipped [0,1].
+   */
+  computeMelFrame(powerSpec, N_MELS) {
+    if (!this.config) return Array(N_MELS).fill(0);
+    const N_FFT = this.config.n_fft || 512;
+    const SR = this.config.sample_rate || 16e3;
+    if (!this.melFilterbank)
+      this.melFilterbank = _MLNoiseSuppressor.buildMelFilterbank(
+        N_MELS,
+        N_FFT,
+        SR
+      );
+    const melPow = new Float32Array(N_MELS);
+    for (let m = 0; m < N_MELS; m++) {
+      let s = 0;
+      const filt = this.melFilterbank[m];
+      for (let k = 0; k < filt.length && k < powerSpec.length; k++)
+        s += filt[k] * powerSpec[k];
+      melPow[m] = s;
+    }
+    let maxP = 1e-10;
+    for (let m = 0; m < N_MELS; m++) if (melPow[m] > maxP) maxP = melPow[m];
+    const refDb = 10 * Math.log10(maxP);
+    const out = new Array(N_MELS);
+    for (let m = 0; m < N_MELS; m++) {
+      const db = 10 * Math.log10(melPow[m] + 1e-10) - refDb;
+      out[m] = Math.max(0, Math.min(1, (db + 80) / 80));
+    }
+    return out;
+  }
+  /**
+   * Run model inference asynchronously.
+   * Updates cachedFftGains (per-FFT-bin gains) — audio thread applies them each hop.
+   * Never awaited from processAudioSync; inferenceInFlight prevents overlapping calls.
+   */
+  async runInferenceAsync(historySnapshot, SEQ_LEN, N_MELS) {
+    this.inferenceInFlight = true;
+    try {
+      const histLen = historySnapshot.length;
+      const padCount = SEQ_LEN - histLen;
+      const flat = new Array(SEQ_LEN * N_MELS).fill(0);
+      for (let f = 0; f < histLen; f++)
+        for (let m = 0; m < N_MELS; m++)
+          flat[(padCount + f) * N_MELS + m] = historySnapshot[f][m];
+      const N_FFT = this.config.n_fft || 512;
+      const SR = this.config.sample_rate || 16e3;
+      const bins = N_FFT / 2 + 1;
+      const inp = tf.tensor(flat, [1, SEQ_LEN, N_MELS]);
+      const out = this.model.predict(inp);
+      const maskFlat = new Float32Array(await out.data());
+      inp.dispose();
+      out.dispose();
+      const mask40 = new Float32Array(N_MELS);
+      for (let m = 0; m < N_MELS; m++)
+        mask40[m] = maskFlat[(SEQ_LEN - 1) * N_MELS + m];
+      const smoothed = this.applyTemporalSmoothing(mask40);
+      if (!this.melFilterbank)
+        this.melFilterbank = _MLNoiseSuppressor.buildMelFilterbank(
+          N_MELS,
+          N_FFT,
+          SR
+        );
+      const gains = new Float32Array(bins);
+      const filtTotal = new Float32Array(bins);
+      for (let m = 0; m < N_MELS; m++) {
+        const filt = this.melFilterbank[m];
+        for (let k = 0; k < filt.length && k < bins; k++) {
+          gains[k] += filt[k] * smoothed[m];
+          filtTotal[k] += filt[k];
+        }
+      }
+      for (let k = 0; k < bins; k++) {
+        gains[k] = filtTotal[k] > 1e-8 ? gains[k] / filtTotal[k] : 1;
+        gains[k] = Math.max(0, Math.min(1, gains[k]));
+      }
+      this.cachedFftGains = gains;
+    } catch {
+    } finally {
+      this.inferenceInFlight = false;
+    }
+  }
+  /**
+   * Downsample audio buffer (e.g., 48kHz → 16kHz)
+   * Simple linear interpolation for speed
+   */
+  downsample(input, ratio) {
+    const outputLength = Math.floor(input.length / ratio);
+    const output = new Float32Array(outputLength);
+    for (let i = 0; i < outputLength; i++) {
+      const srcIndex = i * ratio;
+      const srcIndexFloor = Math.floor(srcIndex);
+      const frac = srcIndex - srcIndexFloor;
+      if (srcIndexFloor + 1 < input.length) {
+        output[i] = input[srcIndexFloor] * (1 - frac) + input[srcIndexFloor + 1] * frac;
+      } else {
+        output[i] = input[srcIndexFloor];
+      }
+    }
+    return output;
+  }
+  /**
+   * Upsample audio buffer (e.g., 16kHz → 48kHz)
+   * Linear interpolation to match original length
+   */
+  upsample(input, ratio, targetLength) {
+    const output = new Float32Array(targetLength);
+    for (let i = 0; i < targetLength; i++) {
+      const srcIndex = i / ratio;
+      const srcIndexFloor = Math.floor(srcIndex);
+      const frac = srcIndex - srcIndexFloor;
+      if (srcIndexFloor + 1 < input.length) {
+        output[i] = input[srcIndexFloor] * (1 - frac) + input[srcIndexFloor + 1] * frac;
+      } else if (srcIndexFloor < input.length) {
+        output[i] = input[srcIndexFloor];
+      } else {
+        output[i] = input[input.length - 1];
+      }
+    }
+    return output;
+  }
+  /**
+   * Extract mel-spectrogram features matching the training pipeline exactly:
+   *   librosa.feature.melspectrogram(n_fft, hop_length, n_mels) — values from config
+   *   → power_to_db(ref=np.max)
+   *   → (mel_db + 80) / 80  clipped to [0, 1]
+   * No z-score normalisation applied (model trained on raw [0,1] values).
+   *
+   * Config driven: works with 16kHz/40mels or 48kHz/128mels depending on model_config.json
+   */
+  extractFeatures(audio) {
+    if (!this.config) return [[Array(128).fill(0)][0]];
+    const N_FFT = this.config?.n_fft || 2048;
+    const HOP = this.config.hop_length || 256;
+    const N_MELS = this.config.n_mels || 128;
+    const SR = this.config.sample_rate || 48e3;
+    if (!this.melFilterbank) {
+      this.melFilterbank = _MLNoiseSuppressor.buildMelFilterbank(
+        N_MELS,
+        N_FFT,
+        SR
+      );
+    }
+    const hannWindow = new Float32Array(N_FFT);
+    for (let i = 0; i < N_FFT; i++) {
+      hannWindow[i] = 0.5 * (1 - Math.cos(2 * Math.PI * i / (N_FFT - 1)));
+    }
+    const numFrames = Math.max(1, Math.floor((audio.length - N_FFT) / HOP) + 1);
+    const features = [];
+    this.lastComplexFrames = [];
+    for (let fi = 0; fi < numFrames; fi++) {
+      const start = fi * HOP;
+      const frame = new Float32Array(N_FFT);
+      for (let i = 0; i < N_FFT; i++) {
+        frame[i] = (start + i < audio.length ? audio[start + i] : 0) * hannWindow[i];
+      }
+      const { real: fftReal, imag: fftImag } = _MLNoiseSuppressor.fftForward(frame);
+      const bins = N_FFT / 2 + 1;
+      this.lastComplexFrames.push({
+        real: fftReal.slice(0, bins),
+        imag: fftImag.slice(0, bins)
+      });
+      const powerSpec = new Float32Array(bins);
+      for (let k = 0; k < bins; k++) {
+        powerSpec[k] = fftReal[k] * fftReal[k] + fftImag[k] * fftImag[k];
+      }
+      const melPower = new Float32Array(N_MELS);
+      for (let m = 0; m < N_MELS; m++) {
+        let sum2 = 0;
+        const filt = this.melFilterbank[m];
+        for (let k = 0; k < filt.length; k++) sum2 += filt[k] * powerSpec[k];
+        melPower[m] = sum2;
+      }
+      let maxPow = 1e-10;
+      for (let m = 0; m < N_MELS; m++)
+        if (melPower[m] > maxPow) maxPow = melPower[m];
+      const refDb = 10 * Math.log10(maxPow);
+      const melNorm = new Array(N_MELS);
+      for (let m = 0; m < N_MELS; m++) {
+        const db = 10 * Math.log10(melPower[m] + 1e-10) - refDb;
+        melNorm[m] = Math.max(0, Math.min(1, (db + 80) / 80));
+      }
+      features.push(melNorm);
+    }
+    return features;
+  }
+  /**
+   * Cooley-Tukey radix-2 FFT — returns full complex spectrum.
+   * Accepts optional imaginary input for use as IFFT building block.
+   * frameReal.length must be a power of 2.
+   */
+  static fftForward(frameReal, frameImag) {
+    const N = frameReal.length;
+    const real = new Float32Array(frameReal);
+    const imag = frameImag ? new Float32Array(frameImag) : new Float32Array(N);
+    let j = 0;
+    for (let i = 1; i < N; i++) {
+      let bit = N >> 1;
+      while (j & bit) {
+        j ^= bit;
+        bit >>= 1;
+      }
+      j ^= bit;
+      if (i < j) {
+        let tmp = real[i];
+        real[i] = real[j];
+        real[j] = tmp;
+        tmp = imag[i];
+        imag[i] = imag[j];
+        imag[j] = tmp;
+      }
+    }
+    for (let len = 2; len <= N; len <<= 1) {
+      const halfLen = len >> 1;
+      const ang = -2 * Math.PI / len;
+      const wRe = Math.cos(ang);
+      const wIm = Math.sin(ang);
+      for (let i = 0; i < N; i += len) {
+        let curRe = 1, curIm = 0;
+        for (let k = 0; k < halfLen; k++) {
+          const uRe = real[i + k], uIm = imag[i + k];
+          const vRe = real[i + k + halfLen] * curRe - imag[i + k + halfLen] * curIm;
+          const vIm = real[i + k + halfLen] * curIm + imag[i + k + halfLen] * curRe;
+          real[i + k] = uRe + vRe;
+          imag[i + k] = uIm + vIm;
+          real[i + k + halfLen] = uRe - vRe;
+          imag[i + k + halfLen] = uIm - vIm;
+          const newRe = curRe * wRe - curIm * wIm;
+          curIm = curRe * wIm + curIm * wRe;
+          curRe = newRe;
+        }
+      }
+    }
+    return { real, imag };
+  }
+  /**
+   * IFFT via conjugate trick: ifft(X) = conj(fft(conj(X))) / N
+   * Returns the real part of the time-domain signal.
+   */
+  static ifftFromComplex(real, imag) {
+    const N = real.length;
+    const conjImag = new Float32Array(N);
+    for (let i = 0; i < N; i++) conjImag[i] = -imag[i];
+    const { real: outReal} = _MLNoiseSuppressor.fftForward(
+      real,
+      conjImag
+    );
+    const output = new Float32Array(N);
+    for (let i = 0; i < N; i++) {
+      output[i] = outReal[i] / N;
+    }
+    return output;
+  }
+  /**
+   * Build an N-band triangular mel filterbank matching librosa's defaults.
+   * Uses Slaney mel scale (htk=False, librosa default): linear below 1 kHz,
+   * logarithmic above. This matches librosa.feature.melspectrogram used in
+   * Colab training — HTK formula would produce different band-frequency
+   * assignments and degrade suppression quality.
+   */
+  static buildMelFilterbank(nMels, nFft, sr) {
+    const bins = nFft / 2 + 1;
+    const F_SP = 200 / 3;
+    const MIN_LOG_HZ = 1e3;
+    const MIN_LOG_MEL = MIN_LOG_HZ / F_SP;
+    const LOGSTEP = Math.log(6.4) / 27;
+    const hzToMel = (hz) => hz < MIN_LOG_HZ ? hz / F_SP : MIN_LOG_MEL + Math.log(hz / MIN_LOG_HZ) / LOGSTEP;
+    const melToHz = (mel) => mel < MIN_LOG_MEL ? mel * F_SP : MIN_LOG_HZ * Math.exp(LOGSTEP * (mel - MIN_LOG_MEL));
+    const melMin = hzToMel(0);
+    const melMax = hzToMel(sr / 2);
+    const melPts = new Float32Array(nMels + 2);
+    for (let i = 0; i < nMels + 2; i++) {
+      melPts[i] = melToHz(melMin + i / (nMels + 1) * (melMax - melMin));
+    }
+    const fftFreqs = new Float32Array(bins);
+    for (let k = 0; k < bins; k++) fftFreqs[k] = k * sr / nFft;
+    const filters = [];
+    for (let m = 0; m < nMels; m++) {
+      const filt = new Float32Array(bins);
+      const left = melPts[m];
+      const center = melPts[m + 1];
+      const right = melPts[m + 2];
+      for (let k = 0; k < bins; k++) {
+        const f = fftFreqs[k];
+        if (f >= left && f <= center) {
+          filt[k] = (f - left) / (center - left + 1e-10);
+        } else if (f > center && f <= right) {
+          filt[k] = (right - f) / (right - center + 1e-10);
+        }
+      }
+      filters.push(filt);
+    }
+    return filters;
+  }
+  /**
+   * Apply temporal smoothing to the 40-band mel mask.
+   *
+   * Standard IRM smoothing: alpha weighted toward the PREVIOUS mask (heavy weight)
+   * to prevent "musical noise" — rapid per-band gain changes that create tonal
+   * artifacts. SMOOTHING_ALPHA=0.85 means 85% previous + 15% new each frame.
+   *
+   * BUG FIX: the old code had `alpha * current + (1-alpha) * prev` which was
+   * effectively 85% tracking the current mask — almost no smoothing, causing chirps.
+   */
+  applyTemporalSmoothing(currentMask, participantId = "__default__") {
+    const smoothed = new Float32Array(currentMask.length);
+    const prev = this.prevMaskMap.get(participantId);
+    if (!prev || prev.length !== currentMask.length) {
+      const init = new Float32Array(currentMask);
+      this.prevMaskMap.set(participantId, init);
+      return init;
+    }
+    for (let i = 0; i < currentMask.length; i++) {
+      smoothed[i] = this.SMOOTHING_ALPHA * prev[i] + (1 - this.SMOOTHING_ALPHA) * currentMask[i];
+      smoothed[i] = Math.max(0, Math.min(1, smoothed[i]));
+    }
+    this.prevMaskMap.set(participantId, smoothed);
+    return smoothed;
+  }
+  /**
+   * Apply the 40-band spectral mask via STFT → gain → ISTFT (overlap-add).
+   *
+   * Replaces the old applyMaskToAudio which incorrectly used frequency-domain mask
+   * values as time-domain sample gains — producing distortion rather than clean
+   * suppression. Correct approach:
+   *   1. Map 40-band mel mask → per-FFT-bin gain via transpose mel filterbank
+   *   2. Apply gains to the saved complex STFT frames
+   *   3. Reconstruct via synthesis Hann window + overlap-add
+   */
+  applyMaskViaOLA(audio, mask40, N_FFT, HOP, N_MELS) {
+    if (!this.melFilterbank || this.lastComplexFrames.length === 0) {
+      return audio;
+    }
+    const bins = N_FFT / 2 + 1;
+    const fftGains = new Float32Array(bins);
+    const filtTotals = new Float32Array(bins);
+    for (let m = 0; m < N_MELS; m++) {
+      const filt = this.melFilterbank[m];
+      for (let k = 0; k < filt.length && k < bins; k++) {
+        fftGains[k] += filt[k] * mask40[m];
+        filtTotals[k] += filt[k];
+      }
+    }
+    for (let k = 0; k < bins; k++) {
+      fftGains[k] = filtTotals[k] > 1e-8 ? fftGains[k] / filtTotals[k] : 1;
+      fftGains[k] = Math.max(0.3, Math.min(1, fftGains[k]));
+    }
+    const hannWindow = new Float32Array(N_FFT);
+    for (let i = 0; i < N_FFT; i++) {
+      hannWindow[i] = 0.5 * (1 - Math.cos(2 * Math.PI * i / (N_FFT - 1)));
+    }
+    const output = new Float32Array(audio.length);
+    const normFactor = new Float32Array(audio.length);
+    for (let fi = 0; fi < this.lastComplexFrames.length; fi++) {
+      const start = fi * HOP;
+      const { real: origReal, imag: origImag } = this.lastComplexFrames[fi];
+      const maskedReal = new Float32Array(N_FFT);
+      const maskedImag = new Float32Array(N_FFT);
+      for (let k = 0; k < bins; k++) {
+        maskedReal[k] = origReal[k] * fftGains[k];
+        maskedImag[k] = origImag[k] * fftGains[k];
+        if (k > 0 && k < N_FFT / 2) {
+          maskedReal[N_FFT - k] = maskedReal[k];
+          maskedImag[N_FFT - k] = -maskedImag[k];
+        }
+      }
+      const reconstructed = _MLNoiseSuppressor.ifftFromComplex(
+        maskedReal,
+        maskedImag
+      );
+      for (let i = 0; i < N_FFT; i++) {
+        const pos = start + i;
+        if (pos < audio.length) {
+          output[pos] += reconstructed[i] * hannWindow[i];
+          normFactor[pos] += hannWindow[i] * hannWindow[i];
+        }
+      }
+    }
+    for (let i = 0; i < output.length; i++) {
+      output[i] = normFactor[i] > 1e-10 ? output[i] / normFactor[i] : audio[i];
+    }
+    return output;
+  }
+  /**
+   * Reset processing state (call when participant reconnects or audio track resets)
+   */
+  reset() {
+    this.prevMaskMap.clear();
+    this.melFrameHistory = [];
+    this.lastComplexFrames = [];
+    this.inRing = new Float32Array(8192);
+    this.inRingLen = 0;
+    this.outAccum = new Float32Array(16384);
+    this.outNorm = new Float32Array(16384);
+    this.cachedFftGains = null;
+    this.inferenceInFlight = false;
+  }
+  /**
+   * Check if ML processor is ready
+   */
+  isReady() {
+    return this.isInitialized && this.model !== null;
+  }
+  /**
+   * Return the loaded model config so callers (e.g. AudioWorkletNode setup)
+   * can read n_fft, hop_length, n_mels, sample_rate, sequence_length.
+   */
+  getModelConfig() {
+    return this.config;
+  }
+  /**
+   * Run one inference pass from pre-computed mel features and return per-FFT-bin
+   * gains. Called by SpatialAudioChannel for each AudioWorkletNode message.
+   *
+   * @param features  Flat Float32Array of shape [SEQ_LEN × N_MELS] (row-major).
+   *                  Produced by the AudioWorklet processor and transferred via postMessage.
+   * @param seqLen    Sequence length (default from config).
+   * @param nMels     Number of mel bands (default from config).
+   * @returns         Float32Array of length N_FFT/2+1 with per-bin gains in [0,1].
+   */
+  async computeGainsFromFeatures(features, seqLen, nMels, participantId = "__default__") {
+    if (!this.model || !this.config) {
+      const bins2 = (this.config?.n_fft || 512) / 2 + 1;
+      return new Float32Array(bins2).fill(1);
+    }
+    const N_FFT = this.config.n_fft || 512;
+    const SR = this.config.sample_rate || 16e3;
+    const bins = N_FFT / 2 + 1;
+    try {
+      const inp = tf.tensor(Array.from(features), [
+        1,
+        seqLen,
+        nMels
+      ]);
+      const out = this.model.predict(inp);
+      const maskFlat = new Float32Array(await out.data());
+      inp.dispose();
+      out.dispose();
+      const rawMask = new Float32Array(nMels);
+      for (let m = 0; m < nMels; m++) {
+        rawMask[m] = Math.max(
+          0,
+          Math.min(1, maskFlat[(seqLen - 1) * nMels + m])
+        );
+      }
+      let rawMax = 0;
+      for (let m = 0; m < nMels; m++) {
+        if (rawMask[m] > rawMax) rawMax = rawMask[m];
+      }
+      if (rawMax < 5e-3) {
+        const passthroughCount = _MLNoiseSuppressor._passthroughCount || 0;
+        _MLNoiseSuppressor._passthroughCount = passthroughCount + 1;
+        const lastPassthroughLog = _MLNoiseSuppressor._lastPassthroughLog || 0;
+        if (Date.now() - lastPassthroughLog > 2e3) {
+          _MLNoiseSuppressor._lastPassthroughLog = Date.now();
+          console.warn(
+            `[ML] \u274C PASSTHROUGH (rawMax=${rawMax.toFixed(5)}) \u2014 model output near-zero. Count since last log: ${passthroughCount}. Weights likely NOT loaded. Check [MLNoiseSuppressor] weight name dump above.`
+          );
+          _MLNoiseSuppressor._passthroughCount = 0;
+        }
+        const passthrough = new Float32Array(bins).fill(1);
+        return passthrough;
+      }
+      let isSpeechFrame = rawMax >= 0.108;
+      const SF_HOLDOVER = 8;
+      const sfMap = _MLNoiseSuppressor._sfHoldoverMap || (_MLNoiseSuppressor._sfHoldoverMap = /* @__PURE__ */ new Map());
+      const sfHold = sfMap.get(participantId) || 0;
+      if (isSpeechFrame) {
+        sfMap.set(participantId, SF_HOLDOVER);
+      } else if (sfHold > 0) {
+        isSpeechFrame = true;
+        sfMap.set(participantId, sfHold - 1);
+      } else {
+        sfMap.set(participantId, 0);
+      }
+      const smoothed = this.applyTemporalSmoothing(rawMask, participantId);
+      if (!this.melFilterbank) {
+        this.melFilterbank = _MLNoiseSuppressor.buildMelFilterbank(
+          nMels,
+          N_FFT,
+          SR
+        );
+      }
+      const gains = new Float32Array(bins);
+      const filtTotal = new Float32Array(bins);
+      for (let m = 0; m < nMels; m++) {
+        const filt = this.melFilterbank[m];
+        for (let k = 0; k < filt.length && k < bins; k++) {
+          gains[k] += filt[k] * smoothed[m];
+          filtTotal[k] += filt[k];
+        }
+      }
+      for (let k = 0; k < bins; k++) {
+        gains[k] = filtTotal[k] > 1e-8 ? gains[k] / filtTotal[k] : 1;
+        gains[k] = Math.max(0, Math.min(1, gains[k]));
+      }
+      const IRM_SPEECH_FLOOR = 0.05;
+      if (isSpeechFrame) {
+        for (let k = 1; k < bins; k++) {
+          gains[k] = Math.max(IRM_SPEECH_FLOOR, gains[k]);
+        }
+      }
+      gains[0] = isSpeechFrame ? 1 : 0;
+      const now = Date.now();
+      const lastLog = _MLNoiseSuppressor._lastGainLog || /* @__PURE__ */ new Map();
+      const lastT = lastLog.get(participantId) || 0;
+      if (!isSpeechFrame || now - lastT > 1e3) {
+        lastLog.set(participantId, now);
+        _MLNoiseSuppressor._lastGainLog = lastLog;
+        let gainSum = 0;
+        for (let k = 1; k < bins; k++) gainSum += gains[k];
+        const meanIRM = gainSum / (bins - 1);
+        const suppPct = ((1 - meanIRM) * 100).toFixed(0);
+        console.log(
+          `[ML] ${isSpeechFrame ? "\u{1F399}\uFE0F SPEECH" : "\u{1F507} NOISE "} p=${participantId.substring(0, 8)} rawMax=${rawMax.toFixed(3)} suppression=${suppPct}% gate=${gains[0].toFixed(0)}`
+        );
+      }
+      return gains;
+    } catch {
+      return new Float32Array(bins).fill(1);
+    }
+  }
+  /**
+   * Get model info
+   */
+  getInfo() {
+    return {
+      initialized: this.isInitialized,
+      backend: tf.getBackend(),
+      modelLoaded: this.model !== null
+    };
+  }
+  /**
+   * Remove per-participant smoothing state when a participant disconnects.
+   * Keeps prevMaskMap from growing unboundedly in long sessions.
+   */
+  clearParticipantSmoothingState(participantId) {
+    this.prevMaskMap.delete(participantId);
+  }
+  /**
+   * Cleanup resources
+   */
+  dispose() {
+    if (this.model) {
+      this.model.dispose();
+      this.model = null;
+    }
+    this.prevMaskMap.clear();
+    this.isInitialized = false;
+  }
+};
+
+// src/utils/debug.ts
+var isDebugEnabled = () => typeof window !== "undefined" && window.ODYSSEY_DEBUG === true;
+var debugLog = (category, message, data) => {
+  if (!isDebugEnabled()) return;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+  if (data !== void 0) {
+    console.log(`[${timestamp}][SDK:${category}] ${message}`, data);
+  } else {
+    console.log(`[${timestamp}][SDK:${category}] ${message}`);
+  }
+};
+
+// src/channels/spatial/SpatialAudioChannel.ts
+function createSpatialAudioManager(config) {
+  const distanceConfig = {
+    ...DEFAULT_SPATIAL_CONFIG,
+    ...config?.distance
+  };
+  ({
+    ...config?.denoiser
+  });
+  const audioContext = new AudioContext({ sampleRate: 48e3 });
+  const resumeOnGesture = () => {
+    if (audioContext.state === "suspended") {
+      audioContext.resume().catch(() => {
+      });
+    }
+    document.removeEventListener("click", resumeOnGesture);
+    document.removeEventListener("keydown", resumeOnGesture);
+    document.removeEventListener("touchstart", resumeOnGesture);
+  };
+  document.addEventListener("click", resumeOnGesture);
+  document.addEventListener("keydown", resumeOnGesture);
+  document.addEventListener("touchstart", resumeOnGesture);
+  const masterGainNode = audioContext.createGain();
+  masterGainNode.gain.value = 2.5;
+  const masterCompressor = audioContext.createDynamicsCompressor();
+  masterCompressor.threshold.value = 0;
+  masterCompressor.knee.value = 0;
+  masterCompressor.ratio.value = 1;
+  masterCompressor.attack.value = 3e-3;
+  masterCompressor.release.value = 0.25;
+  masterGainNode.connect(masterCompressor);
+  masterCompressor.connect(audioContext.destination);
+  const participantNodes = /* @__PURE__ */ new Map();
+  const listenerState = {
+    position: { x: 0, y: 0, z: 0 },
+    right: { x: 1, z: 0 },
+    initialized: false
+  };
+  const positionCache = createPositionSnapCache(0.3);
+  const panSmoother = createPanSmoother();
+  let isMasterMuted = false;
+  const lastGainValues = /* @__PURE__ */ new Map();
+  const lastPanValues = /* @__PURE__ */ new Map();
+  const GAIN_CHANGE_THRESHOLD = 0.02;
+  const PAN_CHANGE_THRESHOLD = 0.03;
+  const lastUpdateTime = /* @__PURE__ */ new Map();
+  const MIN_UPDATE_INTERVAL_MS = 50;
+  let mlNoiseSuppressor = null;
+  let noiseSuppressionMode = "none";
+  const inferenceInFlight = /* @__PURE__ */ new Set();
+  let workletRegistered = false;
+  let workletUrl = null;
+  let outgoingDenoiseChain = null;
+  function createPanner() {
+    const panner = audioContext.createPanner();
+    panner.panningModel = "HRTF";
+    panner.distanceModel = "inverse";
+    panner.refDistance = distanceConfig.refDistance;
+    panner.maxDistance = distanceConfig.maxDistance;
+    panner.rolloffFactor = distanceConfig.rolloffFactor;
+    panner.coneInnerAngle = 360;
+    panner.coneOuterAngle = 360;
+    panner.coneOuterGain = 0.3;
+    return panner;
+  }
+  function createMonoChain() {
+    const monoSplitter = audioContext.createChannelSplitter(2);
+    const monoGainL = audioContext.createGain();
+    const monoGainR = audioContext.createGain();
+    const monoMerger = audioContext.createChannelMerger(1);
+    const stereoUpmixer = audioContext.createChannelMerger(2);
+    monoGainL.gain.value = 0.5;
+    monoGainR.gain.value = 0.5;
+    return { monoSplitter, monoGainL, monoGainR, monoMerger, stereoUpmixer };
+  }
+  function createParticipantCompressor() {
+    const comp = audioContext.createDynamicsCompressor();
+    comp.threshold.value = -30;
+    comp.knee.value = 12;
+    comp.ratio.value = 3;
+    comp.attack.value = 3e-3;
+    comp.release.value = 0.15;
+    return comp;
+  }
+  function createFilters() {
+    const highpassFilter = audioContext.createBiquadFilter();
+    highpassFilter.type = "highpass";
+    highpassFilter.frequency.value = 100;
+    highpassFilter.Q.value = 0.5;
+    const lowpassFilter = audioContext.createBiquadFilter();
+    lowpassFilter.type = "lowpass";
+    lowpassFilter.frequency.value = 1e4;
+    lowpassFilter.Q.value = 0.5;
+    const voiceBandFilter = audioContext.createBiquadFilter();
+    voiceBandFilter.type = "peaking";
+    voiceBandFilter.frequency.value = 180;
+    voiceBandFilter.Q.value = 0.5;
+    voiceBandFilter.gain.value = 0;
+    const dynamicLowpass = audioContext.createBiquadFilter();
+    dynamicLowpass.type = "lowpass";
+    dynamicLowpass.frequency.value = 12e3;
+    dynamicLowpass.Q.value = 0.5;
+    return { highpassFilter, lowpassFilter, voiceBandFilter, dynamicLowpass };
+  }
+  function teardownOutgoingDenoiseChain(chain = outgoingDenoiseChain) {
+    const localPid = "__local_outgoing__";
+    inferenceInFlight.delete(localPid);
+    if (mlNoiseSuppressor) {
+      mlNoiseSuppressor.clearParticipantSmoothingState(localPid);
+    }
+    if (!chain) return;
+    try {
+      chain.denoiseNode.port.close();
+    } catch {
+    }
+    try {
+      chain.source.disconnect();
+    } catch {
+    }
+    try {
+      chain.denoiseNode.disconnect();
+    } catch {
+    }
+    if (outgoingDenoiseChain === chain) {
+      outgoingDenoiseChain = null;
+    }
+  }
+  function getAudioContext() {
+    return audioContext;
+  }
+  async function setupParticipant(participantId, track, bypassSpatialization = false) {
+    if (audioContext.state === "suspended") {
+      await audioContext.resume();
+    }
+    const stream = new MediaStream([track]);
+    const source = audioContext.createMediaStreamSource(stream);
+    const panner = createPanner();
+    const stereoPanner = audioContext.createStereoPanner();
+    const { monoSplitter, monoGainL, monoGainR, monoMerger, stereoUpmixer } = createMonoChain();
+    const analyser = audioContext.createAnalyser();
+    const gain = audioContext.createGain();
+    const proximityGain = audioContext.createGain();
+    const comp = createParticipantCompressor();
+    const { highpassFilter, lowpassFilter, voiceBandFilter, dynamicLowpass } = createFilters();
+    gain.gain.value = 1;
+    proximityGain.gain.value = 1;
+    let noiseNode = null;
+    if (workletRegistered && mlNoiseSuppressor) {
+      const cfg = mlNoiseSuppressor.getModelConfig();
+      noiseNode = new AudioWorkletNode(audioContext, "noise-suppressor", {
+        numberOfInputs: 1,
+        numberOfOutputs: 1,
+        outputChannelCount: [1]
+      });
+      noiseNode.port.postMessage({
+        type: "config",
+        n_fft: cfg?.n_fft ?? 512,
+        hop_length: cfg?.hop_length ?? 80,
+        n_mels: cfg?.n_mels ?? 40,
+        sample_rate: cfg?.sample_rate ?? 16e3,
+        sequence_length: cfg?.sequence_length ?? 8
+      });
+      const workletRef = noiseNode;
+      const seqLen = cfg?.sequence_length ?? 8;
+      const nMels = cfg?.n_mels ?? 40;
+      const _pid = participantId;
+      noiseNode.port.onmessage = async (e) => {
+        if (e.data.type === "mel_features" && mlNoiseSuppressor?.isReady()) {
+          if (inferenceInFlight.has(_pid)) return;
+          inferenceInFlight.add(_pid);
+          try {
+            const gains = await mlNoiseSuppressor.computeGainsFromFeatures(
+              new Float32Array(e.data.features),
+              seqLen,
+              nMels,
+              _pid
+            );
+            try {
+              workletRef.port.postMessage({ type: "gains", gains }, [
+                gains.buffer
+              ]);
+            } catch {
+            }
+          } finally {
+            inferenceInFlight.delete(_pid);
+          }
+        }
+      };
+    }
+    if (noiseNode) {
+      source.connect(noiseNode);
+      noiseNode.connect(comp);
+    } else {
+      source.connect(comp);
+    }
+    comp.connect(highpassFilter);
+    highpassFilter.connect(voiceBandFilter);
+    voiceBandFilter.connect(lowpassFilter);
+    lowpassFilter.connect(dynamicLowpass);
+    dynamicLowpass.connect(proximityGain);
+    proximityGain.connect(monoSplitter);
+    monoSplitter.connect(monoGainL, 0);
+    monoSplitter.connect(monoGainR, 1);
+    monoGainL.connect(monoMerger, 0, 0);
+    monoGainR.connect(monoMerger, 0, 0);
+    monoMerger.connect(stereoUpmixer, 0, 0);
+    monoMerger.connect(stereoUpmixer, 0, 1);
+    stereoUpmixer.connect(analyser);
+    if (bypassSpatialization) {
+      analyser.connect(gain);
+    } else {
+      analyser.connect(stereoPanner);
+      stereoPanner.connect(gain);
+    }
+    gain.connect(masterGainNode);
+    participantNodes.set(participantId, {
+      source,
+      panner,
+      stereoPanner,
+      monoSplitter,
+      monoGainL,
+      monoGainR,
+      monoMerger,
+      stereoUpmixer,
+      analyser,
+      gain,
+      proximityGain,
+      compressor: comp,
+      highpassFilter,
+      lowpassFilter,
+      voiceBandFilter,
+      dynamicLowpass,
+      denoiseNode: noiseNode ?? void 0,
+      stream
+    });
+    lastGainValues.set(participantId, 1);
+    lastPanValues.set(participantId, 0);
+  }
+  function updateSpatialAudio(participantId, position, direction) {
+    const nodes = participantNodes.get(participantId);
+    if (!nodes?.panner) return;
+    if (!listenerState.initialized) return;
+    const now = performance.now();
+    const lastTime = lastUpdateTime.get(participantId) || 0;
+    if (now - lastTime < MIN_UPDATE_INTERVAL_MS) return;
+    lastUpdateTime.set(participantId, now);
+    const normalizedPos = normalizePositionUnits(position, distanceConfig.unit);
+    const snappedPos = positionCache.snap(normalizedPos, participantId);
+    const speakerHead = computeHeadPosition(snappedPos);
+    const listenerPos = listenerState.position;
+    const distance = getDistanceBetween(listenerPos, speakerHead);
+    if (distance >= distanceConfig.maxDistance) {
+      const lastGain2 = lastGainValues.get(participantId) ?? 1;
+      if (lastGain2 > 0.01) {
+        applyGainSmooth(nodes.gain, 0, audioContext, 0.1);
+        lastGainValues.set(participantId, 0);
+      }
+      return;
+    }
+    const rawPan = calculatePanFromPositions(
+      listenerPos,
+      speakerHead,
+      listenerState.right
+    );
+    const smoothedPan = panSmoother.smooth(participantId, rawPan);
+    const gainPercent = calculateLogarithmicGain(distance, {
+      minDistance: distanceConfig.refDistance,
+      maxDistance: distanceConfig.maxDistance
+    });
+    const gainValue = gainPercent / 100;
+    const panValue = smoothedPan;
+    const lastPan = lastPanValues.get(participantId) ?? 0;
+    const lastGain = lastGainValues.get(participantId) ?? 1;
+    const panChanged = Math.abs(panValue - lastPan) > PAN_CHANGE_THRESHOLD;
+    const gainChanged = Math.abs(gainValue - lastGain) > GAIN_CHANGE_THRESHOLD;
+    if (panChanged || gainChanged) {
+      const panDirection = panValue > 0.3 ? "RIGHT" : panValue < -0.3 ? "LEFT" : "CENTER";
+      const panPercent = Math.abs(panValue * 100).toFixed(0);
+      debugLog("SPATIAL", `${participantId.slice(0, 8)}`, {
+        dist: distance.toFixed(1) + "m",
+        gain: (gainValue * 100).toFixed(0) + "%",
+        pan: `${panPercent}% ${panDirection}`,
+        rawPan: rawPan.toFixed(2),
+        listenerRight: `(${listenerState.right.x.toFixed(2)}, ${listenerState.right.z.toFixed(2)})`
+      });
+    }
+    if (panChanged) {
+      applyStereoPanSmooth(nodes.stereoPanner, panValue, audioContext, 0.08);
+      lastPanValues.set(participantId, panValue);
+    }
+    const GAIN_THRESHOLD = 0.025;
+    const isFirstCalculation = !lastGainValues.has(participantId);
+    const significantChange = Math.abs(gainValue - lastGain) > GAIN_THRESHOLD;
+    if (isFirstCalculation || significantChange) {
+      applyGainSmooth(nodes.gain, gainValue, audioContext, 0.15);
+      lastGainValues.set(participantId, gainValue);
+    }
+  }
+  function setListenerFromLSD(listenerPos, cameraPos, lookAtPos, rot) {
+    const normalizedListener = normalizePositionUnits(
+      cameraPos,
+      distanceConfig.unit
+    );
+    const snappedListener = positionCache.snap(normalizedListener, "listener");
+    listenerState.position = snappedListener;
+    listenerState.initialized = true;
+    if (rot && typeof rot.y === "number") {
+      listenerState.right = calculateListenerRight(rot.y);
+    } else if (lookAtPos && cameraPos) {
+      const dx = lookAtPos.x - cameraPos.x;
+      const dz = lookAtPos.z - cameraPos.z;
+      const yawRadians = Math.atan2(dx, dz);
+      const yawDegrees = yawRadians * 180 / Math.PI;
+      listenerState.right = calculateListenerRight(yawDegrees);
+    }
+  }
+  function setParticipantSpatialization(participantId, enableSpatialization) {
+    const nodes = participantNodes.get(participantId);
+    if (!nodes) {
+      console.warn(
+        `[SpatialAudioChannel] Cannot set spatialization - no nodes for participant: ${participantId}`
+      );
+      return;
+    }
+    try {
+      const currentTime = audioContext.currentTime;
+      const fadeTime = 0.03;
+      if (enableSpatialization) {
+        nodes.analyser.connect(nodes.stereoPanner);
+        nodes.stereoPanner.connect(nodes.gain);
+        setTimeout(() => {
+          try {
+          } catch (e) {
+          }
+        }, fadeTime * 1e3);
+      } else {
+        nodes.analyser.connect(nodes.gain);
+        nodes.gain.gain.setTargetAtTime(1, currentTime, fadeTime);
+        nodes.stereoPanner.pan.setTargetAtTime(0, currentTime, fadeTime);
+        setTimeout(() => {
+          try {
+            nodes.stereoPanner.disconnect();
+          } catch (e) {
+          }
+        }, fadeTime * 1e3);
+      }
+    } catch (error) {
+      console.error(
+        `[SpatialAudioChannel] Error setting spatialization for ${participantId}:`,
+        error
+      );
+    }
+  }
+  function setParticipantMuted(participantId, muted) {
+    const nodes = participantNodes.get(participantId);
+    if (!nodes?.gain) return;
+    applyGainSmooth(nodes.gain, muted ? 0 : 1, audioContext, 0.05);
+  }
+  function setMasterMuted(muted) {
+    isMasterMuted = muted;
+    applyGainSmooth(masterGainNode, muted ? 0 : 1, audioContext, 0.05);
+  }
+  function getMasterMuted() {
+    return isMasterMuted;
+  }
+  function setListenerPosition(position, orientation) {
+    const normalizedPosition = normalizePositionUnits(position);
+    positionCache.snap(normalizedPosition, "listener");
+    listenerState.position = normalizedPosition;
+    if (orientation) {
+      const yawRadians = Math.atan2(orientation.forwardX, orientation.forwardZ);
+      const yawDegrees = yawRadians * 180 / Math.PI;
+      listenerState.right = calculateListenerRight(yawDegrees);
+    }
+    listenerState.initialized = true;
+  }
+  async function setupSpatialAudioForParticipant(participantId, track, bypassSpatialization) {
+    return setupParticipant(
+      participantId,
+      track,
+      bypassSpatialization || false
+    );
+  }
+  async function initializeMLNoiseSuppression(modelPath, workletUrlParam) {
+    if (workletUrlParam && !workletRegistered) {
+      try {
+        await audioContext.audioWorklet.addModule(workletUrlParam);
+        workletRegistered = true;
+        workletUrl = workletUrlParam;
+        console.log(
+          `[SpatialAudioChannel] AudioWorklet registered: ${workletUrlParam}`
+        );
+      } catch (e) {
+        console.warn(
+          "[SpatialAudioChannel] AudioWorklet registration failed \u2014 falling back to passthrough:",
+          e
+        );
+      }
+    }
+    mlNoiseSuppressor = createMLNoiseSuppressor();
+    await mlNoiseSuppressor.initialize(modelPath);
+    if (!mlNoiseSuppressor.isReady()) {
+      mlNoiseSuppressor = null;
+      throw new Error(
+        `[SpatialAudioChannel] ML model loaded from ${modelPath} but isReady() returned false`
+      );
+    }
+    noiseSuppressionMode = "ml";
+    console.log(
+      `[SpatialAudioChannel] ML noise suppression ACTIVE \u2014 model loaded from ${modelPath}`
+    );
+  }
+  async function enhanceOutgoingAudioTrack(track) {
+    if (track.kind !== "audio") return track;
+    if (!workletRegistered || !mlNoiseSuppressor?.isReady()) return track;
+    if (outgoingDenoiseChain && outgoingDenoiseChain.outputTrack.id === track.id && outgoingDenoiseChain.outputTrack.readyState === "live") {
+      return outgoingDenoiseChain.outputTrack;
+    }
+    if (outgoingDenoiseChain && outgoingDenoiseChain.inputTrack.id === track.id && outgoingDenoiseChain.outputTrack.readyState === "live") {
+      return outgoingDenoiseChain.outputTrack;
+    }
+    const cfg = mlNoiseSuppressor.getModelConfig();
+    if (!cfg) return track;
+    try {
+      if (audioContext.state === "suspended") {
+        await audioContext.resume();
+      }
+      const previousChain = outgoingDenoiseChain;
+      const stream = new MediaStream([track]);
+      const source = audioContext.createMediaStreamSource(stream);
+      const denoiseNode = new AudioWorkletNode(
+        audioContext,
+        "noise-suppressor",
+        {
+          numberOfInputs: 1,
+          numberOfOutputs: 1,
+          outputChannelCount: [1]
+        }
+      );
+      const destination = audioContext.createMediaStreamDestination();
+      denoiseNode.port.postMessage({
+        type: "config",
+        n_fft: cfg.n_fft ?? 512,
+        hop_length: cfg.hop_length ?? 80,
+        n_mels: cfg.n_mels ?? 40,
+        sample_rate: cfg.sample_rate ?? 16e3,
+        sequence_length: cfg.sequence_length ?? 8
+      });
+      const seqLen = cfg.sequence_length ?? 8;
+      const nMels = cfg.n_mels ?? 40;
+      const localPid = "__local_outgoing__";
+      const workletRef = denoiseNode;
+      denoiseNode.port.onmessage = async (e) => {
+        if (e.data.type === "mel_features" && mlNoiseSuppressor?.isReady()) {
+          if (inferenceInFlight.has(localPid)) return;
+          inferenceInFlight.add(localPid);
+          try {
+            const gains = await mlNoiseSuppressor.computeGainsFromFeatures(
+              new Float32Array(e.data.features),
+              seqLen,
+              nMels,
+              localPid
+            );
+            workletRef.port.postMessage({ type: "gains", gains }, [gains.buffer]);
+          } catch {
+          } finally {
+            inferenceInFlight.delete(localPid);
+          }
+        }
+      };
+      source.connect(denoiseNode);
+      denoiseNode.connect(destination);
+      const enhancedTrack = destination.stream.getAudioTracks()[0];
+      if (!enhancedTrack) {
+        try {
+          source.disconnect();
+        } catch {
+        }
+        try {
+          denoiseNode.disconnect();
+        } catch {
+        }
+        return track;
+      }
+      enhancedTrack.enabled = track.enabled;
+      track.addEventListener("ended", () => teardownOutgoingDenoiseChain(), {
+        once: true
+      });
+      enhancedTrack.addEventListener(
+        "ended",
+        () => teardownOutgoingDenoiseChain(),
+        { once: true }
+      );
+      outgoingDenoiseChain = {
+        inputTrack: track,
+        outputTrack: enhancedTrack,
+        source,
+        denoiseNode,
+        destination
+      };
+      if (previousChain) {
+        teardownOutgoingDenoiseChain(previousChain);
+      }
+      console.log(
+        "[SpatialAudioChannel] Local outgoing ML denoise ACTIVE (AudioWorklet)"
+      );
+      return enhancedTrack;
+    } catch (e) {
+      console.warn(
+        "[SpatialAudioChannel] Failed to enhance outgoing track, using original track:",
+        e
+      );
+      return track;
+    }
+  }
+  function getNoiseSuppressionMode() {
+    return noiseSuppressionMode;
+  }
+  function isMLModelLoaded() {
+    return mlNoiseSuppressor?.isReady() ?? false;
+  }
+  function removeParticipant(participantId) {
+    const nodes = participantNodes.get(participantId);
+    if (nodes) {
+      debugLog("AUDIO", `Removing participant: ${participantId.slice(0, 8)}`, {
+        totalBefore: participantNodes.size,
+        totalAfter: participantNodes.size - 1
+      });
+      nodes.denoiseNode?.port.close();
+      nodes.denoiseNode?.disconnect();
+      nodes.source.disconnect();
+      nodes.panner.disconnect();
+      nodes.stereoPanner.disconnect();
+      nodes.analyser.disconnect();
+      nodes.gain.disconnect();
+      participantNodes.delete(participantId);
+      panSmoother.clear(participantId);
+      positionCache.clear(participantId);
+      lastGainValues.delete(participantId);
+      lastPanValues.delete(participantId);
+      lastUpdateTime.delete(participantId);
+      inferenceInFlight.delete(participantId);
+      if (mlNoiseSuppressor) {
+        mlNoiseSuppressor.clearParticipantSmoothingState(participantId);
+      }
+    } else {
+      debugLog(
+        "AUDIO",
+        `Remove called but participant not found: ${participantId.slice(0, 8)}`
+      );
+    }
+  }
+  async function resumeAudioContext() {
+    if (audioContext.state === "suspended") {
+      await audioContext.resume();
+    }
+  }
+  function getAudioContextState() {
+    return audioContext.state;
+  }
+  function getParticipantAudioLevel(participantId) {
+    const nodes = participantNodes.get(participantId);
+    if (!nodes?.analyser) return 0;
+    const dataArray = new Uint8Array(nodes.analyser.frequencyBinCount);
+    nodes.analyser.getByteFrequencyData(dataArray);
+    let sum2 = 0;
+    for (let i = 0; i < dataArray.length; i++) {
+      sum2 += dataArray[i] * dataArray[i];
+    }
+    const rms = Math.sqrt(sum2 / dataArray.length);
+    return Math.min(100, Math.round(rms / 255 * 100));
+  }
+  function isParticipantSpeaking(participantId, threshold = 5) {
+    return getParticipantAudioLevel(participantId) > threshold;
+  }
+  function getActiveParticipants() {
+    return Array.from(participantNodes.keys());
+  }
+  function hasParticipant(participantId) {
+    return participantNodes.has(participantId);
+  }
+  function getParticipantCount() {
+    return participantNodes.size;
+  }
+  return {
+    getAudioContext,
+    setupParticipant,
+    setupSpatialAudioForParticipant,
+    updateSpatialAudio,
+    setListenerFromLSD,
+    setListenerPosition,
+    setParticipantSpatialization,
+    setParticipantMuted,
+    setMasterMuted,
+    getMasterMuted,
+    initializeMLNoiseSuppression,
+    enhanceOutgoingAudioTrack,
+    getNoiseSuppressionMode,
+    isMLModelLoaded,
+    removeParticipant,
+    resumeAudioContext,
+    getAudioContextState,
+    getParticipantAudioLevel,
+    isParticipantSpeaking,
+    getActiveParticipants,
+    hasParticipant,
+    getParticipantCount
+  };
+}
+
+// src/screen-share-live-in-space/screen-share-live-manager.ts
+function createScreenShareLiveManager(socket) {
+  let isBroadcasting = false;
+  let currentProducerId = null;
+  function findScreenshareProducerId(participant) {
+    for (const [producerId, producer] of participant.producers) {
+      if (producer.appData?.isScreenshare) {
+        return producerId;
+      }
+    }
+    return null;
+  }
+  async function startBroadcast(room, participant, serverUrl) {
+    if (!room || !participant) {
+      throw new Error("Must be in a room to start space live broadcast");
+    }
+    const screenshareProducerId = findScreenshareProducerId(participant);
+    if (!screenshareProducerId) {
+      throw new Error("No active screen share to broadcast to space");
+    }
+    return new Promise((resolve, reject) => {
+      const request = {
+        roomId: room.id,
+        producerId: screenshareProducerId,
+        participantId: participant.participantId,
+        userName: participant.userName || "Unknown"
+      };
+      const timestamp = Date.now();
+      socket.emit(
+        "start-space-live-broadcast",
+        request,
+        (response) => {
+          if (response.error) {
+            reject(new Error(response.error));
+          } else {
+            isBroadcasting = true;
+            currentProducerId = screenshareProducerId;
+            debugLog("SPACE-LIVE", "Started space live broadcast", {
+              producerId: screenshareProducerId
+            });
+            resolve({
+              producerId: screenshareProducerId,
+              roomId: room.id,
+              serverUrl,
+              timestamp
+            });
+          }
+        }
+      );
+    });
+  }
+  async function stopBroadcast(room, participantId) {
+    if (!room) {
+      isBroadcasting = false;
+      currentProducerId = null;
+      return;
+    }
+    return new Promise((resolve) => {
+      const request = {
+        roomId: room.id,
+        participantId
+      };
+      socket.emit("stop-space-live-broadcast", request, () => {
+        isBroadcasting = false;
+        currentProducerId = null;
+        debugLog("SPACE-LIVE", "Stopped space live broadcast");
+        resolve();
+      });
+    });
+  }
+  function getStatus(roomId, callback) {
+    if (!roomId) {
+      callback({ isActive: false });
+      return;
+    }
+    socket.emit("get-space-live-broadcast-status", { roomId }, callback);
+  }
+  function onBroadcastAvailable(callback) {
+    socket.on("space-live-broadcast-available", callback);
+  }
+  function onBroadcastStopped(callback) {
+    socket.on("space-live-broadcast-stopped", callback);
+  }
+  function removeListeners() {
+    socket.off("space-live-broadcast-available");
+    socket.off("space-live-broadcast-stopped");
+  }
+  function cleanup() {
+    isBroadcasting = false;
+    currentProducerId = null;
+    removeListeners();
+  }
+  return {
+    get isActive() {
+      return isBroadcasting;
+    },
+    get broadcastProducerId() {
+      return currentProducerId;
+    },
+    startBroadcast,
+    stopBroadcast,
+    getStatus,
+    onBroadcastAvailable,
+    onBroadcastStopped,
+    removeListeners,
+    cleanup
+  };
+}
+
+// src/core/room.ts
+function createRoomActions(ctx) {
+  const { socket, mediasoupManager, state, emitEvent } = ctx;
+  async function joinRoom(data) {
+    if (!socket.connected) {
+      await new Promise((resolve, reject) => {
+        const CONNECT_TIMEOUT_MS = 1e4;
+        const timer = setTimeout(() => {
+          socket.off("connect", onConnect);
+          socket.off("connect_error", onError);
+          reject(
+            new Error(
+              "[OdysseySDK] Connection timed out. Verify the server is reachable and your apiKey/userToken are valid."
+            )
+          );
+        }, CONNECT_TIMEOUT_MS);
+        const onConnect = () => {
+          clearTimeout(timer);
+          socket.off("connect_error", onError);
+          resolve();
+        };
+        const onError = (err) => {
+          clearTimeout(timer);
+          socket.off("connect", onConnect);
+          reject(new Error(`[OdysseySDK] Connection failed: ${err.message}`));
+        };
+        socket.once("connect", onConnect);
+        socket.once("connect_error", onError);
+      });
+    }
+    return new Promise((resolve, reject) => {
+      const handleRoomJoined = async (roomData) => {
+        try {
+          socket.off("room-joined", handleRoomJoined);
+          await mediasoupManager.loadDevice(roomData.routerRtpCapabilities);
+          await mediasoupManager.createSendTransport(roomData.participantId);
+          await mediasoupManager.createRecvTransport(roomData.participantId);
+          mediasoupManager.sendDeviceRtpCapabilities(roomData.participantId);
+          const localParticipantData = roomData.participants.find(
+            (p) => p.participantId === roomData.participantId
+          );
+          if (!localParticipantData) {
+            throw new Error("Could not find local participant in room data");
+          }
+          state.localParticipant = {
+            ...localParticipantData,
+            isLocal: true,
+            producers: /* @__PURE__ */ new Map(),
+            consumers: /* @__PURE__ */ new Map(),
+            currentChannel: "spatial"
+          };
+          state.room = { id: roomData.roomId, participants: /* @__PURE__ */ new Map() };
+          for (const pData of roomData.participants) {
+            const participant = {
+              ...pData,
+              isLocal: pData.participantId === state.localParticipant.participantId,
+              producers: /* @__PURE__ */ new Map(),
+              consumers: /* @__PURE__ */ new Map()
+            };
+            state.room.participants.set(pData.participantId, participant);
+          }
+          emitEvent("room-joined", roomData);
+          resolve(state.localParticipant);
+        } catch (error) {
+          socket.off("room-joined", handleRoomJoined);
+          reject(error);
+        }
+      };
+      socket.on("room-joined", handleRoomJoined);
+      socket.emit("join-room", data);
+    });
+  }
+  function leaveRoom() {
+    if (!socket.connected) return;
+    socket.emit("leave-room");
+    mediasoupManager.close();
+    socket.disconnect();
+    state.room = null;
+    state.localParticipant = null;
+    ctx.bus.removeAllListeners();
+  }
+  function updatePosition(position, direction, spatialData) {
+    if (state.localParticipant && state.room) {
+      state.localParticipant.position = position;
+      state.localParticipant.direction = direction;
+      socket.emit("update-position", {
+        participantId: state.localParticipant.participantId,
+        conferenceId: state.room.id,
+        roomId: state.room.id,
+        position,
+        direction,
+        rot: spatialData?.rot,
+        cameraDistance: spatialData?.cameraDistance,
+        screenPos: spatialData?.screenPos,
+        pan: spatialData?.pan,
+        dxLocal: spatialData?.dxLocal
+      });
+    }
+  }
+  function updateMediaState(mediaState) {
+    if (state.localParticipant && state.room) {
+      state.localParticipant.mediaState = mediaState;
+      socket.emit("update-media-state", {
+        participantId: state.localParticipant.participantId,
+        conferenceId: state.room.id,
+        roomId: state.room.id,
+        mediaState
+      });
+    }
+  }
+  return { joinRoom, leaveRoom, updatePosition, updateMediaState };
+}
+
+// src/producers/tracks.ts
+function createTrackActions(ctx) {
+  const { socket, state, mediasoupManager, updateMediaState } = ctx;
+  async function produceTrack(track, appData) {
+    const producer = await mediasoupManager.produce(track, appData);
+    if (state.localParticipant) {
+      state.localParticipant.producers.set(producer.id, producer);
+      if (track.kind === "audio") {
+        state.localParticipant.audioTrack = track;
+        state.localParticipant.mediaState.audio = true;
+      } else if (track.kind === "video") {
+        if (appData?.isScreenshare) {
+          state.localParticipant.screenshareTrack = track;
+          state.localParticipant.mediaState.sharescreen = true;
+        } else {
+          state.localParticipant.videoTrack = track;
+          state.localParticipant.mediaState.video = true;
+        }
+      }
+      updateMediaState(state.localParticipant.mediaState);
+    }
+    return producer;
+  }
+  async function recreateProducers() {
+    if (!state.localParticipant) return;
+    state.localParticipant.producers.clear();
+    const tracksToReproduce = [];
+    if (state.localParticipant.audioTrack && state.localParticipant.audioTrack.readyState === "live") {
+      tracksToReproduce.push({ track: state.localParticipant.audioTrack });
+    }
+    if (state.localParticipant.videoTrack && state.localParticipant.videoTrack.readyState === "live") {
+      tracksToReproduce.push({ track: state.localParticipant.videoTrack });
+    }
+    const screenshareTrack = state.localParticipant.screenshareTrack;
+    if (screenshareTrack && screenshareTrack.readyState === "live") {
+      tracksToReproduce.push({
+        track: screenshareTrack,
+        appData: { isScreenshare: true }
+      });
+    }
+    for (const { track, appData } of tracksToReproduce) {
+      try {
+        await produceTrack(track, appData);
+      } catch (error) {
+      }
+    }
+  }
+  async function stopScreenShare() {
+    if (!state.localParticipant || !state.room) return;
+    const screenshareTrack = state.localParticipant.screenshareTrack;
+    if (screenshareTrack) {
+      screenshareTrack.stop();
+      state.localParticipant.screenshareTrack = null;
+    }
+    for (const [producerId, producer] of state.localParticipant.producers) {
+      if (producer.appData?.isScreenshare) {
+        producer.close();
+        state.localParticipant.producers.delete(producerId);
+        break;
+      }
+    }
+    return new Promise((resolve) => {
+      socket.emit(
+        "stop-screenshare",
+        { participantId: state.localParticipant.participantId },
+        () => {
+          state.localParticipant.mediaState.sharescreen = false;
+          resolve();
+        }
+      );
+    });
+  }
+  async function stopVideoProducer() {
+    if (!state.localParticipant || !state.room) return;
+    const videoTrack = state.localParticipant.videoTrack;
+    if (videoTrack) {
+      videoTrack.stop();
+      state.localParticipant.videoTrack = void 0;
+    }
+    for (const [producerId, producer] of state.localParticipant.producers) {
+      if (producer.kind === "video" && !producer.appData?.isScreenshare) {
+        producer.close();
+        state.localParticipant.producers.delete(producerId);
+        break;
+      }
+    }
+    return new Promise((resolve) => {
+      socket.emit(
+        "stop-video",
+        { participantId: state.localParticipant.participantId },
+        () => {
+          state.localParticipant.mediaState.video = false;
+          resolve();
+        }
+      );
+    });
+  }
+  return { produceTrack, recreateProducers, stopScreenShare, stopVideoProducer };
+}
+
+// src/events/listeners.ts
+function registerSocketListeners(ctx) {
+  const { socket, state, mediasoupManager, spatialAudioManager, emitEvent } = ctx;
+  socket.on("all-participants-update", (payload) => {
+    if (!state.room) {
+      state.room = { id: payload.roomId, participants: /* @__PURE__ */ new Map() };
+    }
+    const activeParticipantIds = /* @__PURE__ */ new Set();
+    for (const snapshot of payload.participants) {
+      activeParticipantIds.add(snapshot.participantId);
+      let participant = state.room?.participants.get(snapshot.participantId);
+      const normalizedPosition = {
+        x: snapshot.position?.x ?? 0,
+        y: snapshot.position?.y ?? 0,
+        z: snapshot.position?.z ?? 0
+      };
+      const normalizedDirection = {
+        x: snapshot.direction?.x ?? 0,
+        y: snapshot.direction?.y ?? 0,
+        z: snapshot.direction?.z ?? 1
+      };
+      const normalizedMediaState = {
+        audio: snapshot.mediaState?.audio ?? false,
+        video: snapshot.mediaState?.video ?? false,
+        sharescreen: snapshot.mediaState?.sharescreen ?? false
+      };
+      if (!participant) {
+        participant = {
+          participantId: snapshot.participantId,
+          userId: snapshot.userId,
+          deviceId: snapshot.deviceId,
+          isLocal: state.localParticipant?.participantId === snapshot.participantId,
+          audioTrack: void 0,
+          videoTrack: void 0,
+          producers: /* @__PURE__ */ new Map(),
+          consumers: /* @__PURE__ */ new Map(),
+          position: normalizedPosition,
+          direction: normalizedDirection,
+          mediaState: normalizedMediaState
+        };
+      } else {
+        participant.userId = snapshot.userId;
+        participant.deviceId = snapshot.deviceId;
+        participant.position = normalizedPosition;
+        participant.direction = normalizedDirection;
+        participant.mediaState = normalizedMediaState;
+      }
+      participant.bodyHeight = snapshot.bodyHeight;
+      participant.bodyShape = snapshot.bodyShape;
+      participant.userName = snapshot.userName;
+      participant.userEmail = snapshot.userEmail;
+      participant.isLocal = state.localParticipant?.participantId === snapshot.participantId;
+      participant.currentChannel = snapshot.currentChannel || "spatial";
+      state.room?.participants.set(snapshot.participantId, participant);
+      if (participant.isLocal) {
+        state.localParticipant = participant;
+      }
+    }
+    if (state.room) {
+      for (const existingId of Array.from(state.room.participants.keys())) {
+        if (!activeParticipantIds.has(existingId)) {
+          state.room.participants.delete(existingId);
+        }
+      }
+    }
+    const normalizedParticipants = state.room ? Array.from(state.room.participants.values()) : [];
+    emitEvent("all-participants-update", normalizedParticipants);
+  });
+  socket.on("new-participant", (participantData) => {
+    if (state.room) {
+      const newParticipant = {
+        participantId: participantData.participantId,
+        userId: participantData.userId,
+        deviceId: participantData.deviceId,
+        position: participantData.position,
+        direction: participantData.direction,
+        mediaState: participantData.mediaState,
+        isLocal: false,
+        producers: /* @__PURE__ */ new Map(),
+        consumers: /* @__PURE__ */ new Map(),
+        bodyHeight: participantData.bodyHeight,
+        bodyShape: participantData.bodyShape,
+        userName: participantData.userName,
+        userEmail: participantData.userEmail
+      };
+      newParticipant.currentChannel = participantData.currentChannel || "spatial";
+      state.room.participants.set(
+        participantData.participantId,
+        newParticipant
+      );
+      emitEvent("new-participant", newParticipant);
+    }
+  });
+  socket.on("participant-left", (data) => {
+    if (state.room) {
+      state.room.participants.delete(data.participantId);
+      spatialAudioManager.removeParticipant(data.participantId);
+      emitEvent("participant-left", data.participantId);
+    }
+  });
+  socket.on(
+    "consumer-created",
+    async (data) => {
+      debugLog("CONSUMER", `Full data for ${data.userName}`, {
+        participantId: data.participantId,
+        position: data.position,
+        channel: data.currentChannel,
+        mediaState: data.mediaState
+      });
+      let consumer;
+      let track;
+      try {
+        const result = await mediasoupManager.consume(data);
+        consumer = result.consumer;
+        track = result.track;
+      } catch (err) {
+        console.warn(
+          `[SDK] consume() skipped for ${data.participantId?.substring(0, 8)} \u2014 transport not ready (${err?.message}).`
+        );
+        return;
+      }
+      let participant = state.room?.participants.get(data.participantId);
+      if (!participant && state.room) {
+        participant = {
+          participantId: data.participantId,
+          userId: data.participantId.split(":")[0] || data.participantId,
+          deviceId: data.participantId.split(":")[1] || data.participantId,
+          isLocal: false,
+          position: data.position,
+          direction: data.direction,
+          mediaState: data.mediaState,
+          producers: /* @__PURE__ */ new Map(),
+          consumers: /* @__PURE__ */ new Map(),
+          bodyHeight: data.bodyHeight,
+          bodyShape: data.bodyShape,
+          userName: data.userName,
+          userEmail: data.userEmail
+        };
+        participant.currentChannel = data.currentChannel || "spatial";
+        state.room.participants.set(data.participantId, participant);
+      }
+      if (participant) {
+        participant.position = data.position;
+        participant.direction = data.direction;
+        participant.mediaState = data.mediaState;
+        participant.currentChannel = data.currentChannel || participant.currentChannel || "spatial";
+        if (data.bodyHeight !== void 0)
+          participant.bodyHeight = data.bodyHeight;
+        if (data.bodyShape !== void 0)
+          participant.bodyShape = data.bodyShape;
+        if (data.userName !== void 0) participant.userName = data.userName;
+        if (data.userEmail !== void 0)
+          participant.userEmail = data.userEmail;
+        participant.consumers.set(consumer.id, consumer);
+        if (track.kind === "audio") {
+          participant.audioTrack = track;
+          const isLocalParticipant = participant.participantId === state.localParticipant?.participantId;
+          if (isLocalParticipant) {
+            return;
+          }
+          const participantChannel = participant.currentChannel || "spatial";
+          const isInHuddle = participantChannel !== "spatial";
+          await spatialAudioManager.setupSpatialAudioForParticipant(
+            participant.participantId,
+            track,
+            isInHuddle
+          );
+          mediasoupManager.resumeConsumer(consumer.id).then(() => {
+          }).catch((err) => {
+            console.error(`[SDK] Failed to resume consumer:`, err);
+          });
+        } else if (track.kind === "video") {
+          const isScreenshare = data.appData?.isScreenshare;
+          if (isScreenshare) {
+            participant.screenshareTrack = track;
+          } else {
+            participant.videoTrack = track;
+          }
+          const resumeWithRetry = async (retries = 3) => {
+            for (let i = 0; i < retries; i++) {
+              try {
+                await mediasoupManager.resumeConsumer(consumer.id);
+                return;
+              } catch (err) {
+                if (i < retries - 1) {
+                  await new Promise((resolve) => setTimeout(resolve, 200));
+                } else {
+                  console.error(
+                    `[SDK] Failed to resume video consumer after ${retries} attempts:`,
+                    err
+                  );
+                }
+              }
+            }
+          };
+          resumeWithRetry();
+        }
+        emitEvent("consumer-created", {
+          participant,
+          track,
+          consumer,
+          isScreenshare: data.appData?.isScreenshare,
+          appData: data.appData
+        });
+      }
+    }
+  );
+  socket.on(
+    "participant-position-updated",
+    (data) => {
+      const participant = state.room?.participants.get(data.participantId);
+      if (participant) {
+        debugLog(
+          "POSITION",
+          `${data.userName || data.participantId.slice(0, 8)}`,
+          {
+            pos: {
+              x: data.position?.x?.toFixed(1),
+              y: data.position?.y?.toFixed(1)
+            },
+            channel: data.currentChannel
+          }
+        );
+        participant.position = data.position;
+        participant.direction = data.direction;
+        participant.mediaState = data.mediaState;
+        if (data.bodyHeight !== void 0)
+          participant.bodyHeight = data.bodyHeight;
+        if (data.bodyShape !== void 0)
+          participant.bodyShape = data.bodyShape;
+        if (data.userName !== void 0) participant.userName = data.userName;
+        if (data.userEmail !== void 0)
+          participant.userEmail = data.userEmail;
+        if (data.currentChannel !== void 0)
+          participant.currentChannel = data.currentChannel;
+        if (data.pan !== void 0) participant.pan = data.pan;
+        if (data.dxLocal !== void 0)
+          participant.dxLocal = data.dxLocal;
+        if (data.rot !== void 0) participant.rot = data.rot;
+        const participantChannel = participant.currentChannel;
+        const isInHuddle = participantChannel !== "spatial";
+        if (!isInHuddle) {
+          spatialAudioManager.updateSpatialAudio(
+            data.participantId,
+            data.position,
+            data.rot || data.direction
+          );
+        }
+        emitEvent("participant-position-updated", participant);
+      }
+    }
+  );
+  socket.on(
+    "participant-media-state-updated",
+    (data) => {
+      const participant = state.room?.participants.get(data.participantId);
+      if (participant) {
+        participant.mediaState = data.mediaState;
+        participant.position = data.position;
+        participant.direction = data.direction;
+        emitEvent("participant-media-state-updated", participant);
+      }
+    }
+  );
+  socket.on("error", (error) => {
+    emitEvent("error", error);
+  });
+  socket.on("disconnect", () => {
+    emitEvent("disconnected");
+  });
+  socket.on("huddle-invite-received", (data) => {
+    emitEvent("huddle-invite-received", data);
+  });
+  socket.on("private-huddle-started", (data) => {
+    if (state.localParticipant) {
+      state.localParticipant.currentChannel = data.channelId;
+    }
+    emitEvent("private-huddle-started", data);
+  });
+  socket.on("huddle-updated", (data) => {
+    emitEvent("huddle-updated", data);
+  });
+  socket.on("huddle-invite-rejected", (data) => {
+    emitEvent("huddle-invite-rejected", data);
+  });
+  socket.on("huddle-ended", (data) => {
+    if (state.localParticipant) {
+      state.localParticipant.currentChannel = "spatial";
+    }
+    emitEvent("huddle-ended", data);
+  });
+  socket.on("participant-channel-changed", (data) => {
+    const participant = state.room?.participants.get(data.participantId);
+    if (participant) {
+      participant.currentChannel = data.channelId;
+      const isInSpatialChannel = data.channelId === "spatial";
+      if (participant.audioTrack) {
+        spatialAudioManager.setParticipantSpatialization(
+          data.participantId,
+          isInSpatialChannel
+        );
+      }
+      const myChannel = state.localParticipant?.currentChannel || "spatial";
+      const theirChannel = data.channelId || "spatial";
+      if (myChannel !== theirChannel) {
+        participant.screenshareTrack = null;
+      }
+    }
+    if (state.localParticipant?.participantId === data.participantId) {
+      state.localParticipant.currentChannel = data.channelId;
+    }
+    emitEvent("participant-channel-changed", data);
+  });
+  socket.on(
+    "consumer-closed",
+    (data) => {
+      emitEvent("consumer-closed", data);
+    }
+  );
+  socket.on("mute-requested", (data) => {
+    emitEvent("mute-requested", data);
+  });
+  socket.on(
+    "space-live-broadcast-available",
+    (data) => {
+      debugLog("SPACE-LIVE-BROADCAST", "Broadcast available", data);
+      emitEvent("space-live-broadcast-available", data);
+    }
+  );
+  socket.on("space-live-broadcast-stopped", (data) => {
+    debugLog("SPACE-LIVE-BROADCAST", "Broadcast stopped", data);
+    emitEvent("space-live-broadcast-stopped", data);
+  });
+}
+function createChatManager(options) {
+  const { serverUrl } = options;
+  let client = null;
+  let activeChannel = null;
+  let onMessageCallback = null;
+  function handleNewMessage(event) {
+    const message = event.message;
+    if (message && onMessageCallback) {
+      onMessageCallback(message);
+    }
+  }
+  async function fetchStreamKey(userId) {
+    const response = await fetch(
+      `${serverUrl}/api/chat/stream-key?userId=${userId}`,
+      {
+        method: "GET",
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to get stream key: HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    if (!data.success || !data.consumerKey) {
+      throw new Error("Stream key not available");
+    }
+    return data.consumerKey;
+  }
+  async function fetchStreamToken(userId) {
+    const response = await fetch(`${serverUrl}/api/chat/stream-token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ userId })
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to get stream token: HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    if (!data.success || !data.token) {
+      throw new Error("Stream token not available");
+    }
+    return data.token;
+  }
+  async function init(data) {
+    const { userId, userName, channelId, channelName } = data;
+    const key = await fetchStreamKey(userId);
+    client = StreamChat.getInstance(key);
+    const token = await fetchStreamToken(userId);
+    debugLog("Chat", `Connecting user ${userId}...`);
+    const user = await client.connectUser(
+      { id: userId, name: userName || userId },
+      token
+    );
+    if (!user) throw new Error("Could not connect chat user");
+    debugLog("Chat", "Connected successfully");
+    const channel = client.channel("livestream", channelId, {
+      name: channelName || channelId
+    });
+    await channel.watch();
+    channel.on("message.new", handleNewMessage);
+    activeChannel = channel;
+  }
+  async function sendMessage(message) {
+    if (!activeChannel) throw new Error("Chat not initialized");
+    return activeChannel.sendMessage(message);
+  }
+  async function sendNotification(data) {
+    return sendMessage({
+      notification: {
+        isNotification: true,
+        text: data.text,
+        participants: data.participants,
+        sender: data.sender
+      }
+    });
+  }
+  async function leave() {
+    if (activeChannel) {
+      activeChannel.off("message.new", handleNewMessage);
+      await activeChannel.stopWatching();
+    }
+    if (client) {
+      await client.disconnectUser();
+    }
+    activeChannel = null;
+    client = null;
+  }
+  function getChannel() {
+    return activeChannel;
+  }
+  return {
+    init,
+    sendMessage,
+    sendNotification,
+    leave,
+    getChannel,
+    // Expose for SDK event wiring
+    set onMessage(cb) {
+      onMessageCallback = cb;
+    }
+  };
+}
+
+// src/index.ts
+var ODYSSEY_SERVER_URL = "https://dev-spatial-comms.2x22.com";
+function createOdysseySpatialComms(apiKey, userToken, spatialOptions) {
+  console.log(
+    `[OdysseySDK] \u{1F517} Server URL: ${ODYSSEY_SERVER_URL}`
+  );
+  if (!apiKey || typeof apiKey !== "string" || !apiKey.trim()) {
+    throw new Error("[OdysseySDK] A valid apiKey is required.");
+  }
+  const bus = createEventBus();
+  const socket = io(ODYSSEY_SERVER_URL, {
+    transports: ["websocket"],
+    auth: { apiKey, token: userToken }
+  });
+  let sessionStart = null;
+  socket.on("connect", () => {
+    sessionStart = Date.now();
+    debugLog("Connection", `\u2705 Connected to server socketId=${socket.id}`);
+  });
+  socket.on(
+    "connect_error",
+    (err) => debugLog("Connection", `\u274C Connection error: ${err.message}`)
+  );
+  socket.on("disconnect", (reason) => {
+    if (sessionStart !== null) {
+      const secs = Math.floor((Date.now() - sessionStart) / 1e3);
+      const mins = Math.floor(secs / 60);
+      const remainSecs = secs % 60;
+      const duration = mins > 0 ? `${mins}m ${remainSecs}s` : `${remainSecs}s`;
+      console.log(
+        `[OdysseySDK] \u{1F4CA} Session ended \u2014 duration: ${duration} (${secs}s raw)`
+      );
+      sessionStart = null;
+    }
+    debugLog("Connection", `\u{1F50C} Disconnected reason=${reason}`);
+  });
+  const mediasoupManager = createMediasoupManager(socket);
+  const spatialAudioManager = createSpatialAudioManager(spatialOptions);
+  const screenShareLiveManager = createScreenShareLiveManager(socket);
+  const state = { room: null, localParticipant: null };
+  function emitEvent(event, ...args) {
+    bus.emit(event, ...args);
+  }
+  bus.emit("connected");
+  const chatManager = createChatManager({
+    serverUrl: ODYSSEY_SERVER_URL
+  });
+  const {
+    joinRoom: _joinRoom,
+    leaveRoom: _leaveRoom,
+    updatePosition,
+    updateMediaState
+  } = createRoomActions({ socket, bus, mediasoupManager, state, emitEvent });
+  const { produceTrack, recreateProducers, stopScreenShare, stopVideoProducer } = createTrackActions({ socket, state, mediasoupManager, updateMediaState });
+  registerSocketListeners({
+    socket,
+    state,
+    mediasoupManager,
+    spatialAudioManager,
+    emitEvent
+  });
+  async function joinRoom(data) {
+    return _joinRoom(data);
+  }
+  function leaveRoom() {
+    chatManager.leave().catch(() => {
+    });
+    _leaveRoom();
+  }
+  async function initializeMLNoiseSuppression(modelPath, workletUrl) {
+    try {
+      await spatialAudioManager.initializeMLNoiseSuppression(
+        modelPath,
+        workletUrl
+      );
+    } catch (error) {
+    }
+  }
+  async function resumeAudio() {
+    await spatialAudioManager.resumeAudioContext();
+  }
+  function getAudioContextState() {
+    return spatialAudioManager.getAudioContextState();
+  }
+  async function enhanceOutgoingAudioTrack(track) {
+    return spatialAudioManager.enhanceOutgoingAudioTrack(track);
+  }
+  function isMLNoiseSuppressionActive() {
+    return spatialAudioManager.getNoiseSuppressionMode() === "ml";
+  }
+  function getNoiseSuppressionMode() {
+    return spatialAudioManager.getNoiseSuppressionMode();
+  }
+  function setMasterMuted(muted) {
+    spatialAudioManager.setMasterMuted(muted);
+  }
+  function getMasterMuted() {
+    return spatialAudioManager.getMasterMuted();
+  }
+  async function startSpaceLiveBroadcast() {
+    if (!state.localParticipant || !state.room) {
+      throw new Error("Must be in a room to start space live broadcast");
+    }
+    return screenShareLiveManager.startBroadcast(
+      state.room,
+      state.localParticipant,
+      ODYSSEY_SERVER_URL
+    );
+  }
+  async function stopSpaceLiveBroadcast() {
+    return screenShareLiveManager.stopBroadcast(
+      state.room,
+      state.localParticipant?.participantId
+    );
+  }
+  function getSpaceLiveBroadcastStatus(callback) {
+    screenShareLiveManager.getStatus(state.room?.id || null, callback);
+  }
+  function setListenerPosition(position, orientation) {
+    spatialAudioManager.setListenerPosition(position, orientation);
+  }
+  function setListenerFromLSD(listenerPos, cameraPos, lookAtPos, rot) {
+    spatialAudioManager.setListenerFromLSD(
+      listenerPos,
+      cameraPos,
+      lookAtPos,
+      rot
+    );
+  }
+  async function sendHuddleInvite(toParticipantId) {
+    if (!state.localParticipant || !state.room)
+      return { success: false, error: "Not in a room" };
+    return new Promise((resolve) => {
+      socket.emit(
+        "send-huddle-invite",
+        {
+          fromParticipantId: state.localParticipant.participantId,
+          toParticipantId,
+          roomId: state.room.id
+        },
+        (response) => resolve(response)
+      );
+    });
+  }
+  async function acceptHuddleInvite(inviteId) {
+    if (!state.localParticipant)
+      return { success: false, error: "Not in a room" };
+    return new Promise((resolve) => {
+      socket.emit(
+        "accept-huddle-invite",
+        { inviteId, participantId: state.localParticipant.participantId },
+        (response) => resolve(response)
+      );
+    });
+  }
+  async function rejectHuddleInvite(inviteId) {
+    if (!state.localParticipant)
+      return { success: false, error: "Not in a room" };
+    return new Promise((resolve) => {
+      socket.emit(
+        "reject-huddle-invite",
+        { inviteId, participantId: state.localParticipant.participantId },
+        (response) => resolve(response)
+      );
+    });
+  }
+  async function joinHuddle() {
+    if (!state.localParticipant || !state.room)
+      return { success: false, error: "Not in a room" };
+    return new Promise((resolve) => {
+      socket.emit(
+        "join-huddle",
+        {
+          participantId: state.localParticipant.participantId,
+          roomId: state.room.id
+        },
+        (response) => {
+          if (response.success && state.localParticipant) {
+            state.localParticipant.currentChannel = response.channelId;
+          }
+          resolve(response);
+        }
+      );
+    });
+  }
+  async function leaveHuddle() {
+    if (!state.localParticipant || !state.room)
+      return { success: false, error: "Not in a room" };
+    return new Promise((resolve) => {
+      socket.emit(
+        "leave-huddle",
+        {
+          participantId: state.localParticipant.participantId,
+          roomId: state.room.id
+        },
+        (response) => {
+          if (response.success && state.localParticipant) {
+            state.localParticipant.currentChannel = response.channelId;
+          }
+          resolve(response);
+        }
+      );
+    });
+  }
+  async function getParticipantChannel(participantId) {
+    return new Promise((resolve) => {
+      socket.emit(
+        "get-participant-channel",
+        { participantId },
+        (response) => {
+          resolve(response.channelId || "spatial");
+        }
+      );
+    });
+  }
+  async function muteParticipant(participantId) {
+    if (!state.localParticipant || !state.room)
+      return { success: false, error: "Not in a room" };
+    return new Promise((resolve) => {
+      socket.emit(
+        "mute-participant",
+        {
+          targetParticipantId: participantId,
+          roomId: state.room.id,
+          requesterId: state.localParticipant.participantId
+        },
+        (response) => resolve(response)
+      );
+    });
+  }
+  function getCurrentChannel() {
+    return state.localParticipant?.currentChannel || "spatial";
+  }
+  return {
+    get room() {
+      return state.room;
+    },
+    on: (event, listener) => {
+      bus.on(event, listener);
+    },
+    off: (event, listener) => {
+      bus.off(event, listener);
+    },
+    initializeMLNoiseSuppression,
+    joinRoom,
+    leaveRoom,
+    resumeAudio,
+    getAudioContextState,
+    enhanceOutgoingAudioTrack,
+    isMLNoiseSuppressionActive,
+    getNoiseSuppressionMode,
+    setMasterMuted,
+    getMasterMuted,
+    produceTrack,
+    recreateProducers,
+    updatePosition,
+    updateMediaState,
+    stopScreenShare,
+    stopVideoProducer,
+    startSpaceLiveBroadcast,
+    stopSpaceLiveBroadcast,
+    getSpaceLiveBroadcastStatus,
+    get isSpaceLiveBroadcasting() {
+      return screenShareLiveManager.isActive;
+    },
+    setListenerPosition,
+    setListenerFromLSD,
+    sendHuddleInvite,
+    acceptHuddleInvite,
+    rejectHuddleInvite,
+    joinHuddle,
+    leaveHuddle,
+    getParticipantChannel,
+    muteParticipant,
+    getCurrentChannel,
+    chat: {
+      init: (data) => chatManager.init(data),
+      sendMessage: (message) => chatManager.sendMessage(message),
+      sendNotification: (data) => chatManager.sendNotification(data),
+      leave: () => chatManager.leave(),
+      onMessage: (callback) => {
+        chatManager.onMessage = callback;
+      }
+    }
+  };
+}
+var SpatialCommsSDK = {
+  /**
+   * Create a new SDK client instance.
+   * @param apiKey        SDK API key issued by Odyssey (from payment service)
+   * @param userToken     JWT access token for the authenticated user (from SSO)
+   * @param spatialOptions  Optional spatial audio configuration
+   */
+  create(apiKey, userToken, spatialOptions) {
+    return createOdysseySpatialComms(apiKey, userToken, spatialOptions);
+  }
+};
+
+export { SpatialCommsSDK, createOdysseySpatialComms };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map