snapback4 0.0.1 → 0.0.2

package/dist/replica/key.d.ts

@@ -0,0 +1,9 @@
+export type Kind = "null" | "bool" | "int" | "string" | "id" | "bytes";
+/** Encode a tuple of `(kind, value)` components. */
+export declare function encodeKey(components: readonly (readonly [Kind, unknown])[]): Uint8Array;
+/** The exclusive upper bound of every key that extends `prefix`. */
+export declare function upperBound(prefix: Uint8Array): Uint8Array;
+export declare function compareKeys(a: Uint8Array, b: Uint8Array): number;
+export declare function hex(bytes: Uint8Array): string;
+/** The kind of an index column from its declared column type. */
+export declare function kindOf(columnType: unknown): Kind;

package/dist/replica/key.js

@@ -0,0 +1,107 @@
+// One order-preserving byte encoding for index keys, byte-for-byte the
+// server's (`crates/snapback4-core/src/key.rs`): a device scans the same
+// bytes in the same order. Values on the device are plain JSON, so the
+// column kind says whether a string is text or an identity.
+const T_NULL = 0x01, T_FALSE = 0x02, T_TRUE = 0x03, T_INT = 0x04, T_STRING = 0x05, T_ID = 0x06, T_BYTES = 0x07, T_END = 0xff;
+const utf8 = new TextEncoder();
+/** Encode a tuple of `(kind, value)` components. */
+export function encodeKey(components) {
+    const out = [];
+    for (const [kind, value] of components)
+        encodeOne(kind, value, out);
+    return Uint8Array.from(out);
+}
+function encodeOne(kind, value, out) {
+    if (value === null || value === undefined) {
+        out.push(T_NULL);
+        return;
+    }
+    switch (kind) {
+        case "null":
+            out.push(T_NULL);
+            return;
+        case "bool":
+            out.push(value ? T_TRUE : T_FALSE);
+            return;
+        case "int": {
+            out.push(T_INT);
+            // Flip the sign bit so two's complement sorts as unsigned bytes.
+            const flipped = BigInt.asUintN(64, BigInt(value)) ^ (1n << 63n);
+            for (let shift = 56n; shift >= 0n; shift -= 8n)
+                out.push(Number((flipped >> shift) & 0xffn));
+            return;
+        }
+        case "string":
+            out.push(T_STRING);
+            escape(utf8.encode(String(value)), out);
+            return;
+        case "id":
+            out.push(T_ID);
+            escape(utf8.encode(String(value)), out);
+            return;
+        case "bytes":
+            out.push(T_BYTES);
+            escape(hexBytes(String(value)), out);
+            return;
+    }
+}
+/** `0x00` inside a body becomes `0x00 0xff`; the body ends with `0x00 0x00`. */
+function escape(bytes, out) {
+    for (const byte of bytes) {
+        if (byte === 0)
+            out.push(0, 0xff);
+        else
+            out.push(byte);
+    }
+    out.push(0, 0);
+}
+function hexBytes(hex) {
+    const out = new Uint8Array(hex.length >> 1);
+    for (let i = 0; i < out.length; i++)
+        out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    return out;
+}
+/** The exclusive upper bound of every key that extends `prefix`. */
+export function upperBound(prefix) {
+    const out = new Uint8Array(prefix.length + 1);
+    out.set(prefix);
+    out[prefix.length] = T_END;
+    return out;
+}
+export function compareKeys(a, b) {
+    const n = Math.min(a.length, b.length);
+    for (let i = 0; i < n; i++) {
+        if (a[i] !== b[i])
+            return a[i] < b[i] ? -1 : 1;
+    }
+    return a.length - b.length;
+}
+export function hex(bytes) {
+    let out = "";
+    for (const byte of bytes)
+        out += byte.toString(16).padStart(2, "0");
+    return out;
+}
+/** The kind of an index column from its declared column type. */
+export function kindOf(columnType) {
+    if (columnType === "Id" || columnType === "Principal")
+        return "id";
+    if (columnType === "Int" || columnType === "Time")
+        return "int";
+    if (columnType === "Bool")
+        return "bool";
+    if (typeof columnType === "object" && columnType !== null) {
+        const key = Object.keys(columnType)[0];
+        if (key === "Ref")
+            return "id";
+        if (key === "Text" || key === "Enum")
+            return "string";
+        if (key === "Decimal" || key === "Money")
+            return "int";
+        if (key === "Bytes")
+            return "bytes";
+        if (key === "Optional")
+            return kindOf(columnType.Optional);
+    }
+    return "string";
+}

package/dist/replica/replica.d.ts

@@ -0,0 +1,58 @@
+import type { SchemaJson, Store } from "./store.ts";
+export interface StreamEvent {
+    seq?: number;
+    table: string;
+    kind: "put" | "del" | "scope";
+    id: string;
+    data?: unknown;
+}
+export interface StreamPage {
+    snapshot: boolean;
+    events: StreamEvent[];
+    watermark: number;
+    more: boolean;
+    generation?: number;
+}
+export interface Transport {
+    /** `GET /sync?from=W`; `from: 0` is a snapshot. */
+    sync(from: number, limit: number): Promise<StreamPage | {
+        denied: unknown;
+    }>;
+}
+export interface ReplicaState {
+    watermark: number;
+    generation: number;
+}
+export declare class Replica {
+    readonly store: Store;
+    schema: SchemaJson;
+    private transport;
+    generation: number;
+    private listeners;
+    private caughtUp;
+    private following;
+    private closed;
+    constructor(store: Store, schema: SchemaJson, transport: Transport, generation: number);
+    /** A new generation from the server: the next sync re-derives the partition. */
+    adopt(schema: SchemaJson, generation: number): void;
+    /** Whether the device has applied everything the server had at the last sync. */
+    get isCaughtUp(): boolean;
+    onChange(listener: (touched: Set<string>) => void): () => void;
+    state(): Promise<ReplicaState>;
+    /** One round with the server: a snapshot when the device has none or the
+     * generation changed, else the stream from the watermark; every page
+     * applies as one transaction. Returns the tables that changed. */
+    syncOnce(): Promise<{
+        touched: Set<string>;
+        ok: boolean;
+    }>;
+    /** Apply one page atomically: rows, tombstones and the watermark together. */
+    apply(page: StreamPage, touched: Set<string>): Promise<void>;
+    /** A group the device left: drop its rows (`until-revoked`) or keep what
+     * was delivered (`delivered-history`). */
+    private leave;
+    /** Follow the stream until closed: sync, wait for the transport's next
+     * change signal, sync again. */
+    follow(wait: () => Promise<void>): void;
+    close(): Promise<void>;
+}

package/dist/replica/replica.js

@@ -0,0 +1,147 @@
+// The replica: the viewer's partitions on the device as one store with one
+// watermark (LLP 2000.000 §7.2). A fresh device takes a snapshot, then
+// follows the merged stream; every batch applies in one transaction with
+// its watermark; a scope tombstone applies the table's leave policy; a
+// generation change re-bootstraps. Predictions live beside the rows and are
+// replaced by the server's images as they arrive.
+/** The meta keys the replica keeps. */
+const WATERMARK = "watermark";
+const GENERATION = "generation";
+const PAGE = 2000;
+export class Replica {
+    store;
+    schema;
+    transport;
+    generation;
+    listeners = new Set();
+    caughtUp = false;
+    following = null;
+    closed = false;
+    constructor(store, schema, transport, generation) {
+        this.store = store;
+        this.schema = schema;
+        this.transport = transport;
+        this.generation = generation;
+    }
+    /** A new generation from the server: the next sync re-derives the partition. */
+    adopt(schema, generation) {
+        this.schema = schema;
+        this.generation = generation;
+    }
+    /** Whether the device has applied everything the server had at the last sync. */
+    get isCaughtUp() {
+        return this.caughtUp;
+    }
+    onChange(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    async state() {
+        return this.store.read(async (tx) => ({ watermark: Number((await tx.getMeta(WATERMARK)) ?? 0), generation: Number((await tx.getMeta(GENERATION)) ?? 0) }));
+    }
+    /** One round with the server: a snapshot when the device has none or the
+     * generation changed, else the stream from the watermark; every page
+     * applies as one transaction. Returns the tables that changed. */
+    async syncOnce() {
+        const touched = new Set();
+        let { watermark, generation } = await this.state();
+        if (generation !== this.generation) {
+            // A new generation re-derives the partition: drop rows, keep the outbox.
+            await this.store.clearRows();
+            await this.store.write(async (tx) => { await tx.setMeta(WATERMARK, 0); await tx.setMeta(GENERATION, this.generation); });
+            watermark = 0;
+        }
+        for (let pages = 0; pages < 1_000; pages++) {
+            const page = await this.transport.sync(watermark, PAGE);
+            if ("denied" in page)
+                return { touched, ok: false };
+            if (page.watermark < watermark)
+                return { touched, ok: false }; // never move backwards
+            await this.apply(page, touched);
+            watermark = page.watermark;
+            if (!page.more)
+                break;
+        }
+        this.caughtUp = true;
+        if (touched.size > 0)
+            for (const listener of this.listeners)
+                listener(touched);
+        return { touched, ok: true };
+    }
+    /** Apply one page atomically: rows, tombstones and the watermark together. */
+    async apply(page, touched) {
+        if (page.snapshot) {
+            // A snapshot is the whole partition: clear, then load. Predicted rows
+            // are re-applied from the outbox by the client, not kept here.
+            await this.store.clearRows();
+            for (const table of Object.keys(this.schema.tables))
+                touched.add(table);
+        }
+        await this.store.write(async (tx) => {
+            if (page.snapshot)
+                await tx.setMeta(WATERMARK, 0);
+            for (const event of page.events) {
+                touched.add(event.table);
+                switch (event.kind) {
+                    case "put": {
+                        const row = event.data;
+                        await tx.put(event.table, row);
+                        break;
+                    }
+                    case "del":
+                        await tx.delete(event.table, event.id);
+                        break;
+                    case "scope":
+                        await this.leave(tx, event.table, event.data);
+                        break;
+                }
+            }
+            await tx.setMeta(WATERMARK, page.watermark);
+            await tx.setMeta(GENERATION, this.generation);
+        });
+    }
+    /** A group the device left: drop its rows (`until-revoked`) or keep what
+     * was delivered (`delivered-history`). */
+    async leave(tx, table, group) {
+        const definition = this.schema.tables[table];
+        if (!definition || definition.leave === "delivered-history")
+            return;
+        const audience = definition.sync?.audience;
+        const prefix = audience && typeof audience === "object" && "Target" in audience ? audience.Target.prefix : audience && "Column" in audience ? [audience.Column] : [];
+        // The group's rows are the prefix range of any index leading with the
+        // audience columns; the horizon index does when there is one.
+        const index = definition.sync?.horizon?.by ?? Object.entries(definition.indexes).find(([, i]) => prefix.every((c, n) => i.components[n]?.Column === c))?.[0];
+        if (!index)
+            return;
+        for (;;) {
+            const rows = await tx.scan(table, index, group, {}, "asc", 500);
+            if (rows.length === 0)
+                break;
+            for (const { row } of rows)
+                await tx.delete(table, row.id);
+            if (rows.length < 500)
+                break;
+        }
+    }
+    /** Follow the stream until closed: sync, wait for the transport's next
+     * change signal, sync again. */
+    follow(wait) {
+        if (this.following)
+            return;
+        this.following = (async () => {
+            while (!this.closed) {
+                const { ok } = await this.syncOnce();
+                if (this.closed)
+                    break;
+                if (!ok)
+                    await new Promise((r) => setTimeout(r, 1000));
+                else
+                    await wait();
+            }
+        })();
+    }
+    async close() {
+        this.closed = true;
+        await this.store.close();
+    }
+}

package/dist/replica/sqlite.d.ts

@@ -0,0 +1,29 @@
+import { type SchemaJson, type Store } from "./store.ts";
+/** What a SQLite binding must offer. `expo-sqlite`'s async database and
+ * `node:sqlite`'s `DatabaseSync` both fit behind a few lines. */
+export interface SqliteDriver {
+    run(sql: string, params?: readonly unknown[]): Promise<void>;
+    all(sql: string, params?: readonly unknown[]): Promise<Record<string, unknown>[]>;
+    /** Run `body` inside one transaction; roll back when it throws. */
+    transaction<T>(body: () => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
+export declare function openSqlite(driver: SqliteDriver, schema: SchemaJson): Promise<Store>;
+/** `node:sqlite`'s synchronous database behind the driver, for tests and
+ * for Node hosts. (`expo-sqlite` fits the same way with its async calls.) */
+export declare function nodeSqliteDriver(db: {
+    exec(sql: string): void;
+    prepare(sql: string): {
+        run(...p: unknown[]): unknown;
+        all(...p: unknown[]): unknown[];
+    };
+    close(): void;
+}): SqliteDriver;
+/** `expo-sqlite`'s async database behind the driver. */
+export declare function expoSqliteDriver(db: {
+    runAsync(sql: string, ...p: unknown[]): Promise<unknown>;
+    getAllAsync(sql: string, ...p: unknown[]): Promise<unknown[]>;
+    withExclusiveTransactionAsync?(body: (tx: unknown) => Promise<void>): Promise<void>;
+    withTransactionAsync(body: () => Promise<void>): Promise<void>;
+    closeAsync(): Promise<void>;
+}): SqliteDriver;

package/dist/replica/sqlite.js

@@ -0,0 +1,151 @@
+// The replica store on SQLite: the server's two-table layout, one BLOB key
+// per index entry, for hosts where SQLite is native — Expo (`expo-sqlite`)
+// and Node (`node:sqlite`). The driver is the smallest thing both offer: run
+// a statement, read rows, wrap a transaction. SQLite compares BLOBs byte by
+// byte, so `key.ts` orders here exactly as it does in IndexedDB and on the
+// server.
+import { encodeKey, upperBound } from "./key.js";
+import { indexKey, indexKinds, scanRange } from "./store.js";
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS r (t TEXT NOT NULL, id TEXT NOT NULL, data TEXT NOT NULL, PRIMARY KEY (t, id)) WITHOUT ROWID;
+CREATE TABLE IF NOT EXISTS i (ti TEXT NOT NULL, k BLOB NOT NULL, id TEXT NOT NULL, PRIMARY KEY (ti, k)) WITHOUT ROWID;
+CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS side (name TEXT NOT NULL, key TEXT NOT NULL, value TEXT NOT NULL, PRIMARY KEY (name, key)) WITHOUT ROWID;
+`;
+export async function openSqlite(driver, schema) {
+    for (const statement of SCHEMA.split(";").map((s) => s.trim()).filter(Boolean))
+        await driver.run(statement);
+    return new SqliteStore(driver, schema);
+}
+class SqliteStore {
+    db;
+    schema;
+    constructor(db, schema) {
+        this.db = db;
+        this.schema = schema;
+    }
+    tx() {
+        const db = this.db;
+        const schema = this.schema;
+        const enc = (table, index, values) => {
+            const { kinds } = indexKinds(schema, table, index);
+            return encodeKey(values.map((v, i) => [kinds[i] ?? "string", v]));
+        };
+        const parse = (rows) => rows.map((r) => JSON.parse(r.data));
+        const side = (name) => ({
+            async get(key) {
+                const rows = await db.all("SELECT value FROM side WHERE name = ? AND key = ?", [name, key]);
+                return rows[0] ? JSON.parse(rows[0].value) : undefined;
+            },
+            async put(key, value) { await db.run("INSERT INTO side(name, key, value) VALUES (?, ?, ?) ON CONFLICT(name, key) DO UPDATE SET value = excluded.value", [name, key, JSON.stringify(value)]); },
+            async delete(key) { await db.run("DELETE FROM side WHERE name = ? AND key = ?", [name, key]); },
+            async all() { return (await db.all("SELECT key, value FROM side WHERE name = ? ORDER BY key", [name])).map((r) => ({ key: r.key, value: JSON.parse(r.value) })); },
+            async clear() { await db.run("DELETE FROM side WHERE name = ?", [name]); },
+        });
+        return {
+            async get(table, id) {
+                return parse(await db.all("SELECT data FROM r WHERE t = ? AND id = ?", [table, id]))[0];
+            },
+            async lookup(table, index, key) {
+                const prefix = enc(table, index, key);
+                const rows = await db.all("SELECT r.data FROM i JOIN r ON r.t = ? AND r.id = i.id WHERE i.ti = ? AND i.k >= ? AND i.k < ? ORDER BY i.k LIMIT 1", [table, `${table}.${index}`, prefix, upperBound(prefix)]);
+                return parse(rows)[0];
+            },
+            async scan(table, index, prefix, bounds, dir, limit) {
+                const range = scanRange(schema, table, index, prefix, bounds, dir);
+                if (!range || limit <= 0)
+                    return [];
+                const rows = await db.all(`SELECT r.data, i.k AS k FROM i JOIN r ON r.t = ? AND r.id = i.id WHERE i.ti = ? AND i.k >= ? AND i.k < ? ORDER BY i.k ${dir === "asc" ? "ASC" : "DESC"} LIMIT ?`, [table, `${table}.${index}`, range[0], range[1], limit]);
+                return rows.map((r) => ({ row: JSON.parse(r.data), key: new Uint8Array(r.k) }));
+            },
+            async count(table, index, prefix, limit) {
+                const range = scanRange(schema, table, index, prefix, {}, "asc");
+                if (!range)
+                    return 0;
+                const rows = await db.all("SELECT COUNT(*) AS n FROM (SELECT 1 FROM i WHERE ti = ? AND k >= ? AND k < ? LIMIT ?)", [`${table}.${index}`, range[0], range[1], limit]);
+                return Number(rows[0]?.n ?? 0);
+            },
+            async put(table, row) {
+                const old = parse(await db.all("SELECT data FROM r WHERE t = ? AND id = ?", [table, row.id]))[0];
+                const definition = schema.tables[table];
+                if (!definition)
+                    throw new Error(`unknown table ${table}`);
+                for (const index of Object.keys(definition.indexes)) {
+                    const ti = `${table}.${index}`;
+                    if (old)
+                        await db.run("DELETE FROM i WHERE ti = ? AND k = ?", [ti, indexKey(schema, table, index, old)]);
+                    await db.run("INSERT INTO i(ti, k, id) VALUES (?, ?, ?) ON CONFLICT(ti, k) DO UPDATE SET id = excluded.id", [ti, indexKey(schema, table, index, row), row.id]);
+                }
+                await db.run("INSERT INTO r(t, id, data) VALUES (?, ?, ?) ON CONFLICT(t, id) DO UPDATE SET data = excluded.data", [table, row.id, JSON.stringify(row)]);
+            },
+            async delete(table, id) {
+                const old = parse(await db.all("SELECT data FROM r WHERE t = ? AND id = ?", [table, id]))[0];
+                if (!old)
+                    return;
+                for (const index of Object.keys(schema.tables[table]?.indexes ?? {}))
+                    await db.run("DELETE FROM i WHERE ti = ? AND k = ?", [`${table}.${index}`, indexKey(schema, table, index, old)]);
+                await db.run("DELETE FROM r WHERE t = ? AND id = ?", [table, id]);
+            },
+            async getMeta(key) {
+                const rows = await db.all("SELECT value FROM meta WHERE key = ?", [key]);
+                return rows[0] ? JSON.parse(rows[0].value) : undefined;
+            },
+            async setMeta(key, value) { await db.run("INSERT INTO meta(key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value", [key, JSON.stringify(value)]); },
+            side,
+        };
+    }
+    read(body) { return this.db.transaction(() => body(this.tx())); }
+    write(body) { return this.db.transaction(() => body(this.tx())); }
+    async clearRows() { await this.db.run("DELETE FROM r"); await this.db.run("DELETE FROM i"); }
+    close() { return this.db.close(); }
+}
+/** `node:sqlite`'s synchronous database behind the driver, for tests and
+ * for Node hosts. (`expo-sqlite` fits the same way with its async calls.) */
+export function nodeSqliteDriver(db) {
+    let depth = 0;
+    return {
+        async run(sql, params = []) { db.prepare(sql).run(...params); },
+        async all(sql, params = []) { return db.prepare(sql).all(...params); },
+        async transaction(body) {
+            if (depth > 0)
+                return body();
+            depth++;
+            db.exec("BEGIN");
+            try {
+                const result = await body();
+                db.exec("COMMIT");
+                return result;
+            }
+            catch (error) {
+                db.exec("ROLLBACK");
+                throw error;
+            }
+            finally {
+                depth--;
+            }
+        },
+        async close() { db.close(); },
+    };
+}
+/** `expo-sqlite`'s async database behind the driver. */
+export function expoSqliteDriver(db) {
+    let depth = 0;
+    return {
+        async run(sql, params = []) { await db.runAsync(sql, ...params); },
+        async all(sql, params = []) { return (await db.getAllAsync(sql, ...params)); },
+        async transaction(body) {
+            if (depth > 0)
+                return body();
+            depth++;
+            let result;
+            try {
+                await db.withTransactionAsync(async () => { result = await body(); });
+            }
+            finally {
+                depth--;
+            }
+            return result;
+        },
+        async close() { await db.closeAsync(); },
+    };
+}

package/dist/replica/store.d.ts

@@ -0,0 +1,91 @@
+import { type Kind } from "./key.ts";
+export type Row = Record<string, unknown> & {
+    id: string;
+};
+/** The server's schema, as `GET /schema` sends it. */
+export interface SchemaJson {
+    tables: Record<string, TableJson>;
+    maintains?: unknown[];
+}
+export interface TableJson {
+    columns: Record<string, unknown>;
+    indexes: Record<string, {
+        components: ({
+            Column: string;
+        } | {
+            WordPrefixes: unknown;
+        })[];
+        unique: boolean;
+    }>;
+    sync?: {
+        audience: unknown;
+        horizon?: {
+            last: number;
+            by: string;
+        } | null;
+    } | null;
+    leave?: "until-revoked" | "delivered-history";
+}
+export interface Bounds {
+    after?: unknown[];
+    before?: unknown[];
+    gt?: unknown;
+    gte?: unknown;
+    lt?: unknown;
+    lte?: unknown;
+}
+export interface StoreTx {
+    get(table: string, id: string): Promise<Row | undefined>;
+    lookup(table: string, index: string, key: readonly unknown[]): Promise<Row | undefined>;
+    scan(table: string, index: string, prefix: readonly unknown[], bounds: Bounds, dir: "asc" | "desc", limit: number): Promise<{
+        row: Row;
+        key: Uint8Array;
+    }[]>;
+    count(table: string, index: string, prefix: readonly unknown[], limit: number): Promise<number>;
+    put(table: string, row: Row): Promise<void>;
+    delete(table: string, id: string): Promise<void>;
+    getMeta(key: string): Promise<unknown>;
+    setMeta(key: string, value: unknown): Promise<void>;
+    /** The outbox and other durable side tables share the transaction. */
+    side(name: string): SideTx;
+}
+export interface SideTx {
+    get(key: string): Promise<unknown>;
+    put(key: string, value: unknown): Promise<void>;
+    delete(key: string): Promise<void>;
+    all(): Promise<{
+        key: string;
+        value: unknown;
+    }[]>;
+    clear(): Promise<void>;
+}
+export interface Store {
+    read<T>(body: (tx: StoreTx) => Promise<T>): Promise<T>;
+    write<T>(body: (tx: StoreTx) => Promise<T>): Promise<T>;
+    /** Drop every row and index entry (a re-bootstrap); meta and side tables stay. */
+    clearRows(): Promise<void>;
+    close(): Promise<void>;
+}
+/** The index components' kinds for a table, from the schema. */
+export declare function indexKinds(schema: SchemaJson, table: string, index: string): {
+    columns: string[];
+    kinds: Kind[];
+};
+/** The stored key of one index entry: the components, then the id. */
+export declare function indexKey(schema: SchemaJson, table: string, index: string, row: Row): Uint8Array;
+/** The byte range of a scan: `[lo, hi)`, or null when empty. */
+export declare function scanRange(schema: SchemaJson, table: string, index: string, prefix: readonly unknown[], bounds: Bounds, dir: "asc" | "desc"): [Uint8Array, Uint8Array] | null;
+export declare class MemoryStore implements Store {
+    readonly schema: SchemaJson;
+    private rows;
+    private indexes;
+    private meta;
+    private sides;
+    constructor(schema: SchemaJson);
+    private tx;
+    read<T>(body: (tx: StoreTx) => Promise<T>): Promise<T>;
+    write<T>(body: (tx: StoreTx) => Promise<T>): Promise<T>;
+    clearRows(): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function openIndexedDb(name: string, schema: SchemaJson): Promise<Store>;