@opengeni/sdk 0.57.0 → 2.2.0-canary.0

package/dist/{chunk-JDLDDRNE.js → chunk-C2H7HBNP.js}

@@ -1,6 +1,6 @@
 import {
   OpenGeniApiError
-} from "./chunk-GU6JF75T.js";
+} from "./chunk-C4DJPZRU.js";
 
 // src/codex-realtime-v3-wire.ts
 var CODEX_REALTIME_INITIAL_ITEMS_MAX_COUNT = 128;
@@ -231,6 +231,7 @@ var CODEX_REALTIME_V3_PENDING_MAX_ENTRIES = 256;
 var CODEX_REALTIME_V3_PENDING_MAX_BYTES = 16 * 1024 * 1024;
 var REALTIME_DELEGATION_TRANSCRIPT_MAX_BYTES = 65536;
 var REALTIME_DELEGATION_INPUT_MAX_BYTES = 65536;
+var REALTIME_MODEL_CONTEXT_MAX_CHARACTERS = 32768;
 function createCodexRealtimeV3Bridge(options) {
   let closed = false;
   let sealed = false;
@@ -253,9 +254,27 @@ function createCodexRealtimeV3Bridge(options) {
   const clientReceivedSequences = /* @__PURE__ */ new Set();
   const sentSequences = /* @__PURE__ */ new Set();
   const finalizedTurnIds = /* @__PURE__ */ new Set();
+  const acceptedDelegationItemIds = options.acceptedDelegationItemIds ?? /* @__PURE__ */ new Set();
+  const pendingDelegations = options.pendingDelegations ?? /* @__PURE__ */ new Map();
+  const locallyQueuedDelegationItemIds = /* @__PURE__ */ new Set();
   let transcriptSinceDelegation = [];
   let pendingDelegationUserTranscript = null;
   const randomUUID = options.randomUUID ?? defaultRandomUUID;
+  const currentModelContext = () => {
+    let context;
+    try {
+      context = options.getModelContext?.()?.trim();
+    } catch {
+      lastError = "Realtime model context callback failed; the provider message continued without application context";
+      return void 0;
+    }
+    if (!context) return void 0;
+    if (context.length > REALTIME_MODEL_CONTEXT_MAX_CHARACTERS) {
+      lastError = "Realtime model context exceeded the 32768-character limit; the provider message continued without application context";
+      return void 0;
+    }
+    return context;
+  };
   const snapshot = () => ({
     connectionId: options.connectionId,
     connectionEpoch: options.connectionEpoch,
@@ -274,9 +293,9 @@ function createCodexRealtimeV3Bridge(options) {
     fatal
   });
   const publish = () => options.onSnapshot?.(snapshot());
-  const triggerFatal = (message) => {
+  const triggerFatalCode = (code, message) => {
     if (closed || fatal) return;
-    fatal = { code: "pending_overflow", message };
+    fatal = { code, message };
     lastError = message;
     publish();
     try {
@@ -284,6 +303,9 @@ function createCodexRealtimeV3Bridge(options) {
     } catch {
     }
   };
+  const triggerFatal = (message) => {
+    triggerFatalCode("pending_overflow", message);
+  };
   const enqueue = (entry) => {
     if (closed || sealed || fatal) return false;
     const bytes = utf8ByteLength2(JSON.stringify(entry));
@@ -296,6 +318,9 @@ function createCodexRealtimeV3Bridge(options) {
     pendingInboundBytes += bytes;
     return true;
   };
+  for (const [delegationItemId, entry] of pendingDelegations) {
+    if (enqueue(entry)) locallyQueuedDelegationItemIds.add(delegationItemId);
+  }
   const hasWork = () => pendingInbound.length > 0 || !providerStartedAccepted && providerStarted !== void 0 || clientAckThroughSequence !== null || forceSync;
   const runFlush = async () => {
     while (true) {
@@ -321,7 +346,41 @@ function createCodexRealtimeV3Bridge(options) {
         pendingInbound = [...batch, ...pendingInbound];
         throw error;
       }
+      const acceptedAfterSync = new Set(acceptedDelegationItemIds);
+      const pendingAfterSync = new Map(pendingDelegations);
+      let delegationReplayChanged = false;
+      for (const item of batch) {
+        if (item.entry.kind === "delegation_call" && item.entry.delegationItemId) {
+          delegationReplayChanged = true;
+          acceptedAfterSync.add(item.entry.delegationItemId);
+          if (pendingAfterSync.get(item.entry.delegationItemId) === item.entry) {
+            pendingAfterSync.delete(item.entry.delegationItemId);
+          }
+        }
+      }
+      if (delegationReplayChanged) {
+        try {
+          options.onDelegationReplayStateChange?.({
+            acceptedDelegationItemIds: acceptedAfterSync,
+            pendingDelegations: pendingAfterSync
+          });
+        } catch (error) {
+          pendingInbound = [...batch, ...pendingInbound];
+          triggerFatalCode(
+            "replay_journal_failed",
+            `Codex realtime delegation replay journal failed: ${safeError(error)}`
+          );
+          return;
+        }
+      }
       for (const item of batch) {
+        if (item.entry.kind === "delegation_call" && item.entry.delegationItemId) {
+          acceptedDelegationItemIds.add(item.entry.delegationItemId);
+          if (pendingDelegations.get(item.entry.delegationItemId) === item.entry) {
+            pendingDelegations.delete(item.entry.delegationItemId);
+          }
+          locallyQueuedDelegationItemIds.delete(item.entry.delegationItemId);
+        }
         pendingInboundCount -= 1;
         pendingInboundBytes -= item.bytes;
       }
@@ -423,27 +482,60 @@ function createCodexRealtimeV3Bridge(options) {
       }
     } else if (event.type === "input_transcript.added" || event.type === "output_transcript.added") {
     } else if (event.type === "delegation.created") {
-      activeDelegationId = event.delegationItemId;
-      const transcript = delegationTranscript(transcriptSinceDelegation, event.inputTranscript);
-      const coveredTurnIds = transcriptSinceDelegation.map((entry) => entry.turnId);
-      durable = enqueue({
-        operationId: randomUUID(),
-        kind: "delegation_call",
-        providerEventId: event.providerEventId,
-        delegationItemId: event.delegationItemId,
-        text: renderRealtimeDelegationInput(event.inputTranscript, transcript),
-        payload: {
-          offsetMs: event.offsetMs,
-          inputTranscript: event.inputTranscript,
-          transcriptFenceTurnIds: coveredTurnIds
+      if (acceptedDelegationItemIds.has(event.delegationItemId)) {
+        ignoredEventCount += 1;
+        lastIgnoredEventType = event.type;
+      } else if (locallyQueuedDelegationItemIds.has(event.delegationItemId)) {
+        ignoredEventCount += 1;
+        lastIgnoredEventType = event.type;
+        durable = true;
+      } else {
+        let entry = pendingDelegations.get(event.delegationItemId);
+        if (!entry) {
+          const transcript = delegationTranscript(transcriptSinceDelegation, event.inputTranscript);
+          const coveredTurnIds = transcriptSinceDelegation.map((item) => item.turnId);
+          const modelContext = currentModelContext();
+          entry = {
+            operationId: randomUUID(),
+            kind: "delegation_call",
+            providerEventId: event.providerEventId,
+            delegationItemId: event.delegationItemId,
+            text: renderRealtimeDelegationInput(event.inputTranscript, transcript),
+            payload: {
+              offsetMs: event.offsetMs,
+              inputTranscript: event.inputTranscript,
+              transcriptFenceTurnIds: coveredTurnIds
+            },
+            ...modelContext ? { modelContext } : {}
+          };
+          pendingDelegations.set(event.delegationItemId, entry);
+        }
+        try {
+          options.onDelegationReplayStateChange?.({
+            acceptedDelegationItemIds,
+            pendingDelegations
+          });
+        } catch (error) {
+          triggerFatalCode(
+            "replay_journal_failed",
+            `Codex realtime delegation replay journal failed: ${safeError(error)}`
+          );
+          return Promise.resolve();
+        }
+        durable = enqueue(entry);
+        if (durable) {
+          locallyQueuedDelegationItemIds.add(event.delegationItemId);
+          activeDelegationId = event.delegationItemId;
+          const frozenInputTranscript = typeof entry.payload.inputTranscript === "string" ? entry.payload.inputTranscript : event.inputTranscript;
+          const alreadyFinalized = transcriptSinceDelegation.some(
+            (item) => item.role === "user" && normalizedTranscript(item.text) === normalizedTranscript(frozenInputTranscript)
+          );
+          pendingDelegationUserTranscript = alreadyFinalized ? null : {
+            delegationItemId: event.delegationItemId,
+            text: frozenInputTranscript
+          };
+          transcriptSinceDelegation = [];
         }
-      });
-      if (durable) {
-        const alreadyFinalized = transcriptSinceDelegation.some(
-          (entry) => entry.role === "user" && normalizedTranscript(entry.text) === normalizedTranscript(event.inputTranscript)
-        );
-        pendingDelegationUserTranscript = alreadyFinalized ? null : { delegationItemId: event.delegationItemId, text: event.inputTranscript };
-        transcriptSinceDelegation = [];
       }
     } else if (event.type === "output_audio.delta") {
       speaking = true;
@@ -451,7 +543,9 @@ function createCodexRealtimeV3Bridge(options) {
       speaking = false;
       if (event.transcript.length > 0 && !finalizedTurnIds.has(event.turnId)) {
         const coveredByDelegationItemId = event.role === "user" && pendingDelegationUserTranscript !== null && normalizedTranscript(event.transcript) === normalizedTranscript(pendingDelegationUserTranscript.text) ? pendingDelegationUserTranscript.delegationItemId : null;
-        durable = enqueue(finalTranscript(randomUUID, event, coveredByDelegationItemId));
+        durable = enqueue(
+          finalTranscript(randomUUID, event, coveredByDelegationItemId, currentModelContext())
+        );
         if (durable) {
           finalizedTurnIds.add(event.turnId);
           if (coveredByDelegationItemId) {
@@ -508,7 +602,7 @@ function createCodexRealtimeV3Bridge(options) {
     }
   };
 }
-function finalTranscript(randomUUID, event, coveredByDelegationItemId) {
+function finalTranscript(randomUUID, event, coveredByDelegationItemId, modelContext) {
   return {
     operationId: randomUUID(),
     kind: event.role === "user" ? "user_transcript" : "assistant_transcript",
@@ -517,7 +611,8 @@ function finalTranscript(randomUUID, event, coveredByDelegationItemId) {
     payload: {
       turnId: event.turnId,
       ...coveredByDelegationItemId ? { coveredByDelegationItemId } : {}
-    }
+    },
+    ...modelContext ? { modelContext } : {}
   };
 }
 function delegationTranscript(entries, inputTranscript) {
@@ -573,7 +668,10 @@ function sendOutbound(events, entry) {
     delegationItemId: entry.delegationItemId,
     text,
     channel: payloadChannel ?? "speakable"
-  }) : encodeCodexRealtimeV3SessionContextAppend({ text, channel: payloadChannel });
+  }) : encodeCodexRealtimeV3SessionContextAppend({
+    text,
+    channel: payloadChannel
+  });
   for (const message of messages) events.send(JSON.stringify(message));
 }
 function sendDelegationProgress(events, delegationItemId, entries) {
@@ -972,7 +1070,29 @@ var OUTBOUND_SYNC_INTERVAL_MS = 1e3;
 var CODEX_REALTIME_NEGOTIATION_TIMEOUT_MS = 2e4;
 var DEFAULT_CONNECTION_ROTATION_INTERVAL_MS = 15 * 6e4;
 var DEFAULT_RECONNECT_BACKOFF_MS = [250, 1e3, 2e3, 5e3];
+var MAX_BROWSER_TIMEOUT_MS = 2147483647;
 var OWNER_RECORD_VERSION = 1;
+var OWNER_DELEGATION_REPLAY_VERSION = 1;
+var OWNER_DELEGATION_REPLAY_MAX_CALLS = 4096;
+var OWNER_DELEGATION_REPLAY_MAX_BYTES = 4 * 1024 * 1024;
+var SESSION_REALTIME_INBOUND_ENTRY_KEYS = /* @__PURE__ */ new Set([
+  "operationId",
+  "kind",
+  "role",
+  "providerEventId",
+  "delegationItemId",
+  "text",
+  "payload",
+  "modelContext"
+]);
+var SESSION_REALTIME_INBOUND_KINDS = /* @__PURE__ */ new Set([
+  "user_transcript",
+  "assistant_transcript",
+  "delegation_call",
+  "interruption",
+  "error"
+]);
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
 function sessionRealtimeOwnerStorageNamespace(model) {
   if (model === "gpt-live-1-boulder-alpha") return "codex-realtime-owner";
   if (model === "supergrok/grok-voice-think-fast-2.0") return "xai-realtime-owner";
@@ -1001,6 +1121,7 @@ function createCodexRealtimeController(options) {
   );
   const model = options.model ?? "gpt-live-1-boulder-alpha";
   const randomUUID = options.randomUUID ?? defaultRandomUUID2;
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
   const scheduleInterval = options.setInterval ?? ((callback, delay) => globalThis.setInterval(callback, delay));
   const unscheduleInterval = options.clearInterval ?? ((handle) => globalThis.clearInterval(handle));
   const scheduleTimeout = options.setTimeout ?? ((callback, delay) => globalThis.setTimeout(callback, delay));
@@ -1041,6 +1162,7 @@ function createCodexRealtimeController(options) {
   let rotationTimer = null;
   let reconnectTimer = null;
   let negotiationTimer = null;
+  let lostOwnerExpiryTimer = null;
   let closed = false;
   let stopping = false;
   let generation = 0;
@@ -1048,6 +1170,45 @@ function createCodexRealtimeController(options) {
   let recoveryTerminal = false;
   let mutationTail = Promise.resolve();
   let connectionTask = null;
+  const acceptedDelegationItemIds = new Set(
+    owner?.delegationReplay?.acceptedDelegationItemIds ?? []
+  );
+  const pendingDelegations = new Map(
+    (owner?.delegationReplay?.pendingDelegations ?? []).flatMap(
+      (entry) => entry.delegationItemId ? [[entry.delegationItemId, entry]] : []
+    )
+  );
+  const invalidateStoredOwner = () => {
+    try {
+      storage?.removeItem(storageKey);
+    } catch {
+    }
+  };
+  const persistDelegationReplay = (input) => {
+    if (!owner || !storage) return;
+    const delegationReplay = {
+      version: OWNER_DELEGATION_REPLAY_VERSION,
+      acceptedDelegationItemIds: [...input.acceptedDelegationItemIds],
+      pendingDelegations: [...input.pendingDelegations.values()]
+    };
+    if (delegationReplay.pendingDelegations.length > CODEX_REALTIME_V3_PENDING_MAX_ENTRIES || delegationReplay.acceptedDelegationItemIds.length + delegationReplay.pendingDelegations.length > OWNER_DELEGATION_REPLAY_MAX_CALLS) {
+      invalidateStoredOwner();
+      throw new Error("Realtime delegation replay journal exceeded its call limit");
+    }
+    const next = { ...owner, delegationReplay };
+    const serialized = JSON.stringify(next);
+    if (new TextEncoder().encode(serialized).byteLength > OWNER_DELEGATION_REPLAY_MAX_BYTES) {
+      invalidateStoredOwner();
+      throw new Error("Realtime delegation replay journal exceeded its byte limit");
+    }
+    try {
+      storage.setItem(storageKey, serialized);
+    } catch (error) {
+      invalidateStoredOwner();
+      throw error;
+    }
+    owner = next;
+  };
   const publish = (patch) => {
     state = { ...state, ...patch };
     for (const listener of listeners) listener({ ...state });
@@ -1073,11 +1234,13 @@ function createCodexRealtimeController(options) {
     if (rotationTimer !== null) unscheduleTimeout(rotationTimer);
     if (reconnectTimer !== null) unscheduleTimeout(reconnectTimer);
     if (negotiationTimer !== null) unscheduleTimeout(negotiationTimer);
+    if (lostOwnerExpiryTimer !== null) unscheduleTimeout(lostOwnerExpiryTimer);
     heartbeatTimer = null;
     syncTimer = null;
     rotationTimer = null;
     reconnectTimer = null;
     negotiationTimer = null;
+    lostOwnerExpiryTimer = null;
   };
   const stopNegotiationTimers = () => {
     if (heartbeatTimer !== null) unscheduleInterval(heartbeatTimer);
@@ -1117,6 +1280,8 @@ function createCodexRealtimeController(options) {
   const clearOwner = () => {
     owner = null;
     storage?.removeItem(storageKey);
+    acceptedDelegationItemIds.clear();
+    pendingDelegations.clear();
   };
   const transitionEnded = (message = "Realtime mode ended") => {
     stopping = false;
@@ -1194,7 +1359,10 @@ function createCodexRealtimeController(options) {
       });
       return;
     }
-    publish({ audibleOutput: next, ...next === "audible" ? { error: null } : {} });
+    publish({
+      audibleOutput: next,
+      ...next === "audible" ? { error: null } : {}
+    });
   };
   const startActiveIntervals = () => {
     if (heartbeatTimer === null) {
@@ -1511,6 +1679,10 @@ function createCodexRealtimeController(options) {
         listen: false,
         sync: async (request) => await syncForGeneration(targetGeneration, activated.mode.id, request),
         randomUUID,
+        ...options.getModelContext ? { getModelContext: options.getModelContext } : {},
+        acceptedDelegationItemIds,
+        pendingDelegations,
+        onDelegationReplayStateChange: persistDelegationReplay,
         onSnapshot: (nextBridge) => {
           if (active?.generation === targetGeneration) publish({ bridge: nextBridge });
         },
@@ -1676,7 +1848,12 @@ function createCodexRealtimeController(options) {
           await handleConnectionFailure(error, "reconnect", false);
         } else {
           clearOwner();
-          publish({ status: "error", realtimeId: null, mode: null, error: safeError2(error) });
+          publish({
+            status: "error",
+            realtimeId: null,
+            mode: null,
+            error: safeError2(error)
+          });
         }
         throw error;
       }
@@ -1730,6 +1907,12 @@ function createCodexRealtimeController(options) {
       if (!record2 || record2.operationId !== lifecycle.operationId) {
         closeBrowserResources();
         owner = null;
+        const leaseExpiresAt = Date.parse(lifecycle.leaseExpiresAt);
+        const remainingLeaseMs = leaseExpiresAt - now().getTime();
+        if (Number.isFinite(remainingLeaseMs) && remainingLeaseMs <= 0) {
+          transitionEnded("Realtime lease expired");
+          return;
+        }
         const message = "Realtime is active in another browser owner. It can resume after that owner stops or its lease expires.";
         publish({
           status: "lost_owner",
@@ -1739,13 +1922,26 @@ function createCodexRealtimeController(options) {
           diagnostic: diagnostic("lost_owner", message, false),
           error: message
         });
+        if (Number.isFinite(remainingLeaseMs) && remainingLeaseMs <= MAX_BROWSER_TIMEOUT_MS) {
+          const observedRealtimeId = lifecycle.realtimeId;
+          lostOwnerExpiryTimer = scheduleTimeout(() => {
+            lostOwnerExpiryTimer = null;
+            if (state.status === "lost_owner" && state.realtimeId === observedRealtimeId) {
+              transitionEnded("Realtime lease expired");
+            }
+          }, remainingLeaseMs);
+        }
         return;
       }
       if (connectionTask || state.status === "starting") return;
       closed = false;
       stopping = false;
       owner = record2;
-      publish({ status: "recovering", realtimeId: lifecycle.realtimeId, error: null });
+      publish({
+        status: "recovering",
+        realtimeId: lifecycle.realtimeId,
+        error: null
+      });
       connectionTask = begin(record2, true).then(() => void 0).catch(async (error) => {
         connectionTask = null;
         await handleConnectionFailure(error, "reload", false);
@@ -1912,18 +2108,79 @@ function ownerStorageKey(workspaceId, sessionId, namespace = "codex-realtime-own
 function readOwnerRecord(storage, key, scope) {
   const raw = storage?.getItem(key);
   if (!raw) return null;
+  if (new TextEncoder().encode(raw).byteLength > OWNER_DELEGATION_REPLAY_MAX_BYTES) {
+    storage?.removeItem(key);
+    return null;
+  }
   try {
     const parsed = recordValue2(JSON.parse(raw));
-    if (parsed?.version !== OWNER_RECORD_VERSION || parsed.workspaceId !== scope.workspaceId || parsed.sessionId !== scope.sessionId || !stringValue2(parsed.operationId) || !stringValue2(parsed.browserInstanceId) || !stringValue2(parsed.ownerKey) || String(parsed.ownerKey).length < 32) {
+    const delegationReplay = readOwnerDelegationReplay(parsed?.delegationReplay);
+    if (parsed?.version !== OWNER_RECORD_VERSION || parsed.workspaceId !== scope.workspaceId || parsed.sessionId !== scope.sessionId || !stringValue2(parsed.operationId) || !stringValue2(parsed.browserInstanceId) || !stringValue2(parsed.ownerKey) || String(parsed.ownerKey).length < 32 || delegationReplay === null) {
       storage?.removeItem(key);
       return null;
     }
-    return parsed;
+    return {
+      ...parsed,
+      ...delegationReplay ? { delegationReplay } : {}
+    };
   } catch {
     storage?.removeItem(key);
     return null;
   }
 }
+function readOwnerDelegationReplay(value) {
+  if (value === void 0) return void 0;
+  const record2 = recordValue2(value);
+  if (record2?.version !== OWNER_DELEGATION_REPLAY_VERSION || !Array.isArray(record2.acceptedDelegationItemIds) || !Array.isArray(record2.pendingDelegations) || record2.acceptedDelegationItemIds.length + record2.pendingDelegations.length > OWNER_DELEGATION_REPLAY_MAX_CALLS || record2.pendingDelegations.length > CODEX_REALTIME_V3_PENDING_MAX_ENTRIES) {
+    return null;
+  }
+  const acceptedDelegationItemIds = [];
+  const accepted = /* @__PURE__ */ new Set();
+  for (const candidate of record2.acceptedDelegationItemIds) {
+    if (typeof candidate !== "string" || candidate.length < 1 || candidate.length > 1024) {
+      return null;
+    }
+    if (!accepted.has(candidate)) {
+      accepted.add(candidate);
+      acceptedDelegationItemIds.push(candidate);
+    }
+  }
+  const pendingDelegations = [];
+  const pendingIds = /* @__PURE__ */ new Set();
+  for (const candidate of record2.pendingDelegations) {
+    const parsed = readSessionRealtimeInboundEntry(candidate);
+    if (!parsed || parsed.kind !== "delegation_call" || !parsed.delegationItemId || accepted.has(parsed.delegationItemId) || pendingIds.has(parsed.delegationItemId)) {
+      return null;
+    }
+    pendingIds.add(parsed.delegationItemId);
+    pendingDelegations.push(parsed);
+  }
+  const replay = {
+    version: OWNER_DELEGATION_REPLAY_VERSION,
+    acceptedDelegationItemIds,
+    pendingDelegations
+  };
+  if (new TextEncoder().encode(JSON.stringify(replay)).byteLength > OWNER_DELEGATION_REPLAY_MAX_BYTES) {
+    return null;
+  }
+  return replay;
+}
+function readSessionRealtimeInboundEntry(value) {
+  const record2 = recordValue2(value);
+  if (!record2 || Object.keys(record2).some((key) => !SESSION_REALTIME_INBOUND_ENTRY_KEYS.has(key)) || typeof record2.operationId !== "string" || !UUID_PATTERN.test(record2.operationId) || typeof record2.kind !== "string" || !SESSION_REALTIME_INBOUND_KINDS.has(record2.kind) || !optionalNullableEnum(record2.role, ["user", "assistant"]) || !optionalNullableBoundedString(record2.providerEventId, 1024) || !optionalNullableBoundedString(record2.delegationItemId, 1024) || !optionalNullableBoundedString(record2.text, 131072) || record2.payload !== void 0 && recordValue2(record2.payload) === null || !optionalModelContext(record2.modelContext)) {
+    return null;
+  }
+  return record2;
+}
+function optionalNullableEnum(value, allowed) {
+  return value === void 0 || value === null || typeof value === "string" && allowed.includes(value);
+}
+function optionalNullableBoundedString(value, maxLength) {
+  return value === void 0 || value === null || typeof value === "string" && value.length <= maxLength;
+}
+function optionalModelContext(value) {
+  return value === void 0 || typeof value === "string" && value.length >= 1 && value.length <= 32768 && value.trim() === value;
+}
 function defaultStorage() {
   return typeof sessionStorage === "undefined" ? void 0 : sessionStorage;
 }
@@ -2021,4 +2278,4 @@ export {
   hasStoredSessionRealtimeOwnerProof,
   createCodexRealtimeController
 };
-//# sourceMappingURL=chunk-JDLDDRNE.js.map
+//# sourceMappingURL=chunk-C2H7HBNP.js.map