@opengeni/react 3.3.2 → 3.4.1-canary.38960406141001

package/dist/chunk-R5SBNG7S.js

@@ -0,0 +1,810 @@
+"use client";
+import {
+  usePageLiveActivity
+} from "./chunk-QHUE7E4N.js";
+import {
+  ErrorMessageContext,
+  normalizeError
+} from "./chunk-CM7LVUKC.js";
+import {
+  OpenGeniContext
+} from "./chunk-G76LSA76.js";
+
+// src/provider.tsx
+import {
+  OpenGeniApiContractMismatchError,
+  OPENGENI_API_CONTRACT_REVISION
+} from "@opengeni/sdk";
+import { useCallback as useCallback2, useEffect, useMemo, useRef as useRef2, useState } from "react";
+
+// src/hooks/shared-query.ts
+import { useCallback, useLayoutEffect, useReducer, useRef, useSyncExternalStore } from "react";
+var DEFAULT_STALE_TIME_MS = 1e4;
+var DEFAULT_RETAIN_MS = 10 * 6e4;
+var scopes = /* @__PURE__ */ new WeakMap();
+var resetSequence = 0;
+function idle(loading) {
+  return { data: null, loading, fetching: false, error: null, updatedAt: null };
+}
+var IDLE_LOADING = idle(true);
+var IDLE = idle(false);
+function serialize(parts) {
+  return JSON.stringify(parts);
+}
+function isSharedQueryAccessRefusal(cause) {
+  if (!cause || typeof cause !== "object" || !("status" in cause)) return false;
+  const status = cause.status;
+  return status === 401 || status === 403 || status === 404;
+}
+function scopeState(scope) {
+  let state = scopes.get(scope);
+  if (!state) {
+    state = {
+      entries: /* @__PURE__ */ new Map(),
+      listeners: /* @__PURE__ */ new Map(),
+      epoch: 0,
+      retainers: 0,
+      releaseTimer: null
+    };
+    scopes.set(scope, state);
+  }
+  return state;
+}
+function notify(state, key) {
+  const listeners = state.listeners.get(key);
+  if (!listeners) return;
+  for (const listener of [...listeners]) listener();
+}
+function setSnapshot(entry, next) {
+  entry.snapshot = next;
+  notify(entry.home, entry.key);
+}
+function listen(scope, key, listener) {
+  const state = scopeState(scope);
+  let listeners = state.listeners.get(key);
+  if (!listeners) {
+    listeners = /* @__PURE__ */ new Set();
+    state.listeners.set(key, listeners);
+  }
+  listeners.add(listener);
+  return () => {
+    const current = state.listeners.get(key);
+    if (!current) return;
+    current.delete(listener);
+    if (current.size === 0) state.listeners.delete(key);
+  };
+}
+function readers(entry) {
+  return [...entry.subscribers].filter(
+    (each) => each.enabled && each.binding?.current.key === entry.key
+  );
+}
+function mounted(entry) {
+  return entry.subscribers.size > 0;
+}
+function stopTimer(entry) {
+  if (entry.timer !== null) {
+    clearTimeout(entry.timer);
+    entry.timer = null;
+  }
+  entry.timerInterval = null;
+}
+function stopRetainTimer(entry) {
+  if (entry.retainTimer !== null) {
+    clearTimeout(entry.retainTimer);
+    entry.retainTimer = null;
+  }
+}
+function supersedeReads(entry) {
+  entry.generation += 1;
+  entry.abort?.abort();
+  entry.abort = null;
+  entry.inFlight = null;
+  entry.trailing = null;
+}
+function evict(state, entry) {
+  supersedeReads(entry);
+  stopTimer(entry);
+  stopRetainTimer(entry);
+  if (state.entries.get(entry.key) !== entry) return;
+  state.entries.delete(entry.key);
+  notify(state, entry.key);
+}
+function arm(entry) {
+  let interval;
+  for (const each of readers(entry)) {
+    if (!each.pageLive) continue;
+    if (each.pollIntervalMs === void 0 || each.pollIntervalMs <= 0) continue;
+    interval = interval === void 0 ? each.pollIntervalMs : Math.min(interval, each.pollIntervalMs);
+  }
+  if (entry.timer !== null && entry.timerInterval === interval) return;
+  stopTimer(entry);
+  if (interval === void 0) return;
+  entry.timerInterval = interval;
+  entry.timer = setTimeout(() => {
+    entry.timer = null;
+    entry.timerInterval = null;
+    void run(entry).finally(() => arm(entry));
+  }, interval);
+}
+async function runFresh(entry) {
+  const subscriber = readers(entry).at(-1);
+  if (!subscriber?.binding) return;
+  const { load } = subscriber.binding.current;
+  const ticket = ++entry.generation;
+  const abort = new AbortController();
+  entry.abort = abort;
+  entry.invalidated = false;
+  if (!entry.snapshot.fetching) setSnapshot(entry, { ...entry.snapshot, fetching: true });
+  try {
+    const data = await load(abort.signal);
+    if (ticket !== entry.generation) return;
+    setSnapshot(entry, {
+      data,
+      loading: false,
+      fetching: false,
+      error: null,
+      updatedAt: Date.now()
+    });
+  } catch (cause) {
+    if (ticket !== entry.generation) return;
+    const refused = isSharedQueryAccessRefusal(cause);
+    setSnapshot(entry, {
+      data: refused ? null : entry.snapshot.data,
+      loading: false,
+      fetching: false,
+      error: normalizeError(cause),
+      // A failure is never a fresh read: the next mount re-reads.
+      updatedAt: null
+    });
+  } finally {
+    if (entry.abort === abort) entry.abort = null;
+  }
+}
+function run(entry, force = false) {
+  if (entry.inFlight) {
+    if (!force) return entry.inFlight;
+    if (entry.trailing) return entry.trailing;
+    const predecessor = entry.inFlight;
+    let trailing;
+    trailing = predecessor.then(() => {
+      if (entry.trailing !== trailing) return entry.inFlight ?? void 0;
+      entry.trailing = null;
+      if (readers(entry).length > 0) return run(entry);
+      entry.invalidated = true;
+      return void 0;
+    });
+    entry.trailing = trailing;
+    return trailing;
+  }
+  let promise;
+  promise = runFresh(entry).finally(() => {
+    if (entry.inFlight === promise) entry.inFlight = null;
+  });
+  entry.inFlight = promise;
+  return promise;
+}
+function isStale(entry, staleTimeMs) {
+  const updatedAt = entry.snapshot.updatedAt;
+  return entry.invalidated || updatedAt === null || Date.now() - updatedAt >= staleTimeMs;
+}
+function reconcile(entry) {
+  const active = readers(entry);
+  if (active.length === 0) {
+    stopTimer(entry);
+    if (entry.snapshot.loading) setSnapshot(entry, { ...entry.snapshot, loading: false });
+    return;
+  }
+  const staleTimeMs = Math.min(...active.map((each) => each.staleTimeMs));
+  const due = active.some((each) => each.pageLive) || entry.invalidated || entry.snapshot.data === null;
+  if (due && isStale(entry, staleTimeMs)) {
+    if (entry.snapshot.error || entry.snapshot.data === null && !entry.snapshot.loading) {
+      setSnapshot(entry, {
+        ...entry.snapshot,
+        error: null,
+        loading: entry.snapshot.data === null
+      });
+    }
+    void run(entry).finally(() => arm(entry));
+    return;
+  }
+  arm(entry);
+}
+function scheduleRelease(state, entry, retainMs) {
+  stopRetainTimer(entry);
+  entry.retainTimer = setTimeout(() => {
+    entry.retainTimer = null;
+    if (!mounted(entry)) evict(state, entry);
+  }, retainMs);
+}
+function getOrCreate(scope, key, loading) {
+  const state = scopeState(scope);
+  const existing = state.entries.get(key);
+  if (existing) {
+    stopRetainTimer(existing);
+    return existing;
+  }
+  const created = {
+    key,
+    parts: JSON.parse(key),
+    snapshot: idle(loading),
+    home: state,
+    subscribers: /* @__PURE__ */ new Set(),
+    inFlight: null,
+    trailing: null,
+    abort: null,
+    generation: 0,
+    invalidated: false,
+    timer: null,
+    timerInterval: null,
+    retainTimer: null,
+    releasedBy: null,
+    // Without retention a new entry may be someone else's: writers created
+    // before it (by an earlier, now unmounted reader) never fill it.
+    resetMark: state.retainers === 0 ? ++resetSequence : 0
+  };
+  state.entries.set(key, created);
+  return created;
+}
+function registerSubscriber(scope, entry, subscriber) {
+  const state = scopeState(scope);
+  const foreign = entry.subscribers.size === 0 && entry.releasedBy !== null && entry.releasedBy !== subscriber.owner && state.retainers === 0;
+  if (foreign) {
+    supersedeReads(entry);
+    stopTimer(entry);
+    entry.invalidated = false;
+    entry.resetMark = ++resetSequence;
+    setSnapshot(entry, IDLE);
+  }
+  entry.releasedBy = null;
+  entry.subscribers.add(subscriber);
+  return foreign;
+}
+function unsubscribe(scope, entry, subscriber, retainMs) {
+  entry.subscribers.delete(subscriber);
+  if (entry.subscribers.size > 0) {
+    reconcile(entry);
+    return;
+  }
+  entry.releasedBy = subscriber.owner;
+  stopTimer(entry);
+  if (entry.snapshot.loading) setSnapshot(entry, { ...entry.snapshot, loading: false });
+  const state = scopes.get(scope);
+  if (!state || state.entries.get(entry.key) !== entry) return;
+  scheduleRelease(state, entry, state.retainers > 0 ? retainMs : 0);
+}
+function visibleEntry(scope, key, registered) {
+  const state = scopes.get(scope);
+  const entry = state?.entries.get(key);
+  if (!state || !entry) return null;
+  if (state.retainers === 0 && registered !== entry) return null;
+  return entry;
+}
+function peekSharedQuery(scope, parts) {
+  return scopes.get(scope)?.entries.get(serialize(parts))?.snapshot ?? null;
+}
+function sharedQueryWriter(scope) {
+  const state = scopeState(scope);
+  const epoch = state.epoch;
+  const since = resetSequence;
+  return (parts, data) => {
+    if (state.epoch !== epoch) return false;
+    const key = serialize(parts);
+    const existing = state.entries.get(key);
+    if (existing && existing.resetMark > since) return false;
+    if (!(existing && mounted(existing)) && state.retainers === 0) return false;
+    const entry = existing ?? getOrCreate(scope, key, false);
+    supersedeReads(entry);
+    entry.invalidated = false;
+    setSnapshot(entry, {
+      data,
+      loading: false,
+      fetching: false,
+      error: null,
+      updatedAt: Date.now()
+    });
+    if (!mounted(entry)) scheduleRelease(state, entry, DEFAULT_RETAIN_MS);
+    return true;
+  };
+}
+function invalidateSharedQueries(scope, prefix) {
+  const state = scopes.get(scope);
+  if (!state) return Promise.resolve();
+  const reads = [];
+  for (const entry of [...state.entries.values()]) {
+    if (!prefix.every((part, index) => entry.parts[index] === part)) continue;
+    if (!mounted(entry)) {
+      evict(state, entry);
+      continue;
+    }
+    supersedeReads(entry);
+    entry.invalidated = true;
+    if (readers(entry).length > 0) {
+      reads.push(run(entry).finally(() => arm(entry)));
+      continue;
+    }
+    stopTimer(entry);
+    setSnapshot(entry, IDLE);
+  }
+  return Promise.all(reads).then(() => void 0);
+}
+function clearSharedQueries(scope) {
+  const state = scopes.get(scope);
+  if (!state) return;
+  state.epoch += 1;
+  for (const entry of [...state.entries.values()]) {
+    if (!mounted(entry)) {
+      evict(state, entry);
+      continue;
+    }
+    supersedeReads(entry);
+    stopTimer(entry);
+    stopRetainTimer(entry);
+    entry.invalidated = true;
+    const active = readers(entry).length > 0;
+    setSnapshot(entry, active ? IDLE_LOADING : IDLE);
+    if (active) void run(entry).finally(() => arm(entry));
+  }
+}
+function retainSharedQueries(scope) {
+  const state = scopeState(scope);
+  state.retainers += 1;
+  if (state.releaseTimer !== null) {
+    clearTimeout(state.releaseTimer);
+    state.releaseTimer = null;
+  }
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    state.retainers -= 1;
+    if (state.retainers > 0) return;
+    if (state.releaseTimer !== null) clearTimeout(state.releaseTimer);
+    state.releaseTimer = setTimeout(() => {
+      state.releaseTimer = null;
+      if (state.retainers === 0) clearSharedQueries(scope);
+    }, 0);
+  };
+}
+function useSharedQuery(scope, parts, load, options = {}) {
+  const enabled = options.enabled ?? true;
+  const pageLive = usePageLiveActivity();
+  const key = serialize(parts);
+  const binding = useRef({ key, load });
+  useLayoutEffect(() => {
+    binding.current = { key, load };
+  }, [key, load]);
+  const staleTimeMs = options.staleTimeMs ?? DEFAULT_STALE_TIME_MS;
+  const retainMs = options.retainMs ?? DEFAULT_RETAIN_MS;
+  const pollIntervalMs = options.pollIntervalMs;
+  const subscribe = useCallback(
+    (listener) => listen(scope, key, listener),
+    [scope, key]
+  );
+  const registered = useRef(null);
+  const getSnapshot = useCallback(
+    () => visibleEntry(scope, key, registered.current)?.snapshot ?? (enabled ? IDLE_LOADING : IDLE),
+    [scope, key, enabled]
+  );
+  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const owner = useRef({});
+  const [, rerender] = useReducer((count) => count + 1, 0);
+  useLayoutEffect(() => {
+    const entry = getOrCreate(scope, key, enabled);
+    const subscriber = {
+      owner: owner.current,
+      binding,
+      enabled,
+      pageLive,
+      pollIntervalMs,
+      staleTimeMs,
+      retainMs
+    };
+    registerSubscriber(scope, entry, subscriber);
+    registered.current = entry;
+    reconcile(entry);
+    if (getSnapshot() !== snapshot) rerender();
+    return () => {
+      if (registered.current === entry) registered.current = null;
+      unsubscribe(scope, entry, subscriber, retainMs);
+    };
+  }, [scope, key, enabled, pageLive, pollIntervalMs, staleTimeMs, retainMs]);
+  const refresh = useCallback(() => {
+    const entry = scopes.get(scope)?.entries.get(key);
+    if (!entry || readers(entry).length === 0) return Promise.resolve();
+    return run(entry, true).finally(() => arm(entry));
+  }, [scope, key]);
+  if (!enabled) return { ...IDLE, refresh };
+  const unread = snapshot.data === null && snapshot.error === null && snapshot.updatedAt === null;
+  return { ...snapshot, loading: snapshot.loading || unread, refresh };
+}
+function useSharedQueryValue(scope, parts) {
+  const key = serialize(parts);
+  const subscribe = useCallback(
+    (listener) => listen(scope, key, listener),
+    [scope, key]
+  );
+  const registered = useRef(null);
+  const getSnapshot = useCallback(
+    () => visibleEntry(scope, key, registered.current)?.snapshot ?? IDLE,
+    [scope, key]
+  );
+  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const owner = useRef({});
+  const [, rerender] = useReducer((count) => count + 1, 0);
+  useLayoutEffect(() => {
+    const entry = getOrCreate(scope, key, false);
+    const subscriber = {
+      owner: owner.current,
+      binding: null,
+      enabled: false,
+      pageLive: true,
+      pollIntervalMs: void 0,
+      staleTimeMs: DEFAULT_STALE_TIME_MS,
+      retainMs: DEFAULT_RETAIN_MS
+    };
+    registerSubscriber(scope, entry, subscriber);
+    registered.current = entry;
+    if (getSnapshot() !== snapshot) rerender();
+    return () => {
+      if (registered.current === entry) registered.current = null;
+      unsubscribe(scope, entry, subscriber, DEFAULT_RETAIN_MS);
+    };
+  }, [scope, key]);
+  return snapshot;
+}
+
+// src/provider.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var CONTRACT_RELOAD_STORAGE_PREFIX = "opengeni.reloadForApiContract:";
+function OpenGeniProvider({
+  client,
+  workspaceId,
+  onWorkspaceControlEvent,
+  onWorkspaceInteractionEvent,
+  reloadOnApiContractChange = false,
+  retainReadsAcrossMounts = false,
+  formatError,
+  children
+}) {
+  const [workspaceControlEvent, setWorkspaceControlEvent] = useState(
+    null
+  );
+  const [workspaceControlConnectionState, setWorkspaceControlConnectionState] = useState("idle");
+  const [workspaceInteractionEvent, setWorkspaceInteractionEvent] = useState(null);
+  const [workspaceInteractionConnectionState, setWorkspaceInteractionConnectionState] = useState("idle");
+  const [contractMismatch, setContractMismatch] = useState(
+    null
+  );
+  const callbackRef = useRef2(onWorkspaceControlEvent);
+  const interactionCallbackRef = useRef2(onWorkspaceInteractionEvent);
+  const reconcilersRef = useRef2(/* @__PURE__ */ new Map());
+  const reconcileInFlightRef = useRef2(/* @__PURE__ */ new Map());
+  const workspaceControlSequencesRef = useRef2(/* @__PURE__ */ new Map());
+  const workspaceInteractionSequencesRef = useRef2(/* @__PURE__ */ new Map());
+  const pageLive = usePageLiveActivity();
+  const supportsWorkspaceLiveStream = "streamWorkspaceLiveEvents" in client && typeof client.streamWorkspaceLiveEvents === "function";
+  callbackRef.current = onWorkspaceControlEvent;
+  interactionCallbackRef.current = onWorkspaceInteractionEvent;
+  useEffect(() => {
+    if (!retainReadsAcrossMounts) return;
+    return retainSharedQueries(client);
+  }, [client, retainReadsAcrossMounts]);
+  const strictContract = reloadOnApiContractChange;
+  const verifyApiContract = useCallback2(async () => {
+    try {
+      const config = await client.getClientConfig();
+      if (strictContract && config.apiContractRevision !== OPENGENI_API_CONTRACT_REVISION) {
+        throw new OpenGeniApiContractMismatchError(
+          OPENGENI_API_CONTRACT_REVISION,
+          String(config.apiContractRevision || "(missing)")
+        );
+      }
+    } catch (error) {
+      if (error instanceof OpenGeniApiContractMismatchError) {
+        if (!strictContract) return;
+        setContractMismatch(error);
+        reloadForContractMismatchOnce(error);
+      }
+      throw error;
+    }
+  }, [client, strictContract]);
+  const registerSessionReconciler = useMemo(
+    () => (sessionId, key, reconcile2) => {
+      const sessionReconcilers = reconcilersRef.current.get(sessionId) ?? /* @__PURE__ */ new Map();
+      sessionReconcilers.set(key, reconcile2);
+      reconcilersRef.current.set(sessionId, sessionReconcilers);
+      return () => {
+        const current = reconcilersRef.current.get(sessionId);
+        current?.delete(key);
+        if (current?.size === 0) reconcilersRef.current.delete(sessionId);
+      };
+    },
+    []
+  );
+  const reconcileSession = useMemo(
+    () => (sessionId) => {
+      const existing = reconcileInFlightRef.current.get(sessionId);
+      if (existing) return existing;
+      const promise = (async () => {
+        await withTimeout(verifyApiContract(), 1e4, "API contract reconciliation");
+        const callbacks = [...reconcilersRef.current.get(sessionId)?.values() ?? []];
+        await withTimeout(
+          Promise.all(callbacks.map((reconcile2) => reconcile2())).then(() => void 0),
+          15e3,
+          "session reconciliation"
+        );
+      })().finally(() => {
+        if (reconcileInFlightRef.current.get(sessionId) === promise) {
+          reconcileInFlightRef.current.delete(sessionId);
+        }
+      });
+      reconcileInFlightRef.current.set(sessionId, promise);
+      return promise;
+    },
+    [verifyApiContract]
+  );
+  useEffect(() => {
+    if (!supportsWorkspaceLiveStream) return;
+    const openLiveStream = client.streamWorkspaceLiveEvents;
+    setWorkspaceControlEvent(null);
+    setWorkspaceInteractionEvent(null);
+    if (!pageLive) {
+      setWorkspaceControlConnectionState("idle");
+      setWorkspaceInteractionConnectionState("idle");
+      return;
+    }
+    const controller = new AbortController();
+    const setConnectionState = (state) => {
+      setWorkspaceControlConnectionState(state);
+      setWorkspaceInteractionConnectionState(state);
+    };
+    setConnectionState("connecting");
+    void (async () => {
+      try {
+        await verifyApiContract();
+        const workspace = await client.getWorkspace(workspaceId);
+        const controlAfter = Math.max(
+          workspaceControlSequencesRef.current.get(workspaceId) ?? 0,
+          workspace.inferenceControl.revision
+        );
+        const interactionAfter = workspaceInteractionSequencesRef.current.get(workspaceId) ?? 0;
+        workspaceControlSequencesRef.current.set(workspaceId, controlAfter);
+        const stream = openLiveStream.call(client, workspaceId, {
+          controlAfter,
+          interactionAfter,
+          signal: controller.signal,
+          onStateChange: setConnectionState
+        });
+        for await (const event of stream) {
+          if (controller.signal.aborted) return;
+          if (event.type === "workspace.control.changed") {
+            workspaceControlSequencesRef.current.set(
+              workspaceId,
+              Math.max(workspaceControlSequencesRef.current.get(workspaceId) ?? 0, event.sequence)
+            );
+            setWorkspaceControlEvent(
+              (current) => !current || event.sequence > current.sequence ? event : current
+            );
+            callbackRef.current?.(event);
+          } else {
+            workspaceInteractionSequencesRef.current.set(
+              workspaceId,
+              Math.max(
+                workspaceInteractionSequencesRef.current.get(workspaceId) ?? 0,
+                event.sequence
+              )
+            );
+            setWorkspaceInteractionEvent(
+              (current) => !current || event.sequence > current.sequence ? event : current
+            );
+            interactionCallbackRef.current?.(event);
+          }
+        }
+      } catch (error) {
+        if (strictContract && error instanceof OpenGeniApiContractMismatchError) {
+          setContractMismatch(error);
+          reloadForContractMismatchOnce(error);
+        }
+        if (!controller.signal.aborted) {
+          setWorkspaceControlConnectionState("error");
+          setWorkspaceInteractionConnectionState("error");
+        }
+      }
+    })();
+    return () => controller.abort();
+  }, [
+    client,
+    pageLive,
+    strictContract,
+    supportsWorkspaceLiveStream,
+    verifyApiContract,
+    workspaceId
+  ]);
+  useEffect(() => {
+    if (supportsWorkspaceLiveStream) return;
+    if (!pageLive) {
+      setWorkspaceControlConnectionState("idle");
+      return;
+    }
+    const controller = new AbortController();
+    setWorkspaceControlConnectionState("connecting");
+    void (async () => {
+      try {
+        await verifyApiContract();
+        const workspace = await client.getWorkspace(workspaceId);
+        const resumeAfter = Math.max(
+          workspaceControlSequencesRef.current.get(workspaceId) ?? 0,
+          workspace.inferenceControl.revision
+        );
+        workspaceControlSequencesRef.current.set(workspaceId, resumeAfter);
+        const stream = client.streamWorkspaceControlEvents(workspaceId, {
+          after: resumeAfter,
+          signal: controller.signal,
+          onStateChange: setWorkspaceControlConnectionState
+        });
+        for await (const event of stream) {
+          if (controller.signal.aborted) return;
+          workspaceControlSequencesRef.current.set(
+            workspaceId,
+            Math.max(workspaceControlSequencesRef.current.get(workspaceId) ?? 0, event.sequence)
+          );
+          setWorkspaceControlEvent(
+            (current) => !current || event.sequence > current.sequence ? event : current
+          );
+          callbackRef.current?.(event);
+        }
+      } catch (error) {
+        if (strictContract && error instanceof OpenGeniApiContractMismatchError) {
+          setContractMismatch(error);
+          reloadForContractMismatchOnce(error);
+        }
+        if (!controller.signal.aborted) setWorkspaceControlConnectionState("error");
+      }
+    })();
+    return () => controller.abort();
+  }, [
+    client,
+    pageLive,
+    strictContract,
+    supportsWorkspaceLiveStream,
+    verifyApiContract,
+    workspaceId
+  ]);
+  useEffect(() => {
+    if (supportsWorkspaceLiveStream) return;
+    setWorkspaceInteractionEvent(null);
+    if (!pageLive) {
+      setWorkspaceInteractionConnectionState("idle");
+      return;
+    }
+    const controller = new AbortController();
+    setWorkspaceInteractionConnectionState("connecting");
+    void (async () => {
+      try {
+        await verifyApiContract();
+        const resumeAfter = workspaceInteractionSequencesRef.current.get(workspaceId) ?? 0;
+        const stream = client.streamWorkspaceInteractionRevisions(workspaceId, {
+          after: resumeAfter,
+          signal: controller.signal,
+          onStateChange: setWorkspaceInteractionConnectionState
+        });
+        for await (const event of stream) {
+          if (controller.signal.aborted) return;
+          workspaceInteractionSequencesRef.current.set(
+            workspaceId,
+            Math.max(
+              workspaceInteractionSequencesRef.current.get(workspaceId) ?? 0,
+              event.sequence
+            )
+          );
+          setWorkspaceInteractionEvent(
+            (current) => !current || event.sequence > current.sequence ? event : current
+          );
+          interactionCallbackRef.current?.(event);
+        }
+      } catch (error) {
+        if (strictContract && error instanceof OpenGeniApiContractMismatchError) {
+          setContractMismatch(error);
+          reloadForContractMismatchOnce(error);
+        }
+        if (!controller.signal.aborted) setWorkspaceInteractionConnectionState("error");
+      }
+    })();
+    return () => controller.abort();
+  }, [
+    client,
+    pageLive,
+    strictContract,
+    supportsWorkspaceLiveStream,
+    verifyApiContract,
+    workspaceId
+  ]);
+  const value = useMemo(
+    () => ({
+      client,
+      workspaceId,
+      workspaceControlEvent,
+      workspaceControlConnectionState,
+      workspaceInteractionEvent,
+      workspaceInteractionConnectionState,
+      registerSessionReconciler,
+      reconcileSession
+    }),
+    [
+      client,
+      workspaceId,
+      workspaceControlEvent,
+      workspaceControlConnectionState,
+      workspaceInteractionEvent,
+      workspaceInteractionConnectionState,
+      registerSessionReconciler,
+      reconcileSession
+    ]
+  );
+  return /* @__PURE__ */ jsx(ErrorMessageContext.Provider, { value: formatError, children: /* @__PURE__ */ jsxs(OpenGeniContext.Provider, { value, children: [
+    children,
+    contractMismatch ? /* @__PURE__ */ jsx(ApiContractMismatchScreen, { mismatch: contractMismatch }) : null
+  ] }) });
+}
+function withTimeout(promise, timeoutMs, label) {
+  let timer;
+  return Promise.race([
+    promise,
+    new Promise((_resolve, reject) => {
+      timer = setTimeout(
+        () => reject(new Error(`${label} timed out after ${timeoutMs}ms`)),
+        timeoutMs
+      );
+    })
+  ]).finally(() => {
+    if (timer !== void 0) clearTimeout(timer);
+  });
+}
+function ApiContractMismatchScreen({ mismatch }) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: "og-root fixed inset-0 z-[2147483647] grid place-items-center bg-og-bg/95 p-6 backdrop-blur-sm",
+      role: "alert",
+      "aria-live": "assertive",
+      "data-opengeni-api-contract-mismatch": true,
+      children: /* @__PURE__ */ jsxs("div", { className: "w-full max-w-md rounded-xl border border-og-border bg-og-surface p-6 shadow-2xl", children: [
+        /* @__PURE__ */ jsx("p", { className: "text-og-menu font-semibold text-og-fg", children: "Opengeni updated" }),
+        /* @__PURE__ */ jsx("p", { className: "mt-2 text-og-menu leading-6 text-og-muted", children: "This tab cannot safely continue with the new server version. Reload it before sending or controlling work." }),
+        /* @__PURE__ */ jsxs("p", { className: "mt-3 font-mono text-og-control text-og-subtle", children: [
+          "Client ",
+          mismatch.expected,
+          " \xB7 API ",
+          mismatch.actual
+        ] }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            className: "mt-5 inline-flex h-9 items-center rounded-md border border-og-primary-border bg-og-primary text-og-primary-fg hover:bg-og-primary-hover px-3 text-og-menu font-medium",
+            onClick: () => window.location.reload(),
+            children: "Reload now"
+          }
+        )
+      ] })
+    }
+  );
+}
+function reloadForContractMismatchOnce(mismatch) {
+  if (typeof window === "undefined" || typeof sessionStorage === "undefined") return;
+  const key = `${CONTRACT_RELOAD_STORAGE_PREFIX}${mismatch.actual}`;
+  if (sessionStorage.getItem(key) === OPENGENI_API_CONTRACT_REVISION) return;
+  sessionStorage.setItem(key, OPENGENI_API_CONTRACT_REVISION);
+  window.setTimeout(() => window.location.reload(), 150);
+}
+
+export {
+  peekSharedQuery,
+  sharedQueryWriter,
+  invalidateSharedQueries,
+  useSharedQuery,
+  useSharedQueryValue,
+  OpenGeniProvider
+};
+//# sourceMappingURL=chunk-R5SBNG7S.js.map