@wow-two-beta/ui-vue 0.0.5 → 0.0.6

package/dist/foundation/i18n/providers/LocaleProvider.vue.d.ts

@@ -0,0 +1,18 @@
+import { Messages } from './LocaleContext';
+/** Props for `LocaleProvider`. */
+export interface LocaleProviderProps {
+    /** BCP-47 locale. Defaults to `en-US` on both server and client. */
+    readonly locale?: string;
+    /** Consumer message overrides — a dictionary or a `(key, vars) => string` callback. */
+    readonly messages?: Messages;
+}
+declare const _default: __VLS_WithSlots<import('vue').DefineComponent<LocaleProviderProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<LocaleProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    /** The subtree that reads the provided locale and messages. */
+    default(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/foundation/icons/icon/Icon.vue.d.ts

@@ -0,0 +1,44 @@
+import { Component, SVGAttributes } from 'vue';
+import { AriaAttribute } from '../../dom';
+export interface IconAdapterProps extends SVGAttributes {
+    /**
+     * The pixel size handed to the adapter. `number` only, NOT `number | string`.
+     *
+     * Component props are contravariant: an adapter satisfies this type only if it accepts every
+     * prop declared here. `lucide-vue-next` types its own `size` as `number`, so widening this to
+     * `number | string` — as the React original did, where the looser `SVGProps` made it moot —
+     * makes every lucide icon unassignable to `IconAdapter` and forces an `as unknown as` cast at
+     * each import site. Narrow is the fix; a CSS-unit size belongs on `class`, not on this prop.
+     */
+    readonly size?: number;
+}
+export type IconAdapter = Component<IconAdapterProps>;
+/** @internal An attribute name this component derives or requires. */
+type DerivedAttribute = typeof AriaAttribute.Hidden;
+/** @internal An attribute name this component derives or requires. */
+type NameAttribute = typeof AriaAttribute.Label;
+/**
+ * Defines the accessible name for when the icon stands alone (decorative siblings should pass it via
+ * parent). Sets `role="img"` and unhides from AT. Without it, the icon is `aria-hidden` and decorative.
+ */
+type IconNameAttributes = Readonly<Partial<Record<NameAttribute, string>>>;
+export interface IconProps extends Omit<SVGAttributes, DerivedAttribute | NameAttribute>, IconNameAttributes {
+    /** The icon component — pass a `lucide-vue-next` icon, custom SVG component, or any matching shape. */
+    readonly icon: IconAdapter;
+    /** The pixel size of the rendered SVG. Default 20. */
+    readonly size?: number;
+}
+declare const _default: import('vue').DefineComponent<{
+    /** The icon component — pass a `lucide-vue-next` icon, custom SVG component, or any matching shape. */
+    icon: IconAdapter;
+    /** The pixel size of the rendered SVG. Default 20. */
+    size?: number;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    /** The icon component — pass a `lucide-vue-next` icon, custom SVG component, or any matching shape. */
+    icon: IconAdapter;
+    /** The pixel size of the rendered SVG. Default 20. */
+    size?: number;
+}> & Readonly<{}>, {
+    size: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/foundation/icons/icon/index.d.ts

@@ -0,0 +1 @@
+export { default as Icon, type IconProps, type IconAdapter, type IconAdapterProps } from './Icon.vue';

package/dist/foundation/icons/index.d.ts

@@ -1,2 +1,2 @@
-export { default as Icon, type IconProps, type IconAdapter, type IconAdapterProps, } from './Icon.vue';
-export { default as Spinner, type SpinnerProps } from './Spinner.vue';
+export { Icon, type IconProps, type IconAdapter, type IconAdapterProps } from './icon';
+export { Spinner, type SpinnerProps } from './spinner';

package/dist/foundation/icons/index.js

@@ -1,5 +1,5 @@
-import { _ } from "../../chunks/Icon.vue_vue_type_script_setup_true_lang-DgwdLCRR.js";
-import { _ as _2 } from "../../chunks/Spinner.vue_vue_type_script_setup_true_lang-BAepBy2n.js";
+import { _ } from "../../chunks/Icon.vue_vue_type_script_setup_true_lang-BVWSqaoe.js";
+import { _ as _2 } from "../../chunks/Spinner.vue_vue_type_script_setup_true_lang-CU7oxE3n.js";
 export {
   _ as Icon,
   _2 as Spinner

package/dist/foundation/icons/spinner/Spinner.vue.d.ts

@@ -0,0 +1,6 @@
+export interface SpinnerProps {
+    /** The extra classes merged onto the underlying SVG. */
+    readonly className?: string;
+}
+declare const _default: import('vue').DefineComponent<SpinnerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SpinnerProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/foundation/icons/spinner/index.d.ts

@@ -0,0 +1 @@
+export { default as Spinner, type SpinnerProps } from './Spinner.vue';

package/dist/foundation/idb/KeyValueStore.d.ts

@@ -37,7 +37,7 @@ export interface KeyValueStore<TValue, TKey extends IDBValidKey = string> {
     /** Reads the value stored under `key`, or `undefined` when no record exists. */
     get(key: TKey): Promise<TValue | undefined>;
     /** Reads several keys in one transaction, resolving values positionally — `undefined` for each miss. */
-    getMany(keys: readonly TKey[]): Promise<(TValue | undefined)[]>;
+    getMany(keys: ReadonlyArray<TKey>): Promise<(TValue | undefined)[]>;
     /** Writes `value` under `key`, replacing any existing record; resolves once the transaction commits. */
     set(key: TKey, value: TValue): Promise<void>;
     /** Writes every entry in one transaction — all of them commit, or none do. */
@@ -45,7 +45,7 @@ export interface KeyValueStore<TValue, TKey extends IDBValidKey = string> {
     /** Removes the record under `key`; removing a missing key succeeds. */
     delete(key: TKey): Promise<void>;
     /** Removes every listed key in one transaction. */
-    deleteMany(keys: readonly TKey[]): Promise<void>;
+    deleteMany(keys: ReadonlyArray<TKey>): Promise<void>;
     /** Removes every record in the store. */
     clear(): Promise<void>;
     /** Reports whether a record exists under `key` — the unambiguous test, since a stored value may be `undefined`. */
@@ -56,7 +56,7 @@ export interface KeyValueStore<TValue, TKey extends IDBValidKey = string> {
     keys(): Promise<TKey[]>;
     /** Reads every value, in ascending key order. Materializes the store — prefer {@link iterateEntries} when large. */
     values(): Promise<TValue[]>;
-    /** Reads every key/value pair, in ascending key order. Materializes the store — prefer {@link iterateEntries} when large. */
+    /** Reads every entry, in ascending key order. Materializes the store — prefer {@link iterateEntries} when large. */
     entries(): Promise<[TKey, TValue][]>;
     /**
      * Streams every record through `visit` with a cursor, at constant memory, and resolves with the number

package/dist/foundation/idb/Transactions.d.ts

@@ -32,7 +32,7 @@ export interface IterateOptions {
  *
  * `fn` may await IDB request promises freely, but nothing else; see the file header.
  */
-export declare function withTransaction<TResult>(database: IDBDatabase, storeNames: string | readonly string[], mode: IDBTransactionMode, fn: (transaction: IDBTransaction) => TResult | Promise<TResult>): Promise<TResult>;
+export declare function withTransaction<TResult>(database: IDBDatabase, storeNames: string | ReadonlyArray<string>, mode: IDBTransactionMode, fn: (transaction: IDBTransaction) => TResult | Promise<TResult>): Promise<TResult>;
 /**
  * Walks `source` with a cursor, calling `visit` once per record, and resolves with the number of records
  * visited. Constant memory regardless of store size — the reason to prefer it over `getAll` for anything

package/dist/foundation/idb/index.d.ts

@@ -1,5 +1,5 @@
-export { DefaultProbeTimeoutMs, isIndexedDbAvailable, probeIndexedDb, } from './IndexedDbSupport';
+export { DefaultProbeTimeoutMs, isIndexedDbAvailable, probeIndexedDb } from './IndexedDbSupport';
 export { requestToPromise, transactionToPromise } from './IdbPromises';
 export { DefaultBlockedTimeoutMs, type DeleteDatabaseOptions, type IdbUpgradeContext, type IdbUpgradeHandler, type OpenDatabaseOptions, deleteDatabase, openDatabase, } from './OpenDatabase';
-export { type IdbCursorVisitor, type IdbEntry, type IterateOptions, iterate, withTransaction, } from './Transactions';
+export { type IdbCursorVisitor, type IdbEntry, type IterateOptions, iterate, withTransaction } from './Transactions';
 export { DefaultKeyValueStoreName, type KeyValueStore, type KeyValueStoreOptions, createKeyValueStore, } from './KeyValueStore';

package/dist/foundation/idb/index.js

@@ -1,4 +1,4 @@
-import { t as toError } from "../../chunks/ToError-CyTBsmLO.js";
+import { t as toError } from "../../chunks/ToError-vXncXe19.js";
 const ProbeDatabaseName = "__wow-two-idb-probe__";
 const DefaultProbeTimeoutMs = 2e3;
 function resolveIndexedDb() {
@@ -20,7 +20,10 @@ function probeIndexedDb(timeoutMs = DefaultProbeTimeoutMs) {
     }
     let settled = false;
     const answer = (supported, database) => {
-      if (settled) return;
+      if (settled) {
+        database?.close();
+        return;
+      }
       settled = true;
       clearTimeout(timer);
       try {
@@ -150,7 +153,14 @@ function openDatabase(name, options = {}) {
       if (claim()) reject(request.error ?? new Error(`Failed to open IndexedDB database "${name}".`));
     };
     request.onblocked = () => {
-      onBlocked?.();
+      if (settled) return;
+      try {
+        onBlocked?.();
+      } catch (error) {
+        if (claim()) reject(toError(error));
+        return;
+      }
+      if (blockedTimer !== void 0) return;
       blockedTimer = setTimeout(() => {
         if (!settled) {
           settled = true;
@@ -184,7 +194,14 @@ function deleteDatabase(name, options = {}) {
       if (claim()) reject(request.error ?? new Error(`Failed to delete IndexedDB database "${name}".`));
     };
     request.onblocked = () => {
-      onBlocked?.();
+      if (settled) return;
+      try {
+        onBlocked?.();
+      } catch (error) {
+        if (claim()) reject(toError(error));
+        return;
+      }
+      if (blockedTimer !== void 0) return;
       blockedTimer = setTimeout(() => {
         if (!settled) {
           settled = true;

package/dist/foundation/idb/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../src/foundation/idb/IndexedDbSupport.ts","../../../src/foundation/idb/IdbPromises.ts","../../../src/foundation/idb/OpenDatabase.ts","../../../src/foundation/idb/Transactions.ts","../../../src/foundation/idb/KeyValueStore.ts"],"sourcesContent":["// IndexedDB resolution + capability probes — the single place this slice reads the ambient\n// `globalThis.indexedDB`. Isolated for the same two reasons as `foundation/crypto`'s `WebCrypto`, plus one\n// that is specific to IndexedDB.\n//\n// 1. The global is read at CALL time, never cached at module scope. Caching would freeze an `undefined`\n//    captured during SSR into the module for the page's lifetime, and would block a test from stubbing the\n//    factory to exercise a failure path. This is also what keeps the slice import-safe under SSR: nothing\n//    here runs until a caller asks.\n// 2. Merely READING `globalThis.indexedDB` can throw. A sandboxed iframe without `allow-same-origin` raises\n//    a `SecurityError` from the getter itself, so the read is inside a try/catch — a bare `in` check or a\n//    `typeof` test would still throw there.\n// 3. **Presence does not imply usability.** Firefox in private browsing exposes a complete `indexedDB`\n//    object whose `open()` fails — historically a synchronous `InvalidStateError`, later an async `error`\n//    event on the request. Some Safari/WebView builds behave similarly after a storage eviction. So a\n//    structural check answers \"is the API here?\", NOT \"does it work?\", and the two need separate probes:\n//      - `isIndexedDbAvailable()` — synchronous, structural, free. The fast gate.\n//      - `probeIndexedDb()`       — asynchronous, functional: actually opens and deletes a throwaway\n//                                   database. The only answer that is true in private mode.\n//    A feature that must not half-work (an offline cache, a draft queue) should gate on the async probe\n//    once at startup and cache the result; everything else can use the sync gate.\n\n/** The throwaway database `probeIndexedDb` opens and deletes — namespaced so it cannot collide with an app database. */\nconst ProbeDatabaseName = '__wow-two-idb-probe__';\n\n/** The default ceiling, in milliseconds, `probeIndexedDb` waits for a verdict before answering `false`. */\nexport const DefaultProbeTimeoutMs = 2000;\n\n/**\n * Reads the ambient `IDBFactory`, or `undefined` when the runtime has none (SSR, a worker without the\n * API) or when reading it throws (a sandboxed iframe raising `SecurityError` from the getter).\n */\nexport function resolveIndexedDb(): IDBFactory | undefined {\n  // Widened through an optional-property view: `globalThis.indexedDB` is typed non-optional by lib.dom, so\n  // a direct `=== undefined` check would be a TS2367 \"no overlap\" error even though absence is exactly the\n  // case this function exists to handle.\n  try {\n    return (globalThis as { indexedDB?: IDBFactory }).indexedDB;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Reports whether an `IDBFactory` is present and structurally usable — the synchronous gate. True in every\n * browser; false under SSR, in a sandboxed iframe, and in runtimes without the API (plain Node).\n *\n * **Not a guarantee that a database will open.** Firefox private browsing exposes the full API and fails on\n * `open()`; only {@link probeIndexedDb} detects that. Use this to skip work that would obviously fail, and\n * the async probe before committing a feature to IndexedDB.\n */\nexport function isIndexedDbAvailable(): boolean {\n  return typeof resolveIndexedDb()?.open === 'function';\n}\n\n/**\n * Reports whether IndexedDB actually **works**, by opening a throwaway database and deleting it again.\n * Catches the private-mode case {@link isIndexedDbAvailable} cannot: an API that is present but whose\n * `open()` throws or errors.\n *\n * Never throws and never hangs — a synchronous throw, an `error` event, a `blocked` open, and a runtime\n * that simply never answers all resolve to `false` once `timeoutMs` elapses. Cache the result; the probe\n * costs a real database round trip.\n */\nexport function probeIndexedDb(timeoutMs: number = DefaultProbeTimeoutMs): Promise<boolean> {\n  return new Promise<boolean>((resolve) => {\n    const factory = resolveIndexedDb();\n    if (factory === undefined || typeof factory.open !== 'function') {\n      resolve(false);\n      return;\n    }\n\n    let settled = false;\n    /** Answers once, clears the timer, and best-effort removes the probe database. */\n    const answer = (supported: boolean, database?: IDBDatabase): void => {\n      if (settled) return;\n      settled = true;\n      clearTimeout(timer);\n\n      try {\n        database?.close();\n        factory.deleteDatabase(ProbeDatabaseName);\n      } catch {\n        // Cleanup is best-effort: a leftover empty probe database is harmless, and failing to remove it\n        // must never change the verdict we already reached.\n      }\n      resolve(supported);\n    };\n\n    const timer = setTimeout(() => {\n      answer(false);\n    }, timeoutMs);\n\n    try {\n      const request = factory.open(ProbeDatabaseName);\n      request.onsuccess = () => {\n        answer(true, request.result);\n      };\n      request.onerror = () => {\n        answer(false);\n      };\n      // A `blocked` probe means another tab holds this name open — impossible for a name we always delete,\n      // but treat it as unusable rather than waiting for the timeout.\n      request.onblocked = () => {\n        answer(false);\n      };\n    } catch {\n      // Firefox private browsing: `open()` throws synchronously.\n      answer(false);\n    }\n  });\n}\n\n/**\n * Returns the ambient `IDBFactory`, throwing a diagnostic `Error` when unavailable. Internal — every public\n * entry point in this slice is promise-returning, so this throw always surfaces to the caller as a\n * **rejection**, never a synchronous throw. Not exported from the barrel.\n */\nexport function requireIndexedDb(): IDBFactory {\n  const factory = resolveIndexedDb();\n  if (factory === undefined || typeof factory.open !== 'function') {\n    throw new Error(\n      'IndexedDB is unavailable: `globalThis.indexedDB` is missing or unusable. This runtime cannot open a ' +\n        'database — SSR, a sandboxed iframe, or a browser with storage disabled. Guard with ' +\n        '`isIndexedDbAvailable()`, or `probeIndexedDb()` to also cover private-mode failures.',\n    );\n  }\n\n  return factory;\n}\n","// The event -> promise adapters every other file in this slice is built on. IndexedDB predates promises: an\n// `IDBRequest` reports through `onsuccess` / `onerror`, an `IDBTransaction` through `oncomplete` / `onerror`\n// / `onabort`. Bridging them is mechanical but has three traps worth stating once, here.\n//\n// TRAP 1 — THE TRANSACTION AUTO-CLOSE HAZARD. This is the defining constraint of the whole slice. A\n// transaction stays alive only while the browser can see IndexedDB work pending on it; once control returns\n// to the event loop with no pending request, it commits and any later use throws `TransactionInactiveError`.\n// A promise built from an IDB request is safe to `await` — it settles inside the request's own event\n// callback, and the spec keeps the transaction active for that callback plus the microtask checkpoint that\n// follows it. Awaiting ANYTHING ELSE is not:\n//\n//   await withTransaction(db, 'items', 'readwrite', async (tx) => {\n//     const store = tx.objectStore('items');\n//     const current = await requestToPromise(store.get('k'));   // fine — IDB work keeps tx alive\n//     const patch = await fetch('/api/patch').then((r) => r.json()); // ☠ tx commits during this await\n//     await requestToPromise(store.put(patch, 'k'));            // throws TransactionInactiveError\n//   });\n//\n// The rule: read everything you need, leave the transaction to do unrelated async work, then open a second\n// transaction to write. `setTimeout(0)`, a `postMessage` round trip, an image decode, and an `await` on an\n// already-resolved unrelated promise all trip this — it is not about elapsed time, it is about yielding to\n// the event loop.\n//\n// TRAP 2 — SETTLE EXACTLY ONCE. `requestToPromise` guards against a second settle rather than relying on\n// promise semantics to swallow it, because one request genuinely can fire `success` many times: a cursor\n// request re-fires on every `continue()`. Resolving on the first record would silently truncate iteration to\n// one row, so cursors get their own loop in `Transactions.ts` and must never be passed here.\n//\n// TRAP 3 — ATTACH IN THE CREATING TASK. Both wrappers must be called synchronously in the same task that\n// created the request/transaction. Register a listener a task later and the event may already have fired,\n// leaving a promise that never settles — the same shape of hang as an unhandled `blocked` event.\n\n/**\n * Wraps a single-shot `IDBRequest` as a promise resolving to its `result`. Settles exactly once: on\n * `success` with the result, on `error` with the request's `DOMException` (normalized to an `Error` when the\n * browser leaves it null).\n *\n * Must be called in the same task the request was created in (TRAP 3), and must NOT be used for a cursor\n * request (TRAP 2) — use `iterate` instead.\n *\n * Rejecting here does **not** stop the failure from propagating: an unhandled request error bubbles to the\n * transaction and aborts it, which is IndexedDB's designed behaviour and usually what you want. A caller\n * that needs the transaction to survive a failed request must handle it inside the request's own event\n * callback, which this wrapper deliberately does not expose.\n */\nexport function requestToPromise<TResult>(request: IDBRequest<TResult>): Promise<TResult> {\n  return new Promise<TResult>((resolve, reject) => {\n    let settled = false;\n\n    request.onsuccess = () => {\n      if (settled) return;\n      settled = true;\n      resolve(request.result);\n    };\n\n    request.onerror = () => {\n      if (settled) return;\n      settled = true;\n      reject(request.error ?? new Error('IndexedDB request failed without reporting an error.'));\n    };\n  });\n}\n\n/**\n * Wraps an `IDBTransaction` as a promise that resolves when it **commits** (`complete`) and rejects when it\n * fails (`error`) or is rolled back (`abort`). Settles exactly once.\n *\n * Resolving on `complete` rather than on the last request's success is the point: only `complete` means the\n * writes are durable. An `abort` — whether from an unhandled request error, an explicit `abort()` call, or a\n * quota failure — rejects, so a caller cannot mistake a rolled-back transaction for a committed one.\n *\n * Must be called in the same task the transaction was created in (TRAP 3).\n */\nexport function transactionToPromise(transaction: IDBTransaction): Promise<void> {\n  return new Promise<void>((resolve, reject) => {\n    let settled = false;\n\n    transaction.oncomplete = () => {\n      if (settled) return;\n      settled = true;\n      resolve();\n    };\n\n    transaction.onerror = () => {\n      if (settled) return;\n      settled = true;\n      reject(transaction.error ?? new Error('IndexedDB transaction failed without reporting an error.'));\n    };\n\n    transaction.onabort = () => {\n      if (settled) return;\n      settled = true;\n      // A deliberate `abort()` leaves `transaction.error` null — there was no failure, the rollback WAS the\n      // outcome. Report it as an error anyway: the caller asked for a commit and did not get one.\n      reject(transaction.error ?? new Error('IndexedDB transaction was aborted.'));\n    };\n  });\n}\n","// Opening and deleting a database — the two operations that can DEADLOCK, and the reason this file carries\n// more machinery than a thin promise wrapper would suggest.\n//\n// THE BLOCKED DEADLOCK. A version upgrade (and a delete) needs exclusive access. If any other connection to\n// the same database is still open — most often the same app in a second tab, running the previous deploy —\n// the request cannot proceed. IndexedDB does not fail it: it fires `blocked` and then WAITS, indefinitely,\n// for the other connection to close. A caller that only listens for `success` / `error` gets a promise that\n// never settles, which surfaces as a spinner that spins forever with nothing in the console. It is the\n// classic IndexedDB production bug, and it is invisible in single-tab development.\n//\n// Both sides of that deadlock are handled here:\n//  - INBOUND, we time-box it. `blocked` starts a timer; if the open has not gone through by\n//    `blockedTimeoutMs`, the promise rejects with an error that names the cause. A defined failure beats an\n//    infinite wait — the app can prompt \"close other tabs and reload\" instead of hanging.\n//  - OUTBOUND, we refuse to be the blocker. Every connection opened here gets a `versionchange` handler that\n//    CLOSES it, so when another tab upgrades or deletes, this tab yields immediately instead of blocking it.\n//    That is the reciprocal half most wrappers omit, and omitting it is what makes the deadlock common.\n//\n// The cost of yielding: after `versionchange` the handle is dead, and further use rejects with\n// `InvalidStateError`. `createKeyValueStore` absorbs this by dropping its cached connection and re-opening\n// on the next call; a caller holding a raw `IDBDatabase` should pass `onVersionChange` and re-open (or\n// reload) itself.\n//\n// UPGRADE SEMANTICS. `upgrade` runs inside the browser's own version-change transaction. It is the ONLY\n// place `createObjectStore` / `createIndex` / `deleteObjectStore` may be called, it must be synchronous\n// (awaiting non-IDB work there commits the transaction out from under the schema — see `IdbPromises.ts`),\n// and it may be called with any `oldVersion` from 0 (fresh database) upward, so migrations must be written\n// as a ladder of `if (oldVersion < n)` steps rather than an if/else on the previous version.\n\nimport { toError } from '../errors';\nimport { requireIndexedDb } from './IndexedDbSupport';\n\n/** The default ceiling, in milliseconds, an open or delete waits after `blocked` before rejecting. */\nexport const DefaultBlockedTimeoutMs = 3000;\n\n/** Describes the version transition an {@link IdbUpgradeHandler} is being asked to apply. */\nexport interface IdbUpgradeContext {\n  /** The version already on disk — `0` for a database being created for the first time. */\n  readonly oldVersion: number;\n\n  /** The version being upgraded to; `null` only when the database is being deleted. */\n  readonly newVersion: number | null;\n\n  /** The browser's version-change transaction — the only scope in which schema changes are legal. */\n  readonly transaction: IDBTransaction;\n}\n\n/**\n * Creates or migrates the schema during a version change. Runs inside the version-change transaction, so it\n * must be **synchronous**: awaiting non-IDB work inside it commits the transaction and breaks the migration.\n * Throwing aborts the version change, leaving the on-disk schema untouched, and rejects the open.\n */\nexport type IdbUpgradeHandler = (database: IDBDatabase, context: IdbUpgradeContext) => void;\n\n/** Configures {@link openDatabase}. */\nexport interface OpenDatabaseOptions {\n  /** The schema version to open at; omitted opens whatever version exists (or creates v1). */\n  readonly version?: number;\n\n  /** Creates or migrates object stores and indexes when the requested version exceeds the stored one. */\n  readonly upgrade?: IdbUpgradeHandler;\n\n  /** How long to wait after a `blocked` event before rejecting; defaults to {@link DefaultBlockedTimeoutMs}. */\n  readonly blockedTimeoutMs?: number;\n\n  /** Called when another connection blocks this open — the hook for a \"close your other tabs\" prompt. */\n  readonly onBlocked?: () => void;\n\n  /**\n   * Called when another connection needs this one closed for its own upgrade or delete. The connection is\n   * closed immediately afterwards either way; this hook exists to warn the user or trigger a reload, not to\n   * veto the close.\n   */\n  readonly onVersionChange?: (database: IDBDatabase) => void;\n}\n\n/** Configures {@link deleteDatabase}. */\nexport interface DeleteDatabaseOptions {\n  /** How long to wait after a `blocked` event before rejecting; defaults to {@link DefaultBlockedTimeoutMs}. */\n  readonly blockedTimeoutMs?: number;\n\n  /** Called when an open connection blocks the delete. */\n  readonly onBlocked?: () => void;\n}\n\n/**\n * Opens `name`, running `upgrade` when the stored version is below the requested one, and resolves with the\n * live connection.\n *\n * Rejects — never hangs and never throws synchronously — when IndexedDB is unavailable, when the open fails,\n * when `upgrade` throws (the version change is aborted first, so the schema is left intact), or when another\n * connection blocks the upgrade for longer than `blockedTimeoutMs`.\n *\n * The returned connection closes itself if another tab later needs a version change; see the file header for\n * why that is the safe default and what a caller must do about it.\n */\nexport function openDatabase(name: string, options: OpenDatabaseOptions = {}): Promise<IDBDatabase> {\n  const { version, upgrade, blockedTimeoutMs = DefaultBlockedTimeoutMs, onBlocked, onVersionChange } = options;\n\n  return new Promise<IDBDatabase>((resolve, reject) => {\n    // Throws when IndexedDB is missing; inside the executor that becomes a rejection, upholding the slice's\n    // \"reject, never throw\" contract.\n    const factory = requireIndexedDb();\n\n    let settled = false;\n    let blockedTimer: ReturnType<typeof setTimeout> | undefined;\n\n    /** Marks the promise settled and stops the blocked timer; returns false when someone got there first. */\n    const claim = (): boolean => {\n      if (settled) return false;\n      settled = true;\n      if (blockedTimer !== undefined) clearTimeout(blockedTimer);\n      return true;\n    };\n\n    // `open(name, undefined)` is NOT the same as `open(name)` — passing an explicit undefined version is a\n    // TypeError in some engines, so the two-argument form is only used when a version was actually given.\n    const request = version === undefined ? factory.open(name) : factory.open(name, version);\n\n    request.onupgradeneeded = (event: IDBVersionChangeEvent) => {\n      if (upgrade === undefined) return;\n\n      // Non-null in an `upgradeneeded` callback by spec; lib.dom types it nullable because the property is\n      // null outside one. Treat an absent transaction as a failure rather than casting the guard away.\n      const transaction = request.transaction;\n      if (transaction === null) {\n        if (claim()) reject(new Error(`IndexedDB upgrade for \"${name}\" started without a version-change transaction.`));\n        return;\n      }\n\n      try {\n        upgrade(request.result, {\n          oldVersion: event.oldVersion,\n          newVersion: event.newVersion,\n          transaction,\n        });\n      } catch (error: unknown) {\n        // Roll the schema back before rejecting: a half-applied migration that commits is unrecoverable,\n        // whereas an aborted one leaves the database at its old version and the next load can retry.\n        try {\n          transaction.abort();\n        } catch {\n          // Already aborting or finished — the reject below still reports the real cause.\n        }\n        if (claim()) reject(toError(error));\n      }\n    };\n\n    request.onsuccess = () => {\n      const database = request.result;\n\n      // A `blocked` timeout may already have rejected while the other tab held the lock. If the open then\n      // succeeds anyway, this connection would leak and — worse — go on blocking the next upgrade. Close it.\n      if (!claim()) {\n        try {\n          database.close();\n        } catch {\n          // Nothing to recover: the promise is already settled either way.\n        }\n        return;\n      }\n\n      database.onversionchange = () => {\n        try {\n          onVersionChange?.(database);\n        } finally {\n          // Always close, even if the hook threw: holding on is what deadlocks the other tab.\n          database.close();\n        }\n      };\n\n      resolve(database);\n    };\n\n    request.onerror = () => {\n      if (claim()) reject(request.error ?? new Error(`Failed to open IndexedDB database \"${name}\".`));\n    };\n\n    request.onblocked = () => {\n      onBlocked?.();\n\n      // Do not reject immediately — the common case is another tab closing within a few hundred ms, after\n      // which the open proceeds normally. Reject only if it stays stuck.\n      blockedTimer = setTimeout(() => {\n        if (!settled) {\n          settled = true;\n          reject(\n            new Error(\n              `Opening IndexedDB database \"${name}\" is blocked: another connection (usually this app in ` +\n                `another tab) still holds an older version open, and no upgrade can run until it closes. ` +\n                `Waited ${String(blockedTimeoutMs)}ms.`,\n            ),\n          );\n        }\n      }, blockedTimeoutMs);\n    };\n  });\n}\n\n/**\n * Deletes `name` and everything in it, resolving once the database is gone. Deleting a database that does\n * not exist succeeds — the postcondition is \"no such database\", which already holds.\n *\n * Blocks on open connections exactly like an upgrade does, so it is time-boxed the same way and rejects with\n * a diagnostic error rather than hanging. Close your own connections first (`store.close()`, or\n * `database.close()`) — a connection this tab still holds will block the delete just as another tab's would.\n */\nexport function deleteDatabase(name: string, options: DeleteDatabaseOptions = {}): Promise<void> {\n  const { blockedTimeoutMs = DefaultBlockedTimeoutMs, onBlocked } = options;\n\n  return new Promise<void>((resolve, reject) => {\n    const factory = requireIndexedDb();\n\n    let settled = false;\n    let blockedTimer: ReturnType<typeof setTimeout> | undefined;\n\n    /** Marks the promise settled and stops the blocked timer; returns false when someone got there first. */\n    const claim = (): boolean => {\n      if (settled) return false;\n      settled = true;\n      if (blockedTimer !== undefined) clearTimeout(blockedTimer);\n      return true;\n    };\n\n    const request = factory.deleteDatabase(name);\n\n    request.onsuccess = () => {\n      if (claim()) resolve();\n    };\n\n    request.onerror = () => {\n      if (claim()) reject(request.error ?? new Error(`Failed to delete IndexedDB database \"${name}\".`));\n    };\n\n    request.onblocked = () => {\n      onBlocked?.();\n\n      blockedTimer = setTimeout(() => {\n        if (!settled) {\n          settled = true;\n          reject(\n            new Error(\n              `Deleting IndexedDB database \"${name}\" is blocked: a connection is still open. Close every ` +\n                `connection to it (this tab's included) before deleting. Waited ${String(blockedTimeoutMs)}ms.`,\n            ),\n          );\n        }\n      }, blockedTimeoutMs);\n    };\n  });\n}\n","// Store-level operations: run a unit of work inside one transaction, and walk a store with a cursor.\n//\n// WHY `withTransaction` RESOLVES ON COMMIT, NOT ON THE LAST REQUEST. A `put` reports success as soon as the\n// value is accepted, well before the transaction commits — and a transaction can still abort afterwards\n// (quota exceeded, a constraint violation from a sibling request, an explicit `abort()`). Resolving on the\n// last request's success would therefore report writes as durable that a moment later never happened. The\n// completion listener is attached synchronously at creation, BEFORE the work runs, because `complete` can\n// fire the instant the work function returns; attaching it after would race the event.\n//\n// FAILURE => ROLLBACK, ALWAYS. If the work function throws or rejects, the transaction is aborted rather\n// than left to commit whatever it managed to do first. The error that surfaces is the work function's, not\n// the resulting `AbortError`: the cause the caller can act on is \"your callback threw\", not \"something\n// rolled back\". The completion rejection is deliberately absorbed in that path so it does not resurface as\n// an unhandled rejection.\n//\n// THE AUTO-CLOSE HAZARD APPLIES INSIDE `fn` — awaiting anything that is not an IDB request promise commits\n// the transaction out from under the rest of the callback. Full explanation and worked example:\n// `IdbPromises.ts` header, TRAP 1.\n//\n// WHY `iterate` EXISTS ALONGSIDE `getAll`. `getAll()` materializes every record into one array: fine for a\n// few hundred small rows, ruinous for a store holding thousands of Blobs, where the peak is the whole store\n// resident in memory at once. A cursor streams one record at a time at constant memory, and can stop early.\n// It cannot reuse `requestToPromise` — a cursor request re-fires `success` on every `continue()`, and a\n// settle-once wrapper would silently truncate the walk to a single record — so it runs its own loop.\n\nimport { toError } from '../errors';\nimport { transactionToPromise } from './IdbPromises';\n\n/** One record surfaced by {@link iterate}. */\nexport interface IdbEntry<TValue, TKey extends IDBValidKey = IDBValidKey> {\n  /** The cursor's key — the index key when iterating an index, otherwise the primary key. */\n  readonly key: TKey;\n\n  /** The record's primary key in the object store; identical to `key` unless iterating an index. */\n  readonly primaryKey: IDBValidKey;\n\n  /** The stored value. */\n  readonly value: TValue;\n}\n\n/**\n * Visits one record during {@link iterate}. **Must be synchronous** — returning a promise, or awaiting\n * anything inside, commits the transaction mid-walk and the next `continue()` throws\n * `TransactionInactiveError`. Collect into an array here and do the async work after `iterate` resolves.\n *\n * Return `false` to stop the walk early; any other return value continues it.\n */\nexport type IdbCursorVisitor<TValue, TKey extends IDBValidKey = IDBValidKey> = (\n  entry: IdbEntry<TValue, TKey>,\n) => void | boolean;\n\n/** Narrows an {@link iterate} walk to a subset of the key space, in a chosen direction. */\nexport interface IterateOptions {\n  /** Restricts the walk to a single key or a key range; omitted walks every record. */\n  readonly query?: IDBValidKey | IDBKeyRange | null;\n\n  /** Cursor direction — `'next'` (ascending, the default), `'prev'`, or the `unique` variants. */\n  readonly direction?: IDBCursorDirection;\n}\n\n/**\n * Runs `fn` inside a single transaction over `storeNames` and resolves with its result **once the\n * transaction commits**, so a resolved promise means the writes are durable.\n *\n * Rejects — never throws synchronously — when the transaction cannot be created (database closed, unknown\n * store), when `fn` fails (the transaction is aborted first, so nothing partial is committed), and when the\n * transaction itself errors or aborts. Every rejection value is normalized through `toError`.\n *\n * `fn` may await IDB request promises freely, but nothing else; see the file header.\n */\nexport async function withTransaction<TResult>(\n  database: IDBDatabase,\n  storeNames: string | readonly string[],\n  mode: IDBTransactionMode,\n  fn: (transaction: IDBTransaction) => TResult | Promise<TResult>,\n): Promise<TResult> {\n  // Copied to a mutable array because lib.dom's older overload accepts `string | string[]`, not a readonly\n  // array; the copy also stops a caller mutating the list mid-transaction.\n  const names = typeof storeNames === 'string' ? storeNames : [...storeNames];\n\n  let transaction: IDBTransaction;\n  try {\n    transaction = database.transaction(names, mode);\n  } catch (error: unknown) {\n    // `InvalidStateError` (connection closed, typically after a `versionchange`) or `NotFoundError` (no such\n    // store) — both arrive synchronously and must surface as a rejection like every other failure here.\n    throw toError(error);\n  }\n\n  // Attached before `fn` runs: `complete` can fire in the same turn the work finishes.\n  const completion = transactionToPromise(transaction);\n\n  let result: TResult;\n  try {\n    result = await fn(transaction);\n  } catch (error: unknown) {\n    try {\n      transaction.abort();\n    } catch {\n      // Already finished or aborting — the original error below is still the useful one.\n    }\n    // The abort makes `completion` reject; nobody awaits it on this path, so absorb it rather than let it\n    // surface as an unhandled rejection.\n    completion.catch(() => undefined);\n    throw toError(error);\n  }\n\n  try {\n    await completion;\n  } catch (error: unknown) {\n    throw toError(error);\n  }\n\n  return result;\n}\n\n/**\n * Walks `source` with a cursor, calling `visit` once per record, and resolves with the number of records\n * visited. Constant memory regardless of store size — the reason to prefer it over `getAll` for anything\n * large — and stoppable early by returning `false` from `visit`.\n *\n * Runs inside whatever transaction `source` belongs to, so it composes with {@link withTransaction}. `visit`\n * must be synchronous; see {@link IdbCursorVisitor}.\n */\nexport function iterate<TValue, TKey extends IDBValidKey = IDBValidKey>(\n  source: IDBObjectStore | IDBIndex,\n  visit: IdbCursorVisitor<TValue, TKey>,\n  options: IterateOptions = {},\n): Promise<number> {\n  const { query = null, direction = 'next' } = options;\n\n  return new Promise<number>((resolve, reject) => {\n    let visited = 0;\n    let settled = false;\n\n    let request: IDBRequest<IDBCursorWithValue | null>;\n    try {\n      request = source.openCursor(query, direction);\n    } catch (error: unknown) {\n      reject(toError(error));\n      return;\n    }\n\n    // Not `requestToPromise`: this request fires `success` once per record (see the file header).\n    request.onsuccess = () => {\n      if (settled) return;\n\n      const cursor = request.result;\n      if (cursor === null) {\n        // Null cursor = the walk is over. This is the ONLY successful exit.\n        settled = true;\n        resolve(visited);\n        return;\n      }\n\n      let keepGoing: void | boolean;\n      try {\n        keepGoing = visit({\n          key: cursor.key as TKey,\n          primaryKey: cursor.primaryKey,\n          value: cursor.value as TValue,\n        });\n      } catch (error: unknown) {\n        // A throwing visitor stops the walk. The transaction is left alone — `withTransaction` decides\n        // whether to abort it, since it owns the transaction and this function does not.\n        settled = true;\n        reject(toError(error));\n        return;\n      }\n\n      visited++;\n      if (keepGoing === false) {\n        settled = true;\n        resolve(visited);\n        return;\n      }\n\n      try {\n        cursor.continue();\n      } catch (error: unknown) {\n        // Almost always `TransactionInactiveError` from an async visitor having yielded to the event loop.\n        settled = true;\n        reject(toError(error));\n      }\n    };\n\n    request.onerror = () => {\n      if (settled) return;\n      settled = true;\n      reject(request.error ?? new Error('IndexedDB cursor failed without reporting an error.'));\n    };\n  });\n}\n","// The 90% API: one object store, typed, addressed like a `Map`. Almost every real use of IndexedDB is a\n// keyed cache — offline documents, draft attachments, decoded media, a query cache that must survive a\n// reload — and none of it needs indexes, ranges, or multi-store transactions. Those stay reachable\n// (`openDatabase` + `withTransaction` + `iterate` are exported unchanged for the other 10%); this is the\n// surface that keeps a caller from hand-rolling the boilerplate for the common case.\n//\n// ERROR CONTRACT — ONE MODEL, NO MIXING: **every method rejects with a normalized `Error` on failure, and\n// nothing here ever throws synchronously.** Deliberately unlike `foundation/storage`, whose broker swallows\n// failures and degrades a bad read to a miss. That is right for `localStorage`: the payload is small, cheap\n// to re-derive, and a lost preference is a shrug. It is wrong here — the payloads are large, often the only\n// copy (an unsent draft, a queued upload), and a write that silently vanishes is data loss the caller was\n// never told about. Quota exhaustion, in particular, is a real and recoverable condition that a caller can\n// only handle if it is told. Absence is NOT failure: `get` resolves `undefined` for a missing key, `has`\n// answers the ambiguous case (IndexedDB can store `undefined` as a value), and both are normal results.\n//\n// CONNECTION LIFECYCLE. The database is opened lazily on the first operation, never at construction — so\n// `createKeyValueStore` is safe to call at module scope under SSR, where nothing may touch `indexedDB`. The\n// open promise is cached and shared by concurrent callers, and dropped again whenever the connection dies:\n// a failed open (so the next call retries rather than replaying a stale rejection), a `versionchange` from\n// another tab (`openDatabase` closes the handle to avoid deadlocking it — see that file's header), or a\n// browser-forced `close`. The next operation transparently re-opens. That is what makes a store held in a\n// module-scope `const` survive a second tab upgrading the schema underneath it.\n\nimport { toError } from '../errors';\nimport { requestToPromise } from './IdbPromises';\nimport { openDatabase, type IdbUpgradeHandler } from './OpenDatabase';\nimport { iterate, withTransaction, type IdbCursorVisitor } from './Transactions';\n\n/** The object store name used when none is given. */\nexport const DefaultKeyValueStoreName = 'keyval';\n\n/** Configures {@link createKeyValueStore}. */\nexport interface KeyValueStoreOptions {\n  /** The IndexedDB database to open. One database may host several stores. */\n  readonly databaseName: string;\n\n  /** The object store to address; defaults to {@link DefaultKeyValueStoreName}. Created automatically. */\n  readonly storeName?: string;\n\n  /**\n   * The schema version. Raise it when `upgrade` must run again — for example to add a second store or an\n   * index to an existing database. Defaults to the browser's (1 for a fresh database).\n   */\n  readonly version?: number;\n\n  /**\n   * Extra schema work, run after this store's own object store is ensured to exist. Only needed for\n   * additional stores, indexes, or data migrations; a plain key/value store needs no `upgrade` at all.\n   * Synchronous, like every upgrade handler.\n   */\n  readonly upgrade?: IdbUpgradeHandler;\n\n  /** Called when another tab forces this connection closed for its own upgrade or delete. */\n  readonly onVersionChange?: () => void;\n}\n\n/**\n * A typed, asynchronous key/value view over one IndexedDB object store. Values are persisted by\n * **structured clone**, not JSON: `Blob`, `File`, `ArrayBuffer`, typed arrays, `Map`, `Set`, `Date`,\n * `RegExp`, and cyclic object graphs all round-trip intact, and the store is bounded by the origin's\n * storage quota rather than `localStorage`'s ~5MB. A value the algorithm rejects (a function, a DOM node, a\n * class instance carrying methods) rejects the write with a `DataCloneError`.\n */\nexport interface KeyValueStore<TValue, TKey extends IDBValidKey = string> {\n  /** The database this store lives in. */\n  readonly databaseName: string;\n\n  /** The object store being addressed. */\n  readonly storeName: string;\n\n  /** Reads the value stored under `key`, or `undefined` when no record exists. */\n  get(key: TKey): Promise<TValue | undefined>;\n\n  /** Reads several keys in one transaction, resolving values positionally — `undefined` for each miss. */\n  getMany(keys: readonly TKey[]): Promise<(TValue | undefined)[]>;\n\n  /** Writes `value` under `key`, replacing any existing record; resolves once the transaction commits. */\n  set(key: TKey, value: TValue): Promise<void>;\n\n  /** Writes every entry in one transaction — all of them commit, or none do. */\n  setMany(entries: readonly (readonly [TKey, TValue])[]): Promise<void>;\n\n  /** Removes the record under `key`; removing a missing key succeeds. */\n  delete(key: TKey): Promise<void>;\n\n  /** Removes every listed key in one transaction. */\n  deleteMany(keys: readonly TKey[]): Promise<void>;\n\n  /** Removes every record in the store. */\n  clear(): Promise<void>;\n\n  /** Reports whether a record exists under `key` — the unambiguous test, since a stored value may be `undefined`. */\n  has(key: TKey): Promise<boolean>;\n\n  /** Counts the records in the store. */\n  count(): Promise<number>;\n\n  /** Reads every key, in ascending key order. */\n  keys(): Promise<TKey[]>;\n\n  /** Reads every value, in ascending key order. Materializes the store — prefer {@link iterateEntries} when large. */\n  values(): Promise<TValue[]>;\n\n  /** Reads every key/value pair, in ascending key order. Materializes the store — prefer {@link iterateEntries} when large. */\n  entries(): Promise<[TKey, TValue][]>;\n\n  /**\n   * Streams every record through `visit` with a cursor, at constant memory, and resolves with the number\n   * visited. The way to walk a store of Blobs without holding them all at once. `visit` must be\n   * synchronous, and returning `false` stops the walk early.\n   */\n  iterateEntries(visit: IdbCursorVisitor<TValue, TKey>): Promise<number>;\n\n  /**\n   * Releases the underlying connection. Call it before deleting the database — an open connection blocks a\n   * delete. The store stays usable: the next operation re-opens transparently.\n   */\n  close(): void;\n}\n\n/**\n * Builds a {@link KeyValueStore} over one object store, creating the database and store on first use.\n *\n * Returns synchronously and touches nothing ambient, so it is safe at module scope and under SSR; the first\n * *operation* is where an unavailable IndexedDB surfaces, as a rejection.\n *\n * @example\n * const drafts = createKeyValueStore<Blob>({ databaseName: 'editor', storeName: 'attachments' });\n * await drafts.set('cover.png', file);        // a Blob — no JSON round trip, no base64 inflation\n * const restored = await drafts.get('cover.png');\n */\nexport function createKeyValueStore<TValue, TKey extends IDBValidKey = string>(\n  options: KeyValueStoreOptions,\n): KeyValueStore<TValue, TKey> {\n  const { databaseName, storeName = DefaultKeyValueStoreName, version, upgrade, onVersionChange } = options;\n\n  let connection: Promise<IDBDatabase> | null = null;\n\n  /** Drops the cached connection, but only if `target` is still the current one — a later re-open must survive. */\n  function invalidate(target: Promise<IDBDatabase>): void {\n    if (connection === target) connection = null;\n  }\n\n  /** Opens (or reuses) the connection. Concurrent callers share one open; a failed open is never cached. */\n  function connect(): Promise<IDBDatabase> {\n    const existing = connection;\n    if (existing !== null) return existing;\n\n    const pending: Promise<IDBDatabase> = openDatabase(databaseName, {\n      version,\n      upgrade: (database, context) => {\n        // `contains` matters: the store may already exist from an earlier version, and `createObjectStore`\n        // on an existing name throws `ConstraintError`, which would abort the whole migration.\n        if (!database.objectStoreNames.contains(storeName)) database.createObjectStore(storeName);\n        upgrade?.(database, context);\n      },\n      onVersionChange: () => {\n        // `openDatabase` closes the handle right after this; drop it so the next call re-opens at the new\n        // version instead of using a dead connection.\n        invalidate(pending);\n        onVersionChange?.();\n      },\n    })\n      .then((database) => {\n        // Fired when the browser force-closes the connection (storage eviction, a hard delete elsewhere).\n        // Not fired by an explicit `close()`, which `close()` below handles itself.\n        database.addEventListener('close', () => {\n          invalidate(pending);\n        });\n        return database;\n      })\n      .catch((error: unknown) => {\n        invalidate(pending);\n        throw toError(error);\n      });\n\n    connection = pending;\n    return pending;\n  }\n\n  /** Runs `body` against this store inside one transaction, resolving when it commits. */\n  async function run<TResult>(\n    mode: IDBTransactionMode,\n    body: (store: IDBObjectStore) => Promise<TResult>,\n  ): Promise<TResult> {\n    const database = await connect();\n    return withTransaction(database, storeName, mode, (transaction) => body(transaction.objectStore(storeName)));\n  }\n\n  return {\n    databaseName,\n    storeName,\n\n    async get(key: TKey): Promise<TValue | undefined> {\n      // `get` resolves `undefined` for a missing record — the cast narrows lib.dom's `any` result, it does\n      // not change behaviour.\n      return run('readonly', (store) => requestToPromise(store.get(key) as IDBRequest<TValue | undefined>));\n    },\n\n    async getMany(keys: readonly TKey[]): Promise<(TValue | undefined)[]> {\n      return run('readonly', (store) => {\n        // Every request is issued synchronously in the map, BEFORE the first await — that is what keeps the\n        // transaction alive across the `Promise.all`.\n        const reads = keys.map((key) => requestToPromise(store.get(key) as IDBRequest<TValue | undefined>));\n        return Promise.all(reads);\n      });\n    },\n\n    async set(key: TKey, value: TValue): Promise<void> {\n      await run('readwrite', (store) => requestToPromise(store.put(value, key)));\n    },\n\n    async setMany(entries: readonly (readonly [TKey, TValue])[]): Promise<void> {\n      await run('readwrite', (store) => {\n        const writes = entries.map(([key, value]) => requestToPromise(store.put(value, key)));\n        return Promise.all(writes);\n      });\n    },\n\n    async delete(key: TKey): Promise<void> {\n      await run('readwrite', (store) => requestToPromise(store.delete(key)));\n    },\n\n    async deleteMany(keys: readonly TKey[]): Promise<void> {\n      await run('readwrite', (store) => {\n        const removals = keys.map((key) => requestToPromise(store.delete(key)));\n        return Promise.all(removals);\n      });\n    },\n\n    async clear(): Promise<void> {\n      await run('readwrite', (store) => requestToPromise(store.clear()));\n    },\n\n    async has(key: TKey): Promise<boolean> {\n      const found = await run('readonly', (store) => requestToPromise(store.count(key)));\n      return found > 0;\n    },\n\n    async count(): Promise<number> {\n      return run('readonly', (store) => requestToPromise(store.count()));\n    },\n\n    async keys(): Promise<TKey[]> {\n      // Narrowed after the await, not through the request type: `IDBRequest<T>` is invariant in `result`,\n      // so asserting the request itself is a TS2352 the element-wise assertion avoids.\n      const stored = await run('readonly', (store) => requestToPromise(store.getAllKeys()));\n      return stored as TKey[];\n    },\n\n    async values(): Promise<TValue[]> {\n      return run('readonly', (store) => requestToPromise(store.getAll() as IDBRequest<TValue[]>));\n    },\n\n    async entries(): Promise<[TKey, TValue][]> {\n      // A cursor rather than zipping `getAllKeys()` with `getAll()`: one pass, and no chance of the two\n      // arrays being paired wrongly.\n      const collected: [TKey, TValue][] = [];\n      await run('readonly', async (store) => {\n        await iterate<TValue, TKey>(store, (entry) => {\n          collected.push([entry.key, entry.value]);\n        });\n      });\n      return collected;\n    },\n\n    async iterateEntries(visit: IdbCursorVisitor<TValue, TKey>): Promise<number> {\n      return run('readonly', (store) => iterate<TValue, TKey>(store, visit));\n    },\n\n    close(): void {\n      const existing = connection;\n      connection = null;\n      if (existing === null) return;\n\n      void existing.then(\n        (database) => {\n          database.close();\n        },\n        () => {\n          // The open failed; there is no connection to close and the rejection was already delivered to\n          // whoever awaited the operation that triggered it.\n        },\n      );\n    },\n  };\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../../../src/foundation/idb/IndexedDbSupport.ts","../../../src/foundation/idb/IdbPromises.ts","../../../src/foundation/idb/OpenDatabase.ts","../../../src/foundation/idb/Transactions.ts","../../../src/foundation/idb/KeyValueStore.ts"],"sourcesContent":["// IndexedDB resolution + capability probes — the single place this slice reads the ambient\n// `globalThis.indexedDB`. Isolated for the same two reasons as `foundation/crypto`'s `WebCrypto`, plus one\n// that is specific to IndexedDB.\n//\n// 1. The global is read at CALL time, never cached at module scope. Caching would freeze an `undefined`\n//    captured during SSR into the module for the page's lifetime, and would block a test from stubbing the\n//    factory to exercise a failure path. This is also what keeps the slice import-safe under SSR: nothing\n//    here runs until a caller asks.\n// 2. Merely READING `globalThis.indexedDB` can throw. A sandboxed iframe without `allow-same-origin` raises\n//    a `SecurityError` from the getter itself, so the read is inside a try/catch — a bare `in` check or a\n//    `typeof` test would still throw there.\n// 3. **Presence does not imply usability.** Firefox in private browsing exposes a complete `indexedDB`\n//    object whose `open()` fails — historically a synchronous `InvalidStateError`, later an async `error`\n//    event on the request. Some Safari/WebView builds behave similarly after a storage eviction. So a\n//    structural check answers \"is the API here?\", NOT \"does it work?\", and the two need separate probes:\n//      - `isIndexedDbAvailable()` — synchronous, structural, free. The fast gate.\n//      - `probeIndexedDb()`       — asynchronous, functional: actually opens and deletes a throwaway\n//                                   database. The only answer that is true in private mode.\n//    A feature that must not half-work (an offline cache, a draft queue) should gate on the async probe\n//    once at startup and cache the result; everything else can use the sync gate.\n\n/** The throwaway database `probeIndexedDb` opens and deletes — namespaced so it cannot collide with an app database. */\nconst ProbeDatabaseName = '__wow-two-idb-probe__';\n\n/** The default ceiling, in milliseconds, `probeIndexedDb` waits for a verdict before answering `false`. */\nexport const DefaultProbeTimeoutMs = 2000;\n\n/**\n * Reads the ambient `IDBFactory`, or `undefined` when the runtime has none (SSR, a worker without the\n * API) or when reading it throws (a sandboxed iframe raising `SecurityError` from the getter).\n */\nexport function resolveIndexedDb(): IDBFactory | undefined {\n  // Widened through an optional-property view: `globalThis.indexedDB` is typed non-optional by lib.dom, so\n  // a direct `=== undefined` check would be a TS2367 \"no overlap\" error even though absence is exactly the\n  // case this function exists to handle.\n  try {\n    return (globalThis as { indexedDB?: IDBFactory }).indexedDB;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Reports whether an `IDBFactory` is present and structurally usable — the synchronous gate. True in every\n * browser; false under SSR, in a sandboxed iframe, and in runtimes without the API (plain Node).\n *\n * **Not a guarantee that a database will open.** Firefox private browsing exposes the full API and fails on\n * `open()`; only {@link probeIndexedDb} detects that. Use this to skip work that would obviously fail, and\n * the async probe before committing a feature to IndexedDB.\n */\nexport function isIndexedDbAvailable(): boolean {\n  return typeof resolveIndexedDb()?.open === 'function';\n}\n\n/**\n * Reports whether IndexedDB actually **works**, by opening a throwaway database and deleting it again.\n * Catches the private-mode case {@link isIndexedDbAvailable} cannot: an API that is present but whose\n * `open()` throws or errors.\n *\n * Never throws and never hangs — a synchronous throw, an `error` event, a `blocked` open, and a runtime\n * that simply never answers all resolve to `false` once `timeoutMs` elapses. Cache the result; the probe\n * costs a real database round trip.\n */\nexport function probeIndexedDb(timeoutMs: number = DefaultProbeTimeoutMs): Promise<boolean> {\n  return new Promise<boolean>((resolve) => {\n    const factory = resolveIndexedDb();\n    if (factory === undefined || typeof factory.open !== 'function') {\n      resolve(false);\n      return;\n    }\n\n    let settled = false;\n    /** Answers once, clears the timer, and best-effort removes the probe database. */\n    const answer = (supported: boolean, database?: IDBDatabase): void => {\n      if (settled) {\n        database?.close();\n        return;\n      }\n      settled = true;\n      clearTimeout(timer);\n\n      try {\n        database?.close();\n        factory.deleteDatabase(ProbeDatabaseName);\n      } catch {\n        // Cleanup is best-effort: a leftover empty probe database is harmless, and failing to remove it\n        // must never change the verdict we already reached.\n      }\n      resolve(supported);\n    };\n\n    const timer = setTimeout(() => {\n      answer(false);\n    }, timeoutMs);\n\n    try {\n      const request = factory.open(ProbeDatabaseName);\n      request.onsuccess = () => {\n        answer(true, request.result);\n      };\n      request.onerror = () => {\n        answer(false);\n      };\n      // A `blocked` probe means another tab holds this name open — impossible for a name we always delete,\n      // but treat it as unusable rather than waiting for the timeout.\n      request.onblocked = () => {\n        answer(false);\n      };\n    } catch {\n      // Firefox private browsing: `open()` throws synchronously.\n      answer(false);\n    }\n  });\n}\n\n/**\n * Returns the ambient `IDBFactory`, throwing a diagnostic `Error` when unavailable. Internal — every public\n * entry point in this slice is promise-returning, so this throw always surfaces to the caller as a\n * **rejection**, never a synchronous throw. Not exported from the barrel.\n */\nexport function requireIndexedDb(): IDBFactory {\n  const factory = resolveIndexedDb();\n  if (factory === undefined || typeof factory.open !== 'function') {\n    throw new Error(\n      'IndexedDB is unavailable: `globalThis.indexedDB` is missing or unusable. This runtime cannot open a ' +\n        'database — SSR, a sandboxed iframe, or a browser with storage disabled. Guard with ' +\n        '`isIndexedDbAvailable()`, or `probeIndexedDb()` to also cover private-mode failures.',\n    );\n  }\n\n  return factory;\n}\n","// The event -> promise adapters every other file in this slice is built on. IndexedDB predates promises: an\n// `IDBRequest` reports through `onsuccess` / `onerror`, an `IDBTransaction` through `oncomplete` / `onerror`\n// / `onabort`. Bridging them is mechanical but has three traps worth stating once, here.\n//\n// TRAP 1 — THE TRANSACTION AUTO-CLOSE HAZARD. This is the defining constraint of the whole slice. A\n// transaction stays alive only while the browser can see IndexedDB work pending on it; once control returns\n// to the event loop with no pending request, it commits and any later use throws `TransactionInactiveError`.\n// A promise built from an IDB request is safe to `await` — it settles inside the request's own event\n// callback, and the spec keeps the transaction active for that callback plus the microtask checkpoint that\n// follows it. Awaiting ANYTHING ELSE is not:\n//\n//   await withTransaction(db, 'items', 'readwrite', async (tx) => {\n//     const store = tx.objectStore('items');\n//     const current = await requestToPromise(store.get('k'));   // fine — IDB work keeps tx alive\n//     const patch = await fetch('/api/patch').then((r) => r.json()); // ☠ tx commits during this await\n//     await requestToPromise(store.put(patch, 'k'));            // throws TransactionInactiveError\n//   });\n//\n// The rule: read everything you need, leave the transaction to do unrelated async work, then open a second\n// transaction to write. `setTimeout(0)`, a `postMessage` round trip, an image decode, and an `await` on an\n// already-resolved unrelated promise all trip this — it is not about elapsed time, it is about yielding to\n// the event loop.\n//\n// TRAP 2 — SETTLE EXACTLY ONCE. `requestToPromise` guards against a second settle rather than relying on\n// promise semantics to swallow it, because one request genuinely can fire `success` many times: a cursor\n// request re-fires on every `continue()`. Resolving on the first record would silently truncate iteration to\n// one row, so cursors get their own loop in `Transactions.ts` and must never be passed here.\n//\n// TRAP 3 — ATTACH IN THE CREATING TASK. Both wrappers must be called synchronously in the same task that\n// created the request/transaction. Register a listener a task later and the event may already have fired,\n// leaving a promise that never settles — the same shape of hang as an unhandled `blocked` event.\n\n/**\n * Wraps a single-shot `IDBRequest` as a promise resolving to its `result`. Settles exactly once: on\n * `success` with the result, on `error` with the request's `DOMException` (normalized to an `Error` when the\n * browser leaves it null).\n *\n * Must be called in the same task the request was created in (TRAP 3), and must NOT be used for a cursor\n * request (TRAP 2) — use `iterate` instead.\n *\n * Rejecting here does **not** stop the failure from propagating: an unhandled request error bubbles to the\n * transaction and aborts it, which is IndexedDB's designed behaviour and usually what you want. A caller\n * that needs the transaction to survive a failed request must handle it inside the request's own event\n * callback, which this wrapper deliberately does not expose.\n */\nexport function requestToPromise<TResult>(request: IDBRequest<TResult>): Promise<TResult> {\n  return new Promise<TResult>((resolve, reject) => {\n    let settled = false;\n\n    request.onsuccess = () => {\n      if (settled) return;\n      settled = true;\n      resolve(request.result);\n    };\n\n    request.onerror = () => {\n      if (settled) return;\n      settled = true;\n      reject(request.error ?? new Error('IndexedDB request failed without reporting an error.'));\n    };\n  });\n}\n\n/**\n * Wraps an `IDBTransaction` as a promise that resolves when it **commits** (`complete`) and rejects when it\n * fails (`error`) or is rolled back (`abort`). Settles exactly once.\n *\n * Resolving on `complete` rather than on the last request's success is the point: only `complete` means the\n * writes are durable. An `abort` — whether from an unhandled request error, an explicit `abort()` call, or a\n * quota failure — rejects, so a caller cannot mistake a rolled-back transaction for a committed one.\n *\n * Must be called in the same task the transaction was created in (TRAP 3).\n */\nexport function transactionToPromise(transaction: IDBTransaction): Promise<void> {\n  return new Promise<void>((resolve, reject) => {\n    let settled = false;\n\n    transaction.oncomplete = () => {\n      if (settled) return;\n      settled = true;\n      resolve();\n    };\n\n    transaction.onerror = () => {\n      if (settled) return;\n      settled = true;\n      reject(transaction.error ?? new Error('IndexedDB transaction failed without reporting an error.'));\n    };\n\n    transaction.onabort = () => {\n      if (settled) return;\n      settled = true;\n      // A deliberate `abort()` leaves `transaction.error` null — there was no failure, the rollback WAS the\n      // outcome. Report it as an error anyway: the caller asked for a commit and did not get one.\n      reject(transaction.error ?? new Error('IndexedDB transaction was aborted.'));\n    };\n  });\n}\n","// Opening and deleting a database — the two operations that can DEADLOCK, and the reason this file carries\n// more machinery than a thin promise wrapper would suggest.\n//\n// THE BLOCKED DEADLOCK. A version upgrade (and a delete) needs exclusive access. If any other connection to\n// the same database is still open — most often the same app in a second tab, running the previous deploy —\n// the request cannot proceed. IndexedDB does not fail it: it fires `blocked` and then WAITS, indefinitely,\n// for the other connection to close. A caller that only listens for `success` / `error` gets a promise that\n// never settles, which surfaces as a spinner that spins forever with nothing in the console. It is the\n// classic IndexedDB production bug, and it is invisible in single-tab development.\n//\n// Both sides of that deadlock are handled here:\n//  - INBOUND, we time-box it. `blocked` starts a timer; if the open has not gone through by\n//    `blockedTimeoutMs`, the promise rejects with an error that names the cause. A defined failure beats an\n//    infinite wait — the app can prompt \"close other tabs and reload\" instead of hanging.\n//  - OUTBOUND, we refuse to be the blocker. Every connection opened here gets a `versionchange` handler that\n//    CLOSES it, so when another tab upgrades or deletes, this tab yields immediately instead of blocking it.\n//    That is the reciprocal half most wrappers omit, and omitting it is what makes the deadlock common.\n//\n// The cost of yielding: after `versionchange` the handle is dead, and further use rejects with\n// `InvalidStateError`. `createKeyValueStore` absorbs this by dropping its cached connection and re-opening\n// on the next call; a caller holding a raw `IDBDatabase` should pass `onVersionChange` and re-open (or\n// reload) itself.\n//\n// UPGRADE SEMANTICS. `upgrade` runs inside the browser's own version-change transaction. It is the ONLY\n// place `createObjectStore` / `createIndex` / `deleteObjectStore` may be called, it must be synchronous\n// (awaiting non-IDB work there commits the transaction out from under the schema — see `IdbPromises.ts`),\n// and it may be called with any `oldVersion` from 0 (fresh database) upward, so migrations must be written\n// as a ladder of `if (oldVersion < n)` steps rather than an if/else on the previous version.\n\nimport { toError } from '../errors';\nimport { requireIndexedDb } from './IndexedDbSupport';\n\n/** The default ceiling, in milliseconds, an open or delete waits after `blocked` before rejecting. */\nexport const DefaultBlockedTimeoutMs = 3000;\n\n/** Describes the version transition an {@link IdbUpgradeHandler} is being asked to apply. */\nexport interface IdbUpgradeContext {\n  /** The version already on disk — `0` for a database being created for the first time. */\n  readonly oldVersion: number;\n\n  /** The version being upgraded to; `null` only when the database is being deleted. */\n  readonly newVersion: number | null;\n\n  /** The browser's version-change transaction — the only scope in which schema changes are legal. */\n  readonly transaction: IDBTransaction;\n}\n\n/**\n * Creates or migrates the schema during a version change. Runs inside the version-change transaction, so it\n * must be **synchronous**: awaiting non-IDB work inside it commits the transaction and breaks the migration.\n * Throwing aborts the version change, leaving the on-disk schema untouched, and rejects the open.\n */\nexport type IdbUpgradeHandler = (database: IDBDatabase, context: IdbUpgradeContext) => void;\n\n/** Configures {@link openDatabase}. */\nexport interface OpenDatabaseOptions {\n  /** The schema version to open at; omitted opens whatever version exists (or creates v1). */\n  readonly version?: number;\n\n  /** Creates or migrates object stores and indexes when the requested version exceeds the stored one. */\n  readonly upgrade?: IdbUpgradeHandler;\n\n  /** How long to wait after a `blocked` event before rejecting; defaults to {@link DefaultBlockedTimeoutMs}. */\n  readonly blockedTimeoutMs?: number;\n\n  /** Called when another connection blocks this open — the hook for a \"close your other tabs\" prompt. */\n  readonly onBlocked?: () => void;\n\n  /**\n   * Called when another connection needs this one closed for its own upgrade or delete. The connection is\n   * closed immediately afterwards either way; this hook exists to warn the user or trigger a reload, not to\n   * veto the close.\n   */\n  readonly onVersionChange?: (database: IDBDatabase) => void;\n}\n\n/** Configures {@link deleteDatabase}. */\nexport interface DeleteDatabaseOptions {\n  /** How long to wait after a `blocked` event before rejecting; defaults to {@link DefaultBlockedTimeoutMs}. */\n  readonly blockedTimeoutMs?: number;\n\n  /** Called when an open connection blocks the delete. */\n  readonly onBlocked?: () => void;\n}\n\n/**\n * Opens `name`, running `upgrade` when the stored version is below the requested one, and resolves with the\n * live connection.\n *\n * Rejects — never hangs and never throws synchronously — when IndexedDB is unavailable, when the open fails,\n * when `upgrade` throws (the version change is aborted first, so the schema is left intact), or when another\n * connection blocks the upgrade for longer than `blockedTimeoutMs`.\n *\n * The returned connection closes itself if another tab later needs a version change; see the file header for\n * why that is the safe default and what a caller must do about it.\n */\nexport function openDatabase(name: string, options: OpenDatabaseOptions = {}): Promise<IDBDatabase> {\n  const { version, upgrade, blockedTimeoutMs = DefaultBlockedTimeoutMs, onBlocked, onVersionChange } = options;\n\n  return new Promise<IDBDatabase>((resolve, reject) => {\n    // Throws when IndexedDB is missing; inside the executor that becomes a rejection, upholding the slice's\n    // \"reject, never throw\" contract.\n    const factory = requireIndexedDb();\n\n    let settled = false;\n    let blockedTimer: ReturnType<typeof setTimeout> | undefined;\n\n    /** Marks the promise settled and stops the blocked timer; returns false when someone got there first. */\n    const claim = (): boolean => {\n      if (settled) return false;\n      settled = true;\n      if (blockedTimer !== undefined) clearTimeout(blockedTimer);\n      return true;\n    };\n\n    // `open(name, undefined)` is NOT the same as `open(name)` — passing an explicit undefined version is a\n    // TypeError in some engines, so the two-argument form is only used when a version was actually given.\n    const request = version === undefined ? factory.open(name) : factory.open(name, version);\n\n    request.onupgradeneeded = (event: IDBVersionChangeEvent) => {\n      if (upgrade === undefined) return;\n\n      // Non-null in an `upgradeneeded` callback by spec; lib.dom types it nullable because the property is\n      // null outside one. Treat an absent transaction as a failure rather than casting the guard away.\n      const transaction = request.transaction;\n      if (transaction === null) {\n        if (claim()) reject(new Error(`IndexedDB upgrade for \"${name}\" started without a version-change transaction.`));\n        return;\n      }\n\n      try {\n        upgrade(request.result, {\n          oldVersion: event.oldVersion,\n          newVersion: event.newVersion,\n          transaction,\n        });\n      } catch (error: unknown) {\n        // Roll the schema back before rejecting: a half-applied migration that commits is unrecoverable,\n        // whereas an aborted one leaves the database at its old version and the next load can retry.\n        try {\n          transaction.abort();\n        } catch {\n          // Already aborting or finished — the reject below still reports the real cause.\n        }\n        if (claim()) reject(toError(error));\n      }\n    };\n\n    request.onsuccess = () => {\n      const database = request.result;\n\n      // A `blocked` timeout may already have rejected while the other tab held the lock. If the open then\n      // succeeds anyway, this connection would leak and — worse — go on blocking the next upgrade. Close it.\n      if (!claim()) {\n        try {\n          database.close();\n        } catch {\n          // Nothing to recover: the promise is already settled either way.\n        }\n        return;\n      }\n\n      database.onversionchange = () => {\n        try {\n          onVersionChange?.(database);\n        } finally {\n          // Always close, even if the hook threw: holding on is what deadlocks the other tab.\n          database.close();\n        }\n      };\n\n      resolve(database);\n    };\n\n    request.onerror = () => {\n      if (claim()) reject(request.error ?? new Error(`Failed to open IndexedDB database \"${name}\".`));\n    };\n\n    request.onblocked = () => {\n      if (settled) return;\n      try {\n        onBlocked?.();\n      } catch (error) {\n        if (claim()) reject(toError(error));\n        return;\n      }\n      if (blockedTimer !== undefined) return;\n\n      // Do not reject immediately — the common case is another tab closing within a few hundred ms, after\n      // which the open proceeds normally. Reject only if it stays stuck.\n      blockedTimer = setTimeout(() => {\n        if (!settled) {\n          settled = true;\n          reject(\n            new Error(\n              `Opening IndexedDB database \"${name}\" is blocked: another connection (usually this app in ` +\n                `another tab) still holds an older version open, and no upgrade can run until it closes. ` +\n                `Waited ${String(blockedTimeoutMs)}ms.`,\n            ),\n          );\n        }\n      }, blockedTimeoutMs);\n    };\n  });\n}\n\n/**\n * Deletes `name` and everything in it, resolving once the database is gone. Deleting a database that does\n * not exist succeeds — the postcondition is \"no such database\", which already holds.\n *\n * Blocks on open connections exactly like an upgrade does, so it is time-boxed the same way and rejects with\n * a diagnostic error rather than hanging. Close your own connections first (`store.close()`, or\n * `database.close()`) — a connection this tab still holds will block the delete just as another tab's would.\n */\nexport function deleteDatabase(name: string, options: DeleteDatabaseOptions = {}): Promise<void> {\n  const { blockedTimeoutMs = DefaultBlockedTimeoutMs, onBlocked } = options;\n\n  return new Promise<void>((resolve, reject) => {\n    const factory = requireIndexedDb();\n\n    let settled = false;\n    let blockedTimer: ReturnType<typeof setTimeout> | undefined;\n\n    /** Marks the promise settled and stops the blocked timer; returns false when someone got there first. */\n    const claim = (): boolean => {\n      if (settled) return false;\n      settled = true;\n      if (blockedTimer !== undefined) clearTimeout(blockedTimer);\n      return true;\n    };\n\n    const request = factory.deleteDatabase(name);\n\n    request.onsuccess = () => {\n      if (claim()) resolve();\n    };\n\n    request.onerror = () => {\n      if (claim()) reject(request.error ?? new Error(`Failed to delete IndexedDB database \"${name}\".`));\n    };\n\n    request.onblocked = () => {\n      if (settled) return;\n      try {\n        onBlocked?.();\n      } catch (error) {\n        if (claim()) reject(toError(error));\n        return;\n      }\n      if (blockedTimer !== undefined) return;\n\n      blockedTimer = setTimeout(() => {\n        if (!settled) {\n          settled = true;\n          reject(\n            new Error(\n              `Deleting IndexedDB database \"${name}\" is blocked: a connection is still open. Close every ` +\n                `connection to it (this tab's included) before deleting. Waited ${String(blockedTimeoutMs)}ms.`,\n            ),\n          );\n        }\n      }, blockedTimeoutMs);\n    };\n  });\n}\n","// Store-level operations: run a unit of work inside one transaction, and walk a store with a cursor.\n//\n// WHY `withTransaction` RESOLVES ON COMMIT, NOT ON THE LAST REQUEST. A `put` reports success as soon as the\n// value is accepted, well before the transaction commits — and a transaction can still abort afterwards\n// (quota exceeded, a constraint violation from a sibling request, an explicit `abort()`). Resolving on the\n// last request's success would therefore report writes as durable that a moment later never happened. The\n// completion listener is attached synchronously at creation, BEFORE the work runs, because `complete` can\n// fire the instant the work function returns; attaching it after would race the event.\n//\n// FAILURE => ROLLBACK, ALWAYS. If the work function throws or rejects, the transaction is aborted rather\n// than left to commit whatever it managed to do first. The error that surfaces is the work function's, not\n// the resulting `AbortError`: the cause the caller can act on is \"your callback threw\", not \"something\n// rolled back\". The completion rejection is deliberately absorbed in that path so it does not resurface as\n// an unhandled rejection.\n//\n// THE AUTO-CLOSE HAZARD APPLIES INSIDE `fn` — awaiting anything that is not an IDB request promise commits\n// the transaction out from under the rest of the callback. Full explanation and worked example:\n// `IdbPromises.ts` header, TRAP 1.\n//\n// WHY `iterate` EXISTS ALONGSIDE `getAll`. `getAll()` materializes every record into one array: fine for a\n// few hundred small rows, ruinous for a store holding thousands of Blobs, where the peak is the whole store\n// resident in memory at once. A cursor streams one record at a time at constant memory, and can stop early.\n// It cannot reuse `requestToPromise` — a cursor request re-fires `success` on every `continue()`, and a\n// settle-once wrapper would silently truncate the walk to a single record — so it runs its own loop.\n\nimport { toError } from '../errors';\nimport { transactionToPromise } from './IdbPromises';\n\n/** One record surfaced by {@link iterate}. */\nexport interface IdbEntry<TValue, TKey extends IDBValidKey = IDBValidKey> {\n  /** The cursor's key — the index key when iterating an index, otherwise the primary key. */\n  readonly key: TKey;\n\n  /** The record's primary key in the object store; identical to `key` unless iterating an index. */\n  readonly primaryKey: IDBValidKey;\n\n  /** The stored value. */\n  readonly value: TValue;\n}\n\n/**\n * Visits one record during {@link iterate}. **Must be synchronous** — returning a promise, or awaiting\n * anything inside, commits the transaction mid-walk and the next `continue()` throws\n * `TransactionInactiveError`. Collect into an array here and do the async work after `iterate` resolves.\n *\n * Return `false` to stop the walk early; any other return value continues it.\n */\nexport type IdbCursorVisitor<TValue, TKey extends IDBValidKey = IDBValidKey> = (\n  entry: IdbEntry<TValue, TKey>,\n) => void | boolean;\n\n/** Narrows an {@link iterate} walk to a subset of the key space, in a chosen direction. */\nexport interface IterateOptions {\n  /** Restricts the walk to a single key or a key range; omitted walks every record. */\n  readonly query?: IDBValidKey | IDBKeyRange | null;\n\n  /** Cursor direction — `'next'` (ascending, the default), `'prev'`, or the `unique` variants. */\n  readonly direction?: IDBCursorDirection;\n}\n\n/**\n * Runs `fn` inside a single transaction over `storeNames` and resolves with its result **once the\n * transaction commits**, so a resolved promise means the writes are durable.\n *\n * Rejects — never throws synchronously — when the transaction cannot be created (database closed, unknown\n * store), when `fn` fails (the transaction is aborted first, so nothing partial is committed), and when the\n * transaction itself errors or aborts. Every rejection value is normalized through `toError`.\n *\n * `fn` may await IDB request promises freely, but nothing else; see the file header.\n */\nexport async function withTransaction<TResult>(\n  database: IDBDatabase,\n  storeNames: string | ReadonlyArray<string>,\n  mode: IDBTransactionMode,\n  fn: (transaction: IDBTransaction) => TResult | Promise<TResult>,\n): Promise<TResult> {\n  // Copied to a mutable array because lib.dom's older overload accepts `string | string[]`, not a readonly\n  // array; the copy also stops a caller mutating the list mid-transaction.\n  const names = typeof storeNames === 'string' ? storeNames : [...storeNames];\n\n  let transaction: IDBTransaction;\n  try {\n    transaction = database.transaction(names, mode);\n  } catch (error: unknown) {\n    // `InvalidStateError` (connection closed, typically after a `versionchange`) or `NotFoundError` (no such\n    // store) — both arrive synchronously and must surface as a rejection like every other failure here.\n    throw toError(error);\n  }\n\n  // Attached before `fn` runs: `complete` can fire in the same turn the work finishes.\n  const completion = transactionToPromise(transaction);\n\n  let result: TResult;\n  try {\n    result = await fn(transaction);\n  } catch (error: unknown) {\n    try {\n      transaction.abort();\n    } catch {\n      // Already finished or aborting — the original error below is still the useful one.\n    }\n    // The abort makes `completion` reject; nobody awaits it on this path, so absorb it rather than let it\n    // surface as an unhandled rejection.\n    completion.catch(() => undefined);\n    throw toError(error);\n  }\n\n  try {\n    await completion;\n  } catch (error: unknown) {\n    throw toError(error);\n  }\n\n  return result;\n}\n\n/**\n * Walks `source` with a cursor, calling `visit` once per record, and resolves with the number of records\n * visited. Constant memory regardless of store size — the reason to prefer it over `getAll` for anything\n * large — and stoppable early by returning `false` from `visit`.\n *\n * Runs inside whatever transaction `source` belongs to, so it composes with {@link withTransaction}. `visit`\n * must be synchronous; see {@link IdbCursorVisitor}.\n */\nexport function iterate<TValue, TKey extends IDBValidKey = IDBValidKey>(\n  source: IDBObjectStore | IDBIndex,\n  visit: IdbCursorVisitor<TValue, TKey>,\n  options: IterateOptions = {},\n): Promise<number> {\n  const { query = null, direction = 'next' } = options;\n\n  return new Promise<number>((resolve, reject) => {\n    let visited = 0;\n    let settled = false;\n\n    let request: IDBRequest<IDBCursorWithValue | null>;\n    try {\n      request = source.openCursor(query, direction);\n    } catch (error: unknown) {\n      reject(toError(error));\n      return;\n    }\n\n    // Not `requestToPromise`: this request fires `success` once per record (see the file header).\n    request.onsuccess = () => {\n      if (settled) return;\n\n      const cursor = request.result;\n      if (cursor === null) {\n        // Null cursor = the walk is over. This is the ONLY successful exit.\n        settled = true;\n        resolve(visited);\n        return;\n      }\n\n      let keepGoing: void | boolean;\n      try {\n        keepGoing = visit({\n          key: cursor.key as TKey,\n          primaryKey: cursor.primaryKey,\n          value: cursor.value as TValue,\n        });\n      } catch (error: unknown) {\n        // A throwing visitor stops the walk. The transaction is left alone — `withTransaction` decides\n        // whether to abort it, since it owns the transaction and this function does not.\n        settled = true;\n        reject(toError(error));\n        return;\n      }\n\n      visited++;\n      if (keepGoing === false) {\n        settled = true;\n        resolve(visited);\n        return;\n      }\n\n      try {\n        cursor.continue();\n      } catch (error: unknown) {\n        // Almost always `TransactionInactiveError` from an async visitor having yielded to the event loop.\n        settled = true;\n        reject(toError(error));\n      }\n    };\n\n    request.onerror = () => {\n      if (settled) return;\n      settled = true;\n      reject(request.error ?? new Error('IndexedDB cursor failed without reporting an error.'));\n    };\n  });\n}\n","// The 90% API: one object store, typed, addressed like a `Map`. Almost every real use of IndexedDB is a\n// keyed cache — offline documents, draft attachments, decoded media, a query cache that must survive a\n// reload — and none of it needs indexes, ranges, or multi-store transactions. Those stay reachable\n// (`openDatabase` + `withTransaction` + `iterate` are exported unchanged for the other 10%); this is the\n// surface that keeps a caller from hand-rolling the boilerplate for the common case.\n//\n// ERROR CONTRACT — ONE MODEL, NO MIXING: **every method rejects with a normalized `Error` on failure, and\n// nothing here ever throws synchronously.** Deliberately unlike `foundation/storage`, whose broker swallows\n// failures and degrades a bad read to a miss. That is right for `localStorage`: the payload is small, cheap\n// to re-derive, and a lost preference is a shrug. It is wrong here — the payloads are large, often the only\n// copy (an unsent draft, a queued upload), and a write that silently vanishes is data loss the caller was\n// never told about. Quota exhaustion, in particular, is a real and recoverable condition that a caller can\n// only handle if it is told. Absence is NOT failure: `get` resolves `undefined` for a missing key, `has`\n// answers the ambiguous case (IndexedDB can store `undefined` as a value), and both are normal results.\n//\n// CONNECTION LIFECYCLE. The database is opened lazily on the first operation, never at construction — so\n// `createKeyValueStore` is safe to call at module scope under SSR, where nothing may touch `indexedDB`. The\n// open promise is cached and shared by concurrent callers, and dropped again whenever the connection dies:\n// a failed open (so the next call retries rather than replaying a stale rejection), a `versionchange` from\n// another tab (`openDatabase` closes the handle to avoid deadlocking it — see that file's header), or a\n// browser-forced `close`. The next operation transparently re-opens. That is what makes a store held in a\n// module-scope `const` survive a second tab upgrading the schema underneath it.\n\nimport { toError } from '../errors';\nimport { requestToPromise } from './IdbPromises';\nimport { openDatabase, type IdbUpgradeHandler } from './OpenDatabase';\nimport { iterate, withTransaction, type IdbCursorVisitor } from './Transactions';\n\n/** The object store name used when none is given. */\nexport const DefaultKeyValueStoreName = 'keyval';\n\n/** Configures {@link createKeyValueStore}. */\nexport interface KeyValueStoreOptions {\n  /** The IndexedDB database to open. One database may host several stores. */\n  readonly databaseName: string;\n\n  /** The object store to address; defaults to {@link DefaultKeyValueStoreName}. Created automatically. */\n  readonly storeName?: string;\n\n  /**\n   * The schema version. Raise it when `upgrade` must run again — for example to add a second store or an\n   * index to an existing database. Defaults to the browser's (1 for a fresh database).\n   */\n  readonly version?: number;\n\n  /**\n   * Extra schema work, run after this store's own object store is ensured to exist. Only needed for\n   * additional stores, indexes, or data migrations; a plain key/value store needs no `upgrade` at all.\n   * Synchronous, like every upgrade handler.\n   */\n  readonly upgrade?: IdbUpgradeHandler;\n\n  /** Called when another tab forces this connection closed for its own upgrade or delete. */\n  readonly onVersionChange?: () => void;\n}\n\n/**\n * A typed, asynchronous key/value view over one IndexedDB object store. Values are persisted by\n * **structured clone**, not JSON: `Blob`, `File`, `ArrayBuffer`, typed arrays, `Map`, `Set`, `Date`,\n * `RegExp`, and cyclic object graphs all round-trip intact, and the store is bounded by the origin's\n * storage quota rather than `localStorage`'s ~5MB. A value the algorithm rejects (a function, a DOM node, a\n * class instance carrying methods) rejects the write with a `DataCloneError`.\n */\nexport interface KeyValueStore<TValue, TKey extends IDBValidKey = string> {\n  /** The database this store lives in. */\n  readonly databaseName: string;\n\n  /** The object store being addressed. */\n  readonly storeName: string;\n\n  /** Reads the value stored under `key`, or `undefined` when no record exists. */\n  get(key: TKey): Promise<TValue | undefined>;\n\n  /** Reads several keys in one transaction, resolving values positionally — `undefined` for each miss. */\n  getMany(keys: ReadonlyArray<TKey>): Promise<(TValue | undefined)[]>;\n\n  /** Writes `value` under `key`, replacing any existing record; resolves once the transaction commits. */\n  set(key: TKey, value: TValue): Promise<void>;\n\n  /** Writes every entry in one transaction — all of them commit, or none do. */\n  setMany(entries: readonly (readonly [TKey, TValue])[]): Promise<void>;\n\n  /** Removes the record under `key`; removing a missing key succeeds. */\n  delete(key: TKey): Promise<void>;\n\n  /** Removes every listed key in one transaction. */\n  deleteMany(keys: ReadonlyArray<TKey>): Promise<void>;\n\n  /** Removes every record in the store. */\n  clear(): Promise<void>;\n\n  /** Reports whether a record exists under `key` — the unambiguous test, since a stored value may be `undefined`. */\n  has(key: TKey): Promise<boolean>;\n\n  /** Counts the records in the store. */\n  count(): Promise<number>;\n\n  /** Reads every key, in ascending key order. */\n  keys(): Promise<TKey[]>;\n\n  /** Reads every value, in ascending key order. Materializes the store — prefer {@link iterateEntries} when large. */\n  values(): Promise<TValue[]>;\n\n  /** Reads every entry, in ascending key order. Materializes the store — prefer {@link iterateEntries} when large. */\n  entries(): Promise<[TKey, TValue][]>;\n\n  /**\n   * Streams every record through `visit` with a cursor, at constant memory, and resolves with the number\n   * visited. The way to walk a store of Blobs without holding them all at once. `visit` must be\n   * synchronous, and returning `false` stops the walk early.\n   */\n  iterateEntries(visit: IdbCursorVisitor<TValue, TKey>): Promise<number>;\n\n  /**\n   * Releases the underlying connection. Call it before deleting the database — an open connection blocks a\n   * delete. The store stays usable: the next operation re-opens transparently.\n   */\n  close(): void;\n}\n\n/**\n * Builds a {@link KeyValueStore} over one object store, creating the database and store on first use.\n *\n * Returns synchronously and touches nothing ambient, so it is safe at module scope and under SSR; the first\n * *operation* is where an unavailable IndexedDB surfaces, as a rejection.\n *\n * @example\n * const drafts = createKeyValueStore<Blob>({ databaseName: 'editor', storeName: 'attachments' });\n * await drafts.set('cover.png', file);        // a Blob — no JSON round trip, no base64 inflation\n * const restored = await drafts.get('cover.png');\n */\nexport function createKeyValueStore<TValue, TKey extends IDBValidKey = string>(\n  options: KeyValueStoreOptions,\n): KeyValueStore<TValue, TKey> {\n  const { databaseName, storeName = DefaultKeyValueStoreName, version, upgrade, onVersionChange } = options;\n\n  let connection: Promise<IDBDatabase> | null = null;\n\n  /** Drops the cached connection, but only if `target` is still the current one — a later re-open must survive. */\n  function invalidate(target: Promise<IDBDatabase>): void {\n    if (connection === target) connection = null;\n  }\n\n  /** Opens (or reuses) the connection. Concurrent callers share one open; a failed open is never cached. */\n  function connect(): Promise<IDBDatabase> {\n    const existing = connection;\n    if (existing !== null) return existing;\n\n    const pending: Promise<IDBDatabase> = openDatabase(databaseName, {\n      version,\n      upgrade: (database, context) => {\n        // `contains` matters: the store may already exist from an earlier version, and `createObjectStore`\n        // on an existing name throws `ConstraintError`, which would abort the whole migration.\n        if (!database.objectStoreNames.contains(storeName)) database.createObjectStore(storeName);\n        upgrade?.(database, context);\n      },\n      onVersionChange: () => {\n        // `openDatabase` closes the handle right after this; drop it so the next call re-opens at the new\n        // version instead of using a dead connection.\n        invalidate(pending);\n        onVersionChange?.();\n      },\n    })\n      .then((database) => {\n        // Fired when the browser force-closes the connection (storage eviction, a hard delete elsewhere).\n        // Not fired by an explicit `close()`, which `close()` below handles itself.\n        database.addEventListener('close', () => {\n          invalidate(pending);\n        });\n        return database;\n      })\n      .catch((error: unknown) => {\n        invalidate(pending);\n        throw toError(error);\n      });\n\n    connection = pending;\n    return pending;\n  }\n\n  /** Runs `body` against this store inside one transaction, resolving when it commits. */\n  async function run<TResult>(\n    mode: IDBTransactionMode,\n    body: (store: IDBObjectStore) => Promise<TResult>,\n  ): Promise<TResult> {\n    const database = await connect();\n    return withTransaction(database, storeName, mode, (transaction) => body(transaction.objectStore(storeName)));\n  }\n\n  return {\n    databaseName,\n    storeName,\n\n    async get(key: TKey): Promise<TValue | undefined> {\n      // `get` resolves `undefined` for a missing record — the cast narrows lib.dom's `any` result, it does\n      // not change behaviour.\n      return run('readonly', (store) => requestToPromise(store.get(key) as IDBRequest<TValue | undefined>));\n    },\n\n    async getMany(keys: ReadonlyArray<TKey>): Promise<(TValue | undefined)[]> {\n      return run('readonly', (store) => {\n        // Every request is issued synchronously in the map, BEFORE the first await — that is what keeps the\n        // transaction alive across the `Promise.all`.\n        const reads = keys.map((key) => requestToPromise(store.get(key) as IDBRequest<TValue | undefined>));\n        return Promise.all(reads);\n      });\n    },\n\n    async set(key: TKey, value: TValue): Promise<void> {\n      await run('readwrite', (store) => requestToPromise(store.put(value, key)));\n    },\n\n    async setMany(entries: readonly (readonly [TKey, TValue])[]): Promise<void> {\n      await run('readwrite', (store) => {\n        const writes = entries.map(([key, value]) => requestToPromise(store.put(value, key)));\n        return Promise.all(writes);\n      });\n    },\n\n    async delete(key: TKey): Promise<void> {\n      await run('readwrite', (store) => requestToPromise(store.delete(key)));\n    },\n\n    async deleteMany(keys: ReadonlyArray<TKey>): Promise<void> {\n      await run('readwrite', (store) => {\n        const removals = keys.map((key) => requestToPromise(store.delete(key)));\n        return Promise.all(removals);\n      });\n    },\n\n    async clear(): Promise<void> {\n      await run('readwrite', (store) => requestToPromise(store.clear()));\n    },\n\n    async has(key: TKey): Promise<boolean> {\n      const found = await run('readonly', (store) => requestToPromise(store.count(key)));\n      return found > 0;\n    },\n\n    async count(): Promise<number> {\n      return run('readonly', (store) => requestToPromise(store.count()));\n    },\n\n    async keys(): Promise<TKey[]> {\n      // Narrowed after the await, not through the request type: `IDBRequest<T>` is invariant in `result`,\n      // so asserting the request itself is a TS2352 the element-wise assertion avoids.\n      const stored = await run('readonly', (store) => requestToPromise(store.getAllKeys()));\n      return stored as TKey[];\n    },\n\n    async values(): Promise<TValue[]> {\n      return run('readonly', (store) => requestToPromise(store.getAll() as IDBRequest<TValue[]>));\n    },\n\n    async entries(): Promise<[TKey, TValue][]> {\n      // A cursor rather than zipping `getAllKeys()` with `getAll()`: one pass, and no chance of the two\n      // arrays being paired wrongly.\n      const collected: [TKey, TValue][] = [];\n      await run('readonly', async (store) => {\n        await iterate<TValue, TKey>(store, (entry) => {\n          collected.push([entry.key, entry.value]);\n        });\n      });\n      return collected;\n    },\n\n    async iterateEntries(visit: IdbCursorVisitor<TValue, TKey>): Promise<number> {\n      return run('readonly', (store) => iterate<TValue, TKey>(store, visit));\n    },\n\n    close(): void {\n      const existing = connection;\n      connection = null;\n      if (existing === null) return;\n\n      void existing.then(\n        (database) => {\n          database.close();\n        },\n        () => {\n          // The open failed; there is no connection to close and the rejection was already delivered to\n          // whoever awaited the operation that triggered it.\n        },\n      );\n    },\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/foundation/identifiers/Guid.d.ts

@@ -1,5 +1,8 @@
 import { Temporal } from 'temporal-polyfill';
-/** Defines a branded alias for a raw RFC-9562 GUID string (`0197c8f4-3e2a-7c1d-8f9a-1b2c3d4e5f60`) — wire-identical to a .NET `System.Guid`. */
+/**
+ * Defines a branded alias for a raw RFC-9562 GUID string (`0197c8f4-3e2a-7c1d-8f9a-1b2c3d4e5f60`) —
+ * wire-identical to a .NET `System.Guid`.
+ */
 export type Guid = string & {
     readonly __brand: 'Guid';
 };
@@ -9,7 +12,7 @@ export type Guid = string & {
  * defaults to now; pass a number (epoch ms) or `Temporal.Instant` to backdate.
  */
 declare function createV7(timestamp?: number | Temporal.Instant): Guid;
-/** Creates a random **UUIDv4** (RFC 9562 §4.4) — the .NET `Guid.NewGuid()` parallel (there is no `CreateVersion4`). */
+/** Creates a random **UUIDv4** (RFC 9562 §4.4) — the .NET `Guid.NewGuid()` parallel (no `CreateVersion4`). */
 declare function createV4(): Guid;
 /** Narrows a `string` to `Guid` when it is a legal hyphenated GUID (any version — permissive, like `Guid.Parse`). */
 declare function isGuid(s: string): s is Guid;
@@ -19,7 +22,7 @@ declare function parse(s: string): Guid;
 declare function tryParse(s: string): Guid | undefined;
 /** Case-insensitive value equality — the `Guid.Equals` parallel. */
 declare function equals(a: Guid, b: Guid): boolean;
-/** Lexical compare of the lowercased strings; for v7 values this is creation-time order — the `Guid.CompareTo` parallel. */
+/** Lexical compare of the lowercased strings; for v7 values, creation-time order — the `Guid.CompareTo` parallel. */
 declare function compare(a: Guid, b: Guid): number;
 /** Reads the version nibble (`7`, `4`, …); `undefined` if not a GUID — the `Guid.Version` parallel. */
 declare function version(s: string): number | undefined;

package/dist/foundation/identifiers/index.d.ts

@@ -1 +1,2 @@
 export * from './Guid';
+export * from './UseId';

package/dist/foundation/identifiers/index.js

@@ -1,68 +1,7 @@
-const HYPHEN_D = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-const HEX = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-function format(b) {
-  const h = (i) => HEX[b[i]];
-  return `${h(0)}${h(1)}${h(2)}${h(3)}-${h(4)}${h(5)}-${h(6)}${h(7)}-${h(8)}${h(9)}-${h(10)}${h(11)}${h(12)}${h(13)}${h(14)}${h(15)}`;
-}
-function createV7(timestamp) {
-  const ms = timestamp === void 0 ? Date.now() : typeof timestamp === "number" ? timestamp : timestamp.epochMilliseconds;
-  const b = new Uint8Array(16);
-  crypto.getRandomValues(b);
-  b[0] = ms / 2 ** 40 & 255;
-  b[1] = ms / 2 ** 32 & 255;
-  b[2] = ms / 2 ** 24 & 255;
-  b[3] = ms / 2 ** 16 & 255;
-  b[4] = ms / 2 ** 8 & 255;
-  b[5] = ms & 255;
-  b[6] = b[6] & 15 | 112;
-  b[8] = b[8] & 63 | 128;
-  return format(b);
-}
-function createV4() {
-  const b = new Uint8Array(16);
-  crypto.getRandomValues(b);
-  b[6] = b[6] & 15 | 64;
-  b[8] = b[8] & 63 | 128;
-  return format(b);
-}
-const empty = "00000000-0000-0000-0000-000000000000";
-function isGuid(s) {
-  return HYPHEN_D.test(s);
-}
-function parse(s) {
-  if (!HYPHEN_D.test(s)) throw new TypeError(`Invalid GUID: "${s}"`);
-  return s.toLowerCase();
-}
-function tryParse(s) {
-  return HYPHEN_D.test(s) ? s.toLowerCase() : void 0;
-}
-function equals(a, b) {
-  return a.toLowerCase() === b.toLowerCase();
-}
-function compare(a, b) {
-  const x = a.toLowerCase();
-  const y = b.toLowerCase();
-  return x < y ? -1 : x > y ? 1 : 0;
-}
-function version(s) {
-  return HYPHEN_D.test(s) ? parseInt(s[14], 16) : void 0;
-}
-function toString(g) {
-  return g;
-}
-const Guid = {
-  createV7,
-  createV4,
-  empty,
-  parse,
-  tryParse,
-  isGuid,
-  equals,
-  compare,
-  version,
-  toString
-};
+import { G } from "../../chunks/Guid-CflnxKPZ.js";
+import { u } from "../../chunks/UseId-CtgAhGrn.js";
 export {
-  Guid
+  G as Guid,
+  u as useId
 };
 //# sourceMappingURL=index.js.map

package/dist/foundation/identifiers/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../src/foundation/identifiers/Guid.ts"],"sourcesContent":["import type { Temporal } from 'temporal-polyfill';\n\n/** Defines a branded alias for a raw RFC-9562 GUID string (`0197c8f4-3e2a-7c1d-8f9a-1b2c3d4e5f60`) — wire-identical to a .NET `System.Guid`. */\nexport type Guid = string & { readonly __brand: 'Guid' };\n\nconst HYPHEN_D = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\nconst HEX = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n\n/** Formats 16 bytes as a lowercase hyphenated `D`-string. */\nfunction format(b: Uint8Array): string {\n  const h = (i: number): string => HEX[b[i]!]!;\n  return `${h(0)}${h(1)}${h(2)}${h(3)}-${h(4)}${h(5)}-${h(6)}${h(7)}-${h(8)}${h(9)}-${h(10)}${h(11)}${h(12)}${h(13)}${h(14)}${h(15)}`;\n}\n\n/**\n * Creates a time-ordered **UUIDv7** (RFC 9562 §5.7) — the default factory, mirroring .NET's\n * `Guid.CreateVersion7()`. Non-monotonic within a millisecond (matches .NET). `timestamp`\n * defaults to now; pass a number (epoch ms) or `Temporal.Instant` to backdate.\n */\nfunction createV7(timestamp?: number | Temporal.Instant): Guid {\n  const ms =\n    timestamp === undefined\n      ? Date.now()\n      : typeof timestamp === 'number'\n        ? timestamp\n        : timestamp.epochMilliseconds;\n\n  const b = new Uint8Array(16);\n  crypto.getRandomValues(b);\n\n  b[0] = (ms / 2 ** 40) & 0xff; // 48-bit big-endian unix_ts_ms\n  b[1] = (ms / 2 ** 32) & 0xff;\n  b[2] = (ms / 2 ** 24) & 0xff;\n  b[3] = (ms / 2 ** 16) & 0xff;\n  b[4] = (ms / 2 ** 8) & 0xff;\n  b[5] = ms & 0xff;\n  b[6] = (b[6]! & 0x0f) | 0x70; // version 7\n  b[8] = (b[8]! & 0x3f) | 0x80; // variant 0b10\n\n  return format(b) as Guid;\n}\n\n/** Creates a random **UUIDv4** (RFC 9562 §4.4) — the .NET `Guid.NewGuid()` parallel (there is no `CreateVersion4`). */\nfunction createV4(): Guid {\n  const b = new Uint8Array(16);\n  crypto.getRandomValues(b);\n  b[6] = (b[6]! & 0x0f) | 0x40; // version 4\n  b[8] = (b[8]! & 0x3f) | 0x80; // variant 0b10\n  return format(b) as Guid;\n}\n\n/** The nil GUID (`00000000-0000-0000-0000-000000000000`) — the `Guid.Empty` parallel. */\nconst empty = '00000000-0000-0000-0000-000000000000' as Guid;\n\n/** Narrows a `string` to `Guid` when it is a legal hyphenated GUID (any version — permissive, like `Guid.Parse`). */\nfunction isGuid(s: string): s is Guid {\n  return HYPHEN_D.test(s);\n}\n\n/** Validates + brands (lowercased); **throws** on a non-GUID string — the `Guid.Parse` parallel. */\nfunction parse(s: string): Guid {\n  if (!HYPHEN_D.test(s)) throw new TypeError(`Invalid GUID: \"${s}\"`);\n  return s.toLowerCase() as Guid;\n}\n\n/** Validates + brands (lowercased); returns `undefined` on failure — the `Guid.TryParse` parallel. */\nfunction tryParse(s: string): Guid | undefined {\n  return HYPHEN_D.test(s) ? (s.toLowerCase() as Guid) : undefined;\n}\n\n/** Case-insensitive value equality — the `Guid.Equals` parallel. */\nfunction equals(a: Guid, b: Guid): boolean {\n  return a.toLowerCase() === b.toLowerCase();\n}\n\n/** Lexical compare of the lowercased strings; for v7 values this is creation-time order — the `Guid.CompareTo` parallel. */\nfunction compare(a: Guid, b: Guid): number {\n  const x = a.toLowerCase();\n  const y = b.toLowerCase();\n  return x < y ? -1 : x > y ? 1 : 0;\n}\n\n/** Reads the version nibble (`7`, `4`, …); `undefined` if not a GUID — the `Guid.Version` parallel. */\nfunction version(s: string): number | undefined {\n  return HYPHEN_D.test(s) ? parseInt(s[14]!, 16) : undefined;\n}\n\n/** Identity — a `Guid` already is its `D`-string; kept for .NET `ToString(\"D\")` symmetry. */\nfunction toString(g: Guid): string {\n  return g;\n}\n\n/** Static factory + helper surface for {@link Guid}, mirroring .NET's `System.Guid` statics. */\nexport const Guid = {\n  createV7,\n  createV4,\n  empty,\n  parse,\n  tryParse,\n  isGuid,\n  equals,\n  compare,\n  version,\n  toString,\n} as const;\n"],"names":[],"mappings":"AAKA,MAAM,WAAW;AACjB,MAAM,MAAM,MAAM,KAAK,EAAE,QAAQ,OAAO,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC;AAGjF,SAAS,OAAO,GAAuB;AACrC,QAAM,IAAI,CAAC,MAAsB,IAAI,EAAE,CAAC,CAAE;AAC1C,SAAO,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC;AACnI;AAOA,SAAS,SAAS,WAA6C;AAC7D,QAAM,KACJ,cAAc,SACV,KAAK,QACL,OAAO,cAAc,WACnB,YACA,UAAU;AAElB,QAAM,IAAI,IAAI,WAAW,EAAE;AAC3B,SAAO,gBAAgB,CAAC;AAExB,IAAE,CAAC,IAAK,KAAK,KAAK,KAAM;AACxB,IAAE,CAAC,IAAK,KAAK,KAAK,KAAM;AACxB,IAAE,CAAC,IAAK,KAAK,KAAK,KAAM;AACxB,IAAE,CAAC,IAAK,KAAK,KAAK,KAAM;AACxB,IAAE,CAAC,IAAK,KAAK,KAAK,IAAK;AACvB,IAAE,CAAC,IAAI,KAAK;AACZ,IAAE,CAAC,IAAK,EAAE,CAAC,IAAK,KAAQ;AACxB,IAAE,CAAC,IAAK,EAAE,CAAC,IAAK,KAAQ;AAExB,SAAO,OAAO,CAAC;AACjB;AAGA,SAAS,WAAiB;AACxB,QAAM,IAAI,IAAI,WAAW,EAAE;AAC3B,SAAO,gBAAgB,CAAC;AACxB,IAAE,CAAC,IAAK,EAAE,CAAC,IAAK,KAAQ;AACxB,IAAE,CAAC,IAAK,EAAE,CAAC,IAAK,KAAQ;AACxB,SAAO,OAAO,CAAC;AACjB;AAGA,MAAM,QAAQ;AAGd,SAAS,OAAO,GAAsB;AACpC,SAAO,SAAS,KAAK,CAAC;AACxB;AAGA,SAAS,MAAM,GAAiB;AAC9B,MAAI,CAAC,SAAS,KAAK,CAAC,SAAS,IAAI,UAAU,kBAAkB,CAAC,GAAG;AACjE,SAAO,EAAE,YAAA;AACX;AAGA,SAAS,SAAS,GAA6B;AAC7C,SAAO,SAAS,KAAK,CAAC,IAAK,EAAE,gBAAyB;AACxD;AAGA,SAAS,OAAO,GAAS,GAAkB;AACzC,SAAO,EAAE,kBAAkB,EAAE,YAAA;AAC/B;AAGA,SAAS,QAAQ,GAAS,GAAiB;AACzC,QAAM,IAAI,EAAE,YAAA;AACZ,QAAM,IAAI,EAAE,YAAA;AACZ,SAAO,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI;AAClC;AAGA,SAAS,QAAQ,GAA+B;AAC9C,SAAO,SAAS,KAAK,CAAC,IAAI,SAAS,EAAE,EAAE,GAAI,EAAE,IAAI;AACnD;AAGA,SAAS,SAAS,GAAiB;AACjC,SAAO;AACT;AAGO,MAAM,OAAO;AAAA,EAClB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/foundation/json/JsonFailureCode.d.ts

@@ -0,0 +1,9 @@
+/** Expected lossless JSON failures. */
+export declare const JsonFailureCode: {
+    readonly InvalidSyntax: "InvalidSyntax";
+    readonly DuplicateKey: "DuplicateKey";
+    readonly ResourceLimit: "ResourceLimit";
+    readonly UnsupportedValue: "UnsupportedValue";
+    readonly CircularReference: "CircularReference";
+};
+export type JsonFailureCode = (typeof JsonFailureCode)[keyof typeof JsonFailureCode];

package/dist/foundation/json/JsonLimits.d.ts

@@ -0,0 +1,6 @@
+/** Bounded in-memory codec; counts UTF-16 characters and lexical tokens, not UTF-8 bytes. */
+export declare const JsonLimits: Readonly<{
+    maxCharacters: 1048576;
+    maxDepth: 128;
+    maxTokens: 100000;
+}>;

package/dist/foundation/json/JsonText.d.ts

@@ -0,0 +1,12 @@
+import { JsonFailureCode } from './JsonFailureCode';
+import { JsonFailure } from './models/JsonFailure';
+/** Internal control-flow error translated only at the codec boundary. */
+export declare class JsonOperationError extends Error {
+    readonly failure: JsonFailure;
+    constructor(failure: JsonFailure);
+}
+export declare function rejectJson(code: JsonFailureCode, message: string): never;
+/** Lexical resource/key pass only. The vendor remains responsible for the complete JSON grammar. */
+export declare function rewriteJsonKeys(text: string, key: (value: string, seen: Set<string>) => string): string;
+/** Counts JSON string escaping without allocating the escaped representation. */
+export declare function jsonStringLength(text: string, remaining: number): number;