@athenaintel/react 0.20.0 → 0.21.0

package/dist/packages/agent-runtime/src/quota-safe-local-storage-session.cjs

@@ -1,15 +1,21 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const localStorage = require("@assistant-ui/react-statewire/local-storage");
+const tap = require("@assistant-ui/tap");
+const storage = require("statewire/storage");
+const react = require("react");
 const SESSION_PREFIX = "aui:statewire-session:";
+const SESSION_LOCK_PREFIX = "aui:statewire-session-lock:";
+const SESSION_ACTIVE_PREFIX = "aui:statewire-session-active:";
 const LEGACY_PROTOCOL = { name: "athena", version: "2026-09-07" };
+const DAY_MS = 24 * 60 * 60 * 1e3;
+const READABLE_STORAGE_VERSIONS = /* @__PURE__ */ new Set([1, 2]);
 const browserGlobals = globalThis;
 function readPersistedFailedSendStamps(sessionKey) {
-  const storage = browserGlobals.localStorage;
-  if (!storage) return null;
+  const storage2 = browserGlobals.localStorage;
+  if (!storage2) return null;
   let record;
   try {
-    const raw = storage.getItem(SESSION_PREFIX + sessionKey);
+    const raw = storage2.getItem(SESSION_PREFIX + sessionKey);
     record = raw === null ? null : JSON.parse(raw);
   } catch {
     return null;
@@ -30,18 +36,294 @@ function readFailedSendStampsFromRecord(record) {
   }
   return stamps;
 }
-const QuotaSafeLocalStorageSession = ({
-  threadId,
-  key,
-  ttl = 7 * 24 * 60 * 60 * 1e3,
-  max = 50
-}) => localStorage.LocalStorageSession({
+function isStorageQuotaError(error) {
+  if (typeof error !== "object" || error === null) return false;
+  const { name, code, message } = error;
+  return name === "QuotaExceededError" || name === "NS_ERROR_DOM_QUOTA_REACHED" || code === 22 || code === 1014 || typeof message === "string" && /exceeded the quota|quotaexceedederror|ns_error_dom_quota_reached/i.test(
+    message
+  );
+}
+function asStatewireQuotaError(error) {
+  if (error instanceof Error && error.name === "QuotaExceededError")
+    return error;
+  const normalized = new Error(
+    error instanceof Error ? error.message : "storage quota exceeded"
+  );
+  normalized.name = "QuotaExceededError";
+  return normalized;
+}
+function unreadableRecord(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    return error instanceof Error ? error : new Error("stored session record is not JSON");
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return new Error("stored session record is not an object");
+  }
+  const version = parsed.statewireStorageVersion;
+  if (version !== void 0 && !READABLE_STORAGE_VERSIONS.has(version)) {
+    return new Error(
+      `stored session record uses storage version ${String(version)}`
+    );
+  }
+  return void 0;
+}
+function browserBackend({
+  storage: storage2,
+  locks
+}) {
+  return {
+    getItem: (key) => storage2.getItem(key),
+    setItem: (key, value) => storage2.setItem(key, value),
+    removeItem: (key) => storage2.removeItem(key),
+    getAllKeys: () => Array.from(
+      { length: storage2.length },
+      (_, index) => storage2.key(index)
+    ).filter((key) => key !== null),
+    withUnused: async (key, action) => {
+      await locks.request(
+        SESSION_ACTIVE_PREFIX + key,
+        { ifAvailable: true },
+        async (active) => {
+          if (active === null) return;
+          await locks.request(
+            SESSION_LOCK_PREFIX + key.slice(SESSION_PREFIX.length),
+            { ifAvailable: true },
+            async (lock) => {
+              if (lock === null) return;
+              await action();
+            }
+          );
+        }
+      );
+    }
+  };
+}
+function quotaTolerantBackend({
+  inner,
+  onDegraded
+}) {
+  const quotaSurfaced = /* @__PURE__ */ new Set();
+  const overlay = /* @__PURE__ */ new Map();
+  const shielded = /* @__PURE__ */ new Set();
+  const checked = /* @__PURE__ */ new Map();
+  const readable = (key, raw) => {
+    const previous = checked.get(key);
+    if (previous !== void 0 && previous.raw === raw) return previous.verdict;
+    const verdict = unreadableRecord(raw);
+    checked.set(key, { raw, verdict });
+    return verdict;
+  };
+  return {
+    getItem: (key) => {
+      const shadowed = overlay.get(key);
+      if (shadowed !== void 0) return shadowed;
+      if (shielded.has(key)) return null;
+      let raw;
+      try {
+        raw = inner.getItem(key);
+      } catch (error) {
+        shielded.add(key);
+        onDegraded({ operation: "getItem", key, error });
+        return null;
+      }
+      if (raw === null) return null;
+      const unreadable = readable(key, raw);
+      if (unreadable === void 0) return raw;
+      shielded.add(key);
+      onDegraded({ operation: "record", key, error: unreadable });
+      return null;
+    },
+    setItem: (key, value) => {
+      if (shielded.has(key)) {
+        overlay.set(key, value);
+        return;
+      }
+      try {
+        inner.setItem(key, value);
+        overlay.delete(key);
+        quotaSurfaced.delete(key);
+      } catch (error) {
+        if (isStorageQuotaError(error) && !quotaSurfaced.has(key)) {
+          quotaSurfaced.add(key);
+          throw asStatewireQuotaError(error);
+        }
+        overlay.set(key, value);
+        onDegraded({ operation: "setItem", key, error });
+      }
+    },
+    removeItem: (key) => {
+      overlay.delete(key);
+      if (shielded.has(key)) return;
+      try {
+        inner.removeItem(key);
+      } catch (error) {
+        onDegraded({ operation: "removeItem", key, error });
+      }
+    },
+    getAllKeys: () => {
+      const keys = new Set(overlay.keys());
+      try {
+        for (const key of inner.getAllKeys()) keys.add(key);
+      } catch (error) {
+        onDegraded({ operation: "getAllKeys", key: "", error });
+      }
+      return [...keys];
+    },
+    withUnused: async (key, action) => {
+      try {
+        await inner.withUnused(key, action);
+      } catch (error) {
+        onDegraded({ operation: "withUnused", key, error });
+      }
+    }
+  };
+}
+const sharedBackends = /* @__PURE__ */ new WeakMap();
+function sharedBackend({
+  storage: storage2,
+  locks
+}) {
+  let shared = sharedBackends.get(storage2);
+  if (shared === void 0) {
+    const listeners = /* @__PURE__ */ new Set();
+    shared = {
+      listeners,
+      backend: quotaTolerantBackend({
+        inner: browserBackend({ storage: storage2, locks }),
+        onDegraded: (degradation) => {
+          for (const listener of listeners) listener(degradation);
+        }
+      })
+    };
+    sharedBackends.set(storage2, shared);
+  }
+  return shared;
+}
+const useQuotaSafeLocalStorageSession = ({
   threadId,
-  ...key === void 0 ? {} : { key },
-  legacyProtocol: LEGACY_PROTOCOL,
-  retention: { maxAgeMs: ttl, maxEntries: max }
-});
+  key = (id) => id,
+  ttl = 7 * DAY_MS,
+  max = 50,
+  onStorageDegraded
+}) => {
+  var _a;
+  const storage$1 = browserGlobals.localStorage;
+  const locks = (_a = browserGlobals.navigator) == null ? void 0 : _a.locks;
+  if (!storage$1)
+    throw new Error(
+      "statewire: QuotaSafeLocalStorageSession requires localStorage"
+    );
+  if (!locks)
+    throw new Error(
+      "statewire: QuotaSafeLocalStorageSession requires the Web Locks API (navigator.locks)"
+    );
+  const sessionKey = key(threadId);
+  const storageKey = SESSION_PREFIX + sessionKey;
+  const lockName = SESSION_LOCK_PREFIX + sessionKey;
+  const latestOnDegraded = react.useRef(onStorageDegraded);
+  latestOnDegraded.current = onStorageDegraded;
+  const reportDegradation = react.useMemo(() => {
+    const reported = /* @__PURE__ */ new Set();
+    return (degradation) => {
+      const handler = latestOnDegraded.current;
+      if (handler) {
+        try {
+          handler(degradation);
+        } catch {
+        }
+        return;
+      }
+      const dedupeKey = `${degradation.operation}:${degradation.key}`;
+      if (reported.has(dedupeKey)) return;
+      reported.add(dedupeKey);
+      console.warn(
+        `[statewire] session storage degraded to memory only (${degradation.operation} ${degradation.key})`,
+        degradation.error
+      );
+    };
+  }, []);
+  const shared = sharedBackend({ storage: storage$1, locks });
+  shared.listeners.add(reportDegradation);
+  react.useEffect(() => {
+    shared.listeners.add(reportDegradation);
+    return () => {
+      shared.listeners.delete(reportDegradation);
+    };
+  }, [shared, reportDegradation]);
+  react.useEffect(() => {
+    let release;
+    let disposed = false;
+    Promise.resolve(
+      locks.request(
+        SESSION_ACTIVE_PREFIX + storageKey,
+        { mode: "shared" },
+        () => {
+          if (disposed) return;
+          return new Promise((resolve) => {
+            release = resolve;
+          });
+        }
+      )
+    ).catch(
+      (error) => reportDegradation({ operation: "lock", key: storageKey, error })
+    );
+    return () => {
+      disposed = true;
+      release == null ? void 0 : release();
+    };
+  }, [locks, storageKey, reportDegradation]);
+  const sessionStorage = tap.useResource(
+    storage.KeyValueSessionStorage({
+      backend: shared.backend,
+      key: sessionKey,
+      namespace: SESSION_PREFIX,
+      legacyProtocol: LEGACY_PROTOCOL,
+      retention: { maxAgeMs: ttl, maxEntries: max },
+      // A failure statewire raises itself (a structurally invalid stored
+      // record) still stops the session; it is at least reported the same way.
+      onError: (error) => reportDegradation({ operation: "session", key: storageKey, error })
+    })
+  );
+  return react.useMemo(
+    () => ({
+      ...sessionStorage,
+      lock: async (fn) => {
+        let granted = false;
+        try {
+          return await locks.request(lockName, async () => {
+            granted = true;
+            return fn();
+          });
+        } catch (error) {
+          if (granted) throw error;
+          reportDegradation({ operation: "lock", key: storageKey, error });
+          return fn();
+        }
+      },
+      subscribe: (listener) => {
+        var _a2;
+        const onStorage = (event) => {
+          if (event.key === storageKey) listener();
+        };
+        (_a2 = browserGlobals.addEventListener) == null ? void 0 : _a2.call(browserGlobals, "storage", onStorage);
+        return () => {
+          var _a3;
+          return (_a3 = browserGlobals.removeEventListener) == null ? void 0 : _a3.call(browserGlobals, "storage", onStorage);
+        };
+      }
+    }),
+    [sessionStorage, locks, storageKey, lockName, reportDegradation]
+  );
+};
+const QuotaSafeLocalStorageSession = tap.resource(
+  useQuotaSafeLocalStorageSession
+);
 exports.QuotaSafeLocalStorageSession = QuotaSafeLocalStorageSession;
+exports.isStorageQuotaError = isStorageQuotaError;
+exports.quotaTolerantBackend = quotaTolerantBackend;
 exports.readFailedSendStampsFromRecord = readFailedSendStampsFromRecord;
 exports.readPersistedFailedSendStamps = readPersistedFailedSendStamps;
 //# sourceMappingURL=quota-safe-local-storage-session.cjs.map

package/dist/packages/agent-runtime/src/quota-safe-local-storage-session.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"quota-safe-local-storage-session.cjs","sources":["../../../../../agent-runtime/src/quota-safe-local-storage-session.ts"],"sourcesContent":["import { LocalStorageSession } from \"@assistant-ui/react-statewire/local-storage\";\n\nconst SESSION_PREFIX = \"aui:statewire-session:\";\nconst LEGACY_PROTOCOL = { name: \"athena\", version: \"2026-09-07\" };\nconst browserGlobals = globalThis as {\n  localStorage?: { getItem(key: string): string | null };\n};\n\nexport function readPersistedFailedSendStamps(\n  sessionKey: string,\n): ReadonlyMap<string, number> | null {\n  const storage = browserGlobals.localStorage;\n  if (!storage) return null;\n  let record: { failed?: unknown } | null;\n  try {\n    const raw = storage.getItem(SESSION_PREFIX + sessionKey);\n    record =\n      raw === null ? null : (JSON.parse(raw) as { failed?: unknown } | null);\n  } catch {\n    return null;\n  }\n  return readFailedSendStampsFromRecord(record);\n}\n\n/**\n * Send stamps (message id → epoch ms of the original send) off an already\n * loaded session record's failed lane — the storage-agnostic half of\n * {@link readPersistedFailedSendStamps}, for hosts whose session store is not\n * localStorage (the React Native AsyncStorage-backed store reads its record\n * synchronously through `SessionStorage.load()`).\n *\n * Returns `null` for no record (every failed entry then counts as fresh) and\n * an empty map for a record without failures.\n */\nexport function readFailedSendStampsFromRecord(\n  record: { failed?: unknown } | null | undefined,\n): ReadonlyMap<string, number> | null {\n  if (!record || typeof record !== \"object\") return null;\n  const stamps = new Map<string, number>();\n  if (!Array.isArray(record.failed)) return stamps;\n  for (const entry of record.failed) {\n    const failed = entry as {\n      ts?: unknown;\n      params?: readonly { message?: { id?: unknown } }[];\n    } | null;\n    const messageId = failed?.params?.[0]?.message?.id;\n    if (typeof messageId === \"string\" && typeof failed?.ts === \"number\") {\n      stamps.set(messageId, failed.ts);\n    }\n  }\n  return stamps;\n}\n\n/** Athena's browser session keys and retention policy. */\nexport const QuotaSafeLocalStorageSession = ({\n  threadId,\n  key,\n  ttl = 7 * 24 * 60 * 60 * 1000,\n  max = 50,\n}: QuotaSafeLocalStorageSession.Options) =>\n  LocalStorageSession({\n    threadId,\n    ...(key === undefined ? {} : { key }),\n    legacyProtocol: LEGACY_PROTOCOL,\n    retention: { maxAgeMs: ttl, maxEntries: max },\n  });\n\nexport namespace QuotaSafeLocalStorageSession {\n  export type Options = {\n    threadId: string;\n    key?: (threadId: string) => string;\n    ttl?: number;\n    max?: number;\n  };\n}\n"],"names":["LocalStorageSession"],"mappings":";;;AAEA,MAAM,iBAAiB;AACvB,MAAM,kBAAkB,EAAE,MAAM,UAAU,SAAS,aAAA;AACnD,MAAM,iBAAiB;AAIhB,SAAS,8BACd,YACoC;AACpC,QAAM,UAAU,eAAe;AAC/B,MAAI,CAAC,QAAS,QAAO;AACrB,MAAI;AACJ,MAAI;AACF,UAAM,MAAM,QAAQ,QAAQ,iBAAiB,UAAU;AACvD,aACE,QAAQ,OAAO,OAAQ,KAAK,MAAM,GAAG;AAAA,EACzC,QAAQ;AACN,WAAO;AAAA,EACT;AACA,SAAO,+BAA+B,MAAM;AAC9C;AAYO,SAAS,+BACd,QACoC;;AACpC,MAAI,CAAC,UAAU,OAAO,WAAW,SAAU,QAAO;AAClD,QAAM,6BAAa,IAAA;AACnB,MAAI,CAAC,MAAM,QAAQ,OAAO,MAAM,EAAG,QAAO;AAC1C,aAAW,SAAS,OAAO,QAAQ;AACjC,UAAM,SAAS;AAIf,UAAM,aAAY,kDAAQ,WAAR,mBAAiB,OAAjB,mBAAqB,YAArB,mBAA8B;AAChD,QAAI,OAAO,cAAc,YAAY,QAAO,iCAAQ,QAAO,UAAU;AACnE,aAAO,IAAI,WAAW,OAAO,EAAE;AAAA,IACjC;AAAA,EACF;AACA,SAAO;AACT;AAGO,MAAM,+BAA+B,CAAC;AAAA,EAC3C;AAAA,EACA;AAAA,EACA,MAAM,IAAI,KAAK,KAAK,KAAK;AAAA,EACzB,MAAM;AACR,MACEA,iCAAoB;AAAA,EAClB;AAAA,EACA,GAAI,QAAQ,SAAY,CAAA,IAAK,EAAE,IAAA;AAAA,EAC/B,gBAAgB;AAAA,EAChB,WAAW,EAAE,UAAU,KAAK,YAAY,IAAA;AAC1C,CAAC;;;;"}
+{"version":3,"file":"quota-safe-local-storage-session.cjs","sources":["../../../../../agent-runtime/src/quota-safe-local-storage-session.ts"],"sourcesContent":["import { resource, useResource } from \"@assistant-ui/tap\";\nimport type { StatewireClient } from \"statewire\";\nimport { KeyValueSessionStorage } from \"statewire/storage\";\nimport { useEffect, useMemo, useRef } from \"react\";\n\nconst SESSION_PREFIX = \"aui:statewire-session:\";\nconst SESSION_LOCK_PREFIX = \"aui:statewire-session-lock:\";\nconst SESSION_ACTIVE_PREFIX = \"aui:statewire-session-active:\";\nconst LEGACY_PROTOCOL = { name: \"athena\", version: \"2026-09-07\" };\nconst DAY_MS = 24 * 60 * 60 * 1000;\n/** The stored-record formats the statewire this build ships reads (it writes 2). */\nconst READABLE_STORAGE_VERSIONS: ReadonlySet<unknown> = new Set([1, 2]);\n\n/** Structural view of the browser storage global — this package compiles\n * without the DOM lib (React Native honesty; see `globals.d.ts`). */\ntype StorageLike = {\n  getItem(key: string): string | null;\n  setItem(key: string, value: string): void;\n  removeItem(key: string): void;\n  key(index: number): string | null;\n  readonly length: number;\n};\n\ntype LockGrant = object | null;\n\n/** The Web Locks API surface the session uses (`navigator.locks`). */\ntype LockManagerLike = {\n  request<T>(\n    name: string,\n    callback: (lock: LockGrant) => T | Promise<T>,\n  ): Promise<T>;\n  request<T>(\n    name: string,\n    options: { mode?: \"shared\" | \"exclusive\"; ifAvailable?: boolean },\n    callback: (lock: LockGrant) => T | Promise<T>,\n  ): Promise<T>;\n};\n\ntype StorageEventLike = { key: string | null };\n\ntype BrowserGlobals = {\n  localStorage?: StorageLike;\n  navigator?: { locks?: LockManagerLike };\n  addEventListener?: (\n    type: \"storage\",\n    listener: (event: StorageEventLike) => void,\n  ) => void;\n  removeEventListener?: (\n    type: \"storage\",\n    listener: (event: StorageEventLike) => void,\n  ) => void;\n};\n\nconst browserGlobals = globalThis as BrowserGlobals;\n\nexport function readPersistedFailedSendStamps(\n  sessionKey: string,\n): ReadonlyMap<string, number> | null {\n  const storage = browserGlobals.localStorage;\n  if (!storage) return null;\n  let record: { failed?: unknown } | null;\n  try {\n    const raw = storage.getItem(SESSION_PREFIX + sessionKey);\n    record =\n      raw === null ? null : (JSON.parse(raw) as { failed?: unknown } | null);\n  } catch {\n    return null;\n  }\n  return readFailedSendStampsFromRecord(record);\n}\n\n/**\n * Send stamps (message id → epoch ms of the original send) off an already\n * loaded session record's failed lane — the storage-agnostic half of\n * {@link readPersistedFailedSendStamps}, for hosts whose session store is not\n * localStorage (the React Native AsyncStorage-backed store reads its record\n * synchronously through `SessionStorage.load()`).\n *\n * Returns `null` for no record (every failed entry then counts as fresh) and\n * an empty map for a record without failures.\n */\nexport function readFailedSendStampsFromRecord(\n  record: { failed?: unknown } | null | undefined,\n): ReadonlyMap<string, number> | null {\n  if (!record || typeof record !== \"object\") return null;\n  const stamps = new Map<string, number>();\n  if (!Array.isArray(record.failed)) return stamps;\n  for (const entry of record.failed) {\n    const failed = entry as {\n      ts?: unknown;\n      params?: readonly { message?: { id?: unknown } }[];\n    } | null;\n    const messageId = failed?.params?.[0]?.message?.id;\n    if (typeof messageId === \"string\" && typeof failed?.ts === \"number\") {\n      stamps.set(messageId, failed.ts);\n    }\n  }\n  return stamps;\n}\n\n/** A storage operation the session survived by degrading instead of failing. */\nexport type SessionStorageDegradation = {\n  operation:\n    | \"getItem\"\n    | \"setItem\"\n    | \"removeItem\"\n    | \"getAllKeys\"\n    | \"withUnused\"\n    /** The lock manager refused the transaction fence; it ran unfenced. */\n    | \"lock\"\n    /**\n     * The stored record is one this build cannot read (not JSON, or a newer\n     * storage version): served as absent, and the key is shielded from being\n     * overwritten so the record survives this tab.\n     */\n    | \"record\"\n    /** statewire's own storage failure (a structurally invalid stored record). */\n    | \"session\";\n  key: string;\n  error: unknown;\n};\n\n/**\n * Whether `error` is the browser refusing a write for lack of room, under\n * every name the engines use — `QuotaExceededError` (Chromium, WebKit, current\n * Firefox), `NS_ERROR_DOM_QUOTA_REACHED` (older Firefox), the legacy\n * `DOMException` codes 22 (WebKit) and 1014 (Firefox) — or a plain error whose\n * message carries one of those (storage proxies and WebViews rewrap the\n * exception). Olympus's `isStorageQuotaError` recognises the same set; the two\n * stay in step.\n */\nexport function isStorageQuotaError(error: unknown): boolean {\n  if (typeof error !== \"object\" || error === null) return false;\n  const { name, code, message } = error as {\n    name?: unknown;\n    code?: unknown;\n    message?: unknown;\n  };\n  return (\n    name === \"QuotaExceededError\" ||\n    name === \"NS_ERROR_DOM_QUOTA_REACHED\" ||\n    code === 22 ||\n    code === 1014 ||\n    (typeof message === \"string\" &&\n      /exceeded the quota|quotaexceedederror|ns_error_dom_quota_reached/i.test(\n        message,\n      ))\n  );\n}\n\n/** The one quota shape statewire's retention sweep recognises. */\nfunction asStatewireQuotaError(error: unknown): Error {\n  if (error instanceof Error && error.name === \"QuotaExceededError\")\n    return error;\n  const normalized = new Error(\n    error instanceof Error ? error.message : \"storage quota exceeded\",\n  );\n  normalized.name = \"QuotaExceededError\";\n  return normalized;\n}\n\n/**\n * Why `raw` is a stored record this build cannot read, or `undefined` when it\n * may be one. Mirrors the two decode failures statewire raises for a record it\n * cannot read — invalid JSON, and a `statewireStorageVersion` newer than the\n * ones this build's statewire decodes (a tab left open across a\n * statewire upgrade, reading the record a newer tab keeps) — because statewire\n * throws those out of the resource at mount instead of treating the record as\n * absent. A structurally invalid record of the right version still fails\n * inside statewire.\n */\nfunction unreadableRecord(raw: string): Error | undefined {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(raw);\n  } catch (error) {\n    return error instanceof Error\n      ? error\n      : new Error(\"stored session record is not JSON\");\n  }\n  if (typeof parsed !== \"object\" || parsed === null) {\n    return new Error(\"stored session record is not an object\");\n  }\n  const version = (parsed as { statewireStorageVersion?: unknown })\n    .statewireStorageVersion;\n  if (version !== undefined && !READABLE_STORAGE_VERSIONS.has(version)) {\n    return new Error(\n      `stored session record uses storage version ${String(version)}`,\n    );\n  }\n  return undefined;\n}\n\ntype SyncBackend = {\n  getItem: (key: string) => string | null;\n  setItem: (key: string, value: string) => void;\n  removeItem: (key: string) => void;\n  getAllKeys: () => readonly string[];\n  withUnused: (key: string, action: () => Promise<void>) => Promise<void>;\n};\n\n/**\n * The browser backend `@assistant-ui/react-statewire`'s `LocalStorageSession`\n * uses, reproduced here because that resource does not take a backend: raw\n * `localStorage`, with retention cleanup fenced by the same Web Locks so a\n * sweep never removes a record another tab is actively sharing.\n */\nfunction browserBackend({\n  storage,\n  locks,\n}: {\n  storage: StorageLike;\n  locks: LockManagerLike;\n}): SyncBackend {\n  return {\n    getItem: (key) => storage.getItem(key),\n    setItem: (key, value) => storage.setItem(key, value),\n    removeItem: (key) => storage.removeItem(key),\n    getAllKeys: () =>\n      Array.from({ length: storage.length }, (_, index) =>\n        storage.key(index),\n      ).filter((key): key is string => key !== null),\n    withUnused: async (key, action) => {\n      await locks.request(\n        SESSION_ACTIVE_PREFIX + key,\n        { ifAvailable: true },\n        async (active) => {\n          if (active === null) return;\n          await locks.request(\n            SESSION_LOCK_PREFIX + key.slice(SESSION_PREFIX.length),\n            { ifAvailable: true },\n            async (lock) => {\n              if (lock === null) return;\n              await action();\n            },\n          );\n        },\n      );\n    },\n  };\n}\n\n/**\n * Wraps a synchronous key-value backend so a failing origin degrades the\n * session to memory-only persistence instead of stopping the connection.\n *\n * statewire's session storage latches the first unrecognised write failure\n * and from then on rejects every send (`stopped/storage-error`, \"session\n * storage failed\" on the connection chip). It only recovers a\n * `QuotaExceededError` by that exact name — sweeping old session records and\n * retrying the write once — and latches again when the retry fails too. Here\n * the first quota failure per key is surfaced under that name so the sweep\n * runs; the retry that follows it and every other storage failure are absorbed\n * and reported through `onDegraded`, so chat keeps working.\n *\n * An absorbed write is kept in an in-memory overlay that `getItem` serves\n * first: statewire re-reads the record through `load()` on every shared-mode\n * transaction, so a stale persisted copy would otherwise win back its old\n * `nextSeq`, `clientId` and command journal. The overlay is per tab — another\n * tab sharing the thread still reads the last persisted copy, which is the\n * memory-only degradation this backend exists to allow. A later successful\n * write clears the overlay entry.\n *\n * A key whose read threw, or whose stored value this build cannot read (see\n * {@link unreadableRecord}), is served as absent and shielded: writes to it\n * stay in the overlay for good, so a fresh lane minted over an unreadable\n * record never overwrites what another tab or a newer build persisted.\n */\nexport function quotaTolerantBackend({\n  inner,\n  onDegraded,\n}: {\n  inner: SyncBackend;\n  onDegraded: (degradation: SessionStorageDegradation) => void;\n}): KeyValueSessionStorage.Backend {\n  // Keys whose write already surfaced a quota error to statewire: until a\n  // write succeeds again, later failures on the key are absorbed instead of\n  // surfaced, or every save would re-run statewire's sweep (which evicts\n  // other threads' idle records) and the failure would latch on the retry.\n  const quotaSurfaced = new Set<string>();\n  // Absorbed writes, served ahead of the backend (see the function docs).\n  const overlay = new Map<string, string>();\n  // Keys served as absent and never written through (see the function docs).\n  const shielded = new Set<string>();\n  // statewire re-reads and re-decodes the record on every transaction; the\n  // readability check is memoised on the raw string so it costs one string\n  // comparison per read, not a second parse.\n  const checked = new Map<\n    string,\n    { raw: string; verdict: Error | undefined }\n  >();\n  const readable = (key: string, raw: string): Error | undefined => {\n    const previous = checked.get(key);\n    if (previous !== undefined && previous.raw === raw) return previous.verdict;\n    const verdict = unreadableRecord(raw);\n    checked.set(key, { raw, verdict });\n    return verdict;\n  };\n  return {\n    getItem: (key) => {\n      const shadowed = overlay.get(key);\n      if (shadowed !== undefined) return shadowed;\n      if (shielded.has(key)) return null;\n      let raw: string | null;\n      try {\n        raw = inner.getItem(key);\n      } catch (error) {\n        shielded.add(key);\n        onDegraded({ operation: \"getItem\", key, error });\n        return null;\n      }\n      if (raw === null) return null;\n      const unreadable = readable(key, raw);\n      if (unreadable === undefined) return raw;\n      shielded.add(key);\n      onDegraded({ operation: \"record\", key, error: unreadable });\n      return null;\n    },\n    setItem: (key, value) => {\n      if (shielded.has(key)) {\n        overlay.set(key, value);\n        return;\n      }\n      try {\n        inner.setItem(key, value);\n        overlay.delete(key);\n        quotaSurfaced.delete(key);\n      } catch (error) {\n        if (isStorageQuotaError(error) && !quotaSurfaced.has(key)) {\n          quotaSurfaced.add(key);\n          throw asStatewireQuotaError(error);\n        }\n        overlay.set(key, value);\n        onDegraded({ operation: \"setItem\", key, error });\n      }\n    },\n    removeItem: (key) => {\n      overlay.delete(key);\n      if (shielded.has(key)) return;\n      try {\n        inner.removeItem(key);\n      } catch (error) {\n        onDegraded({ operation: \"removeItem\", key, error });\n      }\n    },\n    getAllKeys: () => {\n      const keys = new Set<string>(overlay.keys());\n      try {\n        for (const key of inner.getAllKeys()) keys.add(key);\n      } catch (error) {\n        onDegraded({ operation: \"getAllKeys\", key: \"\", error });\n      }\n      return [...keys];\n    },\n    withUnused: async (key, action) => {\n      try {\n        await inner.withUnused(key, action);\n      } catch (error) {\n        onDegraded({ operation: \"withUnused\", key, error });\n      }\n    },\n  };\n}\n\ntype DegradationListener = (degradation: SessionStorageDegradation) => void;\n\ntype SharedBackend = {\n  backend: KeyValueSessionStorage.Backend;\n  listeners: Set<DegradationListener>;\n};\n\n/**\n * One backend per storage object — per origin, in a browser — shared by every\n * session mounted in the tab, exactly as the upstream resource's module-level\n * backend is. statewire keys its in-tab \"active\" bookkeeping by backend\n * identity, so a mount's retention sweep only skips the records of other\n * mounts on the *same* backend; and the absorbed-write overlay has to outlive\n * a remount of the same thread (a thread switch and back) or the remount would\n * read the stale persisted copy. Degradations fan out to every mounted\n * session's reporter.\n */\nconst sharedBackends = new WeakMap<StorageLike, SharedBackend>();\n\nfunction sharedBackend({\n  storage,\n  locks,\n}: {\n  storage: StorageLike;\n  locks: LockManagerLike;\n}): SharedBackend {\n  let shared = sharedBackends.get(storage);\n  if (shared === undefined) {\n    const listeners = new Set<DegradationListener>();\n    shared = {\n      listeners,\n      backend: quotaTolerantBackend({\n        inner: browserBackend({ storage, locks }),\n        onDegraded: (degradation) => {\n          for (const listener of listeners) listener(degradation);\n        },\n      }),\n    };\n    sharedBackends.set(storage, shared);\n  }\n  return shared;\n}\n\n/**\n * Athena's browser session store: `@assistant-ui/react-statewire`'s\n * `LocalStorageSession` contract (per-thread key under the shared prefix,\n * cross-tab Web Lock, storage-event subscription, retention) on top of\n * {@link quotaTolerantBackend}, with Athena's legacy protocol and retention\n * policy.\n */\nconst useQuotaSafeLocalStorageSession = ({\n  threadId,\n  key = (id) => id,\n  ttl = 7 * DAY_MS,\n  max = 50,\n  onStorageDegraded,\n}: QuotaSafeLocalStorageSession.Options): StatewireClient.SessionStorage => {\n  const storage = browserGlobals.localStorage;\n  const locks = browserGlobals.navigator?.locks;\n  if (!storage)\n    throw new Error(\n      \"statewire: QuotaSafeLocalStorageSession requires localStorage\",\n    );\n  if (!locks)\n    throw new Error(\n      \"statewire: QuotaSafeLocalStorageSession requires the Web Locks API (navigator.locks)\",\n    );\n  const sessionKey = key(threadId);\n  const storageKey = SESSION_PREFIX + sessionKey;\n  const lockName = SESSION_LOCK_PREFIX + sessionKey;\n\n  const latestOnDegraded = useRef(onStorageDegraded);\n  latestOnDegraded.current = onStorageDegraded;\n  const reportDegradation = useMemo(() => {\n    const reported = new Set<string>();\n    return (degradation: SessionStorageDegradation) => {\n      const handler = latestOnDegraded.current;\n      if (handler) {\n        try {\n          handler(degradation);\n        } catch {\n          // Reporting runs inside the session's recovery path and must never\n          // become the failure it is reporting.\n        }\n        return;\n      }\n      const dedupeKey = `${degradation.operation}:${degradation.key}`;\n      if (reported.has(dedupeKey)) return;\n      reported.add(dedupeKey);\n      console.warn(\n        `[statewire] session storage degraded to memory only (${degradation.operation} ${degradation.key})`,\n        degradation.error,\n      );\n    };\n  }, []);\n\n  const shared = sharedBackend({ storage, locks });\n  // Registered during render as well as in the effect: the read statewire\n  // makes while mounting below happens before any effect runs, and tap may\n  // clean an effect up and re-run it within one commit.\n  shared.listeners.add(reportDegradation);\n  useEffect(() => {\n    shared.listeners.add(reportDegradation);\n    return () => {\n      shared.listeners.delete(reportDegradation);\n    };\n  }, [shared, reportDegradation]);\n\n  // Hold the record's shared \"active\" lock while mounted so another tab's\n  // retention sweep skips it (the same fence the upstream resource holds).\n  useEffect(() => {\n    let release: (() => void) | undefined;\n    let disposed = false;\n    Promise.resolve(\n      locks.request(\n        SESSION_ACTIVE_PREFIX + storageKey,\n        { mode: \"shared\" },\n        () => {\n          if (disposed) return;\n          return new Promise<void>((resolve) => {\n            release = resolve;\n          });\n        },\n      ),\n    ).catch((error: unknown) =>\n      reportDegradation({ operation: \"lock\", key: storageKey, error }),\n    );\n    return () => {\n      disposed = true;\n      release?.();\n    };\n  }, [locks, storageKey, reportDegradation]);\n\n  const sessionStorage = useResource(\n    KeyValueSessionStorage({\n      backend: shared.backend,\n      key: sessionKey,\n      namespace: SESSION_PREFIX,\n      legacyProtocol: LEGACY_PROTOCOL,\n      retention: { maxAgeMs: ttl, maxEntries: max },\n      // A failure statewire raises itself (a structurally invalid stored\n      // record) still stops the session; it is at least reported the same way.\n      onError: (error) =>\n        reportDegradation({ operation: \"session\", key: storageKey, error }),\n    }),\n  );\n\n  return useMemo(\n    () => ({\n      ...sessionStorage,\n      lock: async <T>(fn: () => T | Promise<T>): Promise<T> => {\n        let granted = false;\n        try {\n          return await locks.request(lockName, async () => {\n            granted = true;\n            return fn();\n          });\n        } catch (error) {\n          if (granted) throw error;\n          // The lock manager refused the request itself (a detached or\n          // back/forward-cached document, a lockdown-mode origin): the\n          // transaction runs unfenced rather than stopping the session.\n          reportDegradation({ operation: \"lock\", key: storageKey, error });\n          return fn();\n        }\n      },\n      subscribe: (listener: () => void) => {\n        const onStorage = (event: StorageEventLike) => {\n          if (event.key === storageKey) listener();\n        };\n        browserGlobals.addEventListener?.(\"storage\", onStorage);\n        return () => browserGlobals.removeEventListener?.(\"storage\", onStorage);\n      },\n    }),\n    [sessionStorage, locks, storageKey, lockName, reportDegradation],\n  );\n};\n\n/** Athena's browser session keys and retention policy. */\nexport const QuotaSafeLocalStorageSession = resource(\n  useQuotaSafeLocalStorageSession,\n);\n\nexport namespace QuotaSafeLocalStorageSession {\n  export type Options = {\n    threadId: string;\n    key?: (threadId: string) => string;\n    ttl?: number;\n    max?: number;\n    /**\n     * Called when a storage operation failed and the session carried on in\n     * memory. Defaults to one `console.warn` per operation and key.\n     */\n    onStorageDegraded?: (degradation: SessionStorageDegradation) => void;\n  };\n}\n"],"names":["storage","useRef","useMemo","useEffect","useResource","KeyValueSessionStorage","_a","resource"],"mappings":"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"}