@lostgradient/weft 0.2.0

package/dist/storage/capabilities.d.ts

@@ -0,0 +1,187 @@
+/**
+ * Storage consistency/feature capability types and the runtime gate that acts
+ * on them. Split out from `interface.ts` to keep that module focused. The
+ * `Storage` interface lives in `interface.ts` and imports these types; this
+ * module imports `Storage` type-only, so there is no runtime import cycle.
+ *
+ * @module storage/capabilities
+ */
+import type { Storage } from './interface.ts';
+/**
+ * Honest, self-reported consistency and feature profile for a {@link Storage}
+ * backend, returned by {@link Storage.capabilities}. Values describe the
+ * guarantees a backend actually provides, not what callers wish it provided.
+ *
+ * **Three kinds of capability, treated differently:**
+ * - **Runtime-gated:** `conditionalBatch` is the only capability the engine
+ *   enforces at runtime (see {@link requireStorageCapability}). A backend may
+ *   legitimately omit compare-and-swap, so its absence fails fast with a clear
+ *   diagnostic at the first feature that needs it.
+ * - **Trusted correctness contracts:** `atomicBatch`, `readAfterWrite`, and
+ *   `scanConsistency` are read by the engine but NOT verified at runtime. If a
+ *   backend reports `atomicBatch: true` but applies batches non-atomically, the
+ *   failure mode is checkpoint corruption, not a missing feature — honesty is
+ *   the adapter author's responsibility.
+ * - **Operational hint:** `boundedRangeDelete` is a strength-of-implementation
+ *   claim about the adapter's bounded-delete methods — `deletePrefix()` and, when
+ *   present, `deleteRange()` — being single bounded range ops rather than a
+ *   scan-and-delete fallback. It affects performance, not correctness, and nothing
+ *   gates on it. In every built-in adapter the two methods share the same native
+ *   path (both native, or both fall back), so one boolean describes both honestly;
+ *   a custom adapter whose two methods differ in strength should report `false`
+ *   rather than overclaim.
+ *
+ * **Why the engine needs these.** Checkpoint commit relies on `atomicBatch`
+ * (all-or-nothing); resume relies on `readAfterWrite` (the just-written
+ * checkpoint must be observable on the next read); visibility/index scans rely
+ * on `scanConsistency` (a scan must not observe torn writes); compare-and-swap
+ * state and quota reservation rely on `conditionalBatch`.
+ *
+ * **Consistency-level scope.** All levels are scoped to a single `Storage`
+ * instance. The engine uses one storage instance shared across concurrent
+ * workflows, so `linearizable` is the value it relies on for built-in
+ * single-process backends.
+ *
+ * **Opaque-value invariant.** Storage adapters and decorators MUST treat stored
+ * values as opaque bytes and MUST NOT inspect or depend on value contents;
+ * values MAY later be encrypted or compressed. The engine ranges only over
+ * keys, never value bytes. A value-transforming decorator (e.g.
+ * `CompressedStorage`) MUST therefore downgrade `conditionalBatch` to `false`,
+ * because a caller-supplied `expectedValue` cannot byte-match the transformed
+ * stored value.
+ *
+ * @example
+ * ```ts
+ * import { MemoryStorage } from '@lostgradient/weft';
+ * import type { StorageCapabilities } from '@lostgradient/weft/storage/interface';
+ *
+ * await using storage = new MemoryStorage();
+ * const caps: StorageCapabilities = storage.capabilities();
+ * console.log(caps.conditionalBatch); // true
+ * console.log(caps.readAfterWrite);   // 'linearizable'
+ * ```
+ */
+export type StorageCapabilities = {
+    /**
+     * Persistence scope for data written through this storage instance.
+     * - `ephemeral`: data is process- or session-local and is lost when the
+     *   runtime exits or the storage area is cleared (`MemoryStorage`, in-memory
+     *   SQLite/libSQL, browser-extension session storage).
+     * - `local`: data is durably persisted by a local runtime or origin-backed
+     *   store suitable for same-process recovery checks.
+     * - `remote`: data is owned by a remote service or synchronized storage area
+     *   whose durability and freshness depend on that service.
+     */
+    persistence?: 'ephemeral' | 'local' | 'remote';
+    /**
+     * Visibility of a completed write to a later read, scoped to one `Storage`
+     * instance.
+     * - `linearizable`: a completed `put`/`batch` is observable by **any**
+     *   subsequent read through this instance, including reads issued by other
+     *   concurrent callers sharing the instance (single-process backends
+     *   serialize all callers).
+     * - `session`: only the **same caller's own** ordered operation chain is
+     *   guaranteed to read its writes; a concurrent caller sharing the instance,
+     *   or a separate instance/replica, may lag.
+     * - `eventual`: even a same-instance read may not observe a just-completed
+     *   write.
+     */
+    readAfterWrite: 'linearizable' | 'session' | 'eventual';
+    /**
+     * Consistency of a single `scan()` iteration relative to concurrent writes.
+     * - `snapshot`: the scan observes one point-in-time view; concurrent writes
+     *   never appear partially within the iteration.
+     * - `best-effort`: the scan may interleave with concurrent writes.
+     */
+    scanConsistency: 'snapshot' | 'best-effort';
+    /**
+     * `batch()` applies all operations atomically (all-or-nothing). Trusted
+     * correctness contract — a `true` value the engine relies on for checkpoint
+     * commit and does not verify at runtime.
+     */
+    atomicBatch: boolean;
+    /** `conditionalBatch()` compare-and-swap preconditions are supported. */
+    conditionalBatch: boolean;
+    /**
+     * The adapter's bounded-delete methods — `deletePrefix()` and, when present,
+     * `deleteRange()` — are implemented natively against the backend's own range
+     * machinery rather than as a generic client-side scan-then-`batch()` loop:
+     * a single range-scoped SQL `DELETE`, an `IDBKeyRange` delete, or an
+     * in-memory range-bounded delete. Adapters that use a two-phase approach
+     * (scan keys into an array, then delete in a batch) report `false` even if
+     * the delete phase runs in a single transaction — the two-phase pattern IS
+     * the scan-and-delete fallback. Adapters that only fall back to the derived
+     * `storageDeletePrefixCore`/`storageDeleteRangeCore` helpers also report
+     * `false` even though those methods work. This is a strength-of-implementation
+     * claim about the adapter's own methods, not a guarantee about a remote
+     * backend behind it; an adapter whose two methods differ in strength reports
+     * `false`.
+     */
+    boundedRangeDelete: boolean;
+};
+/**
+ * The boolean capabilities the engine enforces at runtime via
+ * {@link requireStorageCapability}. Today this is only `conditionalBatch` —
+ * see the "three kinds of capability" note on {@link StorageCapabilities}. A
+ * future capability that needs gating is added here deliberately, keeping the
+ * type in lockstep with what is actually enforced rather than implying every
+ * boolean capability is gateable.
+ *
+ * @example
+ * ```ts
+ * import { MemoryStorage } from '@lostgradient/weft';
+ * import { requireStorageCapability } from '@lostgradient/weft/storage/interface';
+ * import type { GatedStorageCapabilityKey } from '@lostgradient/weft/storage/interface';
+ *
+ * await using storage = new MemoryStorage();
+ * // The third argument's type is GatedStorageCapabilityKey — only the
+ * // runtime-gated 'conditionalBatch' is accepted.
+ * const capability: GatedStorageCapabilityKey = 'conditionalBatch';
+ * requireStorageCapability(storage, capability, 'MyFeature compare-and-swap');
+ * ```
+ */
+export type GatedStorageCapabilityKey = 'conditionalBatch';
+/**
+ * Fail fast when a feature requires a runtime-gated storage capability the
+ * backend does not provide. Reads the honest {@link StorageCapabilities} report
+ * (not mere method presence), so a value-transforming decorator that downgrades
+ * a capability is respected. Call this at the first use of a feature — not at
+ * engine startup — so the diagnostic points at the operation that needs the
+ * guarantee.
+ *
+ * Only {@link GatedStorageCapabilityKey} capabilities are accepted: the
+ * non-gated `atomicBatch`/`readAfterWrite`/`scanConsistency` are trusted
+ * contracts the engine does not enforce, and `boundedRangeDelete` is an
+ * operational hint, so gating on any of them would be meaningless.
+ *
+ * @throws {Error} When `storage.capabilities()[capability]` is `false`.
+ *
+ * @example
+ * ```ts
+ * import { MemoryStorage } from '@lostgradient/weft';
+ * import { requireStorageCapability } from '@lostgradient/weft/storage/interface';
+ *
+ * await using storage = new MemoryStorage();
+ * requireStorageCapability(storage, 'conditionalBatch', 'AtomicState compare-and-swap');
+ * // Memory supports conditionalBatch, so this returns without throwing.
+ * ```
+ */
+export declare function requireStorageCapability(storage: Storage, capability: GatedStorageCapabilityKey, featureName: string): void;
+/**
+ * Fail fast when a storage backend is not conservative enough for boot-time
+ * durable recovery. This is intentionally stricter than the engine's per-feature
+ * gates: it rejects ephemeral, remote, eventual, best-effort, non-atomic, and
+ * non-CAS storage before an application starts in durable mode.
+ *
+ * @throws {Error} When the backend's capability row is not suitable for recovery.
+ *
+ * @example
+ * ```ts
+ * import { assertDurableStorageForRecovery } from '@lostgradient/weft';
+ * import { SQLiteStorage } from '@lostgradient/weft/storage/sqlite';
+ *
+ * await using storage = new SQLiteStorage('./weft.db');
+ * assertDurableStorageForRecovery(storage);
+ * ```
+ */
+export declare function assertDurableStorageForRecovery(storage: Storage): void;

package/dist/storage/capabilities.js

@@ -0,0 +1,19 @@
+export function requireStorageCapability(storage, capability, featureName) {
+  if (!storage.capabilities()[capability])
+    throw Error(`Feature "${featureName}" requires storage capability "${capability}", but this storage backend does not provide it.`);
+}
+export function assertDurableStorageForRecovery(storage) {
+  const capabilities = storage.capabilities(), failures = [];
+  if (capabilities.persistence !== "local")
+    failures.push(`persistence must be "local" (got "${capabilities.persistence}")`);
+  if (capabilities.readAfterWrite !== "linearizable")
+    failures.push(`readAfterWrite must be "linearizable" (got "${capabilities.readAfterWrite}")`);
+  if (capabilities.scanConsistency !== "snapshot")
+    failures.push(`scanConsistency must be "snapshot" (got "${capabilities.scanConsistency}")`);
+  if (!capabilities.atomicBatch)
+    failures.push("atomicBatch must be true");
+  if (!capabilities.conditionalBatch)
+    failures.push("conditionalBatch must be true");
+  if (failures.length > 0)
+    throw Error(`Storage is not durable enough for recovery: ${failures.join("; ")}.`);
+}

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

@@ -0,0 +1,45 @@
+/**
+ * Storage decorator that transparently compresses and decompresses payloads.
+ * Wraps any {@link Storage} implementation and applies compression above a
+ * configurable size threshold.
+ *
+ * @module storage/compressed-storage
+ */
+import type { CompressionOptions } from '../core/compression.ts';
+import { type BatchOperation, type ScanOptions, type Storage, type StorageCapabilities } from './interface.ts';
+/**
+ * {@link Storage} decorator that transparently compresses payloads above a
+ * configurable size threshold before writing and decompresses on read.
+ *
+ * Wraps any `Storage` implementation — pass a {@link BunSQLiteStorage},
+ * {@link MemoryStorage}, or any other backend as the first argument. The same
+ * compression algorithm and threshold apply to every stored key.
+ *
+ * @example
+ * ```ts
+ * import { CompressedStorage } from '@lostgradient/weft/storage/compressed';
+ * import { workflow, Engine, MemoryStorage } from '@lostgradient/weft';
+ *
+ * await using inner = new MemoryStorage();
+ * await using storage = new CompressedStorage(inner, {
+ *   algorithm: 'gzip',
+ *   threshold: 1024,
+ * });
+ * await using engine = new Engine({ storage });
+ *
+ * engine.register(workflow({ name: 'noop' }).execute(async function* () { return 'done'; }));
+ * const handle = await engine.start('noop', null);
+ * console.log(await handle.result()); // 'done'
+ * ```
+ */
+export declare class CompressedStorage implements Storage {
+    #private;
+    constructor(inner: Storage, options?: CompressionOptions);
+    capabilities(): StorageCapabilities;
+    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>;
+    [Symbol.dispose](): void;
+}

package/dist/storage/compressed-storage.js

@@ -0,0 +1,2 @@
+// @bun
+var A=Object.defineProperty;var S=(j)=>j;function y(j,J){this[j]=S.bind(null,J)}var p=(j,J)=>{for(var W in J)A(j,W,{get:J[W],enumerable:!0,configurable:!0,set:y.bind(J,W)})};var Y=(j,J)=>()=>(j&&(J=j(j=0)),J);function x(){return typeof(K&&"bun"in K?K.bun:globalThis.Bun)<"u"}function I(){if(K&&"process"in K)return K.process;return globalThis.process}function d(j){if(x())return Bun.sleep(j);return new Promise((J)=>setTimeout(J,j))}function z(j){let J=v;for(let W=0;W<j.length;W++)J^=BigInt(j[W]),J=J*O&_;return J.toString(16).padStart(16,"0")}function n(j){return z(j)}function i(j){return z(b.encode(j))}function w(j){let W=I()?.getBuiltinModule;if(typeof W!=="function")return;return W(j)}function s(j){if(x())return Bun.file(j).size;let J=w("node:fs");if(!J)throw Error("fileSize() requires Bun or Node 22.5+ (process.getBuiltinModule). Not available in browser or edge runtimes.");try{return J.statSync(j).size}catch(W){if(typeof W==="object"&&W!==null&&"code"in W&&W.code==="ENOENT")return 0;throw W}}function C(){let j=w("node:zlib");if(!j)throw Error("gzip/gunzip require Bun or Node 22.5+ (process.getBuiltinModule). "+"Not available in browser or edge runtimes \u2014 use CompressionStream directly.");return j}function P(j){if(x())return new Uint8Array(Bun.gzipSync(new Uint8Array(j)));return new Uint8Array(C().gzipSync(j))}function G(j){if(x())return new Uint8Array(Bun.gunzipSync(new Uint8Array(j)));return new Uint8Array(C().gunzipSync(j))}function N(){return w("node:zlib")}var K,v=0xcbf29ce484222325n,O=0x00000100000001b3n,_=0xffffffffffffffffn,b;var f=Y(()=>{b=new TextEncoder});function L(){let j=N();if(!j)throw Error("Brotli compression requires Bun or Node 22.5+ with process.getBuiltinModule support. Use gzip compression for browser/edge runtimes.");return j}function T(j){return new Uint8Array(L().brotliCompressSync(j))}function h(j){return new Uint8Array(L().brotliDecompressSync(j))}function D(j){return c(j)}function c(j){switch(j){case"gzip":return{algorithm:"gzip",compress(J){return P(J)}};case"brotli":return{algorithm:"brotli",compress(J){return T(J)}};case"none":return{algorithm:"none",compress(J){return J}}}}async function U(j,J,W){if(j.length<W||J.algorithm==="none"){let $=new Uint8Array(j.length+X);return $[0]=V,$[1]=F,$.set(j,X),$}let q=await J.compress(j);if(q.length+X>=j.length+X){let $=new Uint8Array(j.length+X);return $[0]=V,$[1]=F,$.set(j,X),$}let B=J.algorithm==="gzip"?Z:g,Q=new Uint8Array(q.length+X);return Q[0]=V,Q[1]=B,Q.set(q,X),Q}async function k(j){if(j.length<X)throw Error("Compression payload missing 2-byte header.");if(j[0]!==V)throw Error("Compression payload missing magic byte 0xC1.");let J=j[1],W=j.slice(X);switch(J){case F:return W;case Z:return G(W);case g:return h(W);default:throw Error(`Compression payload uses unsupported algorithm byte 0x${J.toString(16).padStart(2,"0")}.`)}}function H(j){return{threshold:j?.threshold??E,algorithm:j?.algorithm??R}}var V=193,F=0,Z=1,g=2,X=2,E=4096,R="gzip";var M=Y(()=>{f()});var m;var u=Y(()=>{M();m=class m{#j;#J;#W;constructor(j,J){this.#j=j;let W=H(J);if(this.#J=D(W.algorithm),this.#W=W.threshold,j.query){let q=j.query.bind(j);Object.defineProperty(this,"query",{value:q,enumerable:!0,configurable:!0})}}capabilities(){let j=this.#j.capabilities();return{...j.persistence===void 0?{}:{persistence:j.persistence},readAfterWrite:j.readAfterWrite,scanConsistency:j.scanConsistency,atomicBatch:j.atomicBatch,conditionalBatch:!1,boundedRangeDelete:!1}}async get(j){let J=await this.#j.get(j);if(!J)return null;return k(J)}async put(j,J){let W=await U(J,this.#J,this.#W);return this.#j.put(j,W)}async delete(j){return this.#j.delete(j)}async*scan(j,J){for await(let[W,q]of this.#j.scan(j,J))yield[W,await k(q)]}async batch(j){let J=await Promise.all(j.map(async(W)=>{if(W.type==="put")return{type:"put",key:W.key,value:await U(W.value,this.#J,this.#W)};return W}));return this.#j.batch(J)}[Symbol.dispose](){this.#j[Symbol.dispose]()}}});u();export{m as CompressedStorage};

package/dist/storage/default-scope.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Constant scope for workflow-type-shared durable state (single source of truth;
+ * never inline the literal). Keys live under `state:workflow-scope:` — distinct
+ * from the legacy `state:workflow:<tenantId>:` layout so a historical tenant id
+ * cannot alias in, making a future re-partition a key rename, not a data
+ * migration. See `KEYS.stateWorkflow` in `./interface.ts`.
+ *
+ * Internal leaf module (no imports) so both `./interface.ts` and
+ * `../core/atomic-state.ts` can depend on it without an import cycle.
+ *
+ * @example
+ * ```ts
+ * import { DEFAULT_SCOPE } from '@lostgradient/weft/storage/interface';
+ * console.log(DEFAULT_SCOPE); // 'default'
+ * ```
+ */
+export declare const DEFAULT_SCOPE = "default";

package/dist/storage/default-scope.js

@@ -0,0 +1 @@
+export const DEFAULT_SCOPE = "default";

package/dist/storage/delete-range.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Bounded range delete: the `deleteRange` contract, its option types, the
+ * validating normalizer, and the public dispatcher. Split out from
+ * `interface.ts` to keep that module focused; this imports the `Storage` type
+ * (type-only) from there and the derived fallback (value) from
+ * `derived-operations.ts`, so there is no runtime import cycle.
+ *
+ * @module storage/delete-range
+ */
+import { type Storage } from './interface.ts';
+/**
+ * Bounds for a bounded range delete ({@link Storage.deleteRange}).
+ *
+ * A deliberate subset of `ScanOptions`: `reverse` is intentionally absent so a
+ * delete can never run high-to-low. At least one of `gt`/`gte`/`lt`/`lte` must
+ * be present — see {@link normalizeDeleteRangeOptions}, which rejects an
+ * unbounded request so the operation can never silently degrade into a
+ * whole-prefix wipe (use {@link Storage.deletePrefix} for that).
+ *
+ * @example
+ * ```ts
+ * import type { DeleteRangeOptions } from '@lostgradient/weft';
+ *
+ * // Delete events strictly below a sequence watermark.
+ * const options: DeleteRangeOptions = { lt: 'ev:wf:0000000003' };
+ * ```
+ */
+export type DeleteRangeOptions = {
+    gt?: string;
+    gte?: string;
+    lt?: string;
+    lte?: string;
+    limit?: number;
+};
+declare const normalizedDeleteRangeBrand: unique symbol;
+/**
+ * A {@link DeleteRangeOptions} that has passed {@link normalizeDeleteRangeOptions}.
+ *
+ * The brand lives strictly below the public boundary: every public surface
+ * accepts raw `DeleteRangeOptions`, but internal SQL builders that would emit a
+ * destructive statement require this type, so an unvalidated or unbounded object
+ * cannot reach them — that is a compile error, not a runtime check. The only way
+ * to obtain a value of this type is to call {@link normalizeDeleteRangeOptions}.
+ */
+export type NormalizedDeleteRangeOptions = DeleteRangeOptions & {
+    readonly [normalizedDeleteRangeBrand]: true;
+};
+/**
+ * Validate and canonicalize {@link DeleteRangeOptions} into a branded
+ * {@link NormalizedDeleteRangeOptions}.
+ *
+ * This is the only door to the branded type, and the single source of truth for
+ * the `deleteRange` contract:
+ * - At least one of `gt`/`gte`/`lt`/`lte` must be present; an unbounded request
+ *   throws rather than degrading into a whole-prefix delete.
+ * - Each bound, when present, must be a string.
+ * - `limit`, when present, must be a finite non-negative integer (a negative
+ *   `LIMIT` silently means "no limit" in SQLite — catastrophic for a delete).
+ * - Only `gt`/`gte`/`lt`/`lte`/`limit` are copied; `reverse` and any other
+ *   field on a wider object are dropped, so a delete can never run high-to-low.
+ *
+ * Idempotent: re-normalizing an already-normalized value returns an equivalent
+ * one, so passing the dispatcher's result into a native adapter method is safe.
+ *
+ * @throws {Error} When no bound is present, a bound is not a string, or `limit`
+ * is not a finite non-negative integer.
+ *
+ * Internal helper: not exported from any package subpath. Callers reach it
+ * transitively through {@link storageDeleteRange} (which is public). No `@example`
+ * here for that reason — it has no public import path, like the derived `*Core`
+ * helpers in `./derived-operations.ts`.
+ */
+export declare function normalizeDeleteRangeOptions(options: DeleteRangeOptions): NormalizedDeleteRangeOptions;
+/**
+ * Delete the keys under `prefix` that fall within the given bounds, using the
+ * adapter's native `deleteRange` when available or a batched scan-and-delete
+ * fallback otherwise. Returns the number of keys deleted.
+ *
+ * Options are validated and canonicalized once here (see
+ * {@link normalizeDeleteRangeOptions}): an unbounded request throws rather than
+ * wiping the whole prefix, and `reverse` can never take effect. When `limit` is
+ * set, the lowest (ascending) keys in range are deleted first.
+ *
+ * @throws {Error} When `options` has no bound, a non-string bound, or an invalid `limit`.
+ *
+ * @example
+ * ```ts
+ * import { MemoryStorage, storageDeleteRange } from '@lostgradient/weft';
+ *
+ * await using storage = new MemoryStorage();
+ * await storage.put('ev:wf:0000000001', new Uint8Array([1]));
+ * await storage.put('ev:wf:0000000002', new Uint8Array([2]));
+ * await storage.put('ev:wf:0000000003', new Uint8Array([3]));
+ * // Delete events strictly below sequence 3.
+ * const deleted = await storageDeleteRange(storage, 'ev:wf:', { lt: 'ev:wf:0000000003' });
+ * console.log(deleted); // 2
+ * ```
+ */
+export declare function storageDeleteRange(storage: Storage, prefix: string, options: DeleteRangeOptions): Promise<number>;
+/** One side of a resolved lexicographic delete range. `open` means exclusive. */
+export type DeleteRangeBound = {
+    key: string;
+    open: boolean;
+};
+export declare function resolveDeleteRangeBounds(prefix: string, options: NormalizedDeleteRangeOptions): {
+    lower: DeleteRangeBound;
+    upper: DeleteRangeBound;
+} | null;
+export {};

package/dist/storage/delete-range.js

@@ -0,0 +1,64 @@
+import { storageDeleteRangeCore } from "./derived-operations.js";
+import { resolvePrefixRangeEnd } from "./interface.js";
+function normalizeDeleteRangeLimit(limit) {
+  if (limit === void 0)
+    return;
+  if (typeof limit !== "number" || !Number.isInteger(limit) || limit < 0)
+    throw Error("deleteRange limit must be a finite non-negative integer");
+  return limit === 0 ? 0 : limit;
+}
+export function normalizeDeleteRangeOptions(options) {
+  const normalized = {};
+  let hasBound = !1;
+  for (const bound of ["gt", "gte", "lt", "lte"]) {
+    const value = options[bound];
+    if (value === void 0)
+      continue;
+    if (typeof value !== "string")
+      throw Error("deleteRange bounds must be strings");
+    normalized[bound] = value;
+    hasBound = !0;
+  }
+  if (!hasBound)
+    throw Error("deleteRange requires at least one of gt/gte/lt/lte; use deletePrefix to delete a whole prefix");
+  const limit = normalizeDeleteRangeLimit(options.limit);
+  if (limit !== void 0)
+    normalized.limit = limit;
+  return normalized;
+}
+export async function storageDeleteRange(storage, prefix, options) {
+  const normalized = normalizeDeleteRangeOptions(options);
+  if (storage.deleteRange)
+    return storage.deleteRange(prefix, normalized);
+  return storageDeleteRangeCore(storage, prefix, normalized);
+}
+function resolveLowerBound(prefix, options) {
+  const bound = { key: prefix, open: !1 };
+  if (options.gte !== void 0 && options.gte > bound.key) {
+    bound.key = options.gte;
+    bound.open = !1;
+  }
+  if (options.gt !== void 0 && options.gt >= bound.key) {
+    bound.key = options.gt;
+    bound.open = !0;
+  }
+  return bound;
+}
+function resolveUpperBound(prefix, options) {
+  const bound = { key: resolvePrefixRangeEnd(prefix), open: !0 };
+  if (options.lt !== void 0 && options.lt <= bound.key) {
+    bound.key = options.lt;
+    bound.open = !0;
+  }
+  if (options.lte !== void 0 && options.lte < bound.key) {
+    bound.key = options.lte;
+    bound.open = !1;
+  }
+  return bound;
+}
+export function resolveDeleteRangeBounds(prefix, options) {
+  const lower = resolveLowerBound(prefix, options), upper = resolveUpperBound(prefix, options);
+  if (lower.key > upper.key || lower.key === upper.key && (lower.open || upper.open))
+    return null;
+  return { lower, upper };
+}

package/dist/storage/derived-operations.d.ts

@@ -0,0 +1,53 @@
+import type { NormalizedDeleteRangeOptions } from './delete-range.ts';
+import { type ScanOptions, type Storage } from './interface.ts';
+/**
+ * Non-dispatching implementations of the derived storage operations.
+ *
+ * These helpers compute `has`/`keys`/`count`/`deletePrefix` purely from the
+ * required `get`/`scan`/`batch` primitives. Unlike the public `storageHas`,
+ * `storageKeys`, `storageCount`, and `storageDeletePrefix` dispatchers in
+ * `./interface.ts`, they **never** consult the adapter's optional fast-path
+ * methods. That distinction matters in two places:
+ *
+ * 1. The public dispatchers call these as their fallback branch (when the
+ *    adapter omits the optional method), so the derived logic lives here once.
+ * 2. Adapters that *do* expose the optional methods (e.g. {@link HTTPStorage},
+ *    {@link WebExtensionStorage}) implement them by delegating here. They cannot
+ *    delegate to the public dispatchers, which would re-dispatch back into the
+ *    adapter method and recurse forever.
+ *
+ * This module is internal: it is not listed as a package subpath export and must
+ * not be re-exported from public entry points.
+ */
+/**
+ * Core `has` derivation: a key exists when `get` returns a non-null value.
+ */
+export declare function storageHasCore(storage: Storage, key: string): Promise<boolean>;
+/**
+ * Core `keys` derivation: project `scan` entries down to their keys, preserving
+ * the adapter's `scan` ordering, `limit`, and `reverse` semantics.
+ */
+export declare function storageKeysCore(storage: Storage, prefix: string, options?: ScanOptions): AsyncIterable<string>;
+/**
+ * Core `count` derivation: count the keys matching a prefix.
+ */
+export declare function storageCountCore(storage: Storage, prefix: string): Promise<number>;
+/**
+ * Core `deletePrefix` derivation: collect the matching keys and remove them in a
+ * single batch. Returns the number of keys deleted.
+ */
+export declare function storageDeletePrefixCore(storage: Storage, prefix: string): Promise<number>;
+/**
+ * Core `deleteRange` derivation: scan the keys under `prefix` that match the
+ * (already-normalized) bounds and remove them in a single batch. Returns the
+ * number of keys deleted.
+ *
+ * The bounds are honored by `scan` via `matchesScanOptions`; `limit` caps the
+ * delete to the lowest (ascending) keys in range. Like
+ * {@link storageDeletePrefixCore}, this is best-effort over the keys observed by
+ * the scan: a key inserted after the scan begins is not deleted. Takes a
+ * {@link NormalizedDeleteRangeOptions} because the only caller, the public
+ * `storageDeleteRange` dispatcher, validates first — keeping this module's
+ * type-only dependency on `interface.ts` intact (no runtime import cycle).
+ */
+export declare function storageDeleteRangeCore(storage: Storage, prefix: string, options: NormalizedDeleteRangeOptions): Promise<number>;

package/dist/storage/derived-operations.js

@@ -0,0 +1,31 @@
+export async function storageHasCore(storage, key) {
+  return await storage.get(key) !== null;
+}
+export async function* storageKeysCore(storage, prefix, options) {
+  for await (const [key] of storage.scan(prefix, options))
+    yield key;
+}
+export async function storageCountCore(storage, prefix) {
+  let count = 0;
+  for await (const _key of storageKeysCore(storage, prefix))
+    count++;
+  return count;
+}
+export 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;
+}
+export 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;
+}

package/dist/storage/http.d.ts

@@ -0,0 +1,67 @@
+import { type DeleteRangeOptions } from './delete-range.ts';
+import { type BatchOperation, type ConditionalBatchCondition, type ScanOptions, type Storage, type StorageCapabilities } from './interface.ts';
+/**
+ * Options for connecting {@link HTTPStorage} to a remote Weft storage API.
+ *
+ * @example
+ * ```ts
+ * import { HTTPStorage, type HTTPStorageOptions } from '@lostgradient/weft/storage/http';
+ *
+ * const token = 'example-token';
+ * const options: HTTPStorageOptions = {
+ *   baseUrl: 'https://weft.example.com',
+ *   headers: { authorization: `Bearer ${token}` },
+ * };
+ * const storage = new HTTPStorage(options);
+ * void storage;
+ * ```
+ */
+export type HTTPStorageOptions = {
+    baseUrl: string | URL;
+    headers?: Record<string, string>;
+    /**
+     * Whether the remote server's storage backend supports compare-and-swap.
+     * The client cannot detect this — it depends on the server's backend — so the
+     * honest default is `false`: a feature gated on `conditionalBatch` fails fast
+     * locally instead of issuing a request the server answers with `501`. Set
+     * `true` only when you have verified the remote backend implements it.
+     *
+     * @default false
+     */
+    remoteConditionalBatch?: boolean;
+};
+/**
+ * Remote {@link Storage} adapter backed by Weft's storage REST endpoints.
+ *
+ * Single-value reads and writes use `application/octet-stream`; scans stream
+ * newline-delimited JSON entries with base64-encoded values.
+ *
+ * @example
+ * ```ts
+ * import { HTTPStorage } from '@lostgradient/weft/storage/http';
+ *
+ * const token = 'example-token';
+ * await using storage = new HTTPStorage({
+ *   baseUrl: 'https://weft.example.com',
+ *   headers: { authorization: `Bearer ${token}` },
+ * });
+ * ```
+ */
+export declare class HTTPStorage implements Storage {
+    #private;
+    constructor(options: HTTPStorageOptions);
+    capabilities(): StorageCapabilities;
+    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>;
+    keys(prefix: string, options?: ScanOptions): AsyncIterable<string>;
+    count(prefix: string): Promise<number>;
+    deletePrefix(prefix: string): Promise<number>;
+    deleteRange(prefix: string, options: DeleteRangeOptions): Promise<number>;
+    scoped(prefix: string): Storage;
+    [Symbol.dispose](): void;
+}

package/dist/storage/http.js

@@ -0,0 +1,2 @@
+var k=Object.defineProperty;var u=(J)=>J;function w(J,Y){this[J]=u.bind(null,Y)}var n=(J,Y)=>{for(var Z in Y)k(J,Z,{get:Y[Z],enumerable:!0,configurable:!0,set:w.bind(Y,Z)})};function U(J){let Y=[];for(let Z=0;Z<J.length;Z+=512)Y.push(String.fromCharCode(...J.subarray(Z,Z+512)));return btoa(Y.join(""))}function T(J){let Y=atob(J),Z=new Uint8Array(Y.length);for(let G=0;G<Y.length;G+=1)Z[G]=Y.charCodeAt(G);return Z}function N(J){return typeof J==="object"&&J!==null&&!Array.isArray(J)}async function M(J,Y){return await J.get(Y)!==null}async function*Q(J,Y,Z){for await(let[G]of J.scan(Y,Z))yield G}async function V(J,Y){let Z=0;for await(let G of Q(J,Y))Z++;return Z}async function E(J,Y){let Z=[];for await(let G of Q(J,Y))Z.push({type:"delete",key:G});if(Z.length===0)return 0;return await J.batch(Z),Z.length}async function H(J,Y,Z){let G=[];for await(let X of Q(J,Y,Z))G.push({type:"delete",key:X});if(G.length===0)return 0;return await J.batch(G),G.length}function q(J,Y,Z){if(!J.capabilities()[Y])throw Error(`Feature "${Z}" requires storage capability "${Y}", but this storage backend does not provide it.`)}var R="default";function O(J){return J.length>0?J.slice(0,-1)+String.fromCharCode(J.charCodeAt(J.length-1)+1):"ÿ"}function _J(J,Y={}){if(Y.gt!==void 0&&J<=Y.gt)return!1;if(Y.gte!==void 0&&J<Y.gte)return!1;if(Y.lt!==void 0&&J>=Y.lt)return!1;if(Y.lte!==void 0&&J>Y.lte)return!1;return!0}function FJ(J,Y){if(J===null||Y===null)return J===Y;if(J.byteLength!==Y.byteLength)return!1;for(let Z=0;Z<J.byteLength;Z++)if(J[Z]!==Y[Z])return!1;return!0}async function P(J,Y){if(J.has)return J.has(Y);return M(J,Y)}function h(J,Y,Z){if(J.keys)return J.keys(Y,Z);return Q(J,Y,Z)}async function C(J,Y){if(J.count)return J.count(Y);return V(J,Y)}async function v(J,Y){if(J.deletePrefix)return J.deletePrefix(Y);return E(J,Y)}async function K(J,Y,Z){if(q(J,"conditionalBatch","storageConditionalBatch"),!J.conditionalBatch)throw Error("This storage backend reports conditionalBatch capability but does not implement the conditionalBatch() method.");return J.conditionalBatch(Y,Z)}function $(J){return encodeURIComponent(J)}function QJ(J){try{return decodeURIComponent(J)}catch{return null}}var _=(J)=>String(J).padStart(16,"0"),WJ={workflow:(J)=>`wf:${$(J)}`,checkpoint:(J)=>`wf:${$(J)}:ckpt`,checkpointHistory:(J,Y)=>`wf:${$(J)}:ckpt:${String(Y).padStart(10,"0")}`,timelinePrefix:(J)=>`wf:${$(J)}:timeline:`,timeline:(J,Y)=>`wf:${$(J)}:timeline:${String(Y).padStart(10,"0")}`,schedule:(J)=>`schedule:${$(J)}`,scheduleTick:(J,Y)=>`schedule-due:${String(J).padStart(16,"0")}:${$(Y)}`,scheduleRun:(J)=>`schedule-run:${$(J)}`,operation:(J,Y,Z)=>`op:${J}:${_(Y)}:${Z}`,operationInflight:(J)=>`op:inflight:${J}`,operationQueued:(J)=>`op:queued:${J}`,operationResolved:(J)=>`op:resolved:${J}`,bulkOperationAuditPrefix:()=>"audit:bulk:",bulkOperationAudit:(J,Y,Z)=>`audit:bulk:${_(J)}:${$(Y)}:${$(Z)}`,operationResolvedByTimePrefix:()=>"op:resolved-by-time:",operationResolvedByTime:(J,Y)=>`op:resolved-by-time:${_(J)}:${$(Y)}`,asyncActivity:(J,Y)=>`async-act:v1:${$(J)}:${$(Y)}`,activityReconciliationPrefix:(J)=>`actrec:v1:${$(J)}:`,activityReconciliation:(J,Y,Z)=>`actrec:v1:${$(J)}:${$(Y)}:${Z}`,eventPrefix:(J)=>`ev:${$(J)}:`,event:(J,Y)=>`ev:${$(J)}:${String(Y).padStart(10,"0")}`,eventHead:(J)=>`ev:${$(J)}:head`,eventWatermark:(J)=>`ev:${$(J)}:watermark`,signal:(J,Y,Z)=>`sig:${$(J)}:${Y}:${$(Z)}`,signalSequence:(J)=>`sigseq:v1:${$(J)}`,signalAcceptedResponsePrefix:(J)=>`sigres:v1:${$(J)}:`,signalAcceptedResponse:(J,Y,Z)=>`sigres:v1:${$(J)}:${$(Y)}:${$(Z)}`,deadline:(J,Y)=>`wf-deadline:${_(J)}:${$(Y)}`,terminalCleanup:(J,Y)=>`wf-cleanup:${_(J)}:${$(Y)}`,delayedStart:(J,Y)=>`wf-delayed:${_(J)}:${$(Y)}`,terminalWorkflowPrefix:()=>"wf-terminal:",terminalWorkflow:(J,Y)=>`wf-terminal:${_(J)}:${$(Y)}`,attribute:(J)=>`attr:${$(J)}`,attributeIndex:(J,Y,Z)=>`idx:${J}:${Y}:${$(Z)}`,tagIndex:(J,Y)=>`tag:${$(J)}:${$(Y)}`,updatePrefix:(J)=>`upd:${$(J)}:`,update:(J,Y)=>`upd:${$(J)}:${Y}`,updateResponse:(J)=>`upr:${J}`,updateIdempotency:(J,Y)=>`upk:${$(J)}:${Y}`,budget:(J,Y,Z)=>`budget:${J}:${Y}:${Z}`,review:(J,Y)=>`review:${$(J)}:${Y}`,workflowHeaders:(J)=>`wf-headers:${$(J)}`,terminalCleanupNeeded:(J)=>`wf-cleanup-needed:${$(J)}`,offload:(J,Y)=>`offload:${$(J)}:${Y}`,archive:(J,Y)=>`archive:${$(J)}:${Y}`,stateExecution:(J,Y)=>`state:execution:${$(J)}:${$(Y)}`,stateWorkflow:(J,Y)=>`state:workflow-scope:${R}:${$(J)}:${$(Y)}`,streamChunkPrefix:(J,Y)=>`blob:${$(J)}:${Y}:chunk:`,streamChunk:(J,Y,Z)=>`blob:${$(J)}:${Y}:chunk:${String(Z).padStart(10,"0")}`,streamMetadata:(J,Y)=>`blob:${$(J)}:${Y}:meta`,budgetCharged:(J)=>`budget-charged:${J}`,toolEffect:(J,Y,Z)=>`tool-effect:${$(J)}:${Y}:${Z}`,workflowVisibilityStatus:(J,Y)=>`wf-idx-status:${$(J)}:${$(Y)}`,workflowVisibilityType:(J,Y)=>`wf-idx-type:${$(J)}:${$(Y)}`,workflowVisibilityCreated:(J,Y)=>`wf-idx-created:${_(J)}:${$(Y)}`,workflowVisibilityUpdated:(J,Y)=>`wf-idx-updated:${_(J)}:${$(Y)}`,workflowVisibilityDeadline:(J,Y)=>`wf-idx-deadline:${_(J)}:${$(Y)}`,workflowVisibilityManifest:(J)=>`wf-idx-manifest:${$(J)}`,workflowVisibilityMetaVersion:()=>"wf-idx-meta:version",workflowVisibilityMetaBuiltAt:()=>"wf-idx-meta:built-at",workflowVisibilityMetaCursor:()=>"wf-idx-meta:cursor"};function m(J){if(J===void 0)return;if(typeof J!=="number"||!Number.isInteger(J)||J<0)throw Error("deleteRange limit must be a finite non-negative integer");return J===0?0:J}function j(J){let Y={},Z=!1;for(let X of["gt","gte","lt","lte"]){let F=J[X];if(F===void 0)continue;if(typeof F!=="string")throw Error("deleteRange bounds must be strings");Y[X]=F,Z=!0}if(!Z)throw Error("deleteRange requires at least one of gt/gte/lt/lte; use deletePrefix to delete a whole prefix");let G=m(J.limit);if(G!==void 0)Y.limit=G;return Y}async function b(J,Y,Z){let G=j(Z);if(J.deleteRange)return J.deleteRange(Y,G);return H(J,Y,G)}function c(J,Y){let Z={key:J,open:!1};if(Y.gte!==void 0&&Y.gte>Z.key)Z.key=Y.gte,Z.open=!1;if(Y.gt!==void 0&&Y.gt>=Z.key)Z.key=Y.gt,Z.open=!0;return Z}function y(J,Y){let Z={key:O(J),open:!0};if(Y.lt!==void 0&&Y.lt<=Z.key)Z.key=Y.lt,Z.open=!0;if(Y.lte!==void 0&&Y.lte<Z.key)Z.key=Y.lte,Z.open=!1;return Z}function HJ(J,Y){let Z=c(J,Y),G=y(J,Y);if(Z.key>G.key||Z.key===G.key&&(Z.open||G.open))return null;return{lower:Z,upper:G}}function B(J){return J.replaceAll(/:+$/g,"")}function g(J,Y){let Z=B(J),G=B(Y);if(Z.length===0)return G;if(G.length===0)return Z;return`${Z}:${G}`}class A{#Y;#Z;constructor(J,Y){this.#Y=J,this.#Z=B(Y)}#J(J){if(this.#Z.length===0)return J;return J.length===0?`${this.#Z}:`:`${this.#Z}:${J}`}#$(J){if(this.#Z.length===0)return J;return J.slice(this.#Z.length+1)}#G(J={}){let Y={};if(J.limit!==void 0)Y.limit=J.limit;if(J.reverse!==void 0)Y.reverse=J.reverse;if(J.gt!==void 0)Y.gt=this.#J(J.gt);if(J.gte!==void 0)Y.gte=this.#J(J.gte);if(J.lt!==void 0)Y.lt=this.#J(J.lt);if(J.lte!==void 0)Y.lte=this.#J(J.lte);return Y}#_(J){let Y={};if(J.limit!==void 0)Y.limit=J.limit;if(J.gt!==void 0)Y.gt=this.#J(J.gt);if(J.gte!==void 0)Y.gte=this.#J(J.gte);if(J.lt!==void 0)Y.lt=this.#J(J.lt);if(J.lte!==void 0)Y.lte=this.#J(J.lte);return Y}capabilities(){return this.#Y.capabilities()}scoped(J){return new A(this.#Y,g(this.#Z,J))}async get(J){return this.#Y.get(this.#J(J))}async put(J,Y){await this.#Y.put(this.#J(J),Y)}async delete(J){await this.#Y.delete(this.#J(J))}async*scan(J,Y){for await(let[Z,G]of this.#Y.scan(this.#J(J),this.#G(Y)))yield[this.#$(Z),G]}async batch(J){await this.#Y.batch(J.map((Y)=>{if(Y.type==="put")return{type:"put",key:this.#J(Y.key),value:Y.value};return{type:"delete",key:this.#J(Y.key)}}))}async conditionalBatch(J,Y){return K(this.#Y,J.map((Z)=>({key:this.#J(Z.key),expectedValue:Z.expectedValue})),Y.map((Z)=>{if(Z.type==="put")return{type:"put",key:this.#J(Z.key),value:Z.value};return{type:"delete",key:this.#J(Z.key)}}))}async has(J){return P(this.#Y,this.#J(J))}async deletePrefix(J){return v(this.#Y,this.#J(J))}async deleteRange(J,Y){let Z=this.#_(j(Y));return b(this.#Y,this.#J(J),Z)}async*keys(J,Y){for await(let Z of h(this.#Y,this.#J(J),this.#G(Y)))yield this.#$(Z)}async count(J){return C(this.#Y,this.#J(J))}[Symbol.dispose](){this.#Y[Symbol.dispose]()}}function S(J,Y){return new A(J,Y)}var f=67108864;function I(J){if(J.type==="put")return{type:"put",key:J.key,value:U(J.value)};return{type:"delete",key:J.key}}function l(J){return{key:J.key,expectedValue:J.expectedValue===null?null:U(J.expectedValue)}}function d(J){if(!N(J)||typeof J.key!=="string"||typeof J.value!=="string")throw Error("HTTPStorage scan response contained an invalid NDJSON entry.");return{key:J.key,value:J.value}}function p(J){if(!N(J)||typeof J.applied!=="boolean")throw Error('HTTPStorage conditional batch response must include a boolean "applied" field.');return J.applied}function W(J,Y,Z){if(Z!==void 0)J.searchParams.set(Y,String(Z))}function s(J){if(J.trim().length===0)return null;let Y=d(JSON.parse(J));return[Y.key,T(Y.value)]}function a(J){if(J>f)throw Error("HTTPStorage scan response exceeded the maximum allowed size.")}async function*i(J){if(J.body===null)return;let Y=J.body.getReader(),Z=new TextDecoder,G="",X=0,F=!1;try{while(!0){let{done:L,value:D}=await Y.read();if(L){F=!0;break}X+=D.byteLength,a(X),G+=Z.decode(D,{stream:!0});let z=G.split(`
+`);G=z.pop()??"";for(let x of z)yield x}if(G+=Z.decode(),G.length>0)yield G}finally{try{if(!F)await Y.cancel()}catch{}Y.releaseLock()}}class r{#Y;#Z;#J;constructor(J){this.#Y=J.baseUrl instanceof URL?J.baseUrl:new URL(J.baseUrl),this.#Z={...J.headers},this.#J=J.remoteConditionalBatch??!1}capabilities(){return{persistence:"remote",readAfterWrite:"eventual",scanConsistency:"best-effort",atomicBatch:!0,conditionalBatch:this.#J,boundedRangeDelete:!1}}#$(J){let Y=this.#Y.href.endsWith("/")?this.#Y.href:`${this.#Y.href}/`;return new URL(J.replace(/^\/+/,""),Y)}#G(J){return this.#$(`/v1/storage/${encodeURIComponent(J)}`)}#_(J,Y){let Z=this.#$("/v1/storage");return Z.searchParams.set("prefix",J),W(Z,"limit",Y.limit),W(Z,"reverse",Y.reverse),W(Z,"gt",Y.gt),W(Z,"gte",Y.gte),W(Z,"lt",Y.lt),W(Z,"lte",Y.lte),Z}async#X(J,Y={},Z=[]){let G=new Headers(this.#Z);for(let[F,L]of new Headers(Y.headers).entries())G.set(F,L);let X=await fetch(J,{...Y,headers:G});if(!X.ok&&!Z.includes(X.status))throw Error(`HTTPStorage request failed: ${Y.method??"GET"} ${J.pathname} returned ${String(X.status)}.`);return X}async get(J){let Y=await this.#X(this.#G(J),{method:"GET"},[404]);if(Y.status===404)return null;return new Uint8Array(await Y.arrayBuffer())}async put(J,Y){await this.#X(this.#G(J),{method:"PUT",headers:{"content-type":"application/octet-stream"},body:new Blob([Y])})}async delete(J){await this.#X(this.#G(J),{method:"DELETE"})}async*scan(J,Y={}){let Z=await this.#X(this.#_(J,Y),{method:"GET",headers:{accept:"application/x-ndjson"}});for await(let G of i(Z)){let X=s(G);if(X!==null)yield X}}async batch(J){await this.#X(this.#$("/v1/storage/-/batch"),{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify({operations:J.map(I)})})}async conditionalBatch(J,Y){let Z=await this.#X(this.#$("/v1/storage/-/conditional-batch"),{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify({conditions:J.map(l),operations:Y.map(I)})});return p(await Z.json())}has(J){return M(this,J)}async*keys(J,Y){yield*Q(this,J,Y)}count(J){return V(this,J)}deletePrefix(J){return E(this,J)}deleteRange(J,Y){return H(this,J,j(Y))}scoped(J){return S(this,J)}[Symbol.dispose](){}}export{r as HTTPStorage};