@lostgradient/weft 0.2.0

package/dist/storage/node-sqlite.js

@@ -0,0 +1,323 @@
+// @bun
+// src/storage/node-sqlite.ts
+import { createRequire } from "module";
+
+// src/storage/capabilities.ts
+function requireStorageCapability(storage, capability, featureName) {
+  if (!storage.capabilities()[capability]) {
+    throw new Error(`Feature "${featureName}" requires storage capability "${capability}", but this storage backend does not provide it.`);
+  }
+}
+
+// src/storage/derived-operations.ts
+async function storageHasCore(storage, key) {
+  return await storage.get(key) !== null;
+}
+async function* storageKeysCore(storage, prefix, options) {
+  for await (const [key] of storage.scan(prefix, options)) {
+    yield key;
+  }
+}
+async function storageCountCore(storage, prefix) {
+  let count = 0;
+  for await (const _key of storageKeysCore(storage, prefix)) {
+    count++;
+  }
+  return count;
+}
+async function storageDeletePrefixCore(storage, prefix) {
+  const operations = [];
+  for await (const key of storageKeysCore(storage, prefix)) {
+    operations.push({ type: "delete", key });
+  }
+  if (operations.length === 0) {
+    return 0;
+  }
+  await storage.batch(operations);
+  return operations.length;
+}
+async function storageDeleteRangeCore(storage, prefix, options) {
+  const operations = [];
+  for await (const key of storageKeysCore(storage, prefix, options)) {
+    operations.push({ type: "delete", key });
+  }
+  if (operations.length === 0) {
+    return 0;
+  }
+  await storage.batch(operations);
+  return operations.length;
+}
+
+// src/storage/interface.ts
+function resolvePrefixRangeEnd(prefix) {
+  return prefix.length > 0 ? prefix.slice(0, -1) + String.fromCharCode(prefix.charCodeAt(prefix.length - 1) + 1) : "\xFF";
+}
+function storageValuesEqual(left, right) {
+  if (left === null || right === null) {
+    return left === right;
+  }
+  if (left.byteLength !== right.byteLength) {
+    return false;
+  }
+  for (let index = 0;index < left.byteLength; index++) {
+    if (left[index] !== right[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+async function storageHas(storage, key) {
+  if (storage.has) {
+    return storage.has(key);
+  }
+  return storageHasCore(storage, key);
+}
+function storageKeys(storage, prefix, options) {
+  if (storage.keys) {
+    return storage.keys(prefix, options);
+  }
+  return storageKeysCore(storage, prefix, options);
+}
+async function storageCount(storage, prefix) {
+  if (storage.count) {
+    return storage.count(prefix);
+  }
+  return storageCountCore(storage, prefix);
+}
+async function storageDeletePrefix(storage, prefix) {
+  if (storage.deletePrefix) {
+    return storage.deletePrefix(prefix);
+  }
+  return storageDeletePrefixCore(storage, prefix);
+}
+async function storageConditionalBatch(storage, conditions, operations) {
+  requireStorageCapability(storage, "conditionalBatch", "storageConditionalBatch");
+  if (!storage.conditionalBatch) {
+    throw new Error("This storage backend reports conditionalBatch capability but does not implement the conditionalBatch() method.");
+  }
+  return storage.conditionalBatch(conditions, operations);
+}
+
+// src/storage/sqlite-key-value-queries.ts
+var SQLITE_CREATE_KEY_VALUE_TABLE = `CREATE TABLE IF NOT EXISTS kv (
+  key TEXT PRIMARY KEY,
+  value BLOB NOT NULL
+) WITHOUT ROWID`;
+var SQLITE_SELECT_VALUE_BY_KEY = "SELECT value FROM kv WHERE key = ?";
+var SQLITE_UPSERT_VALUE_BY_KEY = "INSERT INTO kv (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value";
+var SQLITE_DELETE_VALUE_BY_KEY = "DELETE FROM kv WHERE key = ?";
+var SQLITE_SELECT_KEY_PRESENCE = "SELECT 1 AS present FROM kv WHERE key = ? LIMIT 1";
+var SQLITE_COUNT_KEYS_BY_PREFIX = "SELECT COUNT(*) AS count FROM kv WHERE key >= ? AND key < ?";
+var SQLITE_DELETE_KEYS_BY_PREFIX = "DELETE FROM kv WHERE key >= ? AND key < ?";
+function buildSqlitePrefixRangeParameters(prefix) {
+  return [prefix, resolvePrefixRangeEnd(prefix)];
+}
+function buildSqliteKeyRangeConditions(prefix, bounds) {
+  const { gt, gte, lt, lte } = bounds;
+  const conditions = ["key >= ? AND key < ?"];
+  const parameters = buildSqlitePrefixRangeParameters(prefix);
+  if (gt !== undefined) {
+    conditions.push("key > ?");
+    parameters.push(gt);
+  }
+  if (gte !== undefined) {
+    conditions.push("key >= ?");
+    parameters.push(gte);
+  }
+  if (lt !== undefined) {
+    conditions.push("key < ?");
+    parameters.push(lt);
+  }
+  if (lte !== undefined) {
+    conditions.push("key <= ?");
+    parameters.push(lte);
+  }
+  return { conditions, parameters };
+}
+function buildSqliteKeyRangeQuery(prefix, options = {}) {
+  const { limit, reverse } = options;
+  const { conditions, parameters } = buildSqliteKeyRangeConditions(prefix, options);
+  const direction = reverse ? "DESC" : "ASC";
+  const limitClause = limit !== undefined ? " LIMIT ?" : "";
+  if (limit !== undefined) {
+    parameters.push(limit);
+  }
+  return {
+    parameters,
+    sqlSuffix: `WHERE ${conditions.join(" AND ")} ORDER BY key ${direction}${limitClause}`
+  };
+}
+function buildSqliteKeyRangeDelete(prefix, options) {
+  const { conditions, parameters } = buildSqliteKeyRangeConditions(prefix, options);
+  const whereClause = conditions.join(" AND ");
+  if (options.limit === undefined) {
+    return {
+      parameters,
+      sql: `DELETE FROM kv WHERE ${whereClause}`
+    };
+  }
+  parameters.push(options.limit);
+  return {
+    parameters,
+    sql: `DELETE FROM kv WHERE key IN (SELECT key FROM kv WHERE ${whereClause} ORDER BY key ASC LIMIT ?)`
+  };
+}
+function buildSqliteKeyValueRangeSelect(prefix, options = {}) {
+  const { parameters, sqlSuffix } = buildSqliteKeyRangeQuery(prefix, options);
+  return {
+    parameters,
+    sql: `SELECT key, value FROM kv ${sqlSuffix}`
+  };
+}
+function buildSqliteKeyRangeSelect(prefix, options = {}) {
+  const { parameters, sqlSuffix } = buildSqliteKeyRangeQuery(prefix, options);
+  return {
+    parameters,
+    sql: `SELECT key FROM kv ${sqlSuffix}`
+  };
+}
+
+// src/storage/node-sqlite.ts
+var DatabaseConstructor;
+function createMissingBetterSqlite3Error(cause) {
+  return new Error('NodeSQLiteStorage requires the optional peer dependency "better-sqlite3". ' + "Install it in your application with: bun add better-sqlite3 (or npm install better-sqlite3).", { cause });
+}
+function isBetterSqlite3LoadFailure(error) {
+  if (!(error instanceof Error))
+    return false;
+  const errorCode = error.code;
+  if (errorCode === "MODULE_NOT_FOUND") {
+    return error.message.includes("'better-sqlite3'") || error.message.includes('"better-sqlite3"') || error.message.includes("'bindings'") || error.message.includes('"bindings"');
+  }
+  if (errorCode === "ERR_DLOPEN_FAILED") {
+    return error.message.includes("better-sqlite3");
+  }
+  return false;
+}
+function loadBetterSqlite3() {
+  if (DatabaseConstructor)
+    return DatabaseConstructor;
+  const requireFromHere = createRequire(import.meta.url);
+  let mod;
+  try {
+    mod = requireFromHere("better-sqlite3");
+  } catch (error) {
+    throw createMissingBetterSqlite3Error(error);
+  }
+  DatabaseConstructor = typeof mod.default === "function" ? mod.default : mod;
+  return DatabaseConstructor;
+}
+class NodeSQLiteStorage {
+  #database;
+  #persistence;
+  #getStatement;
+  #putStatement;
+  #deleteStatement;
+  #batchTransaction;
+  #scanStatements = new Map;
+  get scanStatementCacheSize() {
+    return this.#scanStatements.size;
+  }
+  capabilities() {
+    return {
+      persistence: this.#persistence,
+      readAfterWrite: "linearizable",
+      scanConsistency: "snapshot",
+      atomicBatch: true,
+      conditionalBatch: true,
+      boundedRangeDelete: false
+    };
+  }
+  constructor(path = ":memory:", databaseConstructor) {
+    this.#persistence = path === ":memory:" ? "ephemeral" : "local";
+    const Database = databaseConstructor ?? loadBetterSqlite3();
+    try {
+      this.#database = new Database(path);
+    } catch (error) {
+      if (databaseConstructor === undefined && isBetterSqlite3LoadFailure(error)) {
+        throw createMissingBetterSqlite3Error(error);
+      }
+      throw error;
+    }
+    this.#database.pragma("journal_mode = WAL");
+    this.#database.pragma("synchronous = NORMAL");
+    this.#database.pragma("cache_size = -64000");
+    this.#database.pragma("mmap_size = 268435456");
+    this.#database.pragma("temp_store = MEMORY");
+    this.#database.pragma("wal_autocheckpoint = 10000");
+    this.#database.exec(SQLITE_CREATE_KEY_VALUE_TABLE);
+    this.#getStatement = this.#database.prepare(SQLITE_SELECT_VALUE_BY_KEY);
+    this.#putStatement = this.#database.prepare(SQLITE_UPSERT_VALUE_BY_KEY);
+    this.#deleteStatement = this.#database.prepare(SQLITE_DELETE_VALUE_BY_KEY);
+    this.#batchTransaction = this.#database.transaction((entries) => {
+      for (const entry of entries) {
+        if (entry.type === "put") {
+          this.#putStatement.run(entry.key, entry.value);
+        } else {
+          this.#deleteStatement.run(entry.key);
+        }
+      }
+    });
+  }
+  async get(key) {
+    const row = this.#getStatement.get(key);
+    if (!row)
+      return null;
+    const value = row.value;
+    return new Uint8Array(value);
+  }
+  async put(key, value) {
+    this.#putStatement.run(key, value);
+  }
+  async delete(key) {
+    this.#deleteStatement.run(key);
+  }
+  async* scan(prefix, options = {}) {
+    const { parameters, sql } = buildSqliteKeyValueRangeSelect(prefix, options);
+    let statement = this.#scanStatements.get(sql);
+    if (!statement) {
+      statement = this.#database.prepare(sql);
+      this.#scanStatements.set(sql, statement);
+    }
+    const rows = statement.all(...parameters);
+    for (const row of rows) {
+      const typedRow = row;
+      yield [typedRow.key, new Uint8Array(typedRow.value)];
+    }
+  }
+  async batch(operations) {
+    if (operations.length === 0)
+      return;
+    this.#batchTransaction(operations);
+  }
+  async conditionalBatch(conditions, operations) {
+    const conditionalTransaction = this.#database.transaction((...arguments_) => {
+      const pendingConditions = arguments_[0];
+      const pendingOperations = arguments_[1];
+      for (const condition of pendingConditions) {
+        const row = this.#getStatement.get(condition.key);
+        const currentValue = row ? new Uint8Array(row.value) : null;
+        if (!storageValuesEqual(currentValue, condition.expectedValue)) {
+          return false;
+        }
+      }
+      for (const operation of pendingOperations) {
+        if (operation.type === "put") {
+          this.#putStatement.run(operation.key, operation.value);
+        } else {
+          this.#deleteStatement.run(operation.key);
+        }
+      }
+      return true;
+    });
+    return Boolean(conditionalTransaction(conditions, operations));
+  }
+  [Symbol.dispose]() {
+    this.#scanStatements.clear();
+    this.#database.close();
+  }
+}
+export {
+  NodeSQLiteStorage as SQLiteStorage,
+  NodeSQLiteStorage
+};

package/dist/storage/read-only-query.d.ts

@@ -0,0 +1,2 @@
+/** Validate that a storage query contains exactly one read-only SELECT or bare PRAGMA statement. */
+export declare function assertReadOnlyQuery(sql: string): void;

package/dist/storage/read-only-query.js

@@ -0,0 +1,19 @@
+const pragmaStatementPattern = /^PRAGMA\b/iu, readOnlyPragmaPattern = /^PRAGMA\s+(?:[A-Z_][A-Z0-9_]*\.)?[A-Z_][A-Z0-9_]*\s*$/iu, selectStatementPattern = /^SELECT\b/iu;
+function normalizeSql(sql) {
+  return sql.trim().replace(/;+\s*$/u, "").trim();
+}
+function isReadOnlyPragma(sql) {
+  return readOnlyPragmaPattern.test(sql);
+}
+export function assertReadOnlyQuery(sql) {
+  const normalizedSql = normalizeSql(sql);
+  if (normalizedSql.length === 0)
+    throw Error("Storage query must not be empty.");
+  if (normalizedSql.includes(";"))
+    throw Error("Storage query must contain exactly one read-only statement.");
+  if (selectStatementPattern.test(normalizedSql))
+    return;
+  if (pragmaStatementPattern.test(normalizedSql) && isReadOnlyPragma(normalizedSql))
+    return;
+  throw Error("Storage query only supports read-only SELECT and PRAGMA statements.");
+}

package/dist/storage/resolve.d.ts

@@ -0,0 +1,180 @@
+import type { HTTPStorage } from './http.ts';
+import type { IndexedDBStorage } from './indexeddb.ts';
+import type { Storage } from './interface.ts';
+import type { LMDBStorage } from './lmdb.ts';
+import { MemoryStorage } from './memory.ts';
+import type { SQLiteStorageInstance } from './sqlite.ts';
+import type { TursoStorage } from './turso.ts';
+import type { WebExtensionStorage } from './web-extension.ts';
+/**
+ * Runtime configuration for in-memory storage.
+ *
+ * @example
+ * ```ts
+ * import { resolveStorage, type MemoryStorageConfiguration } from '@lostgradient/weft/storage/resolve';
+ *
+ * const configuration: MemoryStorageConfiguration = { type: 'memory' };
+ * const storage = await resolveStorage(configuration);
+ * void storage;
+ * ```
+ */
+export type MemoryStorageConfiguration = {
+    type: 'memory';
+};
+/**
+ * Runtime configuration for SQLite storage.
+ *
+ * @example
+ * ```ts
+ * import { resolveStorage, type SQLiteStorageConfiguration } from '@lostgradient/weft/storage/resolve';
+ *
+ * const configuration: SQLiteStorageConfiguration = { type: 'sqlite', path: './weft.db' };
+ * const storage = await resolveStorage(configuration);
+ * void storage;
+ * ```
+ */
+export type SQLiteStorageConfiguration = {
+    type: 'sqlite';
+    path?: string;
+};
+/**
+ * Runtime configuration for LMDB storage.
+ *
+ * @example
+ * ```ts
+ * import { resolveStorage, type LMDBStorageConfiguration } from '@lostgradient/weft/storage/resolve';
+ *
+ * const configuration: LMDBStorageConfiguration = { type: 'lmdb', path: './weft-data' };
+ * const storage = await resolveStorage(configuration);
+ * void storage;
+ * ```
+ */
+export type LMDBStorageConfiguration = {
+    type: 'lmdb';
+    path: string;
+};
+/**
+ * Runtime configuration for Turso/libSQL storage.
+ *
+ * @example
+ * ```ts
+ * import { resolveStorage, type TursoStorageConfiguration } from '@lostgradient/weft/storage/resolve';
+ *
+ * const configuration: TursoStorageConfiguration = { type: 'turso', url: 'file:weft.db' };
+ * const storage = await resolveStorage(configuration);
+ * void storage;
+ * ```
+ */
+export type TursoStorageConfiguration = {
+    type: 'turso';
+    url: string;
+    authToken?: string;
+};
+/**
+ * Runtime configuration for browser IndexedDB storage.
+ *
+ * @example
+ * ```ts
+ * import { resolveStorage, type IndexedDBStorageConfiguration } from '@lostgradient/weft/storage/resolve';
+ *
+ * const configuration: IndexedDBStorageConfiguration = { type: 'indexeddb', databaseName: 'weft' };
+ * const storage = await resolveStorage(configuration);
+ * void storage;
+ * ```
+ */
+export type IndexedDBStorageConfiguration = {
+    type: 'indexeddb';
+    databaseName?: string;
+};
+/**
+ * Runtime configuration for WebExtension storage.
+ *
+ * @example
+ * ```ts
+ * import { resolveStorage, type WebExtensionStorageConfiguration } from '@lostgradient/weft/storage/resolve';
+ *
+ * const configuration: WebExtensionStorageConfiguration = { type: 'web-extension', area: 'local' };
+ * const storage = await resolveStorage(configuration);
+ * void storage;
+ * ```
+ */
+export type WebExtensionStorageConfiguration = {
+    type: 'web-extension';
+    area?: 'local' | 'sync' | 'session' | 'managed';
+};
+/**
+ * Runtime configuration for remote HTTP storage.
+ *
+ * @example
+ * ```ts
+ * import { resolveStorage, type HTTPStorageConfiguration } from '@lostgradient/weft/storage/resolve';
+ *
+ * const configuration: HTTPStorageConfiguration = { type: 'http', baseUrl: 'https://weft.example.com' };
+ * const storage = await resolveStorage(configuration);
+ * void storage;
+ * ```
+ */
+export type HTTPStorageConfiguration = {
+    type: 'http';
+    baseUrl: string | URL;
+    headers?: Record<string, string>;
+};
+/**
+ * Runtime configuration for automatic storage selection.
+ *
+ * @example
+ * ```ts
+ * import { resolveStorage, type AutoStorageConfiguration } from '@lostgradient/weft/storage/resolve';
+ *
+ * const configuration: AutoStorageConfiguration = { type: 'auto' };
+ * const storage = await resolveStorage(configuration);
+ * void storage;
+ * ```
+ */
+export type AutoStorageConfiguration = {
+    type: 'auto';
+};
+/**
+ * Union of supported runtime-driven storage configurations.
+ *
+ * @example
+ * ```ts
+ * import { resolveStorage, type StorageConfiguration } from '@lostgradient/weft/storage/resolve';
+ *
+ * const configuration: StorageConfiguration = { type: 'memory' };
+ * const storage = await resolveStorage(configuration);
+ * void storage;
+ * ```
+ */
+export type StorageConfiguration = MemoryStorageConfiguration | SQLiteStorageConfiguration | LMDBStorageConfiguration | TursoStorageConfiguration | IndexedDBStorageConfiguration | WebExtensionStorageConfiguration | HTTPStorageConfiguration | AutoStorageConfiguration;
+/**
+ * Storage adapter type resolved for a concrete {@link StorageConfiguration}.
+ *
+ * Use this when a configuration value is already narrowed and downstream code
+ * needs the adapter-specific instance type that {@link resolveStorage} returns.
+ *
+ * @example
+ * ```ts
+ * import type { HTTPStorageConfiguration, ResolvedStorage } from '@lostgradient/weft/storage/resolve';
+ *
+ * type RemoteStorage = ResolvedStorage<HTTPStorageConfiguration>;
+ * declare const storage: RemoteStorage;
+ * void storage;
+ * ```
+ */
+export type ResolvedStorage<Configuration extends StorageConfiguration> = Configuration extends MemoryStorageConfiguration ? MemoryStorage : Configuration extends SQLiteStorageConfiguration ? SQLiteStorageInstance : Configuration extends LMDBStorageConfiguration ? LMDBStorage : Configuration extends TursoStorageConfiguration ? TursoStorage : Configuration extends IndexedDBStorageConfiguration ? IndexedDBStorage : Configuration extends WebExtensionStorageConfiguration ? WebExtensionStorage : Configuration extends HTTPStorageConfiguration ? HTTPStorage : Storage;
+/**
+ * Resolve a storage backend from runtime configuration.
+ *
+ * The helper lazy-loads backends so optional native dependencies are only
+ * required when their configuration is selected.
+ *
+ * @example
+ * ```ts
+ * import { resolveStorage } from '@lostgradient/weft/storage/resolve';
+ *
+ * const storage = await resolveStorage({ type: 'sqlite', path: './weft.db' });
+ * void storage;
+ * ```
+ */
+export declare function resolveStorage<Configuration extends StorageConfiguration>(configuration: Configuration): Promise<ResolvedStorage<Configuration>>;

package/dist/storage/resolve.js

@@ -0,0 +1,2 @@
+// @bun
+var r=Object.defineProperty;var i=(F)=>F;function n(F,Y){this[F]=i.bind(null,Y)}var t=(F,Y)=>{for(var J in Y)r(F,J,{get:Y[J],enumerable:!0,configurable:!0,set:n.bind(Y,J)})};var _=(F,Y)=>()=>(F&&(Y=F(F=0)),Y);function A(F,Y,J){if(!F.capabilities()[Y])throw Error(`Feature "${J}" requires storage capability "${Y}", but this storage backend does not provide it.`)}function o(F){let Y=F.capabilities(),J=[];if(Y.persistence!=="local")J.push(`persistence must be "local" (got "${Y.persistence}")`);if(Y.readAfterWrite!=="linearizable")J.push(`readAfterWrite must be "linearizable" (got "${Y.readAfterWrite}")`);if(Y.scanConsistency!=="snapshot")J.push(`scanConsistency must be "snapshot" (got "${Y.scanConsistency}")`);if(!Y.atomicBatch)J.push("atomicBatch must be true");if(!Y.conditionalBatch)J.push("conditionalBatch must be true");if(J.length>0)throw Error(`Storage is not durable enough for recovery: ${J.join("; ")}.`)}var P="default";async function h(F,Y){return await F.get(Y)!==null}async function*B(F,Y,J){for await(let[Z]of F.scan(Y,J))yield Z}async function C(F,Y){let J=0;for await(let Z of B(F,Y))J++;return J}async function b(F,Y){let J=[];for await(let Z of B(F,Y))J.push({type:"delete",key:Z});if(J.length===0)return 0;return await F.batch(J),J.length}async function v(F,Y,J){let Z=[];for await(let X of B(F,Y,J))Z.push({type:"delete",key:X});if(Z.length===0)return 0;return await F.batch(Z),Z.length}var e;var K=_(()=>{e=["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:"]});function q(F){return F.length>0?F.slice(0,-1)+String.fromCharCode(F.charCodeAt(F.length-1)+1):"\xFF"}function N(F,Y={}){if(Y.gt!==void 0&&F<=Y.gt)return!1;if(Y.gte!==void 0&&F<Y.gte)return!1;if(Y.lt!==void 0&&F>=Y.lt)return!1;if(Y.lte!==void 0&&F>Y.lte)return!1;return!0}function I(F,Y){if(F===null||Y===null)return F===Y;if(F.byteLength!==Y.byteLength)return!1;for(let J=0;J<F.byteLength;J++)if(F[J]!==Y[J])return!1;return!0}async function x(F,Y){if(F.has)return F.has(Y);return h(F,Y)}function S(F,Y,J){if(F.keys)return F.keys(Y,J);return B(F,Y,J)}async function w(F,Y){if(F.count)return F.count(Y);return C(F,Y)}async function k(F,Y){if(F.deletePrefix)return F.deletePrefix(Y);return b(F,Y)}async function m(F,Y,J){if(A(F,"conditionalBatch","storageConditionalBatch"),!F.conditionalBatch)throw Error("This storage backend reports conditionalBatch capability but does not implement the conditionalBatch() method.");return F.conditionalBatch(Y,J)}function W(F){return encodeURIComponent(F)}function bF(F){return decodeURIComponent(F)}function vF(F){try{return decodeURIComponent(F)}catch{return null}}var j=(F)=>String(F).padStart(16,"0"),KF;var E=_(()=>{K();KF={workflow:(F)=>`wf:${W(F)}`,checkpoint:(F)=>`wf:${W(F)}:ckpt`,checkpointHistory:(F,Y)=>`wf:${W(F)}:ckpt:${String(Y).padStart(10,"0")}`,timelinePrefix:(F)=>`wf:${W(F)}:timeline:`,timeline:(F,Y)=>`wf:${W(F)}:timeline:${String(Y).padStart(10,"0")}`,schedule:(F)=>`schedule:${W(F)}`,scheduleTick:(F,Y)=>`schedule-due:${String(F).padStart(16,"0")}:${W(Y)}`,scheduleRun:(F)=>`schedule-run:${W(F)}`,operation:(F,Y,J)=>`op:${F}:${j(Y)}:${J}`,operationInflight:(F)=>`op:inflight:${F}`,operationQueued:(F)=>`op:queued:${F}`,operationResolved:(F)=>`op:resolved:${F}`,bulkOperationAuditPrefix:()=>"audit:bulk:",bulkOperationAudit:(F,Y,J)=>`audit:bulk:${j(F)}:${W(Y)}:${W(J)}`,operationResolvedByTimePrefix:()=>"op:resolved-by-time:",operationResolvedByTime:(F,Y)=>`op:resolved-by-time:${j(F)}:${W(Y)}`,asyncActivity:(F,Y)=>`async-act:v1:${W(F)}:${W(Y)}`,activityReconciliationPrefix:(F)=>`actrec:v1:${W(F)}:`,activityReconciliation:(F,Y,J)=>`actrec:v1:${W(F)}:${W(Y)}:${J}`,eventPrefix:(F)=>`ev:${W(F)}:`,event:(F,Y)=>`ev:${W(F)}:${String(Y).padStart(10,"0")}`,eventHead:(F)=>`ev:${W(F)}:head`,eventWatermark:(F)=>`ev:${W(F)}:watermark`,signal:(F,Y,J)=>`sig:${W(F)}:${Y}:${W(J)}`,signalSequence:(F)=>`sigseq:v1:${W(F)}`,signalAcceptedResponsePrefix:(F)=>`sigres:v1:${W(F)}:`,signalAcceptedResponse:(F,Y,J)=>`sigres:v1:${W(F)}:${W(Y)}:${W(J)}`,deadline:(F,Y)=>`wf-deadline:${j(F)}:${W(Y)}`,terminalCleanup:(F,Y)=>`wf-cleanup:${j(F)}:${W(Y)}`,delayedStart:(F,Y)=>`wf-delayed:${j(F)}:${W(Y)}`,terminalWorkflowPrefix:()=>"wf-terminal:",terminalWorkflow:(F,Y)=>`wf-terminal:${j(F)}:${W(Y)}`,attribute:(F)=>`attr:${W(F)}`,attributeIndex:(F,Y,J)=>`idx:${F}:${Y}:${W(J)}`,tagIndex:(F,Y)=>`tag:${W(F)}:${W(Y)}`,updatePrefix:(F)=>`upd:${W(F)}:`,update:(F,Y)=>`upd:${W(F)}:${Y}`,updateResponse:(F)=>`upr:${F}`,updateIdempotency:(F,Y)=>`upk:${W(F)}:${Y}`,budget:(F,Y,J)=>`budget:${F}:${Y}:${J}`,review:(F,Y)=>`review:${W(F)}:${Y}`,workflowHeaders:(F)=>`wf-headers:${W(F)}`,terminalCleanupNeeded:(F)=>`wf-cleanup-needed:${W(F)}`,offload:(F,Y)=>`offload:${W(F)}:${Y}`,archive:(F,Y)=>`archive:${W(F)}:${Y}`,stateExecution:(F,Y)=>`state:execution:${W(F)}:${W(Y)}`,stateWorkflow:(F,Y)=>`state:workflow-scope:${P}:${W(F)}:${W(Y)}`,streamChunkPrefix:(F,Y)=>`blob:${W(F)}:${Y}:chunk:`,streamChunk:(F,Y,J)=>`blob:${W(F)}:${Y}:chunk:${String(J).padStart(10,"0")}`,streamMetadata:(F,Y)=>`blob:${W(F)}:${Y}:meta`,budgetCharged:(F)=>`budget-charged:${F}`,toolEffect:(F,Y,J)=>`tool-effect:${W(F)}:${Y}:${J}`,workflowVisibilityStatus:(F,Y)=>`wf-idx-status:${W(F)}:${W(Y)}`,workflowVisibilityType:(F,Y)=>`wf-idx-type:${W(F)}:${W(Y)}`,workflowVisibilityCreated:(F,Y)=>`wf-idx-created:${j(F)}:${W(Y)}`,workflowVisibilityUpdated:(F,Y)=>`wf-idx-updated:${j(F)}:${W(Y)}`,workflowVisibilityDeadline:(F,Y)=>`wf-idx-deadline:${j(F)}:${W(Y)}`,workflowVisibilityManifest:(F)=>`wf-idx-manifest:${W(F)}`,workflowVisibilityMetaVersion:()=>"wf-idx-meta:version",workflowVisibilityMetaBuiltAt:()=>"wf-idx-meta:built-at",workflowVisibilityMetaCursor:()=>"wf-idx-meta:cursor"}});function FF(F){if(F===void 0)return;if(typeof F!=="number"||!Number.isInteger(F)||F<0)throw Error("deleteRange limit must be a finite non-negative integer");return F===0?0:F}function L(F){let Y={},J=!1;for(let X of["gt","gte","lt","lte"]){let $=F[X];if($===void 0)continue;if(typeof $!=="string")throw Error("deleteRange bounds must be strings");Y[X]=$,J=!0}if(!J)throw Error("deleteRange requires at least one of gt/gte/lt/lte; use deletePrefix to delete a whole prefix");let Z=FF(F.limit);if(Z!==void 0)Y.limit=Z;return Y}async function y(F,Y,J){let Z=L(J);if(F.deleteRange)return F.deleteRange(Y,Z);return v(F,Y,Z)}var D=()=>{};function M(F){return F.replaceAll(/:+$/g,"")}function YF(F,Y){let J=M(F),Z=M(Y);if(J.length===0)return Z;if(Z.length===0)return J;return`${J}:${Z}`}function u(F,Y){return new R(F,Y)}var R;var c=_(()=>{D();E();R=class R{#F;#J;constructor(F,Y){this.#F=F,this.#J=M(Y)}#Y(F){if(this.#J.length===0)return F;return F.length===0?`${this.#J}:`:`${this.#J}:${F}`}#W(F){if(this.#J.length===0)return F;return F.slice(this.#J.length+1)}#Z(F={}){let Y={};if(F.limit!==void 0)Y.limit=F.limit;if(F.reverse!==void 0)Y.reverse=F.reverse;if(F.gt!==void 0)Y.gt=this.#Y(F.gt);if(F.gte!==void 0)Y.gte=this.#Y(F.gte);if(F.lt!==void 0)Y.lt=this.#Y(F.lt);if(F.lte!==void 0)Y.lte=this.#Y(F.lte);return Y}#$(F){let Y={};if(F.limit!==void 0)Y.limit=F.limit;if(F.gt!==void 0)Y.gt=this.#Y(F.gt);if(F.gte!==void 0)Y.gte=this.#Y(F.gte);if(F.lt!==void 0)Y.lt=this.#Y(F.lt);if(F.lte!==void 0)Y.lte=this.#Y(F.lte);return Y}capabilities(){return this.#F.capabilities()}scoped(F){return new R(this.#F,YF(this.#J,F))}async get(F){return this.#F.get(this.#Y(F))}async put(F,Y){await this.#F.put(this.#Y(F),Y)}async delete(F){await this.#F.delete(this.#Y(F))}async*scan(F,Y){for await(let[J,Z]of this.#F.scan(this.#Y(F),this.#Z(Y)))yield[this.#W(J),Z]}async batch(F){await this.#F.batch(F.map((Y)=>{if(Y.type==="put")return{type:"put",key:this.#Y(Y.key),value:Y.value};return{type:"delete",key:this.#Y(Y.key)}}))}async conditionalBatch(F,Y){return m(this.#F,F.map((J)=>({key:this.#Y(J.key),expectedValue:J.expectedValue})),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 has(F){return x(this.#F,this.#Y(F))}async deletePrefix(F){return k(this.#F,this.#Y(F))}async deleteRange(F,Y){let J=this.#$(L(Y));return y(this.#F,this.#Y(F),J)}async*keys(F,Y){for await(let J of S(this.#F,this.#Y(F),this.#Z(Y)))yield this.#W(J)}async count(F){return w(this.#F,this.#Y(F))}[Symbol.dispose](){this.#F[Symbol.dispose]()}}});var JF={};t(JF,{MemoryStorage:()=>z});var z;var l=_(()=>{D();E();c();z=class z{#F;constructor(){this.#F=new Map}capabilities(){return{persistence:"ephemeral",readAfterWrite:"linearizable",scanConsistency:"snapshot",atomicBatch:!0,conditionalBatch:!0,boundedRangeDelete:!0}}#J(F,Y,J){return F>=Y&&F<J}#Y(F,Y){let J=[];for(let Z of this.#F.keys())if(this.#J(Z,F,Y))J.push(Z);return J.toSorted()}async get(F){return this.#F.get(F)??null}async put(F,Y){this.#F.set(F,Y)}async delete(F){this.#F.delete(F)}async*scan(F,Y={}){let{limit:J,reverse:Z}=Y,X=q(F),$=this.#Y(F,X);if($=$.filter((Q)=>N(Q,Y)),Z)$.reverse();let H=0;for(let Q of $){if(J!==void 0&&H>=J)break;let O=this.#F.get(Q);if(O!==void 0)yield[Q,O],H++}}async batch(F){this.#W(F)}#W(F){for(let Y of F)if(Y.type==="put")this.#F.set(Y.key,Y.value);else this.#F.delete(Y.key)}async conditionalBatch(F,Y){for(let J of F){let Z=this.#F.get(J.key)??null;if(!I(Z,J.expectedValue))return!1}return this.#W(Y),!0}async has(F){return this.#F.has(F)}async deletePrefix(F){let Y=q(F),J=this.#Y(F,Y);for(let Z of J)this.#F.delete(Z);return J.length}async deleteRange(F,Y){let J=L(Y),Z=q(F),X=this.#Y(F,Z).filter((H)=>N(H,J)),$=J.limit===void 0?X:X.slice(0,J.limit);for(let H of $)this.#F.delete(H);return $.length}async*keys(F,Y={}){let{limit:J,reverse:Z}=Y,X=q(F),$=this.#Y(F,X);if($=$.filter((Q)=>N(Q,Y)),Z)$.reverse();let H=0;for(let Q of $){if(J!==void 0&&H>=J)break;yield Q,H++}}async count(F){let Y=q(F);return this.#Y(F,Y).length}scoped(F){return u(this,F)}get size(){return this.#F.size}clear(){this.#F.clear()}snapshot(){let F=new Map;for(let[Y,J]of this.#F)F.set(Y,new Uint8Array(J));return F}[Symbol.dispose](){this.#F.clear()}}});l();function G(F,Y){return import.meta.url.endsWith(".ts")?F:Y}async function V(F){return await import(F)}var WF=G("./bun-sql.ts","./bun-sql.js"),ZF=G("./node-sqlite.ts","./node-sqlite.js"),$F=G("./lmdb.ts","./lmdb.js"),XF=G("./turso.ts","./turso.js"),g=G("./indexeddb.ts","./indexeddb.js"),d=G("./web-extension.ts","./web-extension.js"),jF=G("./http.ts","./http.js"),VF=G("./auto.ts","./auto.js");function p(){return typeof Bun<"u"}function s(){return typeof globalThis.process==="object"&&globalThis.process!==null&&typeof globalThis.process.versions==="object"&&typeof globalThis.process.versions.node==="string"}function HF(){let F=globalThis;return F.browser?.storage!==void 0||F.chrome?.storage!==void 0}function QF(){return typeof globalThis.indexedDB<"u"}async function GF(F){if(p()){let{BunSQLiteStorage:Y}=await V(WF);return new Y(F)}if(s()){let{NodeSQLiteStorage:Y}=await V(ZF);return new Y(F)}throw Error("SQLite storage is only available in Bun or Node runtimes.")}async function qF(){if(p()||s()){let{resolveDefaultStorage:F}=await V(VF);return F()}if(HF()){let{WebExtensionStorage:F}=await V(d);return new F}if(QF()){let{IndexedDBStorage:F}=await V(g);return new F}return new z}var a={memory:async(F)=>new z,sqlite:async(F)=>GF(F.path),lmdb:async(F)=>{let{LMDBStorage:Y}=await V($F);return new Y(F.path)},turso:async(F)=>{let{TursoStorage:Y}=await V(XF);return new Y({url:F.url,...F.authToken===void 0?{}:{authToken:F.authToken}})},indexeddb:async(F)=>{let{IndexedDBStorage:Y}=await V(g);return new Y(F.databaseName)},"web-extension":async(F)=>{let{WebExtensionStorage:Y}=await V(d);return new Y(F.area===void 0?{}:{area:F.area})},http:async(F)=>{let{HTTPStorage:Y}=await V(jF);return new Y({baseUrl:F.baseUrl,...F.headers===void 0?{}:{headers:F.headers}})},auto:async(F)=>qF()};function _F(F){if(typeof F!=="object"||F===null)return"unknown";if(!("type"in F))return"unknown";return typeof F.type==="string"?F.type:"unknown"}function UF(F){if(typeof F!=="object"||F===null||Array.isArray(F))throw Error("Storage configuration must be an object.");return F}function f(F,Y,J){let Z=F[Y];if(typeof Z!=="string"||Z.length===0)throw Error(`${J} storage configuration requires "${Y}" as a string.`);return Z}function T(F,Y,J){let Z=F[Y];if(Z===void 0)return;if(typeof Z!=="string")throw Error(`${J} storage configuration field "${Y}" must be a string.`);return Z}function BF(F,Y,J){let Z=F[Y];if(typeof Z==="string"||Z instanceof URL)return Z;throw Error(`${J} storage configuration requires "${Y}" as a string or URL.`)}function LF(F){let Y=F.headers;if(Y===void 0)return;if(typeof Y!=="object"||Y===null||Array.isArray(Y))throw Error('HTTP storage configuration field "headers" must be a string record.');let J={};for(let[Z,X]of Object.entries(Y)){if(typeof X!=="string")throw Error('HTTP storage configuration field "headers" must be a string record.');J[Z]=X}return J}function zF(F){let Y=F.area;if(Y===void 0)return;if(Y==="local"||Y==="sync"||Y==="session"||Y==="managed")return Y;throw Error('WebExtension storage configuration field "area" must be one of local, sync, session, or managed.')}var NF={memory:(F)=>({type:"memory"}),sqlite:(F)=>{let Y=T(F,"path","SQLite");return Y===void 0?{type:"sqlite"}:{type:"sqlite",path:Y}},lmdb:(F)=>({type:"lmdb",path:f(F,"path","LMDB")}),turso:(F)=>{let Y=T(F,"authToken","Turso");return{type:"turso",url:f(F,"url","Turso"),...Y===void 0?{}:{authToken:Y}}},indexeddb:(F)=>{let Y=T(F,"databaseName","IndexedDB");return Y===void 0?{type:"indexeddb"}:{type:"indexeddb",databaseName:Y}},"web-extension":(F)=>{let Y=zF(F);return Y===void 0?{type:"web-extension"}:{type:"web-extension",area:Y}},http:(F)=>{let Y=LF(F);return{type:"http",baseUrl:BF(F,"baseUrl","HTTP"),...Y===void 0?{}:{headers:Y}}},auto:(F)=>({type:"auto"})};function AF(F,Y){return NF[Y](UF(F))}function PF(F){return Object.hasOwn(a,F)}async function pF(F){let Y=_F(F);if(!PF(Y))throw Error(`Unsupported storage configuration type: ${Y}`);let J=AF(F,Y),Z=a[Y];return Z(J)}export{pF as resolveStorage};

package/dist/storage/scoped-storage.d.ts

@@ -0,0 +1,68 @@
+import { type DeleteRangeOptions } from './delete-range.ts';
+import { type BatchOperation, type ConditionalBatchCondition, type ScanOptions, type Storage, type StorageCapabilities } from './interface.ts';
+/**
+ * {@link Storage} decorator that transparently prefixes all keys with a
+ * namespace, isolating a logical partition of a shared backing store.
+ *
+ * Reads and writes pass through to the underlying storage with the scope prefix
+ * prepended; keys returned by `scan` and `keys` are stripped back to their
+ * unprefixed form.  Use {@link scopedStorage} to construct one without `new`.
+ *
+ * @example
+ * ```ts
+ * import { MemoryStorage, ScopedStorage } from '@lostgradient/weft';
+ *
+ * await using raw = new MemoryStorage();
+ * const scopeA = new ScopedStorage(raw, 'scope:a');
+ * const scopeB = new ScopedStorage(raw, 'scope:b');
+ *
+ * await scopeA.put('setting', new TextEncoder().encode('dark'));
+ * await scopeB.put('setting', new TextEncoder().encode('light'));
+ *
+ * // Keys are isolated — scopeA cannot see scopeB's data
+ * console.log(await scopeA.has('setting')); // true
+ * console.log(await scopeB.get('setting')); // Uint8Array for 'light'
+ * ```
+ */
+export declare class ScopedStorage implements Storage {
+    #private;
+    constructor(storage: Storage, prefix: string);
+    capabilities(): StorageCapabilities;
+    scoped(prefix: string): ScopedStorage;
+    get(key: string): Promise<Uint8Array | null>;
+    put(key: string, value: Uint8Array): Promise<void>;
+    delete(key: string): Promise<void>;
+    scan(prefix: string, options?: ScanOptions): AsyncIterable<[string, Uint8Array]>;
+    batch(operations: BatchOperation[]): Promise<void>;
+    conditionalBatch(conditions: ConditionalBatchCondition[], operations: BatchOperation[]): Promise<boolean>;
+    has(key: string): Promise<boolean>;
+    deletePrefix(prefix: string): Promise<number>;
+    deleteRange(prefix: string, options: DeleteRangeOptions): Promise<number>;
+    keys(prefix: string, options?: ScanOptions): AsyncIterable<string>;
+    count(prefix: string): Promise<number>;
+    [Symbol.dispose](): void;
+}
+/**
+ * Factory that creates a {@link ScopedStorage} view of `storage` under the
+ * given `prefix`.
+ *
+ * This is an ergonomic alternative to `new ScopedStorage(...)`: it avoids
+ * `new` at call sites and reads naturally when storage is being decorated
+ * inline. The return type and behavior are identical to constructing
+ * `ScopedStorage` directly.
+ *
+ * @example
+ * ```ts
+ * import { workflow, Engine, MemoryStorage, scopedStorage } from '@lostgradient/weft';
+ *
+ * await using raw = new MemoryStorage();
+ *
+ * // Give each engine its own key namespace in the same backing store
+ * await using engine = new Engine({ storage: scopedStorage(raw, 'eng:v1') });
+ * engine.register(workflow({ name: 'ping' }).execute(async function* () { return 'pong'; }));
+ *
+ * const handle = await engine.start('ping', null);
+ * console.log(await handle.result()); // 'pong'
+ * ```
+ */
+export declare function scopedStorage(storage: Storage, prefix: string): ScopedStorage;

package/dist/storage/scoped-storage.js

@@ -0,0 +1,2 @@
+// @bun
+var b=Object.defineProperty;var C=(E)=>E;function u(E,_){this[E]=C.bind(null,_)}var k=(E,_)=>{for(var W in _)b(E,W,{get:_[W],enumerable:!0,configurable:!0,set:u.bind(_,W)})};var Z=(E,_)=>()=>(E&&(_=E(E=0)),_);function G(E,_,W){if(!E.capabilities()[_])throw Error(`Feature "${W}" requires storage capability "${_}", but this storage backend does not provide it.`)}function K(E){let _=E.capabilities(),W=[];if(_.persistence!=="local")W.push(`persistence must be "local" (got "${_.persistence}")`);if(_.readAfterWrite!=="linearizable")W.push(`readAfterWrite must be "linearizable" (got "${_.readAfterWrite}")`);if(_.scanConsistency!=="snapshot")W.push(`scanConsistency must be "snapshot" (got "${_.scanConsistency}")`);if(!_.atomicBatch)W.push("atomicBatch must be true");if(!_.conditionalBatch)W.push("conditionalBatch must be true");if(W.length>0)throw Error(`Storage is not durable enough for recovery: ${W.join("; ")}.`)}var j="default";async function B(E,_){return await E.get(_)!==null}async function*U(E,_,W){for await(let[Y]of E.scan(_,W))yield Y}async function L(E,_){let W=0;for await(let Y of U(E,_))W++;return W}async function q(E,_){let W=[];for await(let Y of U(E,_))W.push({type:"delete",key:Y});if(W.length===0)return 0;return await E.batch(W),W.length}async function N(E,_,W){let Y=[];for await(let V of U(E,_,W))Y.push({type:"delete",key:V});if(Y.length===0)return 0;return await E.batch(Y),Y.length}var x;var R=Z(()=>{x=["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:"]});function p(E){return E.length>0?E.slice(0,-1)+String.fromCharCode(E.charCodeAt(E.length-1)+1):"\xFF"}function a(E,_={}){if(_.gt!==void 0&&E<=_.gt)return!1;if(_.gte!==void 0&&E<_.gte)return!1;if(_.lt!==void 0&&E>=_.lt)return!1;if(_.lte!==void 0&&E>_.lte)return!1;return!0}function i(E,_){if(E===null||_===null)return E===_;if(E.byteLength!==_.byteLength)return!1;for(let W=0;W<E.byteLength;W++)if(E[W]!==_[W])return!1;return!0}async function D(E,_){if(E.has)return E.has(_);return B(E,_)}function T(E,_,W){if(E.keys)return E.keys(_,W);return U(E,_,W)}async function A(E,_){if(E.count)return E.count(_);return L(E,_)}async function O(E,_){if(E.deletePrefix)return E.deletePrefix(_);return q(E,_)}async function z(E,_,W){if(G(E,"conditionalBatch","storageConditionalBatch"),!E.conditionalBatch)throw Error("This storage backend reports conditionalBatch capability but does not implement the conditionalBatch() method.");return E.conditionalBatch(_,W)}function F(E){return encodeURIComponent(E)}function r(E){return decodeURIComponent(E)}function n(E){try{return decodeURIComponent(E)}catch{return null}}var X=(E)=>String(E).padStart(16,"0"),t;var P=Z(()=>{R();t={workflow:(E)=>`wf:${F(E)}`,checkpoint:(E)=>`wf:${F(E)}:ckpt`,checkpointHistory:(E,_)=>`wf:${F(E)}:ckpt:${String(_).padStart(10,"0")}`,timelinePrefix:(E)=>`wf:${F(E)}:timeline:`,timeline:(E,_)=>`wf:${F(E)}:timeline:${String(_).padStart(10,"0")}`,schedule:(E)=>`schedule:${F(E)}`,scheduleTick:(E,_)=>`schedule-due:${String(E).padStart(16,"0")}:${F(_)}`,scheduleRun:(E)=>`schedule-run:${F(E)}`,operation:(E,_,W)=>`op:${E}:${X(_)}:${W}`,operationInflight:(E)=>`op:inflight:${E}`,operationQueued:(E)=>`op:queued:${E}`,operationResolved:(E)=>`op:resolved:${E}`,bulkOperationAuditPrefix:()=>"audit:bulk:",bulkOperationAudit:(E,_,W)=>`audit:bulk:${X(E)}:${F(_)}:${F(W)}`,operationResolvedByTimePrefix:()=>"op:resolved-by-time:",operationResolvedByTime:(E,_)=>`op:resolved-by-time:${X(E)}:${F(_)}`,asyncActivity:(E,_)=>`async-act:v1:${F(E)}:${F(_)}`,activityReconciliationPrefix:(E)=>`actrec:v1:${F(E)}:`,activityReconciliation:(E,_,W)=>`actrec:v1:${F(E)}:${F(_)}:${W}`,eventPrefix:(E)=>`ev:${F(E)}:`,event:(E,_)=>`ev:${F(E)}:${String(_).padStart(10,"0")}`,eventHead:(E)=>`ev:${F(E)}:head`,eventWatermark:(E)=>`ev:${F(E)}:watermark`,signal:(E,_,W)=>`sig:${F(E)}:${_}:${F(W)}`,signalSequence:(E)=>`sigseq:v1:${F(E)}`,signalAcceptedResponsePrefix:(E)=>`sigres:v1:${F(E)}:`,signalAcceptedResponse:(E,_,W)=>`sigres:v1:${F(E)}:${F(_)}:${F(W)}`,deadline:(E,_)=>`wf-deadline:${X(E)}:${F(_)}`,terminalCleanup:(E,_)=>`wf-cleanup:${X(E)}:${F(_)}`,delayedStart:(E,_)=>`wf-delayed:${X(E)}:${F(_)}`,terminalWorkflowPrefix:()=>"wf-terminal:",terminalWorkflow:(E,_)=>`wf-terminal:${X(E)}:${F(_)}`,attribute:(E)=>`attr:${F(E)}`,attributeIndex:(E,_,W)=>`idx:${E}:${_}:${F(W)}`,tagIndex:(E,_)=>`tag:${F(E)}:${F(_)}`,updatePrefix:(E)=>`upd:${F(E)}:`,update:(E,_)=>`upd:${F(E)}:${_}`,updateResponse:(E)=>`upr:${E}`,updateIdempotency:(E,_)=>`upk:${F(E)}:${_}`,budget:(E,_,W)=>`budget:${E}:${_}:${W}`,review:(E,_)=>`review:${F(E)}:${_}`,workflowHeaders:(E)=>`wf-headers:${F(E)}`,terminalCleanupNeeded:(E)=>`wf-cleanup-needed:${F(E)}`,offload:(E,_)=>`offload:${F(E)}:${_}`,archive:(E,_)=>`archive:${F(E)}:${_}`,stateExecution:(E,_)=>`state:execution:${F(E)}:${F(_)}`,stateWorkflow:(E,_)=>`state:workflow-scope:${j}:${F(E)}:${F(_)}`,streamChunkPrefix:(E,_)=>`blob:${F(E)}:${_}:chunk:`,streamChunk:(E,_,W)=>`blob:${F(E)}:${_}:chunk:${String(W).padStart(10,"0")}`,streamMetadata:(E,_)=>`blob:${F(E)}:${_}:meta`,budgetCharged:(E)=>`budget-charged:${E}`,toolEffect:(E,_,W)=>`tool-effect:${F(E)}:${_}:${W}`,workflowVisibilityStatus:(E,_)=>`wf-idx-status:${F(E)}:${F(_)}`,workflowVisibilityType:(E,_)=>`wf-idx-type:${F(E)}:${F(_)}`,workflowVisibilityCreated:(E,_)=>`wf-idx-created:${X(E)}:${F(_)}`,workflowVisibilityUpdated:(E,_)=>`wf-idx-updated:${X(E)}:${F(_)}`,workflowVisibilityDeadline:(E,_)=>`wf-idx-deadline:${X(E)}:${F(_)}`,workflowVisibilityManifest:(E)=>`wf-idx-manifest:${F(E)}`,workflowVisibilityMetaVersion:()=>"wf-idx-meta:version",workflowVisibilityMetaBuiltAt:()=>"wf-idx-meta:built-at",workflowVisibilityMetaCursor:()=>"wf-idx-meta:cursor"}});function S(E){if(E===void 0)return;if(typeof E!=="number"||!Number.isInteger(E)||E<0)throw Error("deleteRange limit must be a finite non-negative integer");return E===0?0:E}function M(E){let _={},W=!1;for(let V of["gt","gte","lt","lte"]){let $=E[V];if($===void 0)continue;if(typeof $!=="string")throw Error("deleteRange bounds must be strings");_[V]=$,W=!0}if(!W)throw Error("deleteRange requires at least one of gt/gte/lt/lte; use deletePrefix to delete a whole prefix");let Y=S(E.limit);if(Y!==void 0)_.limit=Y;return _}async function v(E,_,W){let Y=M(W);if(E.deleteRange)return E.deleteRange(_,Y);return N(E,_,Y)}var h=()=>{};function Q(E){return E.replaceAll(/:+$/g,"")}function I(E,_){let W=Q(E),Y=Q(_);if(W.length===0)return Y;if(Y.length===0)return W;return`${W}:${Y}`}function JE(E,_){return new H(E,_)}var H;var c=Z(()=>{h();P();H=class H{#_;#W;constructor(E,_){this.#_=E,this.#W=Q(_)}#E(E){if(this.#W.length===0)return E;return E.length===0?`${this.#W}:`:`${this.#W}:${E}`}#F(E){if(this.#W.length===0)return E;return E.slice(this.#W.length+1)}#Y(E={}){let _={};if(E.limit!==void 0)_.limit=E.limit;if(E.reverse!==void 0)_.reverse=E.reverse;if(E.gt!==void 0)_.gt=this.#E(E.gt);if(E.gte!==void 0)_.gte=this.#E(E.gte);if(E.lt!==void 0)_.lt=this.#E(E.lt);if(E.lte!==void 0)_.lte=this.#E(E.lte);return _}#X(E){let _={};if(E.limit!==void 0)_.limit=E.limit;if(E.gt!==void 0)_.gt=this.#E(E.gt);if(E.gte!==void 0)_.gte=this.#E(E.gte);if(E.lt!==void 0)_.lt=this.#E(E.lt);if(E.lte!==void 0)_.lte=this.#E(E.lte);return _}capabilities(){return this.#_.capabilities()}scoped(E){return new H(this.#_,I(this.#W,E))}async get(E){return this.#_.get(this.#E(E))}async put(E,_){await this.#_.put(this.#E(E),_)}async delete(E){await this.#_.delete(this.#E(E))}async*scan(E,_){for await(let[W,Y]of this.#_.scan(this.#E(E),this.#Y(_)))yield[this.#F(W),Y]}async batch(E){await this.#_.batch(E.map((_)=>{if(_.type==="put")return{type:"put",key:this.#E(_.key),value:_.value};return{type:"delete",key:this.#E(_.key)}}))}async conditionalBatch(E,_){return z(this.#_,E.map((W)=>({key:this.#E(W.key),expectedValue:W.expectedValue})),_.map((W)=>{if(W.type==="put")return{type:"put",key:this.#E(W.key),value:W.value};return{type:"delete",key:this.#E(W.key)}}))}async has(E){return D(this.#_,this.#E(E))}async deletePrefix(E){return O(this.#_,this.#E(E))}async deleteRange(E,_){let W=this.#X(M(_));return v(this.#_,this.#E(E),W)}async*keys(E,_){for await(let W of T(this.#_,this.#E(E),this.#Y(_)))yield this.#F(W)}async count(E){return A(this.#_,this.#E(E))}[Symbol.dispose](){this.#_[Symbol.dispose]()}}});c();export{JE as scopedStorage,H as ScopedStorage};