@athenaintel/react 0.41.3 → 0.42.1

package/dist/agent-runtime/src/sealed-idb.cjs

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const idbGlobals = globalThis;
+const SEALED_IV_BYTES = 12;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+async function sha256Hex(value) {
+  const digest = await crypto.subtle.digest("SHA-256", encoder.encode(value));
+  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function sealJson({
+  key,
+  value,
+  aad
+}) {
+  const iv = crypto.getRandomValues(new Uint8Array(SEALED_IV_BYTES));
+  const ciphertext = new Uint8Array(
+    await crypto.subtle.encrypt(
+      { name: "AES-GCM", iv, additionalData: encoder.encode(aad) },
+      key,
+      encoder.encode(JSON.stringify(value))
+    )
+  );
+  const sealed = new Uint8Array(SEALED_IV_BYTES + ciphertext.byteLength);
+  sealed.set(iv, 0);
+  sealed.set(ciphertext, SEALED_IV_BYTES);
+  return sealed;
+}
+async function openJson({
+  key,
+  sealed,
+  aad
+}) {
+  const iv = sealed.subarray(0, SEALED_IV_BYTES);
+  const plaintext = await crypto.subtle.decrypt(
+    { name: "AES-GCM", iv, additionalData: encoder.encode(aad) },
+    key,
+    sealed.subarray(SEALED_IV_BYTES)
+  );
+  return JSON.parse(decoder.decode(plaintext));
+}
+function requestToPromise(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
+  });
+}
+function transactionDone(tx) {
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onabort = () => reject(tx.error ?? new Error("IndexedDB transaction aborted"));
+    tx.onerror = () => reject(tx.error ?? new Error("IndexedDB transaction failed"));
+  });
+}
+function openSealedDatabase({
+  factory,
+  name,
+  version,
+  upgrade
+}) {
+  return new Promise((resolve) => {
+    try {
+      const request = factory.open(name, version);
+      request.onupgradeneeded = () => upgrade(request.result);
+      request.onsuccess = () => {
+        const db = request.result;
+        db.onversionchange = () => db.close();
+        resolve(db);
+      };
+      request.onerror = () => resolve(null);
+      request.onblocked = () => resolve(null);
+    } catch {
+      resolve(null);
+    }
+  });
+}
+function lazySealedDatabase({
+  factory,
+  name,
+  version,
+  upgrade
+}) {
+  let databasePromise = null;
+  return () => {
+    if (!factory || typeof crypto === "undefined" || !crypto.subtle) return Promise.resolve(null);
+    databasePromise ?? (databasePromise = openSealedDatabase({ factory, name, version, upgrade }).then(
+      (db) => {
+        if (db) {
+          const forget = () => {
+            databasePromise = null;
+          };
+          db.addEventListener("versionchange", forget);
+          db.addEventListener("close", forget);
+        } else {
+          databasePromise = null;
+        }
+        return db;
+      }
+    ));
+    return databasePromise;
+  };
+}
+exports.SEALED_IV_BYTES = SEALED_IV_BYTES;
+exports.idbGlobals = idbGlobals;
+exports.lazySealedDatabase = lazySealedDatabase;
+exports.openJson = openJson;
+exports.openSealedDatabase = openSealedDatabase;
+exports.requestToPromise = requestToPromise;
+exports.sealJson = sealJson;
+exports.sha256Hex = sha256Hex;
+exports.transactionDone = transactionDone;
+//# sourceMappingURL=sealed-idb.cjs.map

package/dist/agent-runtime/src/sealed-idb.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sealed-idb.cjs","sources":["../../../../agent-runtime/src/sealed-idb.ts"],"sourcesContent":["/**\n * The sealed-record toolkit the device stores in this package share (the thread snapshot mirror,\n * the chat outbox): AES-GCM-256 sealing with a fresh IV and additional data that binds a record to\n * where it is stored, SHA-256 names so a database names no one, and the part of IndexedDB they use.\n *\n * This package compiles without the DOM lib (React Native honesty, `globals.d.ts`), so IndexedDB is\n * described structurally here; the stores run only where it exists and degrade to nothing where it\n * does not.\n */\n\nexport type IdbListener = ((event?: unknown) => void) | null;\n\nexport interface IdbRequest<T> {\n  readonly result: T;\n  readonly error: unknown;\n  onsuccess: IdbListener;\n  onerror: IdbListener;\n}\n\nexport interface IdbOpenRequest extends IdbRequest<IdbDatabase> {\n  onupgradeneeded: IdbListener;\n  onblocked: IdbListener;\n}\n\nexport interface IdbFactory {\n  open(name: string, version?: number): IdbOpenRequest;\n}\n\nexport interface IdbCursor {\n  readonly primaryKey: unknown;\n  continue(): void;\n}\n\nexport interface IdbIndex {\n  getAll(query?: unknown): IdbRequest<unknown[]>;\n  getAllKeys(query?: unknown): IdbRequest<unknown[]>;\n  openKeyCursor(range?: unknown, direction?: string): IdbRequest<IdbCursor | null>;\n}\n\nexport interface IdbObjectStore {\n  put(value: unknown): IdbRequest<unknown>;\n  get(key: unknown): IdbRequest<unknown>;\n  delete(key: unknown): IdbRequest<unknown>;\n  clear(): IdbRequest<unknown>;\n  index(name: string): IdbIndex;\n  createIndex(name: string, keyPath: string | string[], options?: { unique?: boolean }): unknown;\n}\n\nexport interface IdbTransaction {\n  objectStore(name: string): IdbObjectStore;\n  readonly error: unknown;\n  oncomplete: IdbListener;\n  onabort: IdbListener;\n  onerror: IdbListener;\n}\n\nexport interface IdbDatabase {\n  readonly objectStoreNames: { contains(name: string): boolean };\n  transaction(stores: string | string[], mode?: \"readonly\" | \"readwrite\"): IdbTransaction;\n  createObjectStore(name: string, options?: { keyPath: string }): IdbObjectStore;\n  onversionchange: IdbListener;\n  addEventListener(type: string, listener: () => void): void;\n  close(): void;\n}\n\nexport interface IdbKeyRangeStatic {\n  bound(lower: unknown, upper: unknown): unknown;\n}\n\nexport const idbGlobals = globalThis as { indexedDB?: object; IDBKeyRange?: IdbKeyRangeStatic };\n\n/** The AES-GCM IV length, prefixed to every sealed payload. */\nexport const SEALED_IV_BYTES = 12;\n\nconst encoder = new TextEncoder();\nconst decoder = new TextDecoder();\n\nexport async function sha256Hex(value: string): Promise<string> {\n  const digest = await crypto.subtle.digest(\"SHA-256\", encoder.encode(value));\n  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, \"0\")).join(\"\");\n}\n\n/** `value` as JSON, sealed under `key` with a fresh IV; `aad` binds it to where it is stored. */\nexport async function sealJson({\n  key,\n  value,\n  aad,\n}: {\n  key: CryptoKey;\n  value: unknown;\n  aad: string;\n}): Promise<Uint8Array> {\n  const iv = crypto.getRandomValues(new Uint8Array(SEALED_IV_BYTES));\n  const ciphertext = new Uint8Array(\n    await crypto.subtle.encrypt(\n      { name: \"AES-GCM\", iv, additionalData: encoder.encode(aad) },\n      key,\n      encoder.encode(JSON.stringify(value)),\n    ),\n  );\n  const sealed = new Uint8Array(SEALED_IV_BYTES + ciphertext.byteLength);\n  sealed.set(iv, 0);\n  sealed.set(ciphertext, SEALED_IV_BYTES);\n  return sealed;\n}\n\n/** Opens what {@link sealJson} sealed; throws for the wrong key, the wrong `aad`, or a damaged record. */\nexport async function openJson({\n  key,\n  sealed,\n  aad,\n}: {\n  key: CryptoKey;\n  sealed: Uint8Array;\n  aad: string;\n}): Promise<unknown> {\n  const iv = sealed.subarray(0, SEALED_IV_BYTES) as Uint8Array<ArrayBuffer>;\n  const plaintext = await crypto.subtle.decrypt(\n    { name: \"AES-GCM\", iv, additionalData: encoder.encode(aad) },\n    key,\n    sealed.subarray(SEALED_IV_BYTES) as Uint8Array<ArrayBuffer>,\n  );\n  return JSON.parse(decoder.decode(plaintext)) as unknown;\n}\n\nexport function requestToPromise<T>(request: IdbRequest<T>): Promise<T> {\n  return new Promise((resolve, reject) => {\n    request.onsuccess = () => resolve(request.result);\n    request.onerror = () => reject(request.error ?? new Error(\"IndexedDB request failed\"));\n  });\n}\n\nexport function transactionDone(tx: IdbTransaction): Promise<void> {\n  return new Promise((resolve, reject) => {\n    tx.oncomplete = () => resolve();\n    tx.onabort = () => reject(tx.error ?? new Error(\"IndexedDB transaction aborted\"));\n    tx.onerror = () => reject(tx.error ?? new Error(\"IndexedDB transaction failed\"));\n  });\n}\n\n/**\n * Opens `name` at `version`, creating what `upgrade` creates. Resolves `null` instead of failing:\n * a database a newer build upgraded past this version, a blocked open, or no IndexedDB at all\n * (private browsing, SSR) all mean \"no store here\".\n */\nexport function openSealedDatabase({\n  factory,\n  name,\n  version,\n  upgrade,\n}: {\n  factory: IdbFactory;\n  name: string;\n  version: number;\n  upgrade: (db: IdbDatabase) => void;\n}): Promise<IdbDatabase | null> {\n  return new Promise((resolve) => {\n    try {\n      const request = factory.open(name, version);\n      request.onupgradeneeded = () => upgrade(request.result);\n      request.onsuccess = () => {\n        const db = request.result;\n        // Another page deleting or upgrading the database: step aside.\n        db.onversionchange = () => db.close();\n        resolve(db);\n      };\n      request.onerror = () => resolve(null);\n      request.onblocked = () => resolve(null);\n    } catch {\n      resolve(null);\n    }\n  });\n}\n\n/**\n * A lazily opened database handle that reopens after the browser (or another page's upgrade or\n * delete) closes it. `null` while there is no IndexedDB or Web Crypto here.\n */\nexport function lazySealedDatabase({\n  factory,\n  name,\n  version,\n  upgrade,\n}: {\n  factory: object | undefined;\n  name: string;\n  version: number;\n  upgrade: (db: IdbDatabase) => void;\n}): () => Promise<IdbDatabase | null> {\n  let databasePromise: Promise<IdbDatabase | null> | null = null;\n  return () => {\n    if (!factory || typeof crypto === \"undefined\" || !crypto.subtle) return Promise.resolve(null);\n    databasePromise ??= openSealedDatabase({ factory: factory as IdbFactory, name, version, upgrade }).then(\n      (db) => {\n        if (db) {\n          const forget = () => {\n            databasePromise = null;\n          };\n          db.addEventListener(\"versionchange\", forget);\n          db.addEventListener(\"close\", forget);\n        } else {\n          databasePromise = null;\n        }\n        return db;\n      },\n    );\n    return databasePromise;\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/agent-runtime/src/sealed-idb.d.ts

@@ -0,0 +1,106 @@
+/**
+ * The sealed-record toolkit the device stores in this package share (the thread snapshot mirror,
+ * the chat outbox): AES-GCM-256 sealing with a fresh IV and additional data that binds a record to
+ * where it is stored, SHA-256 names so a database names no one, and the part of IndexedDB they use.
+ *
+ * This package compiles without the DOM lib (React Native honesty, `globals.d.ts`), so IndexedDB is
+ * described structurally here; the stores run only where it exists and degrade to nothing where it
+ * does not.
+ */
+export type IdbListener = ((event?: unknown) => void) | null;
+export interface IdbRequest<T> {
+    readonly result: T;
+    readonly error: unknown;
+    onsuccess: IdbListener;
+    onerror: IdbListener;
+}
+export interface IdbOpenRequest extends IdbRequest<IdbDatabase> {
+    onupgradeneeded: IdbListener;
+    onblocked: IdbListener;
+}
+export interface IdbFactory {
+    open(name: string, version?: number): IdbOpenRequest;
+}
+export interface IdbCursor {
+    readonly primaryKey: unknown;
+    continue(): void;
+}
+export interface IdbIndex {
+    getAll(query?: unknown): IdbRequest<unknown[]>;
+    getAllKeys(query?: unknown): IdbRequest<unknown[]>;
+    openKeyCursor(range?: unknown, direction?: string): IdbRequest<IdbCursor | null>;
+}
+export interface IdbObjectStore {
+    put(value: unknown): IdbRequest<unknown>;
+    get(key: unknown): IdbRequest<unknown>;
+    delete(key: unknown): IdbRequest<unknown>;
+    clear(): IdbRequest<unknown>;
+    index(name: string): IdbIndex;
+    createIndex(name: string, keyPath: string | string[], options?: {
+        unique?: boolean;
+    }): unknown;
+}
+export interface IdbTransaction {
+    objectStore(name: string): IdbObjectStore;
+    readonly error: unknown;
+    oncomplete: IdbListener;
+    onabort: IdbListener;
+    onerror: IdbListener;
+}
+export interface IdbDatabase {
+    readonly objectStoreNames: {
+        contains(name: string): boolean;
+    };
+    transaction(stores: string | string[], mode?: "readonly" | "readwrite"): IdbTransaction;
+    createObjectStore(name: string, options?: {
+        keyPath: string;
+    }): IdbObjectStore;
+    onversionchange: IdbListener;
+    addEventListener(type: string, listener: () => void): void;
+    close(): void;
+}
+export interface IdbKeyRangeStatic {
+    bound(lower: unknown, upper: unknown): unknown;
+}
+export declare const idbGlobals: {
+    indexedDB?: object;
+    IDBKeyRange?: IdbKeyRangeStatic;
+};
+/** The AES-GCM IV length, prefixed to every sealed payload. */
+export declare const SEALED_IV_BYTES = 12;
+export declare function sha256Hex(value: string): Promise<string>;
+/** `value` as JSON, sealed under `key` with a fresh IV; `aad` binds it to where it is stored. */
+export declare function sealJson({ key, value, aad, }: {
+    key: CryptoKey;
+    value: unknown;
+    aad: string;
+}): Promise<Uint8Array>;
+/** Opens what {@link sealJson} sealed; throws for the wrong key, the wrong `aad`, or a damaged record. */
+export declare function openJson({ key, sealed, aad, }: {
+    key: CryptoKey;
+    sealed: Uint8Array;
+    aad: string;
+}): Promise<unknown>;
+export declare function requestToPromise<T>(request: IdbRequest<T>): Promise<T>;
+export declare function transactionDone(tx: IdbTransaction): Promise<void>;
+/**
+ * Opens `name` at `version`, creating what `upgrade` creates. Resolves `null` instead of failing:
+ * a database a newer build upgraded past this version, a blocked open, or no IndexedDB at all
+ * (private browsing, SSR) all mean "no store here".
+ */
+export declare function openSealedDatabase({ factory, name, version, upgrade, }: {
+    factory: IdbFactory;
+    name: string;
+    version: number;
+    upgrade: (db: IdbDatabase) => void;
+}): Promise<IdbDatabase | null>;
+/**
+ * A lazily opened database handle that reopens after the browser (or another page's upgrade or
+ * delete) closes it. `null` while there is no IndexedDB or Web Crypto here.
+ */
+export declare function lazySealedDatabase({ factory, name, version, upgrade, }: {
+    factory: object | undefined;
+    name: string;
+    version: number;
+    upgrade: (db: IdbDatabase) => void;
+}): () => Promise<IdbDatabase | null>;

package/dist/agent-runtime/src/sealed-idb.js

@@ -0,0 +1,112 @@
+const idbGlobals = globalThis;
+const SEALED_IV_BYTES = 12;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+async function sha256Hex(value) {
+  const digest = await crypto.subtle.digest("SHA-256", encoder.encode(value));
+  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function sealJson({
+  key,
+  value,
+  aad
+}) {
+  const iv = crypto.getRandomValues(new Uint8Array(SEALED_IV_BYTES));
+  const ciphertext = new Uint8Array(
+    await crypto.subtle.encrypt(
+      { name: "AES-GCM", iv, additionalData: encoder.encode(aad) },
+      key,
+      encoder.encode(JSON.stringify(value))
+    )
+  );
+  const sealed = new Uint8Array(SEALED_IV_BYTES + ciphertext.byteLength);
+  sealed.set(iv, 0);
+  sealed.set(ciphertext, SEALED_IV_BYTES);
+  return sealed;
+}
+async function openJson({
+  key,
+  sealed,
+  aad
+}) {
+  const iv = sealed.subarray(0, SEALED_IV_BYTES);
+  const plaintext = await crypto.subtle.decrypt(
+    { name: "AES-GCM", iv, additionalData: encoder.encode(aad) },
+    key,
+    sealed.subarray(SEALED_IV_BYTES)
+  );
+  return JSON.parse(decoder.decode(plaintext));
+}
+function requestToPromise(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
+  });
+}
+function transactionDone(tx) {
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onabort = () => reject(tx.error ?? new Error("IndexedDB transaction aborted"));
+    tx.onerror = () => reject(tx.error ?? new Error("IndexedDB transaction failed"));
+  });
+}
+function openSealedDatabase({
+  factory,
+  name,
+  version,
+  upgrade
+}) {
+  return new Promise((resolve) => {
+    try {
+      const request = factory.open(name, version);
+      request.onupgradeneeded = () => upgrade(request.result);
+      request.onsuccess = () => {
+        const db = request.result;
+        db.onversionchange = () => db.close();
+        resolve(db);
+      };
+      request.onerror = () => resolve(null);
+      request.onblocked = () => resolve(null);
+    } catch {
+      resolve(null);
+    }
+  });
+}
+function lazySealedDatabase({
+  factory,
+  name,
+  version,
+  upgrade
+}) {
+  let databasePromise = null;
+  return () => {
+    if (!factory || typeof crypto === "undefined" || !crypto.subtle) return Promise.resolve(null);
+    databasePromise ?? (databasePromise = openSealedDatabase({ factory, name, version, upgrade }).then(
+      (db) => {
+        if (db) {
+          const forget = () => {
+            databasePromise = null;
+          };
+          db.addEventListener("versionchange", forget);
+          db.addEventListener("close", forget);
+        } else {
+          databasePromise = null;
+        }
+        return db;
+      }
+    ));
+    return databasePromise;
+  };
+}
+export {
+  SEALED_IV_BYTES,
+  idbGlobals,
+  lazySealedDatabase,
+  openJson,
+  openSealedDatabase,
+  requestToPromise,
+  sealJson,
+  sha256Hex,
+  transactionDone
+};
+//# sourceMappingURL=sealed-idb.js.map

package/dist/agent-runtime/src/sealed-idb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sealed-idb.js","sources":["../../../../agent-runtime/src/sealed-idb.ts"],"sourcesContent":["/**\n * The sealed-record toolkit the device stores in this package share (the thread snapshot mirror,\n * the chat outbox): AES-GCM-256 sealing with a fresh IV and additional data that binds a record to\n * where it is stored, SHA-256 names so a database names no one, and the part of IndexedDB they use.\n *\n * This package compiles without the DOM lib (React Native honesty, `globals.d.ts`), so IndexedDB is\n * described structurally here; the stores run only where it exists and degrade to nothing where it\n * does not.\n */\n\nexport type IdbListener = ((event?: unknown) => void) | null;\n\nexport interface IdbRequest<T> {\n  readonly result: T;\n  readonly error: unknown;\n  onsuccess: IdbListener;\n  onerror: IdbListener;\n}\n\nexport interface IdbOpenRequest extends IdbRequest<IdbDatabase> {\n  onupgradeneeded: IdbListener;\n  onblocked: IdbListener;\n}\n\nexport interface IdbFactory {\n  open(name: string, version?: number): IdbOpenRequest;\n}\n\nexport interface IdbCursor {\n  readonly primaryKey: unknown;\n  continue(): void;\n}\n\nexport interface IdbIndex {\n  getAll(query?: unknown): IdbRequest<unknown[]>;\n  getAllKeys(query?: unknown): IdbRequest<unknown[]>;\n  openKeyCursor(range?: unknown, direction?: string): IdbRequest<IdbCursor | null>;\n}\n\nexport interface IdbObjectStore {\n  put(value: unknown): IdbRequest<unknown>;\n  get(key: unknown): IdbRequest<unknown>;\n  delete(key: unknown): IdbRequest<unknown>;\n  clear(): IdbRequest<unknown>;\n  index(name: string): IdbIndex;\n  createIndex(name: string, keyPath: string | string[], options?: { unique?: boolean }): unknown;\n}\n\nexport interface IdbTransaction {\n  objectStore(name: string): IdbObjectStore;\n  readonly error: unknown;\n  oncomplete: IdbListener;\n  onabort: IdbListener;\n  onerror: IdbListener;\n}\n\nexport interface IdbDatabase {\n  readonly objectStoreNames: { contains(name: string): boolean };\n  transaction(stores: string | string[], mode?: \"readonly\" | \"readwrite\"): IdbTransaction;\n  createObjectStore(name: string, options?: { keyPath: string }): IdbObjectStore;\n  onversionchange: IdbListener;\n  addEventListener(type: string, listener: () => void): void;\n  close(): void;\n}\n\nexport interface IdbKeyRangeStatic {\n  bound(lower: unknown, upper: unknown): unknown;\n}\n\nexport const idbGlobals = globalThis as { indexedDB?: object; IDBKeyRange?: IdbKeyRangeStatic };\n\n/** The AES-GCM IV length, prefixed to every sealed payload. */\nexport const SEALED_IV_BYTES = 12;\n\nconst encoder = new TextEncoder();\nconst decoder = new TextDecoder();\n\nexport async function sha256Hex(value: string): Promise<string> {\n  const digest = await crypto.subtle.digest(\"SHA-256\", encoder.encode(value));\n  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, \"0\")).join(\"\");\n}\n\n/** `value` as JSON, sealed under `key` with a fresh IV; `aad` binds it to where it is stored. */\nexport async function sealJson({\n  key,\n  value,\n  aad,\n}: {\n  key: CryptoKey;\n  value: unknown;\n  aad: string;\n}): Promise<Uint8Array> {\n  const iv = crypto.getRandomValues(new Uint8Array(SEALED_IV_BYTES));\n  const ciphertext = new Uint8Array(\n    await crypto.subtle.encrypt(\n      { name: \"AES-GCM\", iv, additionalData: encoder.encode(aad) },\n      key,\n      encoder.encode(JSON.stringify(value)),\n    ),\n  );\n  const sealed = new Uint8Array(SEALED_IV_BYTES + ciphertext.byteLength);\n  sealed.set(iv, 0);\n  sealed.set(ciphertext, SEALED_IV_BYTES);\n  return sealed;\n}\n\n/** Opens what {@link sealJson} sealed; throws for the wrong key, the wrong `aad`, or a damaged record. */\nexport async function openJson({\n  key,\n  sealed,\n  aad,\n}: {\n  key: CryptoKey;\n  sealed: Uint8Array;\n  aad: string;\n}): Promise<unknown> {\n  const iv = sealed.subarray(0, SEALED_IV_BYTES) as Uint8Array<ArrayBuffer>;\n  const plaintext = await crypto.subtle.decrypt(\n    { name: \"AES-GCM\", iv, additionalData: encoder.encode(aad) },\n    key,\n    sealed.subarray(SEALED_IV_BYTES) as Uint8Array<ArrayBuffer>,\n  );\n  return JSON.parse(decoder.decode(plaintext)) as unknown;\n}\n\nexport function requestToPromise<T>(request: IdbRequest<T>): Promise<T> {\n  return new Promise((resolve, reject) => {\n    request.onsuccess = () => resolve(request.result);\n    request.onerror = () => reject(request.error ?? new Error(\"IndexedDB request failed\"));\n  });\n}\n\nexport function transactionDone(tx: IdbTransaction): Promise<void> {\n  return new Promise((resolve, reject) => {\n    tx.oncomplete = () => resolve();\n    tx.onabort = () => reject(tx.error ?? new Error(\"IndexedDB transaction aborted\"));\n    tx.onerror = () => reject(tx.error ?? new Error(\"IndexedDB transaction failed\"));\n  });\n}\n\n/**\n * Opens `name` at `version`, creating what `upgrade` creates. Resolves `null` instead of failing:\n * a database a newer build upgraded past this version, a blocked open, or no IndexedDB at all\n * (private browsing, SSR) all mean \"no store here\".\n */\nexport function openSealedDatabase({\n  factory,\n  name,\n  version,\n  upgrade,\n}: {\n  factory: IdbFactory;\n  name: string;\n  version: number;\n  upgrade: (db: IdbDatabase) => void;\n}): Promise<IdbDatabase | null> {\n  return new Promise((resolve) => {\n    try {\n      const request = factory.open(name, version);\n      request.onupgradeneeded = () => upgrade(request.result);\n      request.onsuccess = () => {\n        const db = request.result;\n        // Another page deleting or upgrading the database: step aside.\n        db.onversionchange = () => db.close();\n        resolve(db);\n      };\n      request.onerror = () => resolve(null);\n      request.onblocked = () => resolve(null);\n    } catch {\n      resolve(null);\n    }\n  });\n}\n\n/**\n * A lazily opened database handle that reopens after the browser (or another page's upgrade or\n * delete) closes it. `null` while there is no IndexedDB or Web Crypto here.\n */\nexport function lazySealedDatabase({\n  factory,\n  name,\n  version,\n  upgrade,\n}: {\n  factory: object | undefined;\n  name: string;\n  version: number;\n  upgrade: (db: IdbDatabase) => void;\n}): () => Promise<IdbDatabase | null> {\n  let databasePromise: Promise<IdbDatabase | null> | null = null;\n  return () => {\n    if (!factory || typeof crypto === \"undefined\" || !crypto.subtle) return Promise.resolve(null);\n    databasePromise ??= openSealedDatabase({ factory: factory as IdbFactory, name, version, upgrade }).then(\n      (db) => {\n        if (db) {\n          const forget = () => {\n            databasePromise = null;\n          };\n          db.addEventListener(\"versionchange\", forget);\n          db.addEventListener(\"close\", forget);\n        } else {\n          databasePromise = null;\n        }\n        return db;\n      },\n    );\n    return databasePromise;\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/agent-runtime/src/send-recovery.d.ts

@@ -0,0 +1,40 @@
+import type { StatewireDiagnosticsCommandUpdate, StatewireDiagnosticsRecorder } from './statewire-diagnostics';
+import type { StatewireFailedSendLane } from './thread-extras';
+export interface DeepAgentSendRecoveryOptions {
+    /**
+     * Reads the thread's failed-send lane. `null` while it is unavailable (the
+     * client has not mounted yet, or its extras are not a statewire thread) —
+     * the controller stays armed and retries on the next state change.
+     */
+    lane: () => StatewireFailedSendLane | null;
+    /**
+     * Persisted failure stamps (message id → epoch ms of the original send) for
+     * the freshness gate. `null`/absent means no persistence is readable — every
+     * lane entry then counts as fresh (an in-memory failed lane can only hold
+     * failures from this page session).
+     */
+    failureStamps?: (() => ReadonlyMap<string, number> | null) | undefined;
+    /** Transport lifecycle recorder; read per event so a late-mounted recorder still sees retries. */
+    diagnostics?: (() => StatewireDiagnosticsRecorder | undefined) | undefined;
+    /** Injectable clock (tests). */
+    now?: () => number;
+    /** Sweep scheduler; defaults to `queueMicrotask` so a sweep never dispatches
+     * from inside a statewire flush or a React render. */
+    schedule?: (task: () => void) => void;
+}
+export interface DeepAgentSendRecovery {
+    /** Feed every (normalized) statewire state change; hydration arms the mount sweep. */
+    observeStateChange(state: unknown): void;
+    /** Feed every command-lifecycle update; a never-server-judged settle arms a sweep. */
+    observeCommand(update: StatewireDiagnosticsCommandUpdate): void;
+    /** Feed client notifications too: failed history can publish after the
+     * command settles, without any change to the canonical thread snapshot. */
+    observeFailedLaneChange(): void;
+    dispose(): void;
+}
+/** Whether a settle failure is a client-side death the recovery re-dispatches
+ * (the server never judged the command). Exported for host-side telemetry. */
+export declare function shouldAutoRetryFailedSend(failure: {
+    fate: string;
+} | undefined): boolean;
+export declare function createDeepAgentSendRecovery(options: DeepAgentSendRecoveryOptions): DeepAgentSendRecovery;

package/dist/agent-runtime/src/statewire-attach-observer.d.ts

@@ -0,0 +1,194 @@
+/**
+ * Attach-path instrumentation for the deep-agent statewire transport, wired
+ * through the two injection points statewire already exposes — the
+ * `webSocket` constructor (`StatewireClient.WebsocketOptions`) and `fetch`
+ * (`StatewireClient.HttpOptions`) — so the runtime can observe what the library
+ * does not surface:
+ *
+ * - socket open latency (`ws_open_ms`), the hello frame's size and its
+ *   synchronous handler cost (`hello_bytes`, `hello_handler_ms`), and close
+ *   codes/reasons, for the thread-switch telemetry;
+ * - a server `Retry-After` hint, honoured as a floor under the next dial.
+ *
+ * Retry-After today: statewire honours `retry-after` only on 429 command-frame
+ * refusals (folded into the refusal `syn.retry`); its attach paths treat a 503
+ * as a generic `HTTP 503` / `network` failure and back off exponentially with
+ * no server input. Browsers never expose the response headers of a refused
+ * WebSocket upgrade at all, so for the WS transport the hint can only ride
+ * something the client can read: the close frame. The contract this module
+ * reads is a close `reason` carrying `retry-after=<seconds>` (or
+ * `retry-after-ms=<ms>`) — the pinboard half of that contract is a separate
+ * change; until it lands the WS path simply sees no hint. The SSE attach
+ * (`POST …/stream`) is a plain fetch, so its `Retry-After` header is read here
+ * directly.
+ *
+ * This package compiles without the DOM lib (React Native honesty), so the
+ * browser surface is typed structurally and resolved through `globalThis`.
+ */
+/**
+ * Who refused a wake (503/429), read off the response body against the two
+ * refusal vocabularies the iris scaler also classifies data-plane 503s by
+ * (`iris/scaler/src/v2AccessLog.ts`):
+ *
+ * - `"placement"` — the pinboard's own refusal, `{"error": …}` with one of its
+ *   known strings ("no live workers for hostname", "registry cold start,
+ *   retry", "takeover in progress, retry", …): the thread has no worker to
+ *   dial right now.
+ * - `"worker"` — a pinned instance-lifecycle refusal, `{"detail": …}` with one
+ *   of its known strings ("instance closing; retry", "activation queue full;
+ *   retry", "host draining; retry", …): one instance on the worker the thread
+ *   is already placed on, cleared in the time a teardown takes.
+ * - `"unknown"` — any other 503/429 body (unreadable, an unfamiliar string, a
+ *   real worker failure such as "Thread history load failed"): treated
+ *   conservatively — the full `Retry-After`, no dial dropped.
+ * - `null` — not a refusal status.
+ */
+export type DeepAgentWakeRefusal = "placement" | "worker" | "unknown" | null;
+export type DeepAgentAttachTimingEvent = {
+    type: "socket-open";
+    url: string;
+    openMs: number;
+} | {
+    type: "hello";
+    url: string;
+    /** UTF-16 length of the hello frame — bytes for the ASCII JSON the wire carries. */
+    bytes: number;
+    /** Synchronous cost of statewire's message handler for the hello (parse + apply + flush). */
+    handlerMs: number;
+    /** Hello arrival relative to the socket open; `null` when the open was not observed. */
+    sinceOpenMs: number | null;
+} | {
+    type: "socket-close";
+    url: string;
+    code: number | undefined;
+    reason: string | undefined;
+    sinceOpenMs: number | null;
+} | {
+    type: "retry-after";
+    url: string;
+    delayMs: number;
+    source: "ws-close" | "http-header";
+} | {
+    /** `POST …/prewarm` answered (see `wakeDeepAgentThread`). */
+    type: "wake";
+    url: string;
+    status: number;
+    durationMs: number;
+    /** How the host sourced the history: already resident (`warm`) or loaded by this call. */
+    history: "fresh_load" | "warm" | null;
+    /** Who refused a 503/429 (see {@link DeepAgentWakeRefusal}); `null` otherwise. */
+    refusal: DeepAgentWakeRefusal;
+};
+/** Longest server hint honoured — a buggy or hostile hint must not park a client. */
+export declare const MAX_RETRY_AFTER_MS = 30000;
+/**
+ * Parse an HTTP `Retry-After` header value: delta-seconds or an HTTP-date.
+ * Returns the delay in ms clamped to {@link MAX_RETRY_AFTER_MS}, or `null` when
+ * the value is absent or unparseable.
+ */
+export declare function parseRetryAfterHeaderMs(value: string | null | undefined, now?: () => number): number | null;
+/**
+ * Parse a retry hint off a WebSocket close reason: `retry-after=<seconds>` or
+ * `retry-after-ms=<ms>` anywhere in the reason text (case-insensitive, `=` or
+ * `:`). Returns ms clamped to {@link MAX_RETRY_AFTER_MS}, or `null`.
+ */
+export declare function parseRetryAfterFromCloseReason(reason: string | undefined): number | null;
+export interface AttachRetryGate {
+    /** Record a hint: no dial for `key` before `now + delayMs` (clamped). */
+    noteRetryAfter(key: string, delayMs: number): void;
+    /** Resolves once the recorded floor for `key` has passed (immediately when none). */
+    waitForDial(key: string): Promise<void>;
+    /** Remaining floor for `key` in ms (0 when none). */
+    remainingMs(key: string): number;
+    /** Drop one key's floor, or every floor. */
+    reset(key?: string): void;
+}
+/**
+ * Per-key dial floors. Keyed by the thread's attach URL so a hint delivered
+ * for one thread never delays another. The floor is a minimum under
+ * statewire's own backoff, never a replacement for it: the transport still
+ * schedules its retry, and the dial simply waits out the remainder inside the
+ * headers resolve (both attach paths resolve headers before they dial).
+ */
+export declare function createAttachRetryGate({ now, wait, }?: {
+    now?: () => number;
+    wait?: (ms: number) => Promise<void>;
+}): AttachRetryGate;
+/** Process-wide gate shared by every deep-agent transport in the host. */
+export declare const attachRetryGate: AttachRetryGate;
+/** Structural subset of the browser `WebSocket` that statewire's WS transport touches. */
+export interface AttachSocketLike {
+    readonly readyState: number;
+    readonly protocol: string;
+    onopen: ((event: unknown) => void) | null;
+    onmessage: ((event: {
+        data: unknown;
+    }) => void) | null;
+    onclose: ((event: {
+        code?: number;
+        reason?: string;
+    }) => void) | null;
+    onerror: ((event: unknown) => void) | null;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+}
+export type AttachWebSocketConstructor = new (url: string, protocols?: string | string[]) => AttachSocketLike;
+/**
+ * Wrap a socket in a forwarding facade whose handler setters time the events
+ * statewire attaches to (`onopen`, `onmessage`, `onclose`). A facade rather
+ * than a subclass so the same instrumentation works over any host `WebSocket`
+ * implementation, including test fakes.
+ */
+export declare function instrumentAttachSocket({ socket, url, onEvent, now, }: {
+    socket: AttachSocketLike;
+    /** The thread attach URL the events are attributed to (not the socket URL). */
+    url: string;
+    onEvent: (event: DeepAgentAttachTimingEvent) => void;
+    now?: () => number;
+}): AttachSocketLike;
+/**
+ * A `WebSocket`-shaped constructor that dials through `Base` and reports the
+ * attach events for `url`. Constructor semantics (`new` returns the facade)
+ * match what statewire's `webSocket` option expects.
+ */
+export declare function instrumentedWebSocketConstructor({ Base, url, onEvent, now, }: {
+    Base: AttachWebSocketConstructor;
+    url: string;
+    onEvent: (event: DeepAgentAttachTimingEvent) => void;
+    now?: () => number;
+}): AttachWebSocketConstructor;
+/** Structural `fetch` — what statewire's SSE transport calls. */
+export type AttachFetch = (input: string | URL, init?: unknown) => Promise<{
+    ok: boolean;
+    status: number;
+    headers: {
+        get(name: string): string | null;
+    };
+}>;
+/**
+ * A `fetch` that reports a `Retry-After` header on refused attach requests
+ * (the SSE `POST …/stream`) before handing the response back untouched.
+ */
+export declare function instrumentedAttachFetch<TFetch extends AttachFetch>({ baseFetch, url, onEvent, now, }: {
+    baseFetch: TFetch;
+    url: string;
+    onEvent: (event: DeepAgentAttachTimingEvent) => void;
+    now?: () => number;
+}): TFetch;
+/**
+ * The transport option overrides for one attach: an instrumented `webSocket`
+ * (WS) or `fetch` (SSE) that reports attach events for `url` and feeds
+ * `Retry-After` hints into the gate. Returns `{}` where the host has no such
+ * global (a server render, a non-browser runtime) so the transport keeps its
+ * defaults.
+ */
+export declare function createAttachInstrumentation({ url, sse, onEvent, retryGate, now, }: {
+    url: string;
+    sse: boolean;
+    onEvent?: ((event: DeepAgentAttachTimingEvent) => void) | undefined;
+    retryGate?: AttachRetryGate;
+    now?: () => number;
+}): {
+    webSocket?: AttachWebSocketConstructor;
+    fetch?: AttachFetch;
+};