@lostgradient/weft 0.2.0

package/dist/service-worker/scheduler.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Browser-compatible timer scheduler for Service Worker environments.
+ *
+ * Replaces the server-side Scheduler with one that uses
+ * Periodic Background Sync (where available) or falls back to
+ * `setTimeout`-based polling.
+ *
+ * @module service-worker/scheduler
+ */
+import type { TimerEntry } from '../core/types';
+import type { Storage } from '../storage/interface';
+export interface ServiceWorkerSchedulerOptions {
+    storage: Storage;
+    onTimerFired: (entry: TimerEntry) => void | Promise<void>;
+    registration?: ServiceWorkerRegistration;
+    periodicSyncTag?: string;
+    fallbackIntervalMilliseconds?: number;
+    getNow?: () => number;
+}
+/** Scheduler for browser Service Worker environments, backed by durable storage. */
+export declare class ServiceWorkerScheduler implements Disposable {
+    #private;
+    constructor(options: ServiceWorkerSchedulerOptions);
+    /** Schedule a durable timer (writes to storage). */
+    schedule(entry: TimerEntry): Promise<void>;
+    /** Cancel a timer (removes from storage). */
+    cancel(id: string): Promise<void>;
+    /** Scan for expired timers, fire callbacks, and clean up. */
+    tick(now?: number): Promise<void>;
+    /** Process all expired timers then stop. */
+    flush(now?: number): Promise<void>;
+    /** Start the scheduler. Uses Periodic Background Sync if available, otherwise falls back to setTimeout polling. */
+    start(): void;
+    /** Stop the scheduler and clear all timeout handles. */
+    stop(): void;
+    [Symbol.dispose](): void;
+}

package/dist/service-worker/scheduler.js

@@ -0,0 +1,117 @@
+import { decode } from "../core/codec.js";
+import { buildTimerBatchOperations } from "../core/scheduler.js";
+import { KEYS, resolvePrefixRangeEnd } from "../storage/interface.js";
+const DEFAULT_PERIODIC_SYNC_TAG = "weft-timers", DEFAULT_FALLBACK_INTERVAL_MILLISECONDS = 60000, DEFAULT_PERIODIC_SYNC_MIN_INTERVAL = 60000;
+
+export class ServiceWorkerScheduler {
+  #storage;
+  #onTimerFired;
+  #registration;
+  #periodicSyncTag;
+  #fallbackIntervalMilliseconds;
+  #getNow;
+  #timeoutHandle = null;
+  #running = !1;
+  #generation = 0;
+  constructor(options) {
+    this.#storage = options.storage;
+    this.#onTimerFired = options.onTimerFired;
+    this.#registration = options.registration;
+    this.#periodicSyncTag = options.periodicSyncTag ?? DEFAULT_PERIODIC_SYNC_TAG;
+    this.#fallbackIntervalMilliseconds = options.fallbackIntervalMilliseconds ?? DEFAULT_FALLBACK_INTERVAL_MILLISECONDS;
+    this.#getNow = options.getNow ?? Date.now;
+  }
+  async schedule(entry) {
+    await this.#storage.batch(buildTimerBatchOperations(entry));
+  }
+  async cancel(id) {
+    const indexKey = `timer-idx:${id}`, indexValue = await this.#storage.get(indexKey);
+    if (indexValue === null)
+      return;
+    const deadlineKey = decode(indexValue);
+    await this.#storage.batch([
+      { type: "delete", key: deadlineKey },
+      { type: "delete", key: indexKey }
+    ]);
+  }
+  async tick(now) {
+    const currentTime = now ?? this.#getNow(), expired = [];
+    for await (const [key, value] of this.#storage.scan("wf-deadline:", {
+      lt: resolvePrefixRangeEnd(KEYS.deadline(currentTime, ""))
+    })) {
+      const entry = decode(value);
+      expired.push({ key, entry });
+    }
+    for await (const [key, value] of this.#storage.scan("wf-delayed:", {
+      lt: resolvePrefixRangeEnd(KEYS.delayedStart(currentTime, ""))
+    })) {
+      const entry = decode(value);
+      expired.push({ key, entry });
+    }
+    expired.sort((left, right) => {
+      if (left.entry.fireAt !== right.entry.fireAt)
+        return left.entry.fireAt - right.entry.fireAt;
+      return left.key.localeCompare(right.key);
+    });
+    for (const { key, entry } of expired) {
+      try {
+        await this.#onTimerFired(entry);
+      } catch (error) {
+        console.error(`Timer callback failed for timer ${entry.id}:`, error);
+      }
+      const indexKey = `timer-idx:${entry.id}`;
+      await this.#storage.batch([
+        { type: "delete", key },
+        { type: "delete", key: indexKey }
+      ]);
+    }
+  }
+  async flush(now) {
+    await this.tick(now);
+    this.stop();
+  }
+  start() {
+    if (this.#running)
+      return;
+    this.#running = !0;
+    this.#generation++;
+    const periodicSync = this.#registration?.periodicSync;
+    if (periodicSync) {
+      const startGeneration = this.#generation;
+      periodicSync.register(this.#periodicSyncTag, {
+        minInterval: DEFAULT_PERIODIC_SYNC_MIN_INTERVAL
+      }).catch(() => {
+        if (this.#generation !== startGeneration)
+          return;
+        this.#schedulePoll();
+      });
+      return;
+    }
+    this.#schedulePoll();
+  }
+  stop() {
+    this.#running = !1;
+    this.#generation++;
+    if (this.#timeoutHandle !== null) {
+      clearTimeout(this.#timeoutHandle);
+      this.#timeoutHandle = null;
+    }
+  }
+  [Symbol.dispose]() {
+    this.stop();
+  }
+  #schedulePoll() {
+    if (!this.#running)
+      return;
+    const pollGeneration = this.#generation;
+    this.#timeoutHandle = setTimeout(() => {
+      this.tick().catch((error) => {
+        console.error("[weft] ServiceWorkerScheduler tick failed:", error);
+      }).finally(() => {
+        if (this.#generation !== pollGeneration)
+          return;
+        this.#schedulePoll();
+      });
+    }, this.#fallbackIntervalMilliseconds);
+  }
+}

package/dist/service-worker/setup.d.ts

@@ -0,0 +1,127 @@
+/**
+ * One-call Service Worker bootstrap for Weft.
+ *
+ * Wires up storage, engine, scheduler, and the four event listeners
+ * (`install`, `activate`, `fetch`, `periodicsync`) in a single async call.
+ * Use this when your Service Worker file calls `register` from inside the
+ * helper. Use the lower-level `createFetchHandler` / `createPeriodicSyncHandler`
+ * / `createLifecycleHandlers` factories when you've already registered
+ * workflows synchronously and want explicit listener attachment.
+ *
+ * @module service-worker/setup
+ */
+import { Engine } from '../core/engine';
+import type { Storage as WeftStorage } from '../storage/interface';
+import { ServiceWorkerScheduler } from './scheduler';
+/**
+ * Options for {@link setupServiceWorker}. All fields are optional; the
+ * helper supplies sensible defaults (`/weft/` path prefix, `'weft'`
+ * IndexedDB database name, `'weft-timers'` periodic-sync tag).
+ *
+ * @example
+ * ```ts
+ * import { workflow } from '@lostgradient/weft';
+ * import { setupServiceWorker, type SetupServiceWorkerOptions } from '@lostgradient/weft/service-worker';
+ *
+ * const checkout = workflow({ name: 'checkout' }).execute(async function* () {
+ *   yield;
+ *   return 'done';
+ * });
+ *
+ * const options: SetupServiceWorkerOptions = {
+ *   pathPrefix: '/weft/',
+ *   register(engine) {
+ *     engine.register(checkout);
+ *   },
+ * };
+ * void setupServiceWorker(options);
+ * ```
+ */
+export interface SetupServiceWorkerOptions {
+    /** Path prefix for engine HTTP routing. Default: `'/weft/'`. */
+    pathPrefix?: string;
+    /** IndexedDB database name. Default: `'weft'`. */
+    databaseName?: string;
+    /** Periodic-sync tag the scheduler ticks on. Default: `'weft-timers'`. */
+    periodicSyncTag?: string;
+    /**
+     * Pre-built engine. If provided, must use the same storage instance as
+     * `options.storage` (or its own storage if `storage` is omitted).
+     */
+    engine?: Engine;
+    /**
+     * Pre-built storage instance. Must be the same `===` reference as the
+     * engine's storage when both are provided.
+     */
+    storage?: WeftStorage;
+    /**
+     * Register workflows on the engine before listeners do real work.
+     * Resolves before the helper returns. Rejection causes subsequent
+     * fetch/periodic-sync handlers to fail-fast with explicit errors.
+     */
+    register?: (engine: Engine) => void | Promise<void>;
+}
+/**
+ * Result returned by {@link setupServiceWorker} once registration completes.
+ *
+ * @example
+ * ```ts
+ * import { workflow } from '@lostgradient/weft';
+ * import { setupServiceWorker, type SetupServiceWorkerResult } from '@lostgradient/weft/service-worker';
+ *
+ * const hello = workflow({ name: 'hello' }).execute(async function* () {
+ *   yield;
+ *   return 'world';
+ * });
+ *
+ * const setup: SetupServiceWorkerResult = await setupServiceWorker();
+ * await setup.ready;
+ * setup.engine.register(hello);
+ * ```
+ */
+export interface SetupServiceWorkerResult {
+    engine: Engine;
+    storage: WeftStorage;
+    scheduler: ServiceWorkerScheduler;
+    /** Resolves when `options.register` completes. Rejects if it threw. */
+    ready: Promise<void>;
+}
+/**
+ * Bootstrap a Weft engine inside a Service Worker scope. Attaches all four
+ * event listeners synchronously, then awaits `register` before any handler
+ * does real work. Safe to call once per worker evaluation; concurrent calls
+ * during initialization converge to the same {@link SetupServiceWorkerResult}.
+ *
+ * @example
+ * ```ts
+ * /// <reference lib="webworker" />
+ * import { workflow } from '@lostgradient/weft';
+ * import { setupServiceWorker } from '@lostgradient/weft/service-worker';
+ *
+ * const checkout = workflow({ name: 'checkout' }).execute(async function* () {
+ *   yield;
+ *   return 'done';
+ * });
+ *
+ * const setup = await setupServiceWorker({
+ *   register(engine) {
+ *     engine.register(checkout);
+ *   },
+ * });
+ * void setup;
+ * ```
+ */
+export declare function setupServiceWorker(options?: SetupServiceWorkerOptions): Promise<SetupServiceWorkerResult>;
+/**
+ * Test helper: clear the per-scope setup registry. Production code does not
+ * call this. Exposed so tests can simulate fresh worker evaluations without
+ * tearing down the scope itself.
+ *
+ * @example
+ * ```ts
+ * import { resetSetupServiceWorkerRegistry } from '@lostgradient/weft/service-worker';
+ * declare const fakeScope: object;
+ * resetSetupServiceWorkerRegistry(fakeScope);
+ * ```
+ */
+export declare function resetSetupServiceWorkerRegistry(scope?: object): void;

package/dist/service-worker/setup.js

@@ -0,0 +1,129 @@
+import { Engine } from "../core/engine.js";
+import { handleRequest } from "../server/handler.js";
+import { IndexedDBStorage } from "../storage/indexeddb.js";
+import { ServiceWorkerScheduler } from "./scheduler.js";
+import {
+  buildDelegatedRequest,
+  DEFAULT_PERIODIC_SYNC_TAG,
+  normalizePathPrefix
+} from "./shared.js";
+const DEFAULT_DATABASE_NAME = "weft", setupRegistry = new WeakMap;
+function isServiceWorkerScope(value) {
+  if (typeof value !== "object" || value === null)
+    return !1;
+  return typeof value.addEventListener === "function";
+}
+function getServiceWorkerScope() {
+  if (typeof self > "u")
+    return null;
+  if (!isServiceWorkerScope(self))
+    return null;
+  return self;
+}
+function buildErrorResponse(error) {
+  return new Response(`Weft service worker registration failed: ${error.message}`, {
+    status: 503,
+    headers: { "Content-Type": "text/plain" }
+  });
+}
+function checkExistingState(scope) {
+  const existing = setupRegistry.get(scope);
+  if (existing === void 0)
+    return null;
+  if (existing.status === "initializing")
+    return existing.resultPromise;
+  if (existing.status === "attached")
+    throw Error("setupServiceWorker already initialized in this scope.");
+  throw Error("setupServiceWorker previously failed in this scope. Re-evaluate the worker script to retry.", { cause: existing.error });
+}
+function resolveStorageAndEngine(options) {
+  if (options.engine !== void 0 && options.storage !== void 0) {
+    if (options.engine.storage !== options.storage)
+      throw TypeError("setupServiceWorker: `options.engine.storage` must be the same instance as `options.storage`. Mismatched storage would persist timers and checkpoints to different databases.");
+  }
+  if (options.engine !== void 0)
+    return {
+      engine: options.engine,
+      storage: options.storage ?? options.engine.storage
+    };
+  const storage = options.storage ?? new IndexedDBStorage(options.databaseName ?? DEFAULT_DATABASE_NAME);
+  return { storage, engine: new Engine({ storage }) };
+}
+function buildFetchListener(pathPrefix, engine, registrationReady) {
+  return (event) => {
+    const delegatedRequest = buildDelegatedRequest(event, pathPrefix);
+    if (delegatedRequest === null)
+      return;
+    event.respondWith(registrationReady.then(() => handleRequest(delegatedRequest, engine)).catch((error) => buildErrorResponse(error instanceof Error ? error : Error(String(error)))));
+  };
+}
+function attachListeners(scope, pathPrefix, periodicSyncTag, engine, scheduler, registrationReady) {
+  const fetchListener = buildFetchListener(pathPrefix, engine, registrationReady), periodicSyncListener = (event) => {
+    if (event.tag !== periodicSyncTag)
+      return;
+    event.waitUntil(registrationReady.then(() => scheduler.tick()));
+  }, installListener = (event) => {
+    const skipWaitingPromise = typeof scope.skipWaiting === "function" ? scope.skipWaiting.call(scope) : Promise.resolve();
+    event.waitUntil(skipWaitingPromise);
+  }, activateListener = (event) => {
+    const clients = scope.clients, claimPromise = clients !== void 0 && typeof clients.claim === "function" ? clients.claim.call(clients) : Promise.resolve();
+    event.waitUntil(claimPromise);
+  }, addEventListener = scope.addEventListener.bind(scope);
+  addEventListener("install", installListener);
+  addEventListener("activate", activateListener);
+  addEventListener("fetch", fetchListener);
+  addEventListener("periodicsync", periodicSyncListener);
+}
+export function setupServiceWorker(options = {}) {
+  const scope = getServiceWorkerScope();
+  if (scope === null)
+    return Promise.reject(Error("setupServiceWorker: not running inside a Service Worker scope. Either `self` is undefined or `self.addEventListener` is missing."));
+  let existingResult;
+  try {
+    existingResult = checkExistingState(scope);
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  if (existingResult !== null)
+    return existingResult;
+  let resolved;
+  try {
+    resolved = resolveStorageAndEngine(options);
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  const { storage, engine } = resolved, periodicSyncTag = options.periodicSyncTag ?? DEFAULT_PERIODIC_SYNC_TAG, pathPrefix = normalizePathPrefix(options.pathPrefix), scheduler = new ServiceWorkerScheduler({
+    storage,
+    onTimerFired: (entry) => engine.fireTimer(entry),
+    periodicSyncTag
+  }), registrationReady = Promise.resolve().then(() => {
+    if (options.register === void 0)
+      return;
+    return options.register(engine);
+  });
+  attachListeners(scope, pathPrefix, periodicSyncTag, engine, scheduler, registrationReady);
+  const result = {
+    engine,
+    storage,
+    scheduler,
+    ready: registrationReady
+  }, resultPromise = registrationReady.then(() => {
+    setupRegistry.set(scope, { status: "attached", result });
+    return result;
+  }, (error) => {
+    const wrapped = error instanceof Error ? error : Error(String(error));
+    setupRegistry.set(scope, { status: "failed", error: wrapped });
+    throw wrapped;
+  });
+  setupRegistry.set(scope, { status: "initializing", resultPromise });
+  return resultPromise;
+}
+export function resetSetupServiceWorkerRegistry(scope) {
+  if (scope !== void 0) {
+    setupRegistry.delete(scope);
+    return;
+  }
+  const sw = getServiceWorkerScope();
+  if (sw !== null)
+    setupRegistry.delete(sw);
+}

package/dist/service-worker/shared.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Internal shared helpers for the Service Worker bootstrap surface. Extracted
+ * here so `index.ts` (low-level factories) and `setup.ts` (one-call helper)
+ * can both depend on them without forming an import cycle.
+ *
+ * @module service-worker/shared
+ */
+/**
+ * Default periodic-sync tag used when callers don't pass one explicitly.
+ * Shared by `createPeriodicSyncHandler` and `setupServiceWorker` so the
+ * two entry points cannot drift to different tags.
+ *
+ * @example
+ * ```ts
+ * import { DEFAULT_PERIODIC_SYNC_TAG } from '@lostgradient/weft/service-worker';
+ * const tag: 'weft-timers' = DEFAULT_PERIODIC_SYNC_TAG;
+ * void tag;
+ * ```
+ */
+export declare const DEFAULT_PERIODIC_SYNC_TAG = "weft-timers";
+/**
+ * Minimal FetchEvent shape used by `createFetchHandler` and the internal
+ * `buildDelegatedRequest` helper. Stays narrow on purpose so the module
+ * doesn't pull in webworker types that conflict with Bun's lib.
+ *
+ * @example
+ * ```ts
+ * import { createFetchHandler, type MinimalFetchEvent } from '@lostgradient/weft/service-worker';
+ * import { Engine, MemoryStorage } from '@lostgradient/weft';
+ * const engine = new Engine({ storage: new MemoryStorage() });
+ * const handler = createFetchHandler({ engine });
+ * declare const event: MinimalFetchEvent;
+ * handler(event);
+ * ```
+ */
+export interface MinimalFetchEvent {
+    request: Request;
+    respondWith(response: Response | Promise<Response>): void;
+}
+/**
+ * Minimal `ExtendableEvent` shape — accepted by `install`, `activate`, and
+ * any handler that wants to extend the event lifetime via `waitUntil`.
+ *
+ * @example
+ * ```ts
+ * import type { MinimalExtendableEvent } from '@lostgradient/weft/service-worker';
+ * declare const event: MinimalExtendableEvent;
+ * event.waitUntil(Promise.resolve());
+ * ```
+ */
+export interface MinimalExtendableEvent {
+    waitUntil(promise: Promise<unknown>): void;
+}
+/**
+ * Minimal `PeriodicSyncEvent` shape — accepted by `createPeriodicSyncHandler`.
+ *
+ * @example
+ * ```ts
+ * import type { MinimalPeriodicSyncEvent } from '@lostgradient/weft/service-worker';
+ * declare const event: MinimalPeriodicSyncEvent;
+ * if (event.tag === 'weft-timers') event.waitUntil(Promise.resolve());
+ * ```
+ */
+export interface MinimalPeriodicSyncEvent extends MinimalExtendableEvent {
+    tag: string;
+}
+/**
+ * Normalize a service-worker path prefix: append a trailing slash if
+ * missing. The default is `'/weft/'`.
+ *
+ * @example
+ * ```ts
+ * import { normalizePathPrefix } from '@lostgradient/weft/service-worker';
+ * normalizePathPrefix('/weft'); // '/weft/'
+ * normalizePathPrefix(undefined); // '/weft/'
+ * ```
+ */
+export declare function normalizePathPrefix(pathPrefix: string | undefined): string;
+/**
+ * Build a delegated request with the path prefix stripped. Returns `null`
+ * if the request's pathname doesn't start with `pathPrefix` (caller should
+ * pass-through, not call `respondWith`). Single source of truth for the
+ * URL-stripping convention shared by `createFetchHandler` and
+ * `setupServiceWorker`.
+ *
+ * @example
+ * ```ts
+ * import { buildDelegatedRequest, normalizePathPrefix } from '@lostgradient/weft/service-worker';
+ * declare const event: { request: Request; respondWith(r: Response | Promise<Response>): void };
+ * const delegated = buildDelegatedRequest(event, normalizePathPrefix('/weft/'));
+ * void delegated;
+ * ```
+ */
+export declare function buildDelegatedRequest(event: MinimalFetchEvent, pathPrefix: string): Request | null;

package/dist/service-worker/shared.js

@@ -0,0 +1,15 @@
+const DEFAULT_PATH_PREFIX = "/weft/";
+export const DEFAULT_PERIODIC_SYNC_TAG = "weft-timers";
+export function normalizePathPrefix(pathPrefix) {
+  const value = pathPrefix ?? DEFAULT_PATH_PREFIX;
+  return value.endsWith("/") ? value : `${value}/`;
+}
+export function buildDelegatedRequest(event, pathPrefix) {
+  const url = new URL(event.request.url);
+  if (!url.pathname.startsWith(pathPrefix))
+    return null;
+  const strippedPathname = "/" + url.pathname.slice(pathPrefix.length), strippedUrl = new URL(strippedPathname, url.origin);
+  strippedUrl.search = url.search;
+  const request = event.request.clone();
+  return new Request(strippedUrl.toString(), request);
+}

package/dist/storage/auto.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Runtime-detected default storage backend for **Bun and Node** processes.
+ *
+ * Imported via `@lostgradient/weft/storage/auto`. Resolves a persistent storage
+ * adapter appropriate for the current runtime:
+ *
+ *   1. Bun → `BunSQLiteStorage`
+ *   2. Node → `NodeSQLiteStorage`
+ *   3. otherwise → throw
+ *
+ * Path policy:
+ *   - `process.env.WEFT_DEFAULT_STORAGE_PATH` if set
+ *   - else `${tmpdir()}/weft-default/<cwd-hash>.db`
+ *
+ * The parent directory is created (recursive) before the path is returned.
+ *
+ * **Not for browsers.** This module statically imports `node:fs`,
+ * `node:os`, `node:path`, and `node:crypto`, so bundling it into a
+ * browser target will fail. Browser/Service Worker contexts should use
+ * `IndexedDBStorage` directly (or `setupServiceWorker()` from
+ * `@lostgradient/weft/service-worker`, which constructs IndexedDB internally).
+ *
+ * `resolveDefaultStorage()` is for developer convenience. Production
+ * deployments should pick an explicit adapter and pass it to
+ * `new Engine({ storage })`.
+ *
+ * @module @lostgradient/weft/storage/auto
+ */
+import type { Storage as WeftStorage } from './interface.ts';
+/**
+ * Resolve a runtime-appropriate persistent storage adapter for Bun or
+ * Node. Throws in browser/Service Worker contexts (and any environment
+ * that exposes neither `Bun` nor a Node-shaped `process`).
+ *
+ * @example
+ * ```ts
+ * import { Engine } from '@lostgradient/weft';
+ * import { resolveDefaultStorage } from '@lostgradient/weft/storage/auto';
+ *
+ * await using storage = await resolveDefaultStorage();
+ * await using engine = new Engine({ storage });
+ * void engine;
+ * ```
+ */
+export declare function resolveDefaultStorage(): Promise<WeftStorage>;

package/dist/storage/auto.js

@@ -0,0 +1,2 @@
+// @bun
+var Y=Object.defineProperty;var Z=(z)=>z;function $(z,C){this[z]=Z.bind(null,C)}var y=(z,C)=>{for(var F in C)Y(z,F,{get:C[F],enumerable:!0,configurable:!0,set:$.bind(C,F)})};var R=(z,C)=>()=>(z&&(C=z(z=0)),C);import{createHash as W}from"crypto";import{mkdirSync as j}from"fs";import{tmpdir as k}from"os";import{dirname as q,join as A}from"path";function H(){return{hasBun:typeof globalThis.Bun<"u",hasNode:typeof process<"u"&&typeof process.versions?.node==="string"}}function I(){let z=typeof process<"u"?process.cwd():"weft-default";return W("sha256").update(z).digest("hex").slice(0,16)}function J(){let z=typeof process<"u"?process.env.WEFT_DEFAULT_STORAGE_PATH:void 0,C=z!==void 0&&z.length>0?z:A(k(),"weft-default",`${I()}.db`);return j(q(C),{recursive:!0}),C}function K(z){if(z==="Bun")return typeof globalThis.Bun;return typeof process}function X(z,C){return import.meta.url.endsWith(".ts")?z:C}async function V(z){return await import(z)}var P=X("./bun-sql.ts","./bun-sql.js"),x=X("./node-sqlite.ts","./node-sqlite.js");async function N(){let z=H();if(z.hasBun){let{BunSQLiteStorage:C}=await V(P);return new C(J())}if(z.hasNode){let{NodeSQLiteStorage:C}=await V(x);return new C(J())}throw Error(`resolveDefaultStorage: requires Bun or Node. Detected: typeof Bun=${K("Bun")}, typeof process=${K("process")}. In browser/Service Worker contexts, use \`IndexedDBStorage\` directly or \`setupServiceWorker()\` from \`@lostgradient/weft/service-worker\`.`)}export{N as resolveDefaultStorage};

package/dist/storage/bun-sql.d.ts

@@ -0,0 +1,64 @@
+import { type SQLQueryBindings } from 'bun:sqlite';
+import { type DeleteRangeOptions } from './delete-range';
+import { type BatchOperation, type ConditionalBatchCondition, type ScanOptions, type Storage, type StorageCapabilities } from './interface';
+/**
+ * Runtime-neutral alias for the Bun SQLite adapter. Consumers that import
+ * from `@lostgradient/weft/storage/sqlite` get this class under Bun.
+ */
+export { BunSQLiteStorage as SQLiteStorage };
+/**
+ * SQLite-backed {@link Storage} using Bun's built-in `bun:sqlite` module.
+ *
+ * Opens the database in WAL mode with prepared-statement caching so the hot
+ * `get`/`put`/`batch` paths pay zero per-call `prepare()` cost.  Pass
+ * `':memory:'` (the default) for ephemeral storage, or a file path for durable
+ * persistence across restarts.
+ *
+ * `query<T>(sql, params?)` runs read-only SQL against the underlying database
+ * after validation with `assertReadOnlyQuery`. It is intended for dashboards or
+ * debugging; arbitrary mutations are rejected.
+ *
+ * @example
+ * ```ts
+ * import { BunSQLiteStorage } from '@lostgradient/weft/storage/sqlite/bun';
+ * import { workflow, Engine, type WorkflowContext } from '@lostgradient/weft';
+ *
+ * // Durable on-disk storage
+ * await using storage = new BunSQLiteStorage('./weft.db');
+ * await using engine = new Engine({ storage });
+ *
+ * engine.register(
+ *   workflow({ name: 'echo' }).execute(async function* (ctx: WorkflowContext, input: unknown) {
+ *     return input;
+ *   }),
+ * );
+ *
+ * const handle = await engine.start('echo', { msg: 'hi' });
+ * console.log(await handle.result()); // { msg: 'hi' }
+ * ```
+ */
+export declare class BunSQLiteStorage implements Storage {
+    #private;
+    /**
+     * Number of distinct prepared-statement cache entries for scan().
+     * Exposed for regression tests that assert the cache stays bounded
+     * regardless of the numeric values callers pass.
+     */
+    get scanStatementCacheSize(): number;
+    constructor(path?: string);
+    capabilities(): StorageCapabilities;
+    get(key: string): Promise<Uint8Array | null>;
+    put(key: string, value: Uint8Array): Promise<void>;
+    delete(key: string): Promise<void>;
+    has(key: string): Promise<boolean>;
+    deletePrefix(prefix: string): Promise<number>;
+    deleteRange(prefix: string, options: DeleteRangeOptions): Promise<number>;
+    scan(prefix: string, options?: ScanOptions): AsyncIterable<[string, Uint8Array]>;
+    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?: SQLQueryBindings[]): Promise<T[]>;
+    [Symbol.dispose](): void;
+}