@lostgradient/weft 0.2.0

package/dist/storage/sqlite-key-value-queries.d.ts

@@ -0,0 +1,40 @@
+import type { NormalizedDeleteRangeOptions } from './delete-range';
+import { type ScanOptions } from './interface';
+export declare const SQLITE_CREATE_KEY_VALUE_TABLE = "CREATE TABLE IF NOT EXISTS kv (\n  key TEXT PRIMARY KEY,\n  value BLOB NOT NULL\n) WITHOUT ROWID";
+export declare const SQLITE_SELECT_VALUE_BY_KEY = "SELECT value FROM kv WHERE key = ?";
+export declare const SQLITE_UPSERT_VALUE_BY_KEY = "INSERT INTO kv (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value";
+export declare const SQLITE_DELETE_VALUE_BY_KEY = "DELETE FROM kv WHERE key = ?";
+export declare const SQLITE_SELECT_KEY_PRESENCE = "SELECT 1 AS present FROM kv WHERE key = ? LIMIT 1";
+export declare const SQLITE_COUNT_KEYS_BY_PREFIX = "SELECT COUNT(*) AS count FROM kv WHERE key >= ? AND key < ?";
+export declare const SQLITE_DELETE_KEYS_BY_PREFIX = "DELETE FROM kv WHERE key >= ? AND key < ?";
+export type SqliteKeyRangeQueryParameter = string | number;
+export type SqliteKeyRangeQuery = {
+    parameters: SqliteKeyRangeQueryParameter[];
+    sqlSuffix: string;
+};
+/** A fully-built SQL statement and its bound parameters (SELECT or DELETE). */
+export type SqliteBuiltQuery = {
+    parameters: SqliteKeyRangeQueryParameter[];
+    sql: string;
+};
+export declare function buildSqlitePrefixRangeParameters(prefix: string): [string, string];
+export declare function buildSqliteKeyRangeQuery(prefix: string, options?: ScanOptions): SqliteKeyRangeQuery;
+/**
+ * Build a bounded-range `DELETE` for the `kv` table from already-validated
+ * delete options.
+ *
+ * Without `limit`, emits a plain `DELETE FROM kv WHERE <conditions>` — no
+ * ordering, since order is meaningless when deleting the whole matched range.
+ * With `limit`, emits a portable subquery form so the lowest (ascending) keys
+ * are deleted first: `DELETE FROM kv WHERE key IN (SELECT key FROM kv WHERE
+ * <conditions> ORDER BY key ASC LIMIT ?)`. The subquery avoids relying on
+ * `DELETE ... ORDER BY ... LIMIT`, which requires the
+ * `SQLITE_ENABLE_UPDATE_DELETE_LIMIT` compile flag and is not available on
+ * libSQL/Turso.
+ *
+ * Requires {@link NormalizedDeleteRangeOptions}: the type guarantees at least
+ * one bound is present, so this builder can never produce a whole-prefix wipe.
+ */
+export declare function buildSqliteKeyRangeDelete(prefix: string, options: NormalizedDeleteRangeOptions): SqliteBuiltQuery;
+export declare function buildSqliteKeyValueRangeSelect(prefix: string, options?: ScanOptions): SqliteBuiltQuery;
+export declare function buildSqliteKeyRangeSelect(prefix: string, options?: ScanOptions): SqliteBuiltQuery;

package/dist/storage/sqlite-key-value-queries.js

@@ -0,0 +1,64 @@
+import { resolvePrefixRangeEnd } from "./interface.js";
+export const SQLITE_CREATE_KEY_VALUE_TABLE = `CREATE TABLE IF NOT EXISTS kv (
+  key TEXT PRIMARY KEY,
+  value BLOB NOT NULL
+) WITHOUT ROWID`, SQLITE_SELECT_VALUE_BY_KEY = "SELECT value FROM kv WHERE key = ?", SQLITE_UPSERT_VALUE_BY_KEY = "INSERT INTO kv (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value", SQLITE_DELETE_VALUE_BY_KEY = "DELETE FROM kv WHERE key = ?", SQLITE_SELECT_KEY_PRESENCE = "SELECT 1 AS present FROM kv WHERE key = ? LIMIT 1", SQLITE_COUNT_KEYS_BY_PREFIX = "SELECT COUNT(*) AS count FROM kv WHERE key >= ? AND key < ?", SQLITE_DELETE_KEYS_BY_PREFIX = "DELETE FROM kv WHERE key >= ? AND key < ?";
+export function buildSqlitePrefixRangeParameters(prefix) {
+  return [prefix, resolvePrefixRangeEnd(prefix)];
+}
+function buildSqliteKeyRangeConditions(prefix, bounds) {
+  const { gt, gte, lt, lte } = bounds, conditions = ["key >= ? AND key < ?"], parameters = buildSqlitePrefixRangeParameters(prefix);
+  if (gt !== void 0) {
+    conditions.push("key > ?");
+    parameters.push(gt);
+  }
+  if (gte !== void 0) {
+    conditions.push("key >= ?");
+    parameters.push(gte);
+  }
+  if (lt !== void 0) {
+    conditions.push("key < ?");
+    parameters.push(lt);
+  }
+  if (lte !== void 0) {
+    conditions.push("key <= ?");
+    parameters.push(lte);
+  }
+  return { conditions, parameters };
+}
+export function buildSqliteKeyRangeQuery(prefix, options = {}) {
+  const { limit, reverse } = options, { conditions, parameters } = buildSqliteKeyRangeConditions(prefix, options), direction = reverse ? "DESC" : "ASC", limitClause = limit !== void 0 ? " LIMIT ?" : "";
+  if (limit !== void 0)
+    parameters.push(limit);
+  return {
+    parameters,
+    sqlSuffix: `WHERE ${conditions.join(" AND ")} ORDER BY key ${direction}${limitClause}`
+  };
+}
+export function buildSqliteKeyRangeDelete(prefix, options) {
+  const { conditions, parameters } = buildSqliteKeyRangeConditions(prefix, options), whereClause = conditions.join(" AND ");
+  if (options.limit === void 0)
+    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 ?)`
+  };
+}
+export function buildSqliteKeyValueRangeSelect(prefix, options = {}) {
+  const { parameters, sqlSuffix } = buildSqliteKeyRangeQuery(prefix, options);
+  return {
+    parameters,
+    sql: `SELECT key, value FROM kv ${sqlSuffix}`
+  };
+}
+export function buildSqliteKeyRangeSelect(prefix, options = {}) {
+  const { parameters, sqlSuffix } = buildSqliteKeyRangeQuery(prefix, options);
+  return {
+    parameters,
+    sql: `SELECT key FROM kv ${sqlSuffix}`
+  };
+}

package/dist/storage/sqlite.d.ts

@@ -0,0 +1,31 @@
+import type { BunSQLiteStorage } from './bun-sql.ts';
+import type { NodeSQLiteStorage } from './node-sqlite.ts';
+/**
+ * Runtime-specific SQLite storage instance resolved from `@lostgradient/weft/storage/sqlite`.
+ *
+ * @example
+ * ```ts
+ * import { SQLiteStorage, type SQLiteStorageInstance } from '@lostgradient/weft/storage/sqlite';
+ *
+ * const storage: SQLiteStorageInstance = new SQLiteStorage('./weft.db');
+ * void storage;
+ * ```
+ */
+export type SQLiteStorageInstance = BunSQLiteStorage | NodeSQLiteStorage;
+/**
+ * Runtime-neutral SQLite storage constructor.
+ *
+ * The `@lostgradient/weft/storage/sqlite` package export resolves this symbol to
+ * `BunSQLiteStorage` under Bun and `NodeSQLiteStorage` under Node.js.
+ *
+ * @example
+ * ```ts
+ * import { SQLiteStorage } from '@lostgradient/weft/storage/sqlite';
+ *
+ * await using storage = new SQLiteStorage('./weft.db');
+ * void storage;
+ * ```
+ */
+export declare const SQLiteStorage: {
+    new (path?: string): SQLiteStorageInstance;
+};

package/dist/storage/text-value-import.d.ts

@@ -0,0 +1,87 @@
+import { type Storage } from './interface.ts';
+/**
+ * A string-valued key/value row from an existing application store.
+ *
+ * The importer treats both fields as application data: `key` becomes the
+ * unencoded suffix under the optional target prefix, and `value` is encoded
+ * as UTF-8 bytes before writing to Weft storage.
+ *
+ * @example
+ * ```ts
+ * import { type TextKeyValueRow } from '@lostgradient/weft/storage';
+ *
+ * const row: TextKeyValueRow = {
+ *   key: 'session:1',
+ *   value: '{"status":"open"}',
+ * };
+ * console.log(row.key); // 'session:1'
+ * ```
+ */
+export type TextKeyValueRow = {
+    key: string;
+    value: string;
+};
+/**
+ * Options for {@link copyTextKeyValueRowsToStorage}.
+ *
+ * @example
+ * ```ts
+ * import { MemoryStorage, type CopyTextKeyValueRowsToStorageOptions } from '@lostgradient/weft/storage';
+ *
+ * await using storage = new MemoryStorage();
+ * const options: CopyTextKeyValueRowsToStorageOptions = {
+ *   storage,
+ *   targetPrefix: 'app:my-service',
+ *   rows: [{ key: 'session:1', value: 'active' }],
+ * };
+ * console.log(options.targetPrefix); // 'app:my-service'
+ * ```
+ */
+export type CopyTextKeyValueRowsToStorageOptions = {
+    /** Destination Weft storage that receives UTF-8 encoded values. */
+    storage: Storage;
+    /** Source rows from a string-valued key/value store. */
+    rows: Iterable<TextKeyValueRow> | AsyncIterable<TextKeyValueRow>;
+    /**
+     * Optional application namespace applied before each source key. A value like
+     * `app:my-service` writes source key `session:1` to
+     * `app:my-service:session:1`.
+     */
+    targetPrefix?: string;
+};
+/**
+ * Result returned by {@link copyTextKeyValueRowsToStorage}.
+ *
+ * @example
+ * ```ts
+ * import { type CopyTextKeyValueRowsToStorageResult } from '@lostgradient/weft/storage';
+ *
+ * const result: CopyTextKeyValueRowsToStorageResult = { copied: 3 };
+ * console.log(result.copied); // 3
+ * ```
+ */
+export type CopyTextKeyValueRowsToStorageResult = {
+    /** Number of rows copied into the target storage. */
+    copied: number;
+};
+/**
+ * Copy string-valued key/value rows into a Weft byte-oriented storage backend.
+ *
+ * This helper is for one-time imports from application stores that already hold
+ * text values. It encodes values as UTF-8 bytes, optionally prefixes target
+ * keys, and refuses to overwrite existing target keys.
+ *
+ * @example
+ * ```ts
+ * import { MemoryStorage, copyTextKeyValueRowsToStorage } from '@lostgradient/weft/storage';
+ *
+ * await using storage = new MemoryStorage();
+ * const result = await copyTextKeyValueRowsToStorage({
+ *   storage,
+ *   targetPrefix: 'app:my-service',
+ *   rows: [{ key: 'session:1', value: 'active' }],
+ * });
+ * console.log(result.copied); // 1
+ * ```
+ */
+export declare function copyTextKeyValueRowsToStorage(options: CopyTextKeyValueRowsToStorageOptions): Promise<CopyTextKeyValueRowsToStorageResult>;

package/dist/storage/text-value-import.js

@@ -0,0 +1,50 @@
+import {
+  WEFT_RESERVED_KEY_PREFIXES,
+  storageConditionalBatch,
+  storageHas
+} from "./interface.js";
+const textEncoder = new TextEncoder;
+function normalizeTargetPrefix(prefix) {
+  return prefix?.replaceAll(/:+$/g, "") ?? "";
+}
+function toTargetKey(prefix, key) {
+  if (prefix.length === 0)
+    return key;
+  return key.length === 0 ? `${prefix}:` : `${prefix}:${key}`;
+}
+async function collectRows(rows, targetPrefix) {
+  const collected = [], seenTargetKeys = new Set;
+  for await (const row of rows) {
+    if (typeof row.key !== "string")
+      throw TypeError("Text key-value import rows must have string keys.");
+    if (typeof row.value !== "string")
+      throw TypeError("Text key-value import rows must have string values.");
+    const targetKey = toTargetKey(targetPrefix, row.key);
+    if (WEFT_RESERVED_KEY_PREFIXES.some((prefix) => targetKey.startsWith(prefix)))
+      throw Error(`Text key-value import target key "${targetKey}" uses a Weft-reserved key prefix.`);
+    if (seenTargetKeys.has(targetKey))
+      throw Error(`Text key-value import source produced duplicate target key "${targetKey}".`);
+    seenTargetKeys.add(targetKey);
+    collected.push({ ...row, targetKey });
+  }
+  return collected;
+}
+export async function copyTextKeyValueRowsToStorage(options) {
+  const targetPrefix = normalizeTargetPrefix(options.targetPrefix), rows = await collectRows(options.rows, targetPrefix);
+  if (rows.length === 0)
+    return { copied: 0 };
+  for (const row of rows)
+    if (await storageHas(options.storage, row.targetKey))
+      throw Error(`Target storage already contains key "${row.targetKey}".`);
+  const conditions = rows.map((row) => ({
+    key: row.targetKey,
+    expectedValue: null
+  })), operations = rows.map((row) => ({
+    type: "put",
+    key: row.targetKey,
+    value: textEncoder.encode(row.value)
+  }));
+  if (!await storageConditionalBatch(options.storage, conditions, operations))
+    throw Error("Target storage changed before import could commit.");
+  return { copied: rows.length };
+}

package/dist/storage/text-value-store.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Text-value compatibility wrapper.
+ *
+ * Adapts Weft's `Uint8Array`-keyed {@link Storage} to a generic
+ * string-valued key/value interface with an array-returning prefix
+ * list. The shape is what downstream consumers that expect a string
+ * `KeyValueStore` typically require. The wrapper lives in Weft so
+ * that adopting Weft storage does not require any runtime dependency
+ * on those consumers.
+ *
+ * Encoding is UTF-8 with fatal decoding: invalid byte sequences raise
+ * `TypeError` rather than silently producing replacement characters,
+ * so a string consumer never sees corrupted data masquerading as
+ * valid text.
+ *
+ * @module @lostgradient/weft/storage/text-value-store
+ */
+import { type Storage } from './interface';
+/**
+ * Options for {@link textValueStore}.
+ *
+ * @example
+ * ```ts
+ * import { type TextValueStoreOptions } from '@lostgradient/weft/storage';
+ *
+ * const options: TextValueStoreOptions = {
+ *   disposeUnderlyingStorage: false,
+ * };
+ * console.log(options.disposeUnderlyingStorage); // false
+ * ```
+ */
+export type TextValueStoreOptions = {
+    /**
+     * Whether `close()` disposes the wrapped storage. Defaults to `true` so the
+     * existing owning-wrapper behavior is preserved. Set `false` when the same
+     * storage instance is shared by the Weft engine and application state.
+     */
+    disposeUnderlyingStorage?: boolean;
+};
+/**
+ * Text compare-and-swap precondition used by
+ * {@link ConditionalTextValueStore.conditionalBatch}.
+ *
+ * @example
+ * ```ts
+ * import { type TextValueStoreCondition } from '@lostgradient/weft/storage';
+ *
+ * const condition: TextValueStoreCondition = {
+ *   key: 'api-key:1:last-used-at',
+ *   expectedValue: '2026-06-01T00:00:00.000Z',
+ * };
+ * console.log(condition.key); // 'api-key:1:last-used-at'
+ * ```
+ */
+export type TextValueStoreCondition = {
+    /** Key whose current text value must match `expectedValue`. */
+    key: string;
+    /** Required current value, or `null` to require the key to be absent. */
+    expectedValue: string | null;
+};
+/**
+ * Text mutation applied by {@link ConditionalTextValueStore.conditionalBatch}.
+ *
+ * `set` and `put` are synonyms so callers can use the naming convention of
+ * their string store while Weft still delegates to raw storage `put`.
+ *
+ * @example
+ * ```ts
+ * import { type TextValueStoreBatchOperation } from '@lostgradient/weft/storage';
+ *
+ * const operation: TextValueStoreBatchOperation = {
+ *   type: 'set',
+ *   key: 'session:1',
+ *   value: 'active',
+ * };
+ * console.log(operation.type); // 'set'
+ * ```
+ */
+export type TextValueStoreBatchOperation = {
+    type: 'set';
+    key: string;
+    value: string;
+} | {
+    type: 'put';
+    key: string;
+    value: string;
+} | {
+    type: 'delete';
+    key: string;
+};
+/**
+ * String-valued key/value store layered on top of a Weft {@link Storage}.
+ *
+ * Matches the structural shape downstream consumers commonly require
+ * from a string `KeyValueStore` backend: `get`/`set`/`delete` over
+ * UTF-8 text, a `list(prefix)` that materializes keys into an array,
+ * and optional `has`, `deletePrefix`, and `close` helpers.
+ *
+ * @example
+ * ```ts
+ * import { MemoryStorage } from '@lostgradient/weft';
+ * import { textValueStore, type TextValueStore } from '@lostgradient/weft/storage/text-value-store';
+ *
+ * await using base = new MemoryStorage();
+ * const store: TextValueStore = textValueStore(base);
+ * await store.set('greeting', 'hello');
+ * console.log(await store.get('greeting')); // 'hello'
+ * ```
+ */
+export type TextValueStore = {
+    /** Read the UTF-8 text stored at `key`, or `null` if absent. */
+    get(key: string): Promise<string | null>;
+    /** Write `value` as UTF-8 bytes at `key`. */
+    set(key: string, value: string): Promise<void>;
+    /** Delete `key`. No-op when absent. */
+    delete(key: string): Promise<void>;
+    /**
+     * Materialize every key matching `prefix` into a stable array.
+     * The array reflects the underlying storage's natural scan order.
+     * For very large prefixes prefer streaming via the underlying
+     * `Storage` directly.
+     */
+    list(prefix: string): Promise<string[]>;
+    /** Check whether `key` exists. */
+    has(key: string): Promise<boolean>;
+    /** Delete every key under `prefix`. Returns the number deleted. */
+    deletePrefix(prefix: string): Promise<number>;
+    /** Close the wrapper, disposing the underlying storage unless configured otherwise. */
+    close(): Promise<void>;
+};
+/**
+ * Text store returned by {@link textValueStore}. It keeps the base
+ * {@link TextValueStore} shape source-compatible for external implementations
+ * while exposing compare-and-swap on Weft's wrapper.
+ *
+ * @example
+ * ```ts
+ * import { MemoryStorage } from '@lostgradient/weft/storage';
+ * import { type ConditionalTextValueStore, textValueStore } from '@lostgradient/weft/storage/text-value-store';
+ *
+ * await using storage = new MemoryStorage();
+ * const store: ConditionalTextValueStore = textValueStore(storage);
+ * const committed = await store.conditionalBatch(
+ *   [{ key: 'session:1', expectedValue: null }],
+ *   [{ type: 'set', key: 'session:1', value: 'open' }],
+ * );
+ * console.log(committed); // true
+ * ```
+ */
+export type ConditionalTextValueStore = TextValueStore & {
+    /** Apply a compare-and-swap batch over UTF-8 text values. */
+    conditionalBatch(conditions: TextValueStoreCondition[], operations: TextValueStoreBatchOperation[]): Promise<boolean>;
+};
+/**
+ * Wrap a Weft {@link Storage} so it satisfies the {@link TextValueStore}
+ * shape. The wrapper holds no state of its own — every call delegates
+ * to `storage` after UTF-8 encoding or decoding.
+ *
+ * @example
+ * ```ts
+ * import { MemoryStorage } from '@lostgradient/weft';
+ * import { textValueStore } from '@lostgradient/weft/storage/text-value-store';
+ *
+ * await using base = new MemoryStorage();
+ * const store = textValueStore(base);
+ * await store.set('greeting', 'hello 🌍');
+ * console.log(await store.get('greeting')); // 'hello 🌍'
+ * console.log(await store.list(''));         // ['greeting']
+ * ```
+ */
+export declare function textValueStore(storage: Storage, options?: TextValueStoreOptions): ConditionalTextValueStore;

package/dist/storage/text-value-store.js

@@ -0,0 +1,55 @@
+import {
+  storageConditionalBatch,
+  storageDeletePrefix,
+  storageHas,
+  storageKeys
+} from "./interface.js";
+const textEncoder = new TextEncoder, textDecoder = new TextDecoder("utf-8", { fatal: !0, ignoreBOM: !0 });
+export function textValueStore(storage, options = {}) {
+  const disposeUnderlyingStorage = options.disposeUnderlyingStorage ?? !0, encodeCondition = (condition) => ({
+    key: condition.key,
+    expectedValue: condition.expectedValue === null ? null : textEncoder.encode(condition.expectedValue)
+  }), encodeOperation = (operation) => {
+    if (operation.type === "delete")
+      return operation;
+    return {
+      type: "put",
+      key: operation.key,
+      value: textEncoder.encode(operation.value)
+    };
+  };
+  return {
+    async get(key) {
+      const bytes = await storage.get(key);
+      if (bytes === null)
+        return null;
+      return textDecoder.decode(bytes);
+    },
+    async set(key, value) {
+      await storage.put(key, textEncoder.encode(value));
+    },
+    async delete(key) {
+      await storage.delete(key);
+    },
+    async list(prefix) {
+      const keys = [];
+      for await (const key of storageKeys(storage, prefix))
+        keys.push(key);
+      return keys;
+    },
+    async has(key) {
+      return storageHas(storage, key);
+    },
+    async deletePrefix(prefix) {
+      return storageDeletePrefix(storage, prefix);
+    },
+    async conditionalBatch(conditions, operations) {
+      return storageConditionalBatch(storage, conditions.map(encodeCondition), operations.map(encodeOperation));
+    },
+    async close() {
+      if (!disposeUnderlyingStorage)
+        return;
+      storage[Symbol.dispose]();
+    }
+  };
+}

package/dist/storage/turso.d.ts

@@ -0,0 +1,60 @@
+import { type DeleteRangeOptions } from './delete-range';
+import { type BatchOperation, type ConditionalBatchCondition, type ScanOptions, type Storage, type StorageCapabilities } from './interface';
+/**
+ * Configuration for connecting to a Turso/libSQL database.
+ *
+ * @example
+ * ```ts
+ * import { TursoStorage, type TursoStorageOptions } from '@lostgradient/weft/storage/turso';
+ *
+ * const options: TursoStorageOptions = {
+ *   url: 'file:local.db',
+ * };
+ * await using storage = new TursoStorage(options);
+ * ```
+ */
+export type TursoStorageOptions = {
+    /** The database URL (e.g., `libsql://your-db.turso.io`, `file:local.db`, `file::memory:`). */
+    url: string;
+    /** Authentication token for remote Turso databases. */
+    authToken?: string;
+};
+/**
+ * Storage adapter backed by Turso/libSQL for distributed SQLite deployments.
+ *
+ * Implements the same `Storage` interface as `BunSQLiteStorage`, but uses `@libsql/client`
+ * so the database can be a remote Turso instance or a local file.
+ * Switch from `BunSQLiteStorage` to `TursoStorage` by changing the connection string —
+ * the rest of the application stays the same.
+ *
+ * @example
+ * ```ts
+ * import { TursoStorage } from '@lostgradient/weft/storage/turso';
+ * import { Engine } from '@lostgradient/weft';
+ *
+ * await using storage = new TursoStorage({
+ *   url: 'libsql://my-db.turso.io',
+ * ...(process.env['TURSO_AUTH_TOKEN'] ? { authToken: process.env['TURSO_AUTH_TOKEN'] } : {}),
+ * });
+ * await using engine = new Engine({ storage });
+ * ```
+ */
+export declare class TursoStorage implements Storage {
+    #private;
+    constructor(options: TursoStorageOptions);
+    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]>;
+    keys(prefix: string, options?: ScanOptions): AsyncIterable<string>;
+    count(prefix: string): Promise<number>;
+    scoped(prefix: string): Storage;
+    batch(operations: BatchOperation[]): Promise<void>;
+    conditionalBatch(conditions: ConditionalBatchCondition[], operations: BatchOperation[]): Promise<boolean>;
+    query<T>(sql: string, parameters?: unknown[]): Promise<T[]>;
+    [Symbol.dispose](): void;
+}

package/dist/storage/turso.js

@@ -0,0 +1,5 @@
+// @bun
+var WW=Object.defineProperty;var FW=(W)=>W;function XW(W,F){this[W]=FW.bind(null,F)}var AW=(W,F)=>{for(var X in F)WW(W,X,{get:F[X],enumerable:!0,configurable:!0,set:XW.bind(F,X)})};var U=(W,F)=>()=>(W&&(F=W(W=0)),F);function O(W,F,X){if(!W.capabilities()[F])throw Error(`Feature "${X}" requires storage capability "${F}", but this storage backend does not provide it.`)}function JW(W){let F=W.capabilities(),X=[];if(F.persistence!=="local")X.push(`persistence must be "local" (got "${F.persistence}")`);if(F.readAfterWrite!=="linearizable")X.push(`readAfterWrite must be "linearizable" (got "${F.readAfterWrite}")`);if(F.scanConsistency!=="snapshot")X.push(`scanConsistency must be "snapshot" (got "${F.scanConsistency}")`);if(!F.atomicBatch)X.push("atomicBatch must be true");if(!F.conditionalBatch)X.push("conditionalBatch must be true");if(X.length>0)throw Error(`Storage is not durable enough for recovery: ${X.join("; ")}.`)}var _="default";async function E(W,F){return await W.get(F)!==null}async function*Y(W,F,X){for await(let[Z]of W.scan(F,X))yield Z}async function v(W,F){let X=0;for await(let Z of Y(W,F))X++;return X}async function h(W,F){let X=[];for await(let Z of Y(W,F))X.push({type:"delete",key:Z});if(X.length===0)return 0;return await W.batch(X),X.length}async function T(W,F,X){let Z=[];for await(let $ of Y(W,F,X))Z.push({type:"delete",key:$});if(Z.length===0)return 0;return await W.batch(Z),Z.length}var ZW;var b=U(()=>{ZW=["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 C(W){return W.length>0?W.slice(0,-1)+String.fromCharCode(W.charCodeAt(W.length-1)+1):"\xFF"}function CW(W,F={}){if(F.gt!==void 0&&W<=F.gt)return!1;if(F.gte!==void 0&&W<F.gte)return!1;if(F.lt!==void 0&&W>=F.lt)return!1;if(F.lte!==void 0&&W>F.lte)return!1;return!0}function K(W,F){if(W===null||F===null)return W===F;if(W.byteLength!==F.byteLength)return!1;for(let X=0;X<W.byteLength;X++)if(W[X]!==F[X])return!1;return!0}async function x(W,F){if(W.has)return W.has(F);return E(W,F)}function I(W,F,X){if(W.keys)return W.keys(F,X);return Y(W,F,X)}async function u(W,F){if(W.count)return W.count(F);return v(W,F)}async function S(W,F){if(W.deletePrefix)return W.deletePrefix(F);return h(W,F)}async function k(W,F,X){if(O(W,"conditionalBatch","storageConditionalBatch"),!W.conditionalBatch)throw Error("This storage backend reports conditionalBatch capability but does not implement the conditionalBatch() method.");return W.conditionalBatch(F,X)}function J(W){return encodeURIComponent(W)}function KW(W){return decodeURIComponent(W)}function xW(W){try{return decodeURIComponent(W)}catch{return null}}var G=(W)=>String(W).padStart(16,"0"),IW;var V=U(()=>{b();IW={workflow:(W)=>`wf:${J(W)}`,checkpoint:(W)=>`wf:${J(W)}:ckpt`,checkpointHistory:(W,F)=>`wf:${J(W)}:ckpt:${String(F).padStart(10,"0")}`,timelinePrefix:(W)=>`wf:${J(W)}:timeline:`,timeline:(W,F)=>`wf:${J(W)}:timeline:${String(F).padStart(10,"0")}`,schedule:(W)=>`schedule:${J(W)}`,scheduleTick:(W,F)=>`schedule-due:${String(W).padStart(16,"0")}:${J(F)}`,scheduleRun:(W)=>`schedule-run:${J(W)}`,operation:(W,F,X)=>`op:${W}:${G(F)}:${X}`,operationInflight:(W)=>`op:inflight:${W}`,operationQueued:(W)=>`op:queued:${W}`,operationResolved:(W)=>`op:resolved:${W}`,bulkOperationAuditPrefix:()=>"audit:bulk:",bulkOperationAudit:(W,F,X)=>`audit:bulk:${G(W)}:${J(F)}:${J(X)}`,operationResolvedByTimePrefix:()=>"op:resolved-by-time:",operationResolvedByTime:(W,F)=>`op:resolved-by-time:${G(W)}:${J(F)}`,asyncActivity:(W,F)=>`async-act:v1:${J(W)}:${J(F)}`,activityReconciliationPrefix:(W)=>`actrec:v1:${J(W)}:`,activityReconciliation:(W,F,X)=>`actrec:v1:${J(W)}:${J(F)}:${X}`,eventPrefix:(W)=>`ev:${J(W)}:`,event:(W,F)=>`ev:${J(W)}:${String(F).padStart(10,"0")}`,eventHead:(W)=>`ev:${J(W)}:head`,eventWatermark:(W)=>`ev:${J(W)}:watermark`,signal:(W,F,X)=>`sig:${J(W)}:${F}:${J(X)}`,signalSequence:(W)=>`sigseq:v1:${J(W)}`,signalAcceptedResponsePrefix:(W)=>`sigres:v1:${J(W)}:`,signalAcceptedResponse:(W,F,X)=>`sigres:v1:${J(W)}:${J(F)}:${J(X)}`,deadline:(W,F)=>`wf-deadline:${G(W)}:${J(F)}`,terminalCleanup:(W,F)=>`wf-cleanup:${G(W)}:${J(F)}`,delayedStart:(W,F)=>`wf-delayed:${G(W)}:${J(F)}`,terminalWorkflowPrefix:()=>"wf-terminal:",terminalWorkflow:(W,F)=>`wf-terminal:${G(W)}:${J(F)}`,attribute:(W)=>`attr:${J(W)}`,attributeIndex:(W,F,X)=>`idx:${W}:${F}:${J(X)}`,tagIndex:(W,F)=>`tag:${J(W)}:${J(F)}`,updatePrefix:(W)=>`upd:${J(W)}:`,update:(W,F)=>`upd:${J(W)}:${F}`,updateResponse:(W)=>`upr:${W}`,updateIdempotency:(W,F)=>`upk:${J(W)}:${F}`,budget:(W,F,X)=>`budget:${W}:${F}:${X}`,review:(W,F)=>`review:${J(W)}:${F}`,workflowHeaders:(W)=>`wf-headers:${J(W)}`,terminalCleanupNeeded:(W)=>`wf-cleanup-needed:${J(W)}`,offload:(W,F)=>`offload:${J(W)}:${F}`,archive:(W,F)=>`archive:${J(W)}:${F}`,stateExecution:(W,F)=>`state:execution:${J(W)}:${J(F)}`,stateWorkflow:(W,F)=>`state:workflow-scope:${_}:${J(W)}:${J(F)}`,streamChunkPrefix:(W,F)=>`blob:${J(W)}:${F}:chunk:`,streamChunk:(W,F,X)=>`blob:${J(W)}:${F}:chunk:${String(X).padStart(10,"0")}`,streamMetadata:(W,F)=>`blob:${J(W)}:${F}:meta`,budgetCharged:(W)=>`budget-charged:${W}`,toolEffect:(W,F,X)=>`tool-effect:${J(W)}:${F}:${X}`,workflowVisibilityStatus:(W,F)=>`wf-idx-status:${J(W)}:${J(F)}`,workflowVisibilityType:(W,F)=>`wf-idx-type:${J(W)}:${J(F)}`,workflowVisibilityCreated:(W,F)=>`wf-idx-created:${G(W)}:${J(F)}`,workflowVisibilityUpdated:(W,F)=>`wf-idx-updated:${G(W)}:${J(F)}`,workflowVisibilityDeadline:(W,F)=>`wf-idx-deadline:${G(W)}:${J(F)}`,workflowVisibilityManifest:(W)=>`wf-idx-manifest:${J(W)}`,workflowVisibilityMetaVersion:()=>"wf-idx-meta:version",workflowVisibilityMetaBuiltAt:()=>"wf-idx-meta:built-at",workflowVisibilityMetaCursor:()=>"wf-idx-meta:cursor"}});function $W(W){if(W===void 0)return;if(typeof W!=="number"||!Number.isInteger(W)||W<0)throw Error("deleteRange limit must be a finite non-negative integer");return W===0?0:W}function Q(W){let F={},X=!1;for(let $ of["gt","gte","lt","lte"]){let j=W[$];if(j===void 0)continue;if(typeof j!=="string")throw Error("deleteRange bounds must be strings");F[$]=j,X=!0}if(!X)throw Error("deleteRange requires at least one of gt/gte/lt/lte; use deletePrefix to delete a whole prefix");let Z=$W(W.limit);if(Z!==void 0)F.limit=Z;return F}async function w(W,F,X){let Z=Q(X);if(W.deleteRange)return W.deleteRange(F,Z);return T(W,F,Z)}var z=()=>{};function A(W){return W.replaceAll(/:+$/g,"")}function jW(W,F){let X=A(W),Z=A(F);if(X.length===0)return Z;if(Z.length===0)return X;return`${X}:${Z}`}function y(W,F){return new P(W,F)}var P;var c=U(()=>{z();V();P=class P{#W;#J;constructor(W,F){this.#W=W,this.#J=A(F)}#F(W){if(this.#J.length===0)return W;return W.length===0?`${this.#J}:`:`${this.#J}:${W}`}#X(W){if(this.#J.length===0)return W;return W.slice(this.#J.length+1)}#Z(W={}){let F={};if(W.limit!==void 0)F.limit=W.limit;if(W.reverse!==void 0)F.reverse=W.reverse;if(W.gt!==void 0)F.gt=this.#F(W.gt);if(W.gte!==void 0)F.gte=this.#F(W.gte);if(W.lt!==void 0)F.lt=this.#F(W.lt);if(W.lte!==void 0)F.lte=this.#F(W.lte);return F}#$(W){let F={};if(W.limit!==void 0)F.limit=W.limit;if(W.gt!==void 0)F.gt=this.#F(W.gt);if(W.gte!==void 0)F.gte=this.#F(W.gte);if(W.lt!==void 0)F.lt=this.#F(W.lt);if(W.lte!==void 0)F.lte=this.#F(W.lte);return F}capabilities(){return this.#W.capabilities()}scoped(W){return new P(this.#W,jW(this.#J,W))}async get(W){return this.#W.get(this.#F(W))}async put(W,F){await this.#W.put(this.#F(W),F)}async delete(W){await this.#W.delete(this.#F(W))}async*scan(W,F){for await(let[X,Z]of this.#W.scan(this.#F(W),this.#Z(F)))yield[this.#X(X),Z]}async batch(W){await this.#W.batch(W.map((F)=>{if(F.type==="put")return{type:"put",key:this.#F(F.key),value:F.value};return{type:"delete",key:this.#F(F.key)}}))}async conditionalBatch(W,F){return k(this.#W,W.map((X)=>({key:this.#F(X.key),expectedValue:X.expectedValue})),F.map((X)=>{if(X.type==="put")return{type:"put",key:this.#F(X.key),value:X.value};return{type:"delete",key:this.#F(X.key)}}))}async has(W){return x(this.#W,this.#F(W))}async deletePrefix(W){return S(this.#W,this.#F(W))}async deleteRange(W,F){let X=this.#$(Q(F));return w(this.#W,this.#F(W),X)}async*keys(W,F){for await(let X of I(this.#W,this.#F(W),this.#Z(F)))yield this.#X(X)}async count(W){return u(this.#W,this.#F(W))}[Symbol.dispose](){this.#W[Symbol.dispose]()}}});function UW(W){return W.trim().replace(/;+\s*$/u,"").trim()}function NW(W){return HW.test(W)}function m(W){let F=UW(W);if(F.length===0)throw Error("Storage query must not be empty.");if(F.includes(";"))throw Error("Storage query must contain exactly one read-only statement.");if(MW.test(F))return;if(GW.test(F)&&NW(F))return;throw Error("Storage query only supports read-only SELECT and PRAGMA statements.")}var GW,HW,MW;var f=U(()=>{GW=/^PRAGMA\b/iu,HW=/^PRAGMA\s+(?:[A-Z_][A-Z0-9_]*\.)?[A-Z_][A-Z0-9_]*\s*$/iu,MW=/^SELECT\b/iu});function R(W){return[W,C(W)]}function s(W,F){let{gt:X,gte:Z,lt:$,lte:j}=F,H=["key >= ? AND key < ?"],M=R(W);if(X!==void 0)H.push("key > ?"),M.push(X);if(Z!==void 0)H.push("key >= ?"),M.push(Z);if($!==void 0)H.push("key < ?"),M.push($);if(j!==void 0)H.push("key <= ?"),M.push(j);return{conditions:H,parameters:M}}function a(W,F={}){let{limit:X,reverse:Z}=F,{conditions:$,parameters:j}=s(W,F),H=Z?"DESC":"ASC",M=X!==void 0?" LIMIT ?":"";if(X!==void 0)j.push(X);return{parameters:j,sqlSuffix:`WHERE ${$.join(" AND ")} ORDER BY key ${H}${M}`}}function i(W,F){let{conditions:X,parameters:Z}=s(W,F),$=X.join(" AND ");if(F.limit===void 0)return{parameters:Z,sql:`DELETE FROM kv WHERE ${$}`};return Z.push(F.limit),{parameters:Z,sql:`DELETE FROM kv WHERE key IN (SELECT key FROM kv WHERE ${$} ORDER BY key ASC LIMIT ?)`}}function r(W,F={}){let{parameters:X,sqlSuffix:Z}=a(W,F);return{parameters:X,sql:`SELECT key, value FROM kv ${Z}`}}function n(W,F={}){let{parameters:X,sqlSuffix:Z}=a(W,F);return{parameters:X,sql:`SELECT key FROM kv ${Z}`}}var g=`CREATE TABLE IF NOT EXISTS kv (
+  key TEXT PRIMARY KEY,
+  value BLOB NOT NULL
+) WITHOUT ROWID`,L="SELECT value FROM kv WHERE key = ?",D="INSERT INTO kv (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value",B="DELETE FROM kv WHERE key = ?",d="SELECT 1 AS present FROM kv WHERE key = ? LIMIT 1",l="SELECT COUNT(*) AS count FROM kv WHERE key >= ? AND key < ?",p="DELETE FROM kv WHERE key >= ? AND key < ?";var t=U(()=>{V()});z();V();f();c();t();import{createClient as YW}from"@libsql/client";var o=`${g};`;function q(W){return typeof W==="object"&&W!==null&&"code"in W&&W.code==="SQLITE_BUSY"}async function QW(W){return W.transaction("write").catch((F)=>{if(q(F))return null;throw F})}async function VW(W){try{await W.rollback()}catch{}}async function DW(W){await new Promise((F)=>{setTimeout(F,Math.min(W*5,50))})}async function BW(W,F){for(let Z=1;Z<=10;Z++)try{await W.batch(F,"write");return}catch($){if(!q($)||Z===10)throw $;await DW(Z)}}async function RW(W,F){for(let X of F){let $=(await W.execute({sql:L,args:[X.key]})).rows[0]?.value,j=$===null||$===void 0?null:new Uint8Array($);if(!K(j,X.expectedValue))return!1}return!0}async function OW(W,F){for(let X of F)if(X.type==="put")await W.execute({sql:D,args:[X.key,X.value]});else await W.execute({sql:B,args:[X.key]})}function _W(W){if(W==="file::memory:"||W===":memory:")return"ephemeral";if(W.startsWith("file:"))return"local";return"remote"}class zW{#W;#J;#F=!1;constructor(W){this.#J=_W(W.url),this.#W=YW(W.authToken?{url:W.url,authToken:W.authToken}:{url:W.url})}capabilities(){return{persistence:this.#J,readAfterWrite:"session",scanConsistency:"snapshot",atomicBatch:!0,conditionalBatch:!0,boundedRangeDelete:!0}}async#X(){if(this.#F)return;await this.#W.executeMultiple(o),this.#F=!0}async get(W){await this.#X();let F=await this.#W.execute({sql:L,args:[W]});if(F.rows.length===0)return null;let X=F.rows[0].value;if(X===null||X===void 0)return null;return new Uint8Array(X)}async put(W,F){await this.#X(),await this.#W.execute({sql:D,args:[W,F]})}async delete(W){await this.#X(),await this.#W.execute({sql:B,args:[W]})}async has(W){return await this.#X(),(await this.#W.execute({sql:d,args:[W]})).rows.length>0}async deletePrefix(W){await this.#X();let[F,X]=R(W);return(await this.#W.execute({sql:p,args:[F,X]})).rowsAffected}async deleteRange(W,F){await this.#X();let X=Q(F),{parameters:Z,sql:$}=i(W,X);return(await this.#W.execute({sql:$,args:Z})).rowsAffected}async*scan(W,F={}){await this.#X();let{parameters:X,sql:Z}=r(W,F),$=await this.#W.execute({sql:Z,args:X});for(let j of $.rows){let{key:H,value:M}=j,e=new Uint8Array(M);yield[H,e]}}async*keys(W,F={}){await this.#X();let{parameters:X,sql:Z}=n(W,F),$=await this.#W.execute({sql:Z,args:X});for(let j of $.rows)yield j.key}async count(W){await this.#X();let[F,X]=R(W),Z=await this.#W.execute({sql:l,args:[F,X]});return Number(Z.rows[0]?.count??0)}scoped(W){return y(this,W)}async batch(W){if(W.length===0)return;await this.#X();let F=W.map((X)=>{if(X.type==="put")return{sql:D,args:[X.key,X.value]};return{sql:B,args:[X.key]}});await BW(this.#W,F)}async conditionalBatch(W,F){await this.#X();let X=await QW(this.#W);if(X===null)return!1;try{if(await X.executeMultiple(o),!await RW(X,W))return await X.rollback(),!1;return await OW(X,F),await X.commit(),!0}catch(Z){if(await VW(X),q(Z))return!1;throw Z}}async query(W,F){return await this.#X(),m(W),(await this.#W.execute({sql:W,args:F??[]})).rows}[Symbol.dispose](){this.#W.close()}}export{zW as TursoStorage};