@lostgradient/weft 0.2.0

package/dist/storage/index.d.ts

@@ -0,0 +1,292 @@
+/**
+ * Storage submodule — zero-native-dependency entry point.
+ *
+ * Exports the `Storage` interface, `KEYS` key-encoding helpers,
+ * and `MemoryStorage`. These have no native dependencies and are
+ * safe to import in any environment including browsers.
+ *
+ * For backends or wrappers that have runtime dependencies, use the
+ * per-backend subpaths:
+ *
+ * ```ts
+ * import { CompressedStorage } from '@lostgradient/weft/storage/compressed'; // requires node:zlib / Bun
+ * import { SQLiteStorage }     from '@lostgradient/weft/storage/sqlite';     // Bun or Node SQLite
+ * import { LMDBStorage }       from '@lostgradient/weft/storage/lmdb';       // peer: lmdb
+ * import { TursoStorage }      from '@lostgradient/weft/storage/turso';      // peer: @libsql/client
+ * import { IndexedDBStorage }  from '@lostgradient/weft/storage/indexeddb';  // browser-only
+ * import { WebExtensionStorage } from '@lostgradient/weft/storage/web-extension'; // extension-only
+ * import { HTTPStorage }       from '@lostgradient/weft/storage/http';       // remote storage
+ * ```
+ *
+ * @module @lostgradient/weft/storage
+ */
+import { storageDeleteRange } from './delete-range';
+import { assertDurableStorageForRecovery, requireStorageCapability, storageConditionalBatch, storageValuesEqual } from './interface';
+import { MemoryStorage } from './memory';
+import { resolveStorage } from './resolve';
+import { ScopedStorage, scopedStorage } from './scoped-storage';
+import { copyTextKeyValueRowsToStorage } from './text-value-import';
+import { textValueStore } from './text-value-store';
+import { jsonCodec, msgpackCodec, withCodec } from './typed-storage';
+/**
+ * Re-exported {@link jsonCodec}. See the original declaration for full docs.
+ *
+ * @example
+ * ```ts
+ * import { jsonCodec } from '@lostgradient/weft/storage';
+ * const codec = jsonCodec();
+ * void codec;
+ * ```
+ */
+declare const exportedJsonCodec: typeof jsonCodec;
+/**
+ * Re-exported {@link assertDurableStorageForRecovery}. See the original declaration for full docs.
+ *
+ * @example
+ * ```ts
+ * import { assertDurableStorageForRecovery } from '@lostgradient/weft/storage';
+ * import { SQLiteStorage } from '@lostgradient/weft/storage/sqlite';
+ *
+ * await using storage = new SQLiteStorage('./weft.db');
+ * assertDurableStorageForRecovery(storage);
+ * ```
+ */
+declare const exportedAssertDurableStorageForRecovery: typeof assertDurableStorageForRecovery;
+/**
+ * Re-exported {@link copyTextKeyValueRowsToStorage}. See the original declaration for full docs.
+ *
+ * @example
+ * ```ts
+ * import { MemoryStorage, copyTextKeyValueRowsToStorage } from '@lostgradient/weft/storage';
+ *
+ * await using storage = new MemoryStorage();
+ * const result = await copyTextKeyValueRowsToStorage({
+ *   storage,
+ *   rows: [{ key: 'session:1', value: 'active' }],
+ *   targetPrefix: 'app:my-service',
+ * });
+ * void result;
+ * ```
+ */
+declare const exportedCopyTextKeyValueRowsToStorage: typeof copyTextKeyValueRowsToStorage;
+/**
+ * Re-exported {@link KEYS}. See the original declaration for full docs.
+ *
+ * @example
+ * ```ts
+ * import { KEYS } from '@lostgradient/weft/storage';
+ * const key = KEYS.workflow('wf-1');
+ * void key;
+ * ```
+ */
+declare const exportedKeys: {
+    readonly workflow: (id: string) => string;
+    readonly checkpoint: (id: string) => string;
+    readonly checkpointHistory: (id: string, step: number) => string;
+    readonly timelinePrefix: (id: string) => string;
+    readonly timeline: (id: string, step: number) => string;
+    readonly schedule: (id: string) => string;
+    readonly scheduleTick: (fireAt: number, id: string) => string;
+    readonly scheduleRun: (workflowId: string) => string;
+    readonly operation: (queue: string, scheduledAt: number, id: string) => string;
+    readonly operationInflight: (id: string) => string;
+    readonly operationQueued: (id: string) => string;
+    readonly operationResolved: (id: string) => string;
+    readonly bulkOperationAuditPrefix: () => string;
+    readonly bulkOperationAudit: (timestamp: number, requestId: string, confirmationToken: string) => string;
+    readonly operationResolvedByTimePrefix: () => string;
+    readonly operationResolvedByTime: (resolvedAt: number, id: string) => string;
+    readonly asyncActivity: (workflowId: string, token: string) => string;
+    readonly activityReconciliationPrefix: (workflowId: string) => string;
+    readonly activityReconciliation: (workflowId: string, activityName: string, idempotencyKeyDigest: string) => string;
+    readonly eventPrefix: (workflowId: string) => string;
+    readonly event: (workflowId: string, sequence: number) => string;
+    readonly eventHead: (workflowId: string) => string;
+    readonly eventWatermark: (workflowId: string) => string;
+    readonly signal: (workflowId: string, name: string, id: string) => string;
+    readonly signalSequence: (workflowId: string) => string;
+    readonly signalAcceptedResponsePrefix: (workflowId: string) => string;
+    readonly signalAcceptedResponse: (workflowId: string, name: string, signalId: string) => string;
+    readonly deadline: (deadline: number, workflowId: string) => string;
+    readonly terminalCleanup: (fireAt: number, timerId: string) => string;
+    readonly delayedStart: (startAt: number, workflowId: string) => string;
+    readonly terminalWorkflowPrefix: () => string;
+    readonly terminalWorkflow: (updatedAt: number, workflowId: string) => string;
+    readonly attribute: (workflowId: string) => string;
+    readonly attributeIndex: (attributeName: string, encodedValue: string, workflowId: string) => string;
+    readonly tagIndex: (tag: string, workflowId: string) => string;
+    readonly updatePrefix: (workflowId: string) => string;
+    readonly update: (workflowId: string, updateId: string) => string;
+    readonly updateResponse: (updateId: string) => string;
+    readonly updateIdempotency: (workflowId: string, key: string) => string;
+    readonly budget: (namespace: string, period: string, date: string) => string;
+    readonly review: (workflowId: string, reviewId: string) => string;
+    readonly workflowHeaders: (workflowId: string) => string;
+    readonly terminalCleanupNeeded: (workflowId: string) => string;
+    readonly offload: (workflowId: string, key: string) => string;
+    readonly archive: (workflowId: string, key: string) => string;
+    readonly stateExecution: (ownerWorkflowId: string, key: string) => string;
+    readonly stateWorkflow: (workflowType: string, key: string) => string;
+    readonly streamChunkPrefix: (workflowId: string, key: string) => string;
+    readonly streamChunk: (workflowId: string, key: string, chunkIndex: number) => string;
+    readonly streamMetadata: (workflowId: string, key: string) => string;
+    readonly budgetCharged: (operationId: string) => string;
+    readonly toolEffect: (workflowId: string, agentId: string, semanticHash: string) => string;
+    readonly workflowVisibilityStatus: (status: string, workflowId: string) => string;
+    readonly workflowVisibilityType: (type: string, workflowId: string) => string;
+    readonly workflowVisibilityCreated: (createdAt: number, workflowId: string) => string;
+    readonly workflowVisibilityUpdated: (updatedAt: number, workflowId: string) => string;
+    readonly workflowVisibilityDeadline: (deadline: number, workflowId: string) => string;
+    readonly workflowVisibilityManifest: (workflowId: string) => string;
+    readonly workflowVisibilityMetaVersion: () => string;
+    readonly workflowVisibilityMetaBuiltAt: () => string;
+    readonly workflowVisibilityMetaCursor: () => string;
+};
+/**
+ * Re-exported {@link MemoryStorage}. See the original declaration for full docs.
+ *
+ * @example
+ * ```ts
+ * import { MemoryStorage } from '@lostgradient/weft/storage';
+ * await using storage = new MemoryStorage();
+ * void storage;
+ * ```
+ */
+declare const exportedMemoryStorage: typeof MemoryStorage;
+/**
+ * Re-exported {@link msgpackCodec}. See the original declaration for full docs.
+ *
+ * @example
+ * ```ts
+ * import { msgpackCodec } from '@lostgradient/weft/storage';
+ * const codec = msgpackCodec();
+ * void codec;
+ * ```
+ */
+declare const exportedMsgpackCodec: typeof msgpackCodec;
+/**
+ * Re-exported {@link resolveStorage}. See the original declaration for full docs.
+ *
+ * @example
+ * ```ts
+ * import { resolveStorage } from '@lostgradient/weft/storage';
+ * const storage = await resolveStorage({ type: 'memory' });
+ * void storage;
+ * ```
+ */
+declare const exportedResolveStorage: typeof resolveStorage;
+/**
+ * Re-exported {@link ScopedStorage}. See the original declaration for full docs.
+ *
+ * @example
+ * ```ts
+ * import { MemoryStorage, ScopedStorage } from '@lostgradient/weft/storage';
+ * await using base = new MemoryStorage();
+ * const scoped = new ScopedStorage(base, 'scope:');
+ * void scoped;
+ * ```
+ */
+declare const exportedScopedStorage: typeof ScopedStorage;
+/**
+ * Re-exported {@link scopedStorage}. See the original declaration for full docs.
+ *
+ * @example
+ * ```ts
+ * import { MemoryStorage, scopedStorage } from '@lostgradient/weft/storage';
+ * await using base = new MemoryStorage();
+ * const scoped = scopedStorage(base, 'scope:');
+ * void scoped;
+ * ```
+ */
+declare const exportedScopedStorageFactory: typeof scopedStorage;
+/**
+ * Re-exported {@link storageConditionalBatch}. See the original declaration for full docs.
+ *
+ * @example
+ * ```ts
+ * import { MemoryStorage, storageConditionalBatch } from '@lostgradient/weft/storage';
+ * await using storage = new MemoryStorage();
+ * await storageConditionalBatch(storage, [], []);
+ * ```
+ */
+declare const exportedStorageConditionalBatch: typeof storageConditionalBatch;
+/**
+ * Re-exported {@link storageDeleteRange}. See the original declaration for full docs.
+ *
+ * @example
+ * ```ts
+ * import { MemoryStorage, storageDeleteRange } from '@lostgradient/weft/storage';
+ * await using storage = new MemoryStorage();
+ * await storage.put('ev:wf:0000000001', new Uint8Array([1]));
+ * const deleted = await storageDeleteRange(storage, 'ev:wf:', { lte: 'ev:wf:0000000001' });
+ * void deleted;
+ * ```
+ */
+declare const exportedStorageDeleteRange: typeof storageDeleteRange;
+/**
+ * Re-exported {@link requireStorageCapability}. See the original declaration for full docs.
+ *
+ * @example
+ * ```ts
+ * import { MemoryStorage, requireStorageCapability } from '@lostgradient/weft/storage';
+ * await using storage = new MemoryStorage();
+ * requireStorageCapability(storage, 'conditionalBatch', 'compare-and-swap');
+ * ```
+ */
+declare const exportedRequireStorageCapability: typeof requireStorageCapability;
+/**
+ * Re-exported {@link storageValuesEqual}. See the original declaration for full docs.
+ *
+ * @example
+ * ```ts
+ * import { storageValuesEqual } from '@lostgradient/weft/storage';
+ * const equal = storageValuesEqual(new Uint8Array([1]), new Uint8Array([1]));
+ * void equal;
+ * ```
+ */
+declare const exportedStorageValuesEqual: typeof storageValuesEqual;
+/**
+ * Re-exported {@link textValueStore}. See the original declaration for full docs.
+ *
+ * @example
+ * ```ts
+ * import { MemoryStorage, textValueStore } from '@lostgradient/weft/storage';
+ * await using base = new MemoryStorage();
+ * const store = textValueStore(base);
+ * void store;
+ * ```
+ */
+declare const exportedTextValueStore: typeof textValueStore;
+/**
+ * Re-exported {@link WEFT_RESERVED_KEY_PREFIXES}. See the original declaration for full docs.
+ *
+ * @example
+ * ```ts
+ * import { WEFT_RESERVED_KEY_PREFIXES } from '@lostgradient/weft/storage';
+ *
+ * const key = 'wf:order-123';
+ * const isWeftKey = WEFT_RESERVED_KEY_PREFIXES.some((prefix) => key.startsWith(prefix));
+ * void isWeftKey;
+ * ```
+ */
+declare const exportedWeftReservedKeyPrefixes: readonly ["actrec:", "archive:", "async-act:", "attr:", "audit:bulk:", "blob:", "budget:", "budget-charged:", "ev:", "idx:", "offload:", "op:", "review:", "schedule:", "schedule-due:", "schedule-run:", "sig:", "sigres:", "sigseq:", "state:", "tag:", "tool-effect:", "upd:", "upk:", "upr:", "wf:", "wf-cleanup:", "wf-cleanup-needed:", "wf-deadline:", "wf-delayed:", "wf-headers:", "wf-idx-", "wf-terminal:"];
+/**
+ * Re-exported {@link withCodec}. See the original declaration for full docs.
+ *
+ * @example
+ * ```ts
+ * import { jsonCodec, MemoryStorage, withCodec } from '@lostgradient/weft/storage';
+ * await using base = new MemoryStorage();
+ * const typed = withCodec(base, jsonCodec());
+ * void typed;
+ * ```
+ */
+declare const exportedWithCodec: typeof withCodec;
+export type { JSONValue } from '../core/json.ts';
+export type { DeleteRangeOptions } from './delete-range';
+export type { BatchOperation, ConditionalBatchCondition, GatedStorageCapabilityKey, ScanOptions, Storage, StorageCapabilities, } from './interface';
+export type { StorageConfiguration } from './resolve';
+export type { CopyTextKeyValueRowsToStorageOptions, CopyTextKeyValueRowsToStorageResult, TextKeyValueRow, } from './text-value-import';
+export type { TextValueStore, TextValueStoreBatchOperation, TextValueStoreCondition, TextValueStoreOptions, } from './text-value-store';
+export type { CodecStorageOptions, MessagePackValue, StorageCodec, StorageValueParser, TypedBatchOperation, TypedConditionalBatchCondition, TypedStorage, } from './typed-storage';
+export { exportedAssertDurableStorageForRecovery as assertDurableStorageForRecovery, exportedCopyTextKeyValueRowsToStorage as copyTextKeyValueRowsToStorage, exportedJsonCodec as jsonCodec, exportedKeys as KEYS, exportedMemoryStorage as MemoryStorage, exportedMsgpackCodec as msgpackCodec, exportedRequireStorageCapability as requireStorageCapability, exportedResolveStorage as resolveStorage, exportedScopedStorage as ScopedStorage, exportedScopedStorageFactory as scopedStorage, exportedStorageConditionalBatch as storageConditionalBatch, exportedStorageDeleteRange as storageDeleteRange, exportedStorageValuesEqual as storageValuesEqual, exportedTextValueStore as textValueStore, exportedWeftReservedKeyPrefixes as WEFT_RESERVED_KEY_PREFIXES, exportedWithCodec as withCodec, };

package/dist/storage/index.js

@@ -0,0 +1,51 @@
+import {
+  assertDurableStorageForRecovery,
+  KEYS,
+  requireStorageCapability,
+  storageConditionalBatch,
+  storageValuesEqual,
+  WEFT_RESERVED_KEY_PREFIXES,
+} from './interface.js';
+import { storageDeleteRange } from './delete-range.js';
+import { MemoryStorage } from './memory.js';
+import { resolveStorage } from './resolve.js';
+import { ScopedStorage, scopedStorage } from './scoped-storage.js';
+import { copyTextKeyValueRowsToStorage } from './text-value-import.js';
+import { textValueStore } from './text-value-store.js';
+import { jsonCodec, msgpackCodec, withCodec } from './typed-storage.js';
+
+const exportedAssertDurableStorageForRecovery = assertDurableStorageForRecovery;
+const exportedCopyTextKeyValueRowsToStorage = copyTextKeyValueRowsToStorage;
+const exportedJsonCodec = jsonCodec;
+const exportedKeys = KEYS;
+const exportedMemoryStorage = MemoryStorage;
+const exportedMsgpackCodec = msgpackCodec;
+const exportedRequireStorageCapability = requireStorageCapability;
+const exportedResolveStorage = resolveStorage;
+const exportedScopedStorage = ScopedStorage;
+const exportedScopedStorageFactory = scopedStorage;
+const exportedStorageConditionalBatch = storageConditionalBatch;
+const exportedStorageDeleteRange = storageDeleteRange;
+const exportedStorageValuesEqual = storageValuesEqual;
+const exportedTextValueStore = textValueStore;
+const exportedWeftReservedKeyPrefixes = WEFT_RESERVED_KEY_PREFIXES;
+const exportedWithCodec = withCodec;
+
+export {
+  exportedAssertDurableStorageForRecovery as assertDurableStorageForRecovery,
+  exportedCopyTextKeyValueRowsToStorage as copyTextKeyValueRowsToStorage,
+  exportedJsonCodec as jsonCodec,
+  exportedKeys as KEYS,
+  exportedMemoryStorage as MemoryStorage,
+  exportedMsgpackCodec as msgpackCodec,
+  exportedRequireStorageCapability as requireStorageCapability,
+  exportedResolveStorage as resolveStorage,
+  exportedScopedStorage as ScopedStorage,
+  exportedScopedStorageFactory as scopedStorage,
+  exportedStorageConditionalBatch as storageConditionalBatch,
+  exportedStorageDeleteRange as storageDeleteRange,
+  exportedStorageValuesEqual as storageValuesEqual,
+  exportedTextValueStore as textValueStore,
+  exportedWeftReservedKeyPrefixes as WEFT_RESERVED_KEY_PREFIXES,
+  exportedWithCodec as withCodec,
+};

package/dist/storage/indexeddb.d.ts

@@ -0,0 +1,49 @@
+import { type DeleteRangeOptions } from './delete-range';
+import { type BatchOperation, type ConditionalBatchCondition, type ScanOptions, type Storage, type StorageCapabilities } from './interface';
+/**
+ * IndexedDB-backed {@link Storage} implementation for browser and service-worker
+ * environments.
+ *
+ * Initiates an IndexedDB open request on construction and lazily awaits it on
+ * the first call. All operations transparently await the in-flight open before
+ * issuing their transaction. The database has a single `'kv'` object store, and
+ * `databaseName` defaults to `'weft'`. Use this when running weft inside a
+ * browser tab or service worker where SQLite and LMDB are unavailable.
+ *
+ * @example
+ * ```ts
+ * import { IndexedDBStorage } from '@lostgradient/weft/storage/indexeddb';
+ * import { workflow, Engine, type WorkflowContext } from '@lostgradient/weft';
+ *
+ * // Opens (or re-opens) the default 'weft' IndexedDB database
+ * await using storage = new IndexedDBStorage();
+ * await using engine = new Engine({ storage });
+ *
+ * engine.register(
+ *   workflow({ name: 'greet' }).execute(async function* (ctx: WorkflowContext, input: { name: string }) {
+ *     return `Hello, ${input.name}!`;
+ *   }),
+ * );
+ *
+ * const handle = await engine.start('greet', { name: 'World' });
+ * console.log(await handle.result()); // 'Hello, World!'
+ * ```
+ */
+export declare class IndexedDBStorage implements Storage {
+    #private;
+    constructor(databaseName?: string);
+    capabilities(): StorageCapabilities;
+    get(key: string): Promise<Uint8Array | null>;
+    put(key: string, value: Uint8Array): Promise<void>;
+    delete(key: string): Promise<void>;
+    has(key: string): Promise<boolean>;
+    deletePrefix(prefix: string): Promise<number>;
+    deleteRange(prefix: string, options: DeleteRangeOptions): Promise<number>;
+    scan(prefix: string, options?: ScanOptions): AsyncIterable<[string, Uint8Array]>;
+    batch(operations: BatchOperation[]): Promise<void>;
+    conditionalBatch(conditions: ConditionalBatchCondition[], operations: BatchOperation[]): Promise<boolean>;
+    keys(prefix: string, options?: ScanOptions): AsyncIterable<string>;
+    count(prefix: string): Promise<number>;
+    scoped(prefix: string): Storage;
+    [Symbol.dispose](): void;
+}

package/dist/storage/indexeddb.js

@@ -0,0 +1 @@
+var l=Object.defineProperty;var d=(Y)=>Y;function p(Y,J){this[Y]=d.bind(null,J)}var t=(Y,J)=>{for(var U in J)l(Y,U,{get:J[U],enumerable:!0,configurable:!0,set:p.bind(J,U)})};async function E(Y,J){return await Y.get(J)!==null}async function*T(Y,J,U){for await(let[X]of Y.scan(J,U))yield X}async function v(Y,J){let U=0;for await(let X of T(Y,J))U++;return U}async function K(Y,J){let U=[];for await(let X of T(Y,J))U.push({type:"delete",key:X});if(U.length===0)return 0;return await Y.batch(U),U.length}async function C(Y,J,U){let X=[];for await(let $ of T(Y,J,U))X.push({type:"delete",key:$});if(X.length===0)return 0;return await Y.batch(X),X.length}function q(Y,J,U){if(!Y.capabilities()[J])throw Error(`Feature "${U}" requires storage capability "${J}", but this storage backend does not provide it.`)}var b="default";function N(Y){return Y.length>0?Y.slice(0,-1)+String.fromCharCode(Y.charCodeAt(Y.length-1)+1):"ÿ"}function O(Y,J={}){if(J.gt!==void 0&&Y<=J.gt)return!1;if(J.gte!==void 0&&Y<J.gte)return!1;if(J.lt!==void 0&&Y>=J.lt)return!1;if(J.lte!==void 0&&Y>J.lte)return!1;return!0}function I(Y,J){if(Y===null||J===null)return Y===J;if(Y.byteLength!==J.byteLength)return!1;for(let U=0;U<Y.byteLength;U++)if(Y[U]!==J[U])return!1;return!0}async function S(Y,J){if(Y.has)return Y.has(J);return E(Y,J)}function x(Y,J,U){if(Y.keys)return Y.keys(J,U);return T(Y,J,U)}async function k(Y,J){if(Y.count)return Y.count(J);return v(Y,J)}async function w(Y,J){if(Y.deletePrefix)return Y.deletePrefix(J);return K(Y,J)}async function u(Y,J,U){if(q(Y,"conditionalBatch","storageConditionalBatch"),!Y.conditionalBatch)throw Error("This storage backend reports conditionalBatch capability but does not implement the conditionalBatch() method.");return Y.conditionalBatch(J,U)}function Z(Y){return encodeURIComponent(Y)}function GY(Y){try{return decodeURIComponent(Y)}catch{return null}}var _=(Y)=>String(Y).padStart(16,"0"),FY={workflow:(Y)=>`wf:${Z(Y)}`,checkpoint:(Y)=>`wf:${Z(Y)}:ckpt`,checkpointHistory:(Y,J)=>`wf:${Z(Y)}:ckpt:${String(J).padStart(10,"0")}`,timelinePrefix:(Y)=>`wf:${Z(Y)}:timeline:`,timeline:(Y,J)=>`wf:${Z(Y)}:timeline:${String(J).padStart(10,"0")}`,schedule:(Y)=>`schedule:${Z(Y)}`,scheduleTick:(Y,J)=>`schedule-due:${String(Y).padStart(16,"0")}:${Z(J)}`,scheduleRun:(Y)=>`schedule-run:${Z(Y)}`,operation:(Y,J,U)=>`op:${Y}:${_(J)}:${U}`,operationInflight:(Y)=>`op:inflight:${Y}`,operationQueued:(Y)=>`op:queued:${Y}`,operationResolved:(Y)=>`op:resolved:${Y}`,bulkOperationAuditPrefix:()=>"audit:bulk:",bulkOperationAudit:(Y,J,U)=>`audit:bulk:${_(Y)}:${Z(J)}:${Z(U)}`,operationResolvedByTimePrefix:()=>"op:resolved-by-time:",operationResolvedByTime:(Y,J)=>`op:resolved-by-time:${_(Y)}:${Z(J)}`,asyncActivity:(Y,J)=>`async-act:v1:${Z(Y)}:${Z(J)}`,activityReconciliationPrefix:(Y)=>`actrec:v1:${Z(Y)}:`,activityReconciliation:(Y,J,U)=>`actrec:v1:${Z(Y)}:${Z(J)}:${U}`,eventPrefix:(Y)=>`ev:${Z(Y)}:`,event:(Y,J)=>`ev:${Z(Y)}:${String(J).padStart(10,"0")}`,eventHead:(Y)=>`ev:${Z(Y)}:head`,eventWatermark:(Y)=>`ev:${Z(Y)}:watermark`,signal:(Y,J,U)=>`sig:${Z(Y)}:${J}:${Z(U)}`,signalSequence:(Y)=>`sigseq:v1:${Z(Y)}`,signalAcceptedResponsePrefix:(Y)=>`sigres:v1:${Z(Y)}:`,signalAcceptedResponse:(Y,J,U)=>`sigres:v1:${Z(Y)}:${Z(J)}:${Z(U)}`,deadline:(Y,J)=>`wf-deadline:${_(Y)}:${Z(J)}`,terminalCleanup:(Y,J)=>`wf-cleanup:${_(Y)}:${Z(J)}`,delayedStart:(Y,J)=>`wf-delayed:${_(Y)}:${Z(J)}`,terminalWorkflowPrefix:()=>"wf-terminal:",terminalWorkflow:(Y,J)=>`wf-terminal:${_(Y)}:${Z(J)}`,attribute:(Y)=>`attr:${Z(Y)}`,attributeIndex:(Y,J,U)=>`idx:${Y}:${J}:${Z(U)}`,tagIndex:(Y,J)=>`tag:${Z(Y)}:${Z(J)}`,updatePrefix:(Y)=>`upd:${Z(Y)}:`,update:(Y,J)=>`upd:${Z(Y)}:${J}`,updateResponse:(Y)=>`upr:${Y}`,updateIdempotency:(Y,J)=>`upk:${Z(Y)}:${J}`,budget:(Y,J,U)=>`budget:${Y}:${J}:${U}`,review:(Y,J)=>`review:${Z(Y)}:${J}`,workflowHeaders:(Y)=>`wf-headers:${Z(Y)}`,terminalCleanupNeeded:(Y)=>`wf-cleanup-needed:${Z(Y)}`,offload:(Y,J)=>`offload:${Z(Y)}:${J}`,archive:(Y,J)=>`archive:${Z(Y)}:${J}`,stateExecution:(Y,J)=>`state:execution:${Z(Y)}:${Z(J)}`,stateWorkflow:(Y,J)=>`state:workflow-scope:${b}:${Z(Y)}:${Z(J)}`,streamChunkPrefix:(Y,J)=>`blob:${Z(Y)}:${J}:chunk:`,streamChunk:(Y,J,U)=>`blob:${Z(Y)}:${J}:chunk:${String(U).padStart(10,"0")}`,streamMetadata:(Y,J)=>`blob:${Z(Y)}:${J}:meta`,budgetCharged:(Y)=>`budget-charged:${Y}`,toolEffect:(Y,J,U)=>`tool-effect:${Z(Y)}:${J}:${U}`,workflowVisibilityStatus:(Y,J)=>`wf-idx-status:${Z(Y)}:${Z(J)}`,workflowVisibilityType:(Y,J)=>`wf-idx-type:${Z(Y)}:${Z(J)}`,workflowVisibilityCreated:(Y,J)=>`wf-idx-created:${_(Y)}:${Z(J)}`,workflowVisibilityUpdated:(Y,J)=>`wf-idx-updated:${_(Y)}:${Z(J)}`,workflowVisibilityDeadline:(Y,J)=>`wf-idx-deadline:${_(Y)}:${Z(J)}`,workflowVisibilityManifest:(Y)=>`wf-idx-manifest:${Z(Y)}`,workflowVisibilityMetaVersion:()=>"wf-idx-meta:version",workflowVisibilityMetaBuiltAt:()=>"wf-idx-meta:built-at",workflowVisibilityMetaCursor:()=>"wf-idx-meta:cursor"};function s(Y){if(Y===void 0)return;if(typeof Y!=="number"||!Number.isInteger(Y)||Y<0)throw Error("deleteRange limit must be a finite non-negative integer");return Y===0?0:Y}function P(Y){let J={},U=!1;for(let $ of["gt","gte","lt","lte"]){let F=Y[$];if(F===void 0)continue;if(typeof F!=="string")throw Error("deleteRange bounds must be strings");J[$]=F,U=!0}if(!U)throw Error("deleteRange requires at least one of gt/gte/lt/lte; use deletePrefix to delete a whole prefix");let X=s(Y.limit);if(X!==void 0)J.limit=X;return J}async function y(Y,J,U){let X=P(U);if(Y.deleteRange)return Y.deleteRange(J,X);return C(Y,J,X)}function a(Y,J){let U={key:Y,open:!1};if(J.gte!==void 0&&J.gte>U.key)U.key=J.gte,U.open=!1;if(J.gt!==void 0&&J.gt>=U.key)U.key=J.gt,U.open=!0;return U}function i(Y,J){let U={key:N(Y),open:!0};if(J.lt!==void 0&&J.lt<=U.key)U.key=J.lt,U.open=!0;if(J.lte!==void 0&&J.lte<U.key)U.key=J.lte,U.open=!1;return U}function m(Y,J){let U=a(Y,J),X=i(Y,J);if(U.key>X.key||U.key===X.key&&(U.open||X.open))return null;return{lower:U,upper:X}}function R(Y){return Y.replaceAll(/:+$/g,"")}function n(Y,J){let U=R(Y),X=R(J);if(U.length===0)return X;if(X.length===0)return U;return`${U}:${X}`}class h{#J;#U;constructor(Y,J){this.#J=Y,this.#U=R(J)}#Y(Y){if(this.#U.length===0)return Y;return Y.length===0?`${this.#U}:`:`${this.#U}:${Y}`}#X(Y){if(this.#U.length===0)return Y;return Y.slice(this.#U.length+1)}#Z(Y={}){let J={};if(Y.limit!==void 0)J.limit=Y.limit;if(Y.reverse!==void 0)J.reverse=Y.reverse;if(Y.gt!==void 0)J.gt=this.#Y(Y.gt);if(Y.gte!==void 0)J.gte=this.#Y(Y.gte);if(Y.lt!==void 0)J.lt=this.#Y(Y.lt);if(Y.lte!==void 0)J.lte=this.#Y(Y.lte);return J}#$(Y){let J={};if(Y.limit!==void 0)J.limit=Y.limit;if(Y.gt!==void 0)J.gt=this.#Y(Y.gt);if(Y.gte!==void 0)J.gte=this.#Y(Y.gte);if(Y.lt!==void 0)J.lt=this.#Y(Y.lt);if(Y.lte!==void 0)J.lte=this.#Y(Y.lte);return J}capabilities(){return this.#J.capabilities()}scoped(Y){return new h(this.#J,n(this.#U,Y))}async get(Y){return this.#J.get(this.#Y(Y))}async put(Y,J){await this.#J.put(this.#Y(Y),J)}async delete(Y){await this.#J.delete(this.#Y(Y))}async*scan(Y,J){for await(let[U,X]of this.#J.scan(this.#Y(Y),this.#Z(J)))yield[this.#X(U),X]}async batch(Y){await this.#J.batch(Y.map((J)=>{if(J.type==="put")return{type:"put",key:this.#Y(J.key),value:J.value};return{type:"delete",key:this.#Y(J.key)}}))}async conditionalBatch(Y,J){return u(this.#J,Y.map((U)=>({key:this.#Y(U.key),expectedValue:U.expectedValue})),J.map((U)=>{if(U.type==="put")return{type:"put",key:this.#Y(U.key),value:U.value};return{type:"delete",key:this.#Y(U.key)}}))}async has(Y){return S(this.#J,this.#Y(Y))}async deletePrefix(Y){return w(this.#J,this.#Y(Y))}async deleteRange(Y,J){let U=this.#$(P(J));return y(this.#J,this.#Y(Y),U)}async*keys(Y,J){for await(let U of x(this.#J,this.#Y(Y),this.#Z(J)))yield this.#X(U)}async count(Y){return k(this.#J,this.#Y(Y))}[Symbol.dispose](){this.#J[Symbol.dispose]()}}function f(Y,J){return new h(Y,J)}var Q="kv";function A(Y){return new Promise((J,U)=>{Y.onsuccess=()=>J(Y.result),Y.onerror=()=>U(Y.error)})}function g(Y,J){let U=null,X=null,$=null,F=(G,V)=>{let W=G??Error(V);if(X){let B=X;U=null,X=null,B(W);return}$=W};return Y.onsuccess=()=>{if(!U)return;let G=U;U=null,X=null,G(Y.result)},Y.onerror=()=>{F(Y.error,"IndexedDB cursor request failed.")},J.onerror=()=>{F(J.error,"IndexedDB transaction failed.")},J.onabort=()=>{F(J.error,"IndexedDB transaction aborted.")},()=>{return new Promise((G,V)=>{if($){let W=$;$=null,V(W);return}if(U=G,X=V,Y.readyState==="done"){let W=U;U=null,X=null,W?.(Y.result)}})}}class r{#J;#U=null;#Y;constructor(Y="weft"){this.#J=Y,this.#Y=this.#X()}capabilities(){return{persistence:"local",readAfterWrite:"linearizable",scanConsistency:"best-effort",atomicBatch:!0,conditionalBatch:!0,boundedRangeDelete:!0}}#X(){let Y=indexedDB.open(this.#J,1);return Y.onupgradeneeded=()=>{let J=Y.result;if(!J.objectStoreNames.contains(Q))J.createObjectStore(Q)},A(Y).then((J)=>{return this.#U=J,J})}async get(Y){let X=(await this.#Y).transaction(Q,"readonly").objectStore(Q),$=await A(X.get(Y));return $===void 0?null:new Uint8Array($)}async put(Y,J){let $=(await this.#Y).transaction(Q,"readwrite").objectStore(Q);await A($.put(J,Y))}async delete(Y){let X=(await this.#Y).transaction(Q,"readwrite").objectStore(Q);await A(X.delete(Y))}async has(Y){let X=(await this.#Y).transaction(Q,"readonly").objectStore(Q);return await A(X.count(Y))>0}async deletePrefix(Y){let J=await this.#Y,U=N(Y),X=IDBKeyRange.bound(Y,U,!1,!0);return new Promise(($,F)=>{let G=J.transaction(Q,"readwrite"),V=G.objectStore(Q),W=0,B=V.count(X);B.onsuccess=()=>{W=B.result,V.delete(X)},G.oncomplete=()=>$(W),G.onerror=()=>F(G.error)})}async deleteRange(Y,J){let U=P(J),X=m(Y,U);if(X===null)return 0;let $=IDBKeyRange.bound(X.lower.key,X.upper.key,X.lower.open,X.upper.open),F=await this.#Y,{limit:G}=U;return new Promise((V,W)=>{let B=F.transaction(Q,"readwrite"),M=B.objectStore(Q),D=0;if(G===void 0){let H=M.count($);H.onsuccess=()=>{D=H.result,M.delete($)}}else{let H=M.openCursor($,"next");H.onsuccess=()=>{let z=H.result;if(z===null||D>=G)return;if(z.delete(),D++,D<G)z.continue()}}B.oncomplete=()=>V(D),B.onerror=()=>W(B.error)})}async*scan(Y,J={}){let{limit:U,reverse:X}=J,$=await this.#Y,F=N(Y),G=IDBKeyRange.bound(Y,F,!1,!0),V=X?"prev":"next",W=$.transaction(Q,"readonly"),M=W.objectStore(Q).openCursor(G,V),D=0,H=g(M,W),z=!1;try{let L=await H();while(L){if(U!==void 0&&D>=U)break;let j=L.key;if(O(j,J))yield[j,new Uint8Array(L.value)],D++;L.continue(),L=await H()}z=!0}finally{if(!z)try{W.abort()}catch{}}}async batch(Y){if(Y.length===0)return;let J=await this.#Y;return new Promise((U,X)=>{let $=J.transaction(Q,"readwrite"),F=$.objectStore(Q);for(let G of Y)if(G.type==="put")F.put(G.value,G.key);else F.delete(G.key);$.oncomplete=()=>U(),$.onerror=()=>X($.error)})}async conditionalBatch(Y,J){let U=await this.#Y;return new Promise((X,$)=>{let F=U.transaction(Q,"readwrite"),G=F.objectStore(Q),V=!1,W=!1,B=(H,z)=>{if(V)return;V=!0,$(H??Error(z))};F.oncomplete=()=>{if(V)return;V=!0,X(!0)},F.onerror=()=>{B(F.error,"IndexedDB conditionalBatch transaction failed.")},F.onabort=()=>{if(V)return;if(V=!0,W){X(!1);return}$(F.error??Error("IndexedDB conditionalBatch transaction aborted."))};let M=()=>{for(let H of J)if(H.type==="put")G.put(H.value,H.key);else G.delete(H.key)},D=(H)=>{if(H>=Y.length){M();return}let z=Y[H],L=G.get(z.key);L.onsuccess=()=>{let j=L.result,c=j===void 0?null:new Uint8Array(j);if(!I(c,z.expectedValue)){W=!0,F.abort();return}D(H+1)},L.onerror=()=>{B(L.error,"IndexedDB conditionalBatch condition check failed.")}};D(0)})}async*keys(Y,J={}){let{limit:U,reverse:X}=J,$=await this.#Y,F=N(Y),G=IDBKeyRange.bound(Y,F,!1,!0),V=X?"prev":"next",W=$.transaction(Q,"readonly"),M=W.objectStore(Q).openKeyCursor(G,V),D=0,H=g(M,W),z=!1;try{let L=await H();while(L){if(U!==void 0&&D>=U)break;let j=L.key;if(O(j,J))yield j,D++;L.continue(),L=await H()}z=!0}finally{if(!z)try{W.abort()}catch{}}}async count(Y){let J=await this.#Y,U=N(Y),$=J.transaction(Q,"readonly").objectStore(Q);return A($.count(IDBKeyRange.bound(Y,U,!1,!0)))}scoped(Y){return f(this,Y)}[Symbol.dispose](){if(this.#U)this.#U.close(),this.#U=null}}export{r as IndexedDBStorage};