@freecorps/ember-offline 0.1.0 → 0.3.0

package/dist/opfs.js

@@ -0,0 +1,66 @@
+// The page half of OPFS storage: a `StorageAdapter` whose calls run in the app's offline Worker (opfs-worker.ts),
+// where SQLite-Wasm owns the OPFS files. Local results are watched there and streamed back. The Worker reports its
+// `sync` specs on load, so they are declared once, in the Worker.
+//
+//   import { opfsStorage } from "@freecorps/ember-offline/opfs";
+//   new EmberClient({
+//     url,
+//     storage: opfsStorage({ worker: new Worker(new URL("./ember-offline.worker.ts", import.meta.url), { type: "module" }) }),
+//     optimisticUpdates: { "messages:send": addMessage },
+//   });
+//
+// If OPFS or the Worker fails to start, `load()` rejects and the client carries on without offline storage
+// (`storage_error`), as with any adapter.
+import { RemoteStorage } from "./remote.js";
+export class OpfsStorage extends RemoteStorage {
+    options;
+    worker;
+    failed;
+    constructor(options) {
+        const worker = typeof options.worker === "function" ? options.worker() : options.worker;
+        super(worker);
+        this.options = options;
+        this.worker = worker;
+        // A Worker that cannot load (bad URL, syntax error, no module workers) fails the load instead of hanging it.
+        let fail = () => { };
+        this.failed = new Promise((_, reject) => (fail = reject));
+        this.failed.catch(() => undefined);
+        // After a successful load too: a Worker that reports an error (crash, wasm abort, OOM) is not trusted again —
+        // calls in flight and later ones fail with the error, watches get it once, and the Worker is terminated so it
+        // releases its OPFS handles (and, with several tabs, the leader lock for the next tab).
+        const w = worker;
+        w.addEventListener?.("error", (e) => {
+            const error = new Error(`offline worker failed: ${e?.message ?? "error"}`);
+            fail(error);
+            this.setUnavailable(error, { permanent: true });
+            this.terminate();
+        });
+    }
+    terminated = false;
+    terminate() {
+        if (this.terminated || this.options.terminate === false)
+            return;
+        this.terminated = true;
+        this.worker.terminate?.();
+    }
+    async load() {
+        return await Promise.race([super.load(), this.failed]);
+    }
+    async close() {
+        // A dead Worker never answers "close": stop waiting when it has failed or after the timeout.
+        let timer;
+        const timeout = new Promise((r) => (timer = setTimeout(r, this.options.closeTimeoutMs ?? 5000)));
+        try {
+            await Promise.race([this.shutdown(), this.failed.catch(() => undefined), timeout]);
+        }
+        finally {
+            clearTimeout(timer);
+            this.detach();
+            this.terminate();
+        }
+    }
+}
+/** Offline storage on SQLite-Wasm over OPFS, run in a dedicated Worker (see opfs-worker.ts). */
+export function opfsStorage(options) {
+    return new OpfsStorage(options);
+}

package/dist/remote.d.ts

@@ -0,0 +1,109 @@
+import { type LocalIdentity, type LocalQueryRequest, type LocalQueryResult, type PendingStorage, type QueryUpdate, type StorageAdapter, type SyncSpec } from "@freecorps/ember-client";
+/** Anything that carries messages both ways (Worker, `self` in a worker, MessagePort, BroadcastChannel). */
+export interface Endpoint {
+    postMessage(message: unknown): void;
+    addEventListener(type: "message", listener: (e: {
+        data: unknown;
+    }) => void): void;
+    removeEventListener(type: "message", listener: (e: {
+        data: unknown;
+    }) => void): void;
+}
+/** What can be served: a StorageAdapter, optionally with `watchQueryLocally` and `clear` (OfflineStore has both). */
+export type ServableStorage = StorageAdapter & {
+    clear?(): Promise<void>;
+};
+type Op = "load" | "getClientId" | "setClientId" | "loadPending" | "putPending" | "removePending" | "applyPatch" | "runQueryLocally" | "setIdentity" | "flush" | "clear" | "close" | "watch" | "unwatch";
+export declare const randomId: () => string;
+/** Calls `op` on an adapter (the serving side of the protocol, also used to re-run calls locally). */
+export declare function invoke(s: ServableStorage, op: Op, a: unknown[]): Promise<unknown>;
+export interface ServeOptions {
+    /** The address requests must be sent to (default `"*"`: any). */
+    address?: string;
+    /** First message from a caller (tabs.ts watches its liveness). */
+    onPeer?(peer: string): void;
+}
+export interface Served {
+    /** Announce this server (callers resend what is in flight). */
+    announce(from: string): void;
+    /** Forget a caller's watches (it is gone). */
+    dropPeer(peer: string): void;
+    stop(): void;
+}
+/** Serves an adapter on an endpoint: answers calls addressed to it, streams watched results. */
+export declare function serveStorage(storage: ServableStorage, endpoint: Endpoint, options?: ServeOptions): Served;
+export interface RemoteStorageOptions {
+    /** This caller's address (default: random). */
+    id?: string;
+    /** The server's address (default `"*"`). */
+    to?: string;
+    /** Instead of posting, run calls here (a tab that became the leader runs its own calls locally). */
+    local?: ServableStorage | null;
+    /** A server announced itself (after the calls in flight were resent to it). */
+    onLeader?(from: string): void;
+}
+/**
+ * The client side: a StorageAdapter whose calls run on a remote `serveStorage`. Calls in flight are resent when a
+ * new server announces itself (`k: "leader"`), and watches are re-established there.
+ */
+export declare class RemoteStorage implements StorageAdapter {
+    private readonly endpoint;
+    readonly id: string;
+    readonly persistPending: PendingStorage;
+    private syncSpecs;
+    private seq;
+    private readonly inflight;
+    private readonly watches;
+    /** Local unwatch functions while calls run locally. */
+    private readonly localWatches;
+    private local;
+    /** No server to send to (see setUnavailable): calls fail with this until one announces itself. */
+    private unavailable;
+    /** The server is gone for good (setUnavailable permanent): calls fail with this, announcements are ignored. */
+    private dead;
+    private readonly to;
+    private readonly onLeader;
+    private closed;
+    private readonly listener;
+    constructor(endpoint: Endpoint, options?: RemoteStorageOptions);
+    /** Known after `load()` (the server's `sync` specs, as names). */
+    get sync(): readonly SyncSpec[];
+    load(): Promise<{
+        identity?: LocalIdentity | null;
+    }>;
+    applyPatch(u: QueryUpdate): Promise<void>;
+    runQueryLocally(req: LocalQueryRequest): Promise<LocalQueryResult | undefined>;
+    setIdentity(identity: LocalIdentity | null): Promise<void>;
+    flush(): Promise<void>;
+    clear(): Promise<void>;
+    watchQueryLocally(req: LocalQueryRequest, onResult: (r: LocalQueryResult | undefined) => void, onError?: (e: Error) => void): () => void;
+    private establish;
+    /**
+     * Run calls here from now on (null: post them again). Calls in flight are re-run on the new target and watches
+     * re-established there.
+     */
+    setLocal(local: ServableStorage | null): void;
+    /**
+     * Nobody serves now (a tab that could not open the storage gave up the lead): calls in flight and new calls
+     * fail with `error` instead of waiting, watches get `error` once. The next server that announces itself ends
+     * this — calls go to it and watches are re-established there.
+     */
+    setUnavailable(error: Error, options?: {
+        permanent?: boolean;
+    }): void;
+    private call;
+    private dispatch;
+    /**
+     * A new server (or a local target): every call still in flight runs again there, in order; watches too. Each
+     * call goes out under a new request id, so only the server it was last sent to can answer it: a late answer of
+     * the previous server (to the old id) finds nothing.
+     */
+    private resend;
+    private onMessage;
+    /** Closes the served storage itself (then this caller): e.g. the Worker's database before terminating it. */
+    shutdown(): Promise<void>;
+    /** Stop: pending calls are rejected, the server drops this caller's watches. */
+    close(): void | Promise<void>;
+    protected detach(): void;
+}
+export {};

package/dist/remote.js

@@ -0,0 +1,388 @@
+// A `StorageAdapter` across a message boundary: the main thread ⇄ the Worker that owns an OPFS database
+// (opfs.ts), and follower tabs ⇄ the leader tab (tabs.ts). One small request/response protocol over anything with
+// `postMessage` + `message` events (Worker, worker global scope, MessagePort, BroadcastChannel); values cross by
+// structured clone (bigint and Uint8Array included).
+//
+//   → { ember: "offline/1", k: "req", id, from, to, op, a }          a call (to: the serving address)
+//   ← { ember: "offline/1", k: "res", id, to, ok, v | e }            its answer (to: the caller)
+//   ← { ember: "offline/1", k: "watch", to, wid, r | e }             a watched local result (watchQueryLocally)
+//   ← { ember: "offline/1", k: "leader", from }                      a new server took over: resend in-flight calls
+//   → { ember: "offline/1", k: "bye", from }                         the caller is gone: drop its watches
+//
+// Operations: load (+ the server's `sync` specs), getClientId, setClientId, loadPending, putPending, removePending,
+// applyPatch, runQueryLocally, setIdentity, flush, clear, close, watch / unwatch.
+//
+// Every operation is idempotent (results are keyed by query, the pending queue by `mid`, metadata by key), so a
+// client resends whatever is still in flight when a new server announces itself — each call under a new `id`, so
+// only the server it was last sent to can settle it. A stopped server (a leader leaving) answers nothing more: what
+// it was still running is resent to the next one rather than failed with an error it got while closing.
+import { getFunctionName, } from "@freecorps/ember-client";
+const TAG = "offline/1";
+const isMsg = (x) => typeof x === "object" && x !== null && x.ember === TAG;
+const toErr = (e) => {
+    const x = e;
+    return { name: String(x?.name ?? "Error"), message: String(x?.message ?? e), ...(typeof x?.code === "string" ? { code: x.code } : {}) };
+};
+const fromErr = (e) => Object.assign(new Error(e.message), { name: e.name, ...(e.code ? { code: e.code } : {}) });
+export const randomId = () => typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
+/** `sync` specs as plain data (function references are proxies: not cloneable). */
+const plainSync = (s) => (s ?? []).map((x) => ({ query: getFunctionName(x.query), ...(x.args ? { args: x.args } : {}), ...(x.shard !== undefined ? { shard: x.shard } : {}) }));
+/** Calls `op` on an adapter (the serving side of the protocol, also used to re-run calls locally). */
+export async function invoke(s, op, a) {
+    switch (op) {
+        case "load":
+            return { ...((await s.load()) ?? {}), sync: plainSync(s.sync) };
+        case "getClientId":
+            return await s.persistPending.getClientId();
+        case "setClientId":
+            return void (await s.persistPending.setClientId(a[0]));
+        case "loadPending":
+            return await s.persistPending.load();
+        case "putPending":
+            return void (await s.persistPending.put(a[0]));
+        case "removePending":
+            return void (await s.persistPending.remove(a[0]));
+        case "applyPatch":
+            return void (await s.applyPatch(a[0]));
+        case "runQueryLocally":
+            return (await s.runQueryLocally(a[0])) ?? null;
+        case "setIdentity":
+            return void (await s.setIdentity?.(a[0]));
+        case "flush":
+            return void (await s.flush?.());
+        case "clear":
+            return void (await s.clear?.());
+        case "close":
+            return void (await s.close?.());
+        default:
+            throw new Error(`offline storage: unknown operation ${op}`);
+    }
+}
+/** Serves an adapter on an endpoint: answers calls addressed to it, streams watched results. */
+export function serveStorage(storage, endpoint, options = {}) {
+    const address = options.address ?? "*";
+    // Once stopped (a leader leaving), calls still running here are not answered: their callers resend them to the
+    // next server (every op is idempotent), instead of settling with an error this server got while closing.
+    let stopped = false;
+    const peers = new Set();
+    const watches = new Map();
+    const post = (m) => {
+        if (!stopped)
+            endpoint.postMessage(m);
+    };
+    const watchesOf = (peer) => {
+        let w = watches.get(peer);
+        if (!w)
+            watches.set(peer, (w = new Map()));
+        return w;
+    };
+    const dropPeer = (peer) => {
+        for (const off of watches.get(peer)?.values() ?? [])
+            off();
+        watches.delete(peer);
+        peers.delete(peer);
+    };
+    const listener = (ev) => {
+        const m = ev.data;
+        if (!isMsg(m))
+            return;
+        if (m.k === "bye")
+            return dropPeer(m.from);
+        if (m.k !== "req" || (address !== "*" && m.to !== address))
+            return;
+        if (!peers.has(m.from)) {
+            peers.add(m.from);
+            options.onPeer?.(m.from);
+        }
+        if (m.op === "watch") {
+            const [wid, req] = m.a;
+            const mine = watchesOf(m.from);
+            mine.get(wid)?.();
+            const send = (r) => post({ ember: TAG, k: "watch", to: m.from, wid, r: r ?? null });
+            const fail = (e) => post({ ember: TAG, k: "watch", to: m.from, wid, e: toErr(e) });
+            if (storage.watchQueryLocally)
+                mine.set(wid, storage.watchQueryLocally(req, send, fail));
+            else {
+                // One-shot fallback for adapters without watches.
+                Promise.resolve(storage.runQueryLocally(req)).then(send, fail);
+                mine.set(wid, () => { });
+            }
+            return post({ ember: TAG, k: "res", id: m.id, to: m.from, ok: true });
+        }
+        if (m.op === "unwatch") {
+            const mine = watchesOf(m.from);
+            mine.get(m.a[0])?.();
+            mine.delete(m.a[0]);
+            return post({ ember: TAG, k: "res", id: m.id, to: m.from, ok: true });
+        }
+        invoke(storage, m.op, m.a).then((v) => post({ ember: TAG, k: "res", id: m.id, to: m.from, ok: true, v }), (e) => post({ ember: TAG, k: "res", id: m.id, to: m.from, ok: false, e: toErr(e) }));
+    };
+    endpoint.addEventListener("message", listener);
+    return {
+        announce: (from) => post({ ember: TAG, k: "leader", from }),
+        dropPeer,
+        stop() {
+            if (stopped)
+                return;
+            stopped = true;
+            endpoint.removeEventListener("message", listener);
+            for (const p of [...watches.keys()])
+                dropPeer(p);
+        },
+    };
+}
+/**
+ * The client side: a StorageAdapter whose calls run on a remote `serveStorage`. Calls in flight are resent when a
+ * new server announces itself (`k: "leader"`), and watches are re-established there.
+ */
+export class RemoteStorage {
+    endpoint;
+    id;
+    persistPending;
+    syncSpecs = [];
+    seq = 0;
+    inflight = new Map();
+    watches = new Map();
+    /** Local unwatch functions while calls run locally. */
+    localWatches = new Map();
+    local;
+    /** No server to send to (see setUnavailable): calls fail with this until one announces itself. */
+    unavailable = null;
+    /** The server is gone for good (setUnavailable permanent): calls fail with this, announcements are ignored. */
+    dead = null;
+    to;
+    onLeader;
+    closed = false;
+    listener = (ev) => this.onMessage(ev.data);
+    constructor(endpoint, options = {}) {
+        this.endpoint = endpoint;
+        this.id = options.id ?? randomId();
+        this.to = options.to ?? "*";
+        this.local = options.local ?? null;
+        this.onLeader = options.onLeader;
+        endpoint.addEventListener("message", this.listener);
+        this.persistPending = {
+            getClientId: () => this.call("getClientId"),
+            setClientId: (id) => this.call("setClientId", id),
+            load: () => this.call("loadPending"),
+            put: (r) => this.call("putPending", r),
+            remove: (mid) => this.call("removePending", mid),
+        };
+    }
+    /** Known after `load()` (the server's `sync` specs, as names). */
+    get sync() {
+        return this.syncSpecs;
+    }
+    async load() {
+        const r = (await this.call("load"));
+        this.syncSpecs = r.sync ?? [];
+        return { identity: r.identity ?? null };
+    }
+    applyPatch(u) {
+        return this.call("applyPatch", u);
+    }
+    async runQueryLocally(req) {
+        return (await this.call("runQueryLocally", req)) ?? undefined;
+    }
+    setIdentity(identity) {
+        return this.call("setIdentity", identity);
+    }
+    flush() {
+        return this.call("flush");
+    }
+    clear() {
+        return this.call("clear");
+    }
+    watchQueryLocally(req, onResult, onError) {
+        const wid = ++this.seq;
+        this.watches.set(wid, { req, onResult, ...(onError ? { onError } : {}) });
+        this.establish(wid);
+        return () => {
+            if (!this.watches.delete(wid))
+                return;
+            const off = this.localWatches.get(wid);
+            if (off) {
+                this.localWatches.delete(wid);
+                off();
+            }
+            else if (!this.closed && !this.unavailable)
+                void this.call("unwatch", wid).catch(() => undefined);
+        };
+    }
+    establish(wid) {
+        const w = this.watches.get(wid);
+        if (!w || this.closed)
+            return;
+        if (this.unavailable) {
+            // Kept: established again when a server announces itself.
+            w.onError?.(this.unavailable);
+            return;
+        }
+        const local = this.local;
+        if (local?.watchQueryLocally) {
+            this.localWatches.set(wid, local.watchQueryLocally(w.req, w.onResult, w.onError));
+            return;
+        }
+        if (local) {
+            // One-shot fallback for adapters without watches, as serveStorage gives followers.
+            this.localWatches.set(wid, () => { });
+            const live = () => this.watches.get(wid) === w && this.local === local && !this.closed;
+            Promise.resolve()
+                .then(() => local.runQueryLocally(w.req))
+                .then((r) => live() && w.onResult(r), (e) => live() && w.onError?.(e));
+            return;
+        }
+        this.call("watch", wid, w.req).catch((e) => w.onError?.(e));
+    }
+    /**
+     * Run calls here from now on (null: post them again). Calls in flight are re-run on the new target and watches
+     * re-established there.
+     */
+    setLocal(local) {
+        if (this.dead)
+            return;
+        for (const off of this.localWatches.values())
+            off();
+        this.localWatches.clear();
+        this.local = local;
+        this.unavailable = null;
+        this.resend();
+    }
+    /**
+     * Nobody serves now (a tab that could not open the storage gave up the lead): calls in flight and new calls
+     * fail with `error` instead of waiting, watches get `error` once. The next server that announces itself ends
+     * this — calls go to it and watches are re-established there.
+     */
+    setUnavailable(error, options = {}) {
+        if (this.closed || this.dead)
+            return;
+        for (const off of this.localWatches.values())
+            off();
+        this.localWatches.clear();
+        this.local = null;
+        this.unavailable = error;
+        // Permanent (the server itself died, e.g. a crashed Worker): no announcement brings it back.
+        if (options.permanent)
+            this.dead = error;
+        for (const [id, c] of [...this.inflight]) {
+            this.inflight.delete(id);
+            if (c.op === "watch" || c.op === "unwatch")
+                c.resolve(undefined);
+            else
+                c.reject(error);
+        }
+        for (const wid of this.watches.keys())
+            this.establish(wid);
+    }
+    call(op, ...a) {
+        if (this.closed)
+            return Promise.reject(new Error("offline storage: closed"));
+        if (this.unavailable)
+            return Promise.reject(this.unavailable);
+        return new Promise((resolve, reject) => {
+            const id = ++this.seq;
+            this.inflight.set(id, { op, a, resolve, reject });
+            this.dispatch(id);
+        });
+    }
+    dispatch(id) {
+        const c = this.inflight.get(id);
+        if (!c)
+            return;
+        if (this.local) {
+            const local = this.local;
+            invoke(local, c.op, c.a).then((v) => {
+                if (this.inflight.get(id) !== c || this.local !== local)
+                    return;
+                this.inflight.delete(id);
+                c.resolve(v);
+            }, (e) => {
+                if (this.inflight.get(id) !== c || this.local !== local)
+                    return;
+                this.inflight.delete(id);
+                c.reject(e);
+            });
+            return;
+        }
+        this.endpoint.postMessage({ ember: TAG, k: "req", id, from: this.id, to: this.to, op: c.op, a: c.a });
+    }
+    /**
+     * A new server (or a local target): every call still in flight runs again there, in order; watches too. Each
+     * call goes out under a new request id, so only the server it was last sent to can answer it: a late answer of
+     * the previous server (to the old id) finds nothing.
+     */
+    resend() {
+        const calls = [...this.inflight].sort(([x], [y]) => x - y);
+        this.inflight.clear();
+        for (const [, c] of calls) {
+            // (Un)watch calls addressed the old server: every live watch is established afresh below.
+            if (c.op === "watch" || c.op === "unwatch")
+                c.resolve(undefined);
+            else {
+                const id = ++this.seq;
+                this.inflight.set(id, c);
+                this.dispatch(id);
+            }
+        }
+        for (const wid of this.watches.keys())
+            this.establish(wid);
+    }
+    onMessage(m) {
+        if (!isMsg(m) || this.closed)
+            return;
+        if (m.k === "leader") {
+            if (this.local || this.dead)
+                return;
+            this.unavailable = null;
+            this.resend();
+            this.onLeader?.(m.from);
+            return;
+        }
+        if (m.k === "res" && m.to === this.id) {
+            const c = this.inflight.get(m.id);
+            if (!c)
+                return;
+            this.inflight.delete(m.id);
+            if (m.ok)
+                c.resolve(m.v);
+            else
+                c.reject(fromErr(m.e));
+            return;
+        }
+        if (m.k === "watch" && m.to === this.id) {
+            const w = this.watches.get(m.wid);
+            if (!w)
+                return;
+            if (m.e)
+                w.onError?.(fromErr(m.e));
+            else
+                w.onResult(m.r ?? undefined);
+        }
+    }
+    /** Closes the served storage itself (then this caller): e.g. the Worker's database before terminating it. */
+    async shutdown() {
+        if (this.closed)
+            return;
+        await this.call("close").catch(() => undefined);
+        this.detach();
+    }
+    /** Stop: pending calls are rejected, the server drops this caller's watches. */
+    close() {
+        this.detach();
+    }
+    detach() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const off of this.localWatches.values())
+            off();
+        this.localWatches.clear();
+        this.watches.clear();
+        if (!this.local)
+            this.endpoint.postMessage({ ember: TAG, k: "bye", from: this.id });
+        this.endpoint.removeEventListener("message", this.listener);
+        for (const c of this.inflight.values())
+            c.reject(new Error("offline storage: closed"));
+        this.inflight.clear();
+    }
+}

package/dist/sqlite-wasm.d.ts

@@ -0,0 +1,30 @@
+import type { SqlDriver, SqlValue } from "@freecorps/ember-server";
+import { type OfflineOptions, type OfflineStore } from "./store.ts";
+/** The part of an oo1 prepared statement this driver uses. */
+export interface WasmSqliteStatement {
+    readonly columnCount: number;
+    bind(values: SqlValue[]): unknown;
+    step(): boolean;
+    get(target: Record<string, unknown>): Record<string, unknown>;
+    reset(clearBindings?: boolean): unknown;
+    finalize(): unknown;
+}
+/** The part of an oo1 `DB` (`sqlite3.oo1.DB`, `OpfsSAHPoolDb`, ...) this driver uses. */
+export interface WasmSqliteDatabase {
+    prepare(sql: string): WasmSqliteStatement;
+    exec(sql: string): unknown;
+    changes(): number;
+    close(): unknown;
+}
+/** `SqlDriver` over an oo1 database: cached prepared statements, savepoints for nested transactions. */
+export declare function wasmSqliteDriver(db: WasmSqliteDatabase): SqlDriver & {
+    close(): void;
+};
+export interface SqliteWasmStorageOptions extends OfflineOptions {
+    /** Database name prefix. Default `"ember"`. */
+    name?: string;
+    /** Opens (creating if needed) a database by name, e.g. `(n) => new poolUtil.OpfsSAHPoolDb(`/${n}.db`)`. */
+    open: (name: string) => WasmSqliteDatabase;
+}
+/** Offline storage on SQLite-Wasm (same DDL, SQL and FTS5 as `sqliteStorage`). Runs where the database lives. */
+export declare function sqliteWasmStorage(options: SqliteWasmStorageOptions): OfflineStore;

package/dist/sqlite-wasm.js

@@ -0,0 +1,77 @@
+// SQLite compiled to WebAssembly (`@sqlite.org/sqlite-wasm`, the SQLite project's official build: FTS5 included)
+// as a `SqlDriver`, so the SQLite backend runs on it unchanged: the server's DDL, row codec, SQL compiler and FTS5
+// search. Any oo1 database works — in-memory, `kvvfs`, or OPFS through the `opfs-sahpool` VFS (see opfs.ts, which
+// runs it in a dedicated Worker). In Node the same build runs over an in-memory file system (tests).
+//
+//   import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
+//   const sqlite3 = await sqlite3InitModule();
+//   sqliteWasmStorage({ schema, queries, open: (name) => new sqlite3.oo1.DB(`/${name}.db`, "c") })
+import { SqliteBackend } from "./sqlite.js";
+import { createOfflineStorage } from "./store.js";
+const WRITES = /^\s*(INSERT|UPDATE|DELETE|REPLACE)/i;
+/** `SqlDriver` over an oo1 database: cached prepared statements, savepoints for nested transactions. */
+export function wasmSqliteDriver(db) {
+    const cache = new Map();
+    let sp = 0;
+    const finalizeAll = () => {
+        for (const s of cache.values())
+            s.finalize();
+        cache.clear();
+    };
+    return {
+        exec(sql, ...params) {
+            let stmt = cache.get(sql);
+            if (!stmt) {
+                if (cache.size > 500)
+                    finalizeAll();
+                stmt = db.prepare(sql);
+                cache.set(sql, stmt);
+            }
+            try {
+                if (params.length)
+                    stmt.bind(params);
+                const rows = [];
+                if (stmt.columnCount > 0)
+                    while (stmt.step())
+                        rows.push(stmt.get({}));
+                else
+                    stmt.step();
+                const write = WRITES.test(sql);
+                return {
+                    rows,
+                    rowsRead: write ? 0 : rows.length,
+                    rowsWritten: write ? (rows.length || db.changes()) : 0,
+                };
+            }
+            finally {
+                stmt.reset(true);
+            }
+        },
+        transaction(fn) {
+            const name = `ember_sp_${sp++}`;
+            db.exec(`SAVEPOINT ${name}`);
+            try {
+                const out = fn();
+                if (out && typeof out.then === "function") {
+                    Promise.resolve(out).catch(() => { });
+                    throw new Error("transaction(fn): fn must be synchronous");
+                }
+                db.exec(`RELEASE ${name}`);
+                return out;
+            }
+            catch (e) {
+                db.exec(`ROLLBACK TO ${name}`);
+                db.exec(`RELEASE ${name}`);
+                throw e;
+            }
+        },
+        close: () => {
+            finalizeAll();
+            db.close();
+        },
+    };
+}
+/** Offline storage on SQLite-Wasm (same DDL, SQL and FTS5 as `sqliteStorage`). Runs where the database lives. */
+export function sqliteWasmStorage(options) {
+    return createOfflineStorage(new SqliteBackend(options.schema, (n) => wasmSqliteDriver(options.open(n)), options.name ?? "ember"), options);
+}