@ephia/dova-sdk 1.0.0

package/dist/chunk-LXMCRXXF.js

@@ -0,0 +1,778 @@
+import {
+  EphiaSdkError
+} from "./chunk-N7U5M3VZ.js";
+
+// src/core/transport/LiveKitTransport.ts
+import {
+  Room,
+  RoomEvent,
+  DataPacket_Kind,
+  LocalAudioTrack,
+  ConnectionState,
+  ConnectionQuality,
+  MediaDeviceFailure,
+  AudioPresets,
+  Track
+} from "livekit-client";
+import { ephiaWireServerEventSchema, PROTOCOL_VERSION } from "ephia-protocol";
+
+// src/debug/sdk-debug-collector.ts
+function isDev() {
+  if (typeof window === "undefined") return false;
+  try {
+    return process.env.NODE_ENV === "development";
+  } catch {
+    return false;
+  }
+}
+var collector = null;
+function getSdkDebugCollector() {
+  if (!isDev()) return null;
+  if (!collector) {
+    collector = {
+      events: [],
+      rawEvents: [],
+      states: {},
+      pushEvent(source, type, payload) {
+        const entry = { ts: performance.now(), source, type, payload };
+        this.events.push(entry);
+        if (this.events.length > 3e3) this.events.shift();
+      },
+      pushRawEvent(source, type, payload) {
+        const entry = { ts: performance.now(), source, type, payload };
+        this.rawEvents.push(entry);
+        if (this.rawEvents.length > 3e3) this.rawEvents.shift();
+      },
+      setState(source, state) {
+        this.states[source] = { ts: performance.now(), source, state };
+      }
+    };
+    window.__ephia_sdk_debug__ = collector;
+  }
+  return collector;
+}
+function dbgRawEvent(source, type, payload) {
+  getSdkDebugCollector()?.pushRawEvent(source, type, payload);
+}
+function dbgState(source, state) {
+  getSdkDebugCollector()?.setState(source, state);
+}
+
+// src/core/transport/LiveKitTransport.ts
+var TOPIC_CLIENT_CONTROL = "ephia.client.control";
+var TOPIC_SERVER_EVENT = "ephia.server.event";
+var TRACK_MIC = "ephia-microphone";
+var textDecoder = new TextDecoder();
+var textEncoder = new TextEncoder();
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+var RECONNECT_POLICY = {
+  nextRetryDelayInMs(ctx) {
+    if (ctx.retryCount >= 10) return null;
+    const base = Math.min(300 * 2 ** ctx.retryCount, 3e4);
+    const jitter = Math.floor(Math.random() * 1e3);
+    return base + jitter;
+  }
+};
+function uuid() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+var LiveKitTransport = class {
+  room = null;
+  _eventCallbacks = /* @__PURE__ */ new Set();
+  _serverEventCallbacks = /* @__PURE__ */ new Set();
+  _stateCallbacks = /* @__PURE__ */ new Set();
+  _errorCallbacks = /* @__PURE__ */ new Set();
+  _state = {
+    status: "idle",
+    localAudioPublished: false,
+    localAudioMuted: false,
+    reconnectCount: 0
+  };
+  _localAudioTrack = null;
+  _krispProcessor = null;
+  _sessionId = "";
+  _clientSeq = 0;
+  async connect(params) {
+    if (!this.room) {
+      this.room = new Room(this._roomOptions());
+    } else if (this.room.state === ConnectionState.Connected || this.room.state === ConnectionState.Reconnecting || this.room.state === ConnectionState.Connecting) {
+      await this.disconnect("reconnect");
+      this.room = new Room(this._roomOptions());
+    } else {
+      this.room.removeAllListeners();
+    }
+    this._sessionId = params.sessionId ?? params.roomName;
+    this._clientSeq = 0;
+    this._setState({ status: "connecting", roomName: params.roomName });
+    this._attachRoomListeners(params);
+    await this.room.connect(params.livekitUrl, params.token);
+    if (this.room.state !== ConnectionState.Connected) {
+      throw new EphiaSdkError(
+        "transport.connect_failed",
+        `LiveKit room not connected: ${this.room.state}`
+      );
+    }
+    this._setState({
+      status: "connected",
+      roomName: this.room.name,
+      participantIdentity: this.room.localParticipant?.identity
+    });
+  }
+  async prepareConnection(url, token) {
+    if (!this.room) {
+      this.room = new Room(this._roomOptions());
+    }
+    await this.room.prepareConnection(url, token);
+  }
+  async disconnect(_reason) {
+    if (this.room) {
+      const room = this.room;
+      await room.disconnect();
+      room.removeAllListeners();
+      this.room = null;
+    }
+    this._localAudioTrack = null;
+    this._setState({
+      status: "disconnected",
+      localAudioPublished: false,
+      localAudioMuted: false
+    });
+  }
+  async sendMessage(message) {
+    if (!this.room) {
+      throw new EphiaSdkError("transport.not_connected", "Cannot send message: room is null");
+    }
+    if (this.room.state !== ConnectionState.Connected) {
+      throw new EphiaSdkError("transport.not_connected", `Cannot send message: room state is ${this.room.state}`);
+    }
+    const wire = this._toWireClientEvent(message);
+    await this.room.localParticipant.publishData(textEncoder.encode(JSON.stringify(wire)), {
+      reliable: true,
+      topic: TOPIC_CLIENT_CONTROL
+    });
+  }
+  onEvent(callback) {
+    this._eventCallbacks.add(callback);
+    return () => this._eventCallbacks.delete(callback);
+  }
+  onServerEvent(callback) {
+    this._serverEventCallbacks.add(callback);
+    return () => this._serverEventCallbacks.delete(callback);
+  }
+  onTransportState(callback) {
+    this._stateCallbacks.add(callback);
+    return () => this._stateCallbacks.delete(callback);
+  }
+  onError(callback) {
+    this._errorCallbacks.add(callback);
+    return () => this._errorCallbacks.delete(callback);
+  }
+  getState() {
+    return { ...this._state };
+  }
+  getLocalAudioPublication() {
+    return this._localAudioTrack;
+  }
+  async publishAudio(track, options) {
+    if (this._localAudioTrack) {
+      await this.unpublishAudio();
+    }
+    if (!this.room) {
+      throw new EphiaSdkError("transport.connect_failed", "Cannot publish audio: room is null");
+    }
+    if (this.room.state !== ConnectionState.Connected) {
+      throw new EphiaSdkError("transport.connect_failed", `Room not connected: ${this.room.state}`);
+    }
+    this._localAudioTrack = await this.room.localParticipant.publishTrack(track, {
+      name: TRACK_MIC,
+      source: Track.Source.Microphone,
+      audioPreset: AudioPresets.speech
+    });
+    this._setState({ localAudioMuted: false });
+    const tryKrisp = options?.enableNoiseFilter === true;
+    if (tryKrisp && this._localAudioTrack?.track instanceof LocalAudioTrack) {
+      try {
+        const { KrispNoiseFilter, isKrispNoiseFilterSupported } = await import("@livekit/krisp-noise-filter");
+        if (isKrispNoiseFilterSupported()) {
+          const processor = KrispNoiseFilter();
+          await this._localAudioTrack.track.setProcessor(processor);
+          this._krispProcessor = processor;
+          await track.applyConstraints({
+            echoCancellation: false,
+            noiseSuppression: false,
+            autoGainControl: false
+          });
+          this._setState({ krispActive: true });
+        }
+      } catch (err) {
+        console.warn("[LiveKitTransport] Krisp initialization failed \u2014 fallback WebRTC natif", err);
+      }
+    }
+  }
+  async unpublishAudio() {
+    if (this._localAudioTrack && this.room) {
+      if (this._krispProcessor && this._localAudioTrack.track instanceof LocalAudioTrack) {
+        try {
+          await this._localAudioTrack.track.stopProcessor();
+        } catch {
+        }
+        this._krispProcessor = null;
+      }
+      await this.room.localParticipant.unpublishTrack(this._localAudioTrack.track);
+      this._localAudioTrack = null;
+      this._setState({ krispActive: false, localAudioMuted: false });
+    }
+  }
+  async performRpc(method, payload, timeout = 3e3) {
+    if (!this.room) {
+      throw new EphiaSdkError("transport.not_connected", "Cannot perform RPC: room not available");
+    }
+    return this.room.localParticipant.performRpc({
+      destinationIdentity: "ephia-transcribe-agent",
+      method,
+      payload: JSON.stringify(payload),
+      responseTimeout: timeout
+    });
+  }
+  async switchActiveDevice(kind, deviceId) {
+    if (!this.room) {
+      throw new EphiaSdkError("transport.not_connected", "Cannot switch device: room not available");
+    }
+    return this.room.switchActiveDevice(kind, deviceId);
+  }
+  // ------------------------------------------------------------------
+  // Internals
+  // ------------------------------------------------------------------
+  _toWireClientEvent(message) {
+    const msgType = message.type;
+    return {
+      protocolVersion: PROTOCOL_VERSION,
+      type: msgType,
+      eventId: uuid(),
+      sessionId: this._sessionId,
+      clientSeq: ++this._clientSeq,
+      sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: this._toWireClientPayload(message)
+    };
+  }
+  _toWireClientPayload(message) {
+    const msgType = message.type;
+    const payload = message.payload;
+    const raw = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+    if (msgType === "session.reset") {
+      const scope = raw.scope === "target" ? "target" : "global";
+      const targetId = asString(raw.targetId) ?? asString(raw.target_id);
+      const reason = asString(raw.reason) ?? "user_explicit";
+      if (scope === "target" && !targetId) {
+        throw new EphiaSdkError(
+          "protocol.invalid_event",
+          "session.reset target scope requires targetId"
+        );
+      }
+      return scope === "target" && targetId ? { scope: "target", targetId, reason } : { scope: "global", reason };
+    }
+    if (msgType === "session.target.changed") {
+      return { targetId: asString(raw.targetId) ?? asString(raw.target_id) ?? "" };
+    }
+    if (msgType === "session.editor_context.update") {
+      return {
+        targetId: asString(raw.targetId) ?? asString(raw.target_id) ?? "",
+        documentEmpty: raw.documentEmpty ?? raw.document_empty ?? false,
+        insertionMode: raw.insertionMode ?? raw.insertion_mode ?? "append",
+        leftContext: raw.leftContext ?? raw.left_context ?? "",
+        rightContext: raw.rightContext ?? raw.right_context ?? "",
+        selectedText: raw.selectedText ?? raw.selected_text,
+        cursorOffset: raw.cursorOffset ?? raw.cursor_offset
+      };
+    }
+    return raw;
+  }
+  _attachRoomListeners(_params) {
+    if (!this.room) return;
+    this.room.on(RoomEvent.ConnectionStateChanged, (lkState) => {
+      dbgRawEvent("livekit", "RoomEvent.ConnectionStateChanged", { state: lkState });
+      switch (lkState) {
+        case ConnectionState.Connected:
+          this._setState({ status: "connected" });
+          break;
+        case ConnectionState.Disconnected:
+          this._setState({ status: "disconnected" });
+          break;
+        case ConnectionState.Reconnecting:
+          this._setState({
+            status: "reconnecting",
+            reconnectCount: this._state.reconnectCount + 1
+          });
+          break;
+      }
+      dbgState("livekit.transport", this._state);
+    });
+    this.room.on(RoomEvent.Reconnecting, () => {
+      dbgRawEvent("livekit", "RoomEvent.Reconnecting", {});
+      this._setState({
+        status: "reconnecting",
+        reconnectCount: this._state.reconnectCount + 1
+      });
+      dbgState("livekit.transport", this._state);
+    });
+    this.room.on(RoomEvent.Reconnected, () => {
+      dbgRawEvent("livekit", "RoomEvent.Reconnected", {});
+      this._setState({ status: "reconnected" });
+      dbgState("livekit.transport", this._state);
+    });
+    this.room.on(RoomEvent.ConnectionQualityChanged, (quality) => {
+      dbgRawEvent("livekit", "RoomEvent.ConnectionQualityChanged", { quality });
+      const mapped = quality === ConnectionQuality.Excellent ? "excellent" : quality === ConnectionQuality.Good ? "good" : quality === ConnectionQuality.Poor ? "poor" : "unknown";
+      this._setState({ connectionQuality: mapped });
+      dbgState("livekit.transport", this._state);
+    });
+    this.room.on(RoomEvent.LocalTrackPublished, () => {
+      dbgRawEvent("livekit", "RoomEvent.LocalTrackPublished", {});
+      this._setState({ localAudioPublished: true });
+      dbgState("livekit.transport", this._state);
+    });
+    this.room.on(RoomEvent.LocalTrackUnpublished, () => {
+      dbgRawEvent("livekit", "RoomEvent.LocalTrackUnpublished", {});
+      this._setState({ localAudioPublished: false });
+      dbgState("livekit.transport", this._state);
+    });
+    this.room.on(RoomEvent.LocalAudioSilenceDetected, () => {
+      dbgRawEvent("livekit", "RoomEvent.LocalAudioSilenceDetected", {});
+      this._setState({ localAudioMuted: true });
+      dbgState("livekit.transport", this._state);
+    });
+    this.room.on(RoomEvent.MediaDevicesError, (err) => {
+      dbgRawEvent("livekit", "RoomEvent.MediaDevicesError", { error: err instanceof Error ? err.message : String(err) });
+      const failure = MediaDeviceFailure.getFailure(err);
+      switch (failure) {
+        case MediaDeviceFailure.PermissionDenied:
+          this._emitError("audio.permission_denied", "Autorisation micro refus\xE9e \u2014 v\xE9rifier les param\xE8tres du navigateur");
+          break;
+        case MediaDeviceFailure.NotFound:
+          this._emitError("audio.no_input_device", "Aucun microphone d\xE9tect\xE9");
+          break;
+        case MediaDeviceFailure.DeviceInUse:
+          this._emitError("audio.device_in_use", "Micro occup\xE9 par une autre application");
+          break;
+        default:
+          this._emitError("audio.no_input_device", err instanceof Error ? err.message : String(err));
+      }
+    });
+    this.room.on(RoomEvent.DataReceived, (payload, _participant, kind, topic) => {
+      const isReliable = kind === DataPacket_Kind.RELIABLE;
+      const isLossy = kind === DataPacket_Kind.LOSSY;
+      if (topic !== TOPIC_SERVER_EVENT) return;
+      if (!isReliable && !isLossy) return;
+      try {
+        const data = JSON.parse(textDecoder.decode(payload));
+        dbgRawEvent("livekit", "RoomEvent.DataReceived", { topic, kind, data });
+        const parsed = ephiaWireServerEventSchema.safeParse(data);
+        if (!parsed.success) {
+          console.warn("[LiveKitTransport] invalid server event schema (ignored):", parsed.error.issues);
+          return;
+        }
+        this._handleWireServerEvent(parsed.data);
+      } catch (err) {
+        console.warn("[LiveKitTransport] failed to parse data channel payload", err);
+      }
+    });
+  }
+  _handleWireServerEvent(event) {
+    this._serverEventCallbacks.forEach((cb) => cb(event));
+  }
+  _roomOptions() {
+    return {
+      adaptiveStream: false,
+      dynacast: false,
+      disconnectOnPageLeave: false,
+      reconnectPolicy: RECONNECT_POLICY,
+      audioCaptureDefaults: {
+        echoCancellation: true,
+        noiseSuppression: true,
+        autoGainControl: true
+      }
+    };
+  }
+  _setState(partial) {
+    const next = { ...this._state, ...partial };
+    let changed = false;
+    for (const key in partial) {
+      if (next[key] !== this._state[key]) {
+        changed = true;
+        break;
+      }
+    }
+    if (!changed) return;
+    this._state = next;
+    this._stateCallbacks.forEach((cb) => cb(this._state));
+  }
+  _emitError(code, message) {
+    const err = new EphiaSdkError(code, message);
+    this._errorCallbacks.forEach((cb) => cb(err));
+  }
+};
+
+// src/core/client/client-state.ts
+var initialClientState = {
+  status: "idle",
+  sessionId: null,
+  roomName: null,
+  error: null,
+  isMicEnabled: false
+};
+
+// src/core/session/session-machine.ts
+var ALLOWED_TRANSITIONS = {
+  idle: ["creating_session", "disposed"],
+  creating_session: ["connecting_transport", "error", "disposed"],
+  connecting_transport: ["ready", "error", "disposed"],
+  ready: ["recording", "finalizing", "error", "disposed"],
+  recording: ["paused", "finalizing", "error", "disposed"],
+  paused: ["recording", "finalizing", "error", "disposed"],
+  // "paused" : stop() passe par finalizing pendant le drain backend, puis retombe en paused
+  finalizing: ["paused", "ended", "error", "disposed"],
+  ended: ["idle", "disposed"],
+  error: ["idle", "disposed"],
+  disposed: []
+};
+function transitionSessionStatus(current, next) {
+  if (current === next) return current;
+  const allowed = ALLOWED_TRANSITIONS[current] ?? [];
+  if (!allowed.includes(next)) {
+    throw new EphiaSdkError(
+      "client.invalid_state",
+      `Transition interdite: ${current} -> ${next}`,
+      { current, next, allowed }
+    );
+  }
+  return next;
+}
+function canTransition(current, next) {
+  if (current === next) return true;
+  const allowed = ALLOWED_TRANSITIONS[current] ?? [];
+  return allowed.includes(next);
+}
+
+// src/core/runtime/TranscriptApplier.ts
+var MAX_SEEN_EVENTS = 1e3;
+var MAX_PENDING_EVENTS = 50;
+var TranscriptApplier = class {
+  targetManager;
+  warn;
+  debug;
+  /** eventId → déjà traité (idempotence). */
+  seenEventIds = /* @__PURE__ */ new Set();
+  seenEventQueue = [];
+  /** segmentId → dernière segmentRevision appliquée. */
+  latestRevisionBySegment = /* @__PURE__ */ new Map();
+  /** segmentId → targetId (cache défensif). */
+  segmentTargetMap = /* @__PURE__ */ new Map();
+  /** segmentIds pour lesquels un canonical a été appliqué avec succès. */
+  canonicalSegments = /* @__PURE__ */ new Set();
+  /** Events en attente de montage de leur cible (targetId → events[]). */
+  pendingEvents = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.targetManager = options.targetManager;
+    this.warn = options.warn ?? ((message, details) => console.warn(message, details));
+    this.debug = options.debug ?? (() => {
+    });
+  }
+  handleEvent(event) {
+    if (this.seenEventIds.has(event.eventId)) {
+      this.debug("duplicate event ignored", { eventId: event.eventId, type: event.type });
+      return;
+    }
+    if (event.type === "segment.preview") {
+      if (this.canonicalSegments.has(event.payload.segmentId)) {
+        this.debug("late preview ignored after canonical", {
+          segmentId: event.payload.segmentId
+        });
+        this._markEventSeen(event.eventId);
+        return;
+      }
+      const binding = this.resolveBinding(event.payload.targetId, event.payload.segmentId);
+      if (!binding) {
+        this._enqueuePendingEvent(event, event.payload.targetId);
+        return;
+      }
+      this._markEventSeen(event.eventId);
+      binding.previewSegment?.({ id: event.payload.segmentId, text: event.payload.text });
+      return;
+    }
+    if (event.type === "segment.operation") {
+      const applied = this.applyOperation(event.payload, event);
+      if (applied) this._markEventSeen(event.eventId);
+    }
+  }
+  /**
+   * Rejoue les events en attente pour une cible donnée.
+   * À appeler après l'enregistrement d'une nouvelle target.
+   */
+  flushPendingEvents(targetId) {
+    const pending = this.pendingEvents.get(targetId);
+    if (!pending || pending.length === 0) return;
+    this.debug("flushing pending events", { targetId, count: pending.length });
+    const toRetry = [...pending];
+    this.pendingEvents.delete(targetId);
+    for (const event of toRetry) {
+      this.handleEvent(event);
+    }
+  }
+  applyOperation(payload, event) {
+    const binding = this.resolveBinding(payload.targetId, payload.segmentId);
+    if (!binding) {
+      if (event && payload.targetId) {
+        this._enqueuePendingEvent(event, payload.targetId);
+      }
+      return false;
+    }
+    if (!this.shouldApplySegmentRevision(payload)) {
+      return true;
+    }
+    if (payload.operation === "noop") return true;
+    if (payload.operation === "delete") {
+      binding.removeSegment(payload.segmentId);
+      if (payload.absorbedSegmentIds?.length) {
+        binding.removeSegments(payload.absorbedSegmentIds);
+      }
+      return true;
+    }
+    binding.upsertSegment({
+      id: payload.segmentId,
+      text: payload.textForInsertion || payload.text,
+      stage: payload.stage,
+      source: payload.source
+    });
+    if (payload.stage === "canonical") {
+      this.canonicalSegments.add(payload.segmentId);
+    }
+    if (payload.absorbedSegmentIds?.length) {
+      binding.removeSegments(payload.absorbedSegmentIds);
+    }
+    return true;
+  }
+  shouldApplySegmentRevision(payload) {
+    const previous = this.latestRevisionBySegment.get(payload.segmentId);
+    const current = payload.segmentRevision;
+    if (previous !== void 0 && current <= previous) {
+      this.debug("stale segment revision ignored", {
+        segmentId: payload.segmentId,
+        previous,
+        current
+      });
+      return false;
+    }
+    this.latestRevisionBySegment.set(payload.segmentId, current);
+    return true;
+  }
+  resolveBinding(targetId, segmentId) {
+    if (targetId) {
+      const target = this.targetManager.get(targetId);
+      const binding = this.asEphiaBinding(target?.binding);
+      if (!binding) {
+        this.warn("[ephia] target not found; transcript event ignored", {
+          targetId,
+          segmentId
+        });
+        return null;
+      }
+      this.segmentTargetMap.set(segmentId, targetId);
+      return binding;
+    }
+    const mappedTargetId = this.segmentTargetMap.get(segmentId);
+    if (mappedTargetId) {
+      return this.asEphiaBinding(this.targetManager.get(mappedTargetId)?.binding);
+    }
+    this.warn("[ephia] segment.operation missing targetId; event ignored", {
+      segmentId
+    });
+    return null;
+  }
+  _markEventSeen(eventId) {
+    this.seenEventIds.add(eventId);
+    this.seenEventQueue.push(eventId);
+    if (this.seenEventQueue.length > MAX_SEEN_EVENTS) {
+      const oldest = this.seenEventQueue.shift();
+      if (oldest) this.seenEventIds.delete(oldest);
+    }
+  }
+  asEphiaBinding(binding) {
+    if (!binding) return null;
+    if (typeof binding === "object" && "upsertSegment" in binding) return binding;
+    return null;
+  }
+  _enqueuePendingEvent(event, targetId) {
+    if (!targetId) return;
+    const queue = this.pendingEvents.get(targetId) ?? [];
+    if (queue.length >= MAX_PENDING_EVENTS) {
+      this.debug("pending events queue full, dropping oldest", { targetId });
+      queue.shift();
+    }
+    queue.push(event);
+    this.pendingEvents.set(targetId, queue);
+    this.debug("event enqueued for target", {
+      targetId,
+      eventId: event.eventId,
+      type: event.type,
+      queueSize: queue.length
+    });
+  }
+};
+
+// src/core/targets/TargetManager.ts
+var TargetManager = class {
+  targets = /* @__PURE__ */ new Map();
+  sendMessage;
+  flushDelayMs;
+  onActiveTargetChange;
+  onTargetRegistered;
+  activeTargetId = null;
+  flushTimers = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.sendMessage = options.sendMessage;
+    this.flushDelayMs = options.flushDelayMs ?? 80;
+    this.onActiveTargetChange = options.onActiveTargetChange;
+    this.onTargetRegistered = options.onTargetRegistered;
+  }
+  /**
+   * Register a target and return its registration token.
+   * Pass the token to unregister() to prevent stale cleanups from accidentally
+   * removing a newer registration with the same id (React StrictMode / remounts).
+   */
+  register(target) {
+    const token = Symbol(target.id);
+    this.targets.set(target.id, { ...target, token });
+    if (this.activeTargetId === null && target.mode !== "read") {
+      this.setActive(target.id);
+    }
+    this.onTargetRegistered?.(target.id);
+    return token;
+  }
+  /**
+   * Unregister a target.
+   * When `token` is provided, only unregisters if the stored token matches
+   * (prevents a stale cleanup from removing a newer registration).
+   * Returns true if the target was removed, false if skipped.
+   */
+  unregister(targetId, token) {
+    const current = this.targets.get(targetId);
+    if (!current) return false;
+    if (token !== void 0 && current.token !== token) {
+      return false;
+    }
+    this.targets.delete(targetId);
+    this.clearFlush(targetId);
+    if (this.activeTargetId === targetId) {
+      const next = this.firstWritableTargetId();
+      this.activeTargetId = null;
+      if (next) {
+        this.setActive(next);
+      } else {
+        this.onActiveTargetChange?.(null);
+      }
+    }
+    return true;
+  }
+  get(targetId) {
+    return this.targets.get(targetId);
+  }
+  getActiveTargetId() {
+    return this.activeTargetId;
+  }
+  getActiveTarget() {
+    return this.activeTargetId ? this.targets.get(this.activeTargetId) : void 0;
+  }
+  setActive(targetId) {
+    if (!this.targets.has(targetId)) return;
+    if (this.activeTargetId === targetId) {
+      this.scheduleEditorContextFlush(targetId);
+      return;
+    }
+    this.activeTargetId = targetId;
+    this.onActiveTargetChange?.(targetId);
+    this.send({
+      type: "session.target.changed",
+      payload: { targetId }
+    });
+    this.scheduleEditorContextFlush(targetId);
+  }
+  syncActiveTarget() {
+    if (!this.activeTargetId) return;
+    this.send({
+      type: "session.target.changed",
+      payload: { targetId: this.activeTargetId }
+    });
+    this.flushEditorContext(this.activeTargetId);
+  }
+  /** Resync native bindings from current DOM before dictation (manual edits between sessions). */
+  prepareForDictation(targetId = this.activeTargetId) {
+    if (!targetId) return;
+    const binding = this.targets.get(targetId)?.binding;
+    if (binding?.kind === "native" && "prepareForDictation" in binding) {
+      binding.prepareForDictation();
+    }
+  }
+  flushEditorContext(targetId = this.activeTargetId) {
+    if (!targetId) return;
+    this.clearFlush(targetId);
+    const target = this.targets.get(targetId);
+    if (!target?.binding) return;
+    const context = target.binding.getEditorContext(target.id);
+    this.send({
+      type: "session.editor_context.update",
+      payload: context
+    });
+  }
+  scheduleEditorContextFlush(targetId = this.activeTargetId) {
+    if (!targetId) return;
+    this.clearFlush(targetId);
+    const timer = setTimeout(() => {
+      this.flushTimers.delete(targetId);
+      this.flushEditorContext(targetId);
+    }, this.flushDelayMs);
+    this.flushTimers.set(targetId, timer);
+  }
+  reset(scope, targetId = this.activeTargetId, reason = "user_explicit") {
+    this.send({
+      type: "session.reset",
+      payload: scope === "target" && targetId ? { scope: "target", targetId, reason } : { scope: "global", reason }
+    });
+  }
+  dispose() {
+    for (const targetId of this.flushTimers.keys()) {
+      this.clearFlush(targetId);
+    }
+    this.targets.clear();
+    this.activeTargetId = null;
+  }
+  firstWritableTargetId() {
+    for (const target of this.targets.values()) {
+      if (target.mode !== "read") return target.id;
+    }
+    return null;
+  }
+  clearFlush(targetId) {
+    const timer = this.flushTimers.get(targetId);
+    if (timer) clearTimeout(timer);
+    this.flushTimers.delete(targetId);
+  }
+  send(message) {
+    this.sendMessage(message).catch(() => {
+    });
+  }
+};
+
+export {
+  dbgState,
+  LiveKitTransport,
+  initialClientState,
+  transitionSessionStatus,
+  canTransition,
+  TranscriptApplier,
+  TargetManager
+};
+//# sourceMappingURL=chunk-LXMCRXXF.js.map