@syncular/server 0.15.45 → 0.15.47

package/dist/sqlite-bun-driver.js

@@ -0,0 +1,27 @@
+import { Database } from 'bun:sqlite';
+export class BunSqliteDatabase {
+    native;
+    constructor(path = ':memory:') {
+        this.native = new Database(path);
+    }
+    exec(sql) {
+        this.native.exec(sql);
+    }
+    run(sql, bindings = []) {
+        return this.native.run(sql, [...bindings]);
+    }
+    query(sql) {
+        const statement = this.native.query(sql);
+        return {
+            run: (...params) => statement.run(...params),
+            get: (...params) => statement.get(...params),
+            all: (...params) => statement.all(...params),
+        };
+    }
+    serialize() {
+        return new Uint8Array(this.native.serialize());
+    }
+    close() {
+        this.native.close();
+    }
+}

package/dist/sqlite-bun.d.ts

@@ -0,0 +1,24 @@
+import { SqliteBlobStore as SharedSqliteBlobStore } from './sqlite-blob-store.js';
+import type { SqliteDatabase } from './sqlite-driver.js';
+import { type SqliteImageBuilder } from './sqlite-image.js';
+import { SqliteLeaseStore as SharedSqliteLeaseStore } from './sqlite-lease-store.js';
+import { SqliteSegmentStore as SharedSqliteSegmentStore } from './sqlite-segment-store.js';
+import { SqliteServerStorage as SharedSqliteServerStorage } from './sqlite-storage.js';
+export declare class SqliteServerStorage extends SharedSqliteServerStorage {
+    constructor(value?: SqliteDatabase | string);
+}
+export declare class SqliteSegmentStore extends SharedSqliteSegmentStore {
+    constructor(value?: SqliteDatabase | string, options?: {
+        ttlMs?: number;
+    });
+}
+export declare class SqliteBlobStore extends SharedSqliteBlobStore {
+    constructor(value?: SqliteDatabase | string);
+}
+export declare class SqliteLeaseStore extends SharedSqliteLeaseStore {
+    constructor(value?: SqliteDatabase | string, options?: {
+        readonly leaseId?: () => string;
+    });
+}
+export declare const buildSqliteImage: SqliteImageBuilder;
+export { BunSqliteDatabase } from './sqlite-bun-driver.js';

package/dist/sqlite-bun.js

@@ -0,0 +1,40 @@
+import { SqliteBlobStore as SharedSqliteBlobStore } from './sqlite-blob-store.js';
+import { BunSqliteDatabase } from './sqlite-bun-driver.js';
+import { writeSqliteImage } from './sqlite-image.js';
+import { SqliteLeaseStore as SharedSqliteLeaseStore } from './sqlite-lease-store.js';
+import { SqliteSegmentStore as SharedSqliteSegmentStore } from './sqlite-segment-store.js';
+import { SqliteServerStorage as SharedSqliteServerStorage } from './sqlite-storage.js';
+function database(value) {
+    return typeof value === 'string' ? new BunSqliteDatabase(value) : value;
+}
+export class SqliteServerStorage extends SharedSqliteServerStorage {
+    constructor(value = ':memory:') {
+        super(database(value));
+    }
+}
+export class SqliteSegmentStore extends SharedSqliteSegmentStore {
+    constructor(value = ':memory:', options) {
+        super(database(value), options);
+    }
+}
+export class SqliteBlobStore extends SharedSqliteBlobStore {
+    constructor(value = ':memory:') {
+        super(database(value));
+    }
+}
+export class SqliteLeaseStore extends SharedSqliteLeaseStore {
+    constructor(value = ':memory:', options) {
+        super(database(value), options);
+    }
+}
+export const buildSqliteImage = (input) => {
+    const db = new BunSqliteDatabase();
+    try {
+        writeSqliteImage(db, input);
+        return db.serialize();
+    }
+    finally {
+        db.close();
+    }
+};
+export { BunSqliteDatabase } from './sqlite-bun-driver.js';

package/dist/sqlite-dialect.d.ts

@@ -1,12 +1,12 @@
 /**
- * Shared SQLite dialect for the two SQLite-family storages: `bun:sqlite`
- * (synchronous, `SqliteServerStorage`) and Cloudflare D1 (async,
- * `D1ServerStorage`). D1 *is* SQLite — same DDL, same statement grammar,
+ * Shared SQLite dialect for synchronous `SqliteServerStorage` on Bun or Node
+ * and asynchronous `D1ServerStorage` on Cloudflare Workers. D1 is SQLite:
+ * same DDL, same statement grammar,
  * same `?` positional placeholders, same `INSERT ... ON CONFLICT` / `INSERT
  * OR IGNORE` upsert idioms — so the schema and the value (de)serialization are
  * genuinely common ground and live here.
  *
- * What is NOT shared: statement *execution*. `bun:sqlite` is sync
+ * What is not shared: statement execution. The server SQLite driver is sync
  * (`db.query(sql).get(...)`) and D1 is async (`await
  * db.prepare(sql).bind(...).all()`); a shared execution layer would have to
  * pick one calling convention and adapt the other, which is uglier than two
@@ -18,7 +18,7 @@
 import type { ScopeMap } from '@syncular/core';
 import type { StoredChange, StoredCommit, StoredPushResult, StoredRow } from './storage.js';
 /**
- * Schema DDL — one statement per `;`-delimited chunk. `bun:sqlite` applies
+ * Schema DDL, one statement per `;`-delimited chunk. Native SQLite applies
  * the whole string via `db.exec(SQLITE_DDL)`; D1 applies each statement
  * separately (its `prepare`/`batch` API is one statement per call). Types
  * are SQLite's: `INTEGER`/`TEXT`/`BLOB`. Scopes are stored as JSON `TEXT`
@@ -30,7 +30,7 @@ import type { StoredChange, StoredCommit, StoredPushResult, StoredRow } from './
  * the Postgres storage documents (§3.1, performance-by-
  * construction).
  */
-export declare const SQLITE_DDL = "\nCREATE TABLE IF NOT EXISTS sync_partitions(\n  partition TEXT PRIMARY KEY,\n  max_commit_seq INTEGER NOT NULL DEFAULT 0,\n  horizon_seq INTEGER NOT NULL DEFAULT 0\n);\nCREATE TABLE IF NOT EXISTS sync_row_scopes(\n  partition TEXT NOT NULL, tbl TEXT NOT NULL,\n  var TEXT NOT NULL, value TEXT NOT NULL, row_id TEXT NOT NULL,\n  PRIMARY KEY(partition, tbl, var, value, row_id)\n);\nCREATE TABLE IF NOT EXISTS sync_commits(\n  partition TEXT NOT NULL, commit_seq INTEGER NOT NULL,\n  client_id TEXT NOT NULL, client_commit_id TEXT NOT NULL,\n  actor_id TEXT NOT NULL, created_at_ms INTEGER NOT NULL,\n  PRIMARY KEY(partition, commit_seq)\n);\nCREATE INDEX IF NOT EXISTS sync_commits_by_time\n  ON sync_commits(partition, created_at_ms);\nCREATE TABLE IF NOT EXISTS sync_changes(\n  partition TEXT NOT NULL, commit_seq INTEGER NOT NULL, idx INTEGER NOT NULL,\n  tbl TEXT NOT NULL, row_id TEXT NOT NULL, op INTEGER NOT NULL,\n  row_version INTEGER, scopes TEXT NOT NULL, payload BLOB,\n  PRIMARY KEY(partition, commit_seq, idx)\n);\nCREATE INDEX IF NOT EXISTS sync_changes_by_table\n  ON sync_changes(partition, commit_seq, tbl, idx);\nCREATE TABLE IF NOT EXISTS sync_change_scopes(\n  partition TEXT NOT NULL, tbl TEXT NOT NULL,\n  var TEXT NOT NULL, value TEXT NOT NULL, commit_seq INTEGER NOT NULL,\n  PRIMARY KEY(partition, tbl, var, value, commit_seq)\n);\nCREATE TABLE IF NOT EXISTS sync_push_results(\n  partition TEXT NOT NULL, client_id TEXT NOT NULL,\n  client_commit_id TEXT NOT NULL, result TEXT NOT NULL,\n  PRIMARY KEY(partition, client_id, client_commit_id)\n);\nCREATE TABLE IF NOT EXISTS sync_clients(\n  partition TEXT NOT NULL, client_id TEXT NOT NULL, actor_id TEXT NOT NULL,\n  cursor INTEGER NOT NULL, subscriptions TEXT NOT NULL,\n  updated_at_ms INTEGER NOT NULL,\n  PRIMARY KEY(partition, client_id)\n);\nCREATE TABLE IF NOT EXISTS sync_blob_refs(\n  partition TEXT NOT NULL, tbl TEXT NOT NULL, row_id TEXT NOT NULL,\n  blob_id TEXT NOT NULL,\n  PRIMARY KEY(partition, tbl, row_id, blob_id)\n);\nCREATE INDEX IF NOT EXISTS sync_blob_refs_by_blob\n  ON sync_blob_refs(partition, blob_id);\n";
+export declare const SQLITE_DDL = "\nCREATE TABLE IF NOT EXISTS sync_partitions(\n  partition TEXT PRIMARY KEY,\n  max_commit_seq INTEGER NOT NULL DEFAULT 0,\n  horizon_seq INTEGER NOT NULL DEFAULT 0\n);\nCREATE TABLE IF NOT EXISTS sync_row_scopes(\n  partition TEXT NOT NULL, tbl TEXT NOT NULL,\n  var TEXT NOT NULL, value TEXT NOT NULL, row_id TEXT NOT NULL,\n  PRIMARY KEY(partition, tbl, var, value, row_id)\n);\nCREATE TABLE IF NOT EXISTS sync_commits(\n  partition TEXT NOT NULL, commit_seq INTEGER NOT NULL,\n  client_id TEXT NOT NULL, client_commit_id TEXT NOT NULL,\n  actor_id TEXT NOT NULL, created_at_ms INTEGER NOT NULL,\n  PRIMARY KEY(partition, commit_seq)\n);\nCREATE INDEX IF NOT EXISTS sync_commits_by_time\n  ON sync_commits(partition, created_at_ms);\nCREATE TABLE IF NOT EXISTS sync_changes(\n  partition TEXT NOT NULL, commit_seq INTEGER NOT NULL, idx INTEGER NOT NULL,\n  tbl TEXT NOT NULL, row_id TEXT NOT NULL, op INTEGER NOT NULL,\n  row_version INTEGER, scopes TEXT NOT NULL, payload BLOB,\n  PRIMARY KEY(partition, commit_seq, idx)\n);\nCREATE INDEX IF NOT EXISTS sync_changes_by_table\n  ON sync_changes(partition, commit_seq, tbl, idx);\nCREATE TABLE IF NOT EXISTS sync_change_scopes(\n  partition TEXT NOT NULL, tbl TEXT NOT NULL,\n  var TEXT NOT NULL, value TEXT NOT NULL, commit_seq INTEGER NOT NULL,\n  PRIMARY KEY(partition, tbl, var, value, commit_seq)\n);\nCREATE TABLE IF NOT EXISTS sync_push_results(\n  partition TEXT NOT NULL, client_id TEXT NOT NULL,\n  client_commit_id TEXT NOT NULL, result TEXT NOT NULL,\n  PRIMARY KEY(partition, client_id, client_commit_id)\n);\nCREATE TABLE IF NOT EXISTS sync_reactions(\n  partition TEXT NOT NULL, idempotency_key TEXT NOT NULL,\n  type TEXT NOT NULL, version INTEGER NOT NULL, payload TEXT NOT NULL,\n  source_client_id TEXT NOT NULL, source_client_commit_id TEXT NOT NULL,\n  source_commit_seq INTEGER NOT NULL, created_at_ms INTEGER NOT NULL,\n  available_at_ms INTEGER NOT NULL, status TEXT NOT NULL,\n  attempts INTEGER NOT NULL, max_attempts INTEGER NOT NULL,\n  lease_owner TEXT, lease_expires_at_ms INTEGER, completed_at_ms INTEGER,\n  last_failure TEXT,\n  PRIMARY KEY(partition, idempotency_key),\n  CHECK(status IN ('pending', 'leased', 'completed', 'dead-letter'))\n);\nCREATE INDEX IF NOT EXISTS sync_reactions_due\n  ON sync_reactions(partition, status, available_at_ms, created_at_ms, idempotency_key);\nCREATE INDEX IF NOT EXISTS sync_reactions_lease\n  ON sync_reactions(partition, status, lease_expires_at_ms);\nCREATE INDEX IF NOT EXISTS sync_reactions_completed\n  ON sync_reactions(partition, status, completed_at_ms, idempotency_key);\nCREATE INDEX IF NOT EXISTS sync_reactions_dead_letter\n  ON sync_reactions(partition, status, available_at_ms, idempotency_key);\nCREATE TABLE IF NOT EXISTS sync_clients(\n  partition TEXT NOT NULL, client_id TEXT NOT NULL, actor_id TEXT NOT NULL,\n  cursor INTEGER NOT NULL, subscriptions TEXT NOT NULL,\n  updated_at_ms INTEGER NOT NULL,\n  PRIMARY KEY(partition, client_id)\n);\nCREATE TABLE IF NOT EXISTS sync_blob_refs(\n  partition TEXT NOT NULL, tbl TEXT NOT NULL, row_id TEXT NOT NULL,\n  blob_id TEXT NOT NULL,\n  PRIMARY KEY(partition, tbl, row_id, blob_id)\n);\nCREATE INDEX IF NOT EXISTS sync_blob_refs_by_blob\n  ON sync_blob_refs(partition, blob_id);\n";
 /** Split the DDL into individual statements (D1 applies them one by one). */
 export declare function sqliteDdlStatements(): string[];
 /** `?,?,…` for an `IN (…)` clause of `count` positional parameters. */
@@ -53,7 +53,7 @@ export interface SqliteChangeRecord {
     scopes: string;
     payload: Uint8Array | null;
 }
-/** `bun:sqlite` returns `Uint8Array`; D1 returns `ArrayBuffer` for BLOBs. */
+/** Native SQLite returns `Uint8Array`; D1 returns `ArrayBuffer` for BLOBs. */
 export declare function asUint8Array(value: unknown): Uint8Array;
 export declare function toStoredRow(record: SqliteRowRecord): StoredRow;
 export declare function toStoredChange(record: SqliteChangeRecord): StoredChange;
@@ -61,7 +61,7 @@ export declare function toStoredChange(record: SqliteChangeRecord): StoredChange
  * One result row of `commitWindowPageSql` (candidate LEFT JOIN commit meta
  * LEFT JOIN changes): meta/change columns are NULL when the joined row
  * vanished (see the builder's LEFT JOIN contract). `payload` is a BLOB —
- * `bun:sqlite` hands back `Uint8Array`, D1 `ArrayBuffer`; `toStoredChange`
+ * Native SQLite hands back `Uint8Array`, D1 `ArrayBuffer`; `toStoredChange`
  * normalizes via `asUint8Array`.
  */
 export interface SqliteCommitWindowRecord {

package/dist/sqlite-dialect.js

@@ -1,6 +1,6 @@
 import { matchesEffective } from './scopes.js';
 /**
- * Schema DDL — one statement per `;`-delimited chunk. `bun:sqlite` applies
+ * Schema DDL, one statement per `;`-delimited chunk. Native SQLite applies
  * the whole string via `db.exec(SQLITE_DDL)`; D1 applies each statement
  * separately (its `prepare`/`batch` API is one statement per call). Types
  * are SQLite's: `INTEGER`/`TEXT`/`BLOB`. Scopes are stored as JSON `TEXT`
@@ -49,6 +49,26 @@ CREATE TABLE IF NOT EXISTS sync_push_results(
   client_commit_id TEXT NOT NULL, result TEXT NOT NULL,
   PRIMARY KEY(partition, client_id, client_commit_id)
 );
+CREATE TABLE IF NOT EXISTS sync_reactions(
+  partition TEXT NOT NULL, idempotency_key TEXT NOT NULL,
+  type TEXT NOT NULL, version INTEGER NOT NULL, payload TEXT NOT NULL,
+  source_client_id TEXT NOT NULL, source_client_commit_id TEXT NOT NULL,
+  source_commit_seq INTEGER NOT NULL, created_at_ms INTEGER NOT NULL,
+  available_at_ms INTEGER NOT NULL, status TEXT NOT NULL,
+  attempts INTEGER NOT NULL, max_attempts INTEGER NOT NULL,
+  lease_owner TEXT, lease_expires_at_ms INTEGER, completed_at_ms INTEGER,
+  last_failure TEXT,
+  PRIMARY KEY(partition, idempotency_key),
+  CHECK(status IN ('pending', 'leased', 'completed', 'dead-letter'))
+);
+CREATE INDEX IF NOT EXISTS sync_reactions_due
+  ON sync_reactions(partition, status, available_at_ms, created_at_ms, idempotency_key);
+CREATE INDEX IF NOT EXISTS sync_reactions_lease
+  ON sync_reactions(partition, status, lease_expires_at_ms);
+CREATE INDEX IF NOT EXISTS sync_reactions_completed
+  ON sync_reactions(partition, status, completed_at_ms, idempotency_key);
+CREATE INDEX IF NOT EXISTS sync_reactions_dead_letter
+  ON sync_reactions(partition, status, available_at_ms, idempotency_key);
 CREATE TABLE IF NOT EXISTS sync_clients(
   partition TEXT NOT NULL, client_id TEXT NOT NULL, actor_id TEXT NOT NULL,
   cursor INTEGER NOT NULL, subscriptions TEXT NOT NULL,
@@ -161,7 +181,7 @@ export function deserializePushResult(text) {
         results,
     };
 }
-/** `bun:sqlite` returns `Uint8Array`; D1 returns `ArrayBuffer` for BLOBs. */
+/** Native SQLite returns `Uint8Array`; D1 returns `ArrayBuffer` for BLOBs. */
 export function asUint8Array(value) {
     if (value instanceof Uint8Array)
         return value;

package/dist/sqlite-driver.d.ts

@@ -0,0 +1,26 @@
+/** Values accepted by the synchronous SQLite adapters. */
+export type SqliteValue = string | number | bigint | boolean | Uint8Array | null;
+/** Result of a SQLite statement that does not return rows. */
+export interface SqliteRunResult {
+    readonly changes: number | bigint;
+    readonly lastInsertRowid: number | bigint;
+}
+/** Prepared synchronous SQLite statement used by the server stores. */
+export interface SqliteStatement<Row, Params extends readonly SqliteValue[]> {
+    run(...params: Params): SqliteRunResult;
+    get(...params: Params): Row | null;
+    all(...params: Params): Row[];
+}
+/** Runtime-neutral database surface shared by the Bun and Node adapters. */
+export interface SqliteDatabase {
+    exec(sql: string): void;
+    run(sql: string, bindings?: readonly SqliteValue[]): SqliteRunResult;
+    query<Row = Record<string, SqliteValue>, Params extends readonly SqliteValue[] = SqliteValue[]>(sql: string): SqliteStatement<Row, Params>;
+    close(): void;
+}
+/** Raised when a neutral-runtime import is used without a SQLite adapter. */
+export declare class SqliteAdapterRequiredError extends Error {
+    readonly name = "SqliteAdapterRequiredError";
+    readonly code = "sync.sqlite_adapter_required";
+    constructor();
+}

package/dist/sqlite-driver.js

@@ -0,0 +1,8 @@
+/** Raised when a neutral-runtime import is used without a SQLite adapter. */
+export class SqliteAdapterRequiredError extends Error {
+    name = 'SqliteAdapterRequiredError';
+    code = 'sync.sqlite_adapter_required';
+    constructor() {
+        super('SQLite paths require the @syncular/server/sqlite runtime adapter');
+    }
+}

package/dist/sqlite-image.d.ts

@@ -1,4 +1,5 @@
 import type { CompiledTable } from './schema.js';
+import type { SqliteDatabase } from './sqlite-driver.js';
 import type { StoredRow } from './storage.js';
 /** The §5.6 version column as it appears inside a sqlite image (§5.3). */
 export declare const IMAGE_VERSION_COLUMN = "_syncular_version";
@@ -14,14 +15,11 @@ export interface SqliteImageInput {
 /**
  * The §5.3 image-builder capability, injected through
  * `SyncServerConfig.sqliteImageBuilder`. Building an image needs
- * a real SQLite engine (`bun:sqlite` here), which is not available on every
- * runtime — Cloudflare Workers has none. So the core takes the builder as an
- * optional capability rather than importing `bun:sqlite` on the pull path:
- * a Bun/Node host passes `buildSqliteImage`; a Workers host omits it and the
- * pull serves the rows lane (§5.3 clients advertise sqlite as an *accept*,
- * never a requirement — the host chooses the served format from what it can
- * produce; this is a support floor, not a fallback).
+ * a real SQLite engine, which is not available on every runtime. The core
+ * takes the builder as an optional capability rather than importing a driver
+ * on the pull path. A Bun or Node host passes `buildSqliteImage`; a Workers
+ * host omits it and serves the rows lane.
  */
 export type SqliteImageBuilder = (input: SqliteImageInput) => Uint8Array;
-/** Build the §5.3 image bytes for a whole-table snapshot. */
-export declare const buildSqliteImage: SqliteImageBuilder;
+/** Populate a §5.3 image database for a whole-table snapshot. */
+export declare function writeSqliteImage(db: SqliteDatabase, input: SqliteImageInput): void;

package/dist/sqlite-image.js

@@ -2,13 +2,12 @@
  * SQLite-image segment generation (SPEC.md §5.3): a complete SQLite
  * database file carrying one table's whole effective-scope snapshot at
  * the bootstrap pin, plus the single-row `_syncular_segment` metadata
- * table. Built in memory on bun:sqlite — dependency-free.
+ * table. Runtime entries provide the concrete SQLite database.
  *
  * Images are NOT byte-deterministic (§5.3): the content address pins the
  * served bytes, and cross-client dedup comes from the segment store's
  * metadata lookup (`SegmentStore.find`), not from hash convergence.
  */
-import { Database } from 'bun:sqlite';
 import { decodeRow } from '@syncular/core';
 /** The §5.6 version column as it appears inside a sqlite image (§5.3). */
 export const IMAGE_VERSION_COLUMN = '_syncular_version';
@@ -45,39 +44,38 @@ function toSql(value) {
         return value ? 1 : 0;
     return value;
 }
-/** Build the §5.3 image bytes for a whole-table snapshot. */
-export const buildSqliteImage = (input) => {
+/** Populate a §5.3 image database for a whole-table snapshot. */
+export function writeSqliteImage(db, input) {
     const { table, rows } = input;
     const primaryKey = table.columns[table.primaryKeyIndex]?.name;
-    const db = new Database(':memory:');
+    const columnDefs = table.columns.map((column) => {
+        const notNull = column.nullable ? '' : ' NOT NULL';
+        const pk = column.name === primaryKey ? ' PRIMARY KEY' : '';
+        return `${quoteIdent(column.name)} ${sqlType(column)}${notNull}${pk}`;
+    });
+    columnDefs.push(`${quoteIdent(IMAGE_VERSION_COLUMN)} INTEGER NOT NULL`);
+    db.exec(`CREATE TABLE ${quoteIdent(table.name)} (${columnDefs.join(', ')})`);
+    db.exec(`CREATE TABLE ${IMAGE_METADATA_TABLE} (
+      format INTEGER NOT NULL, "table" TEXT NOT NULL,
+      "schemaVersion" INTEGER NOT NULL, "asOfCommitSeq" INTEGER NOT NULL,
+      "scopeDigest" TEXT NOT NULL, "rowCount" INTEGER NOT NULL)`);
+    db.query(`INSERT INTO ${IMAGE_METADATA_TABLE} VALUES (1, ?, ?, ?, ?, ?)`).run(table.name, input.schemaVersion, input.asOfCommitSeq, input.scopeDigest, rows.length);
+    const names = [
+        ...table.columns.map((column) => quoteIdent(column.name)),
+        quoteIdent(IMAGE_VERSION_COLUMN),
+    ];
+    const insert = db.query(`INSERT INTO ${quoteIdent(table.name)} (${names.join(', ')})
+     VALUES (${names.map(() => '?').join(', ')})`);
+    db.exec('BEGIN');
     try {
-        const columnDefs = table.columns.map((column) => {
-            const notNull = column.nullable ? '' : ' NOT NULL';
-            const pk = column.name === primaryKey ? ' PRIMARY KEY' : '';
-            return `${quoteIdent(column.name)} ${sqlType(column)}${notNull}${pk}`;
-        });
-        columnDefs.push(`${quoteIdent(IMAGE_VERSION_COLUMN)} INTEGER NOT NULL`);
-        db.exec(`CREATE TABLE ${quoteIdent(table.name)} (${columnDefs.join(', ')})`);
-        db.exec(`CREATE TABLE ${IMAGE_METADATA_TABLE} (
-        format INTEGER NOT NULL, "table" TEXT NOT NULL,
-        "schemaVersion" INTEGER NOT NULL, "asOfCommitSeq" INTEGER NOT NULL,
-        "scopeDigest" TEXT NOT NULL, "rowCount" INTEGER NOT NULL)`);
-        db.query(`INSERT INTO ${IMAGE_METADATA_TABLE} VALUES (1, ?, ?, ?, ?, ?)`).run(table.name, input.schemaVersion, input.asOfCommitSeq, input.scopeDigest, rows.length);
-        const names = [
-            ...table.columns.map((column) => quoteIdent(column.name)),
-            quoteIdent(IMAGE_VERSION_COLUMN),
-        ];
-        const insert = db.query(`INSERT INTO ${quoteIdent(table.name)} (${names.join(', ')})
-       VALUES (${names.map(() => '?').join(', ')})`);
-        db.exec('BEGIN');
         for (const row of rows) {
             const values = decodeRow(table.columns, row.payload);
             insert.run(...values.map(toSql), row.serverVersion);
         }
         db.exec('COMMIT');
-        return new Uint8Array(db.serialize());
     }
-    finally {
-        db.close();
+    catch (error) {
+        db.exec('ROLLBACK');
+        throw error;
     }
-};
+}

package/dist/sqlite-lease-store.d.ts

@@ -1,18 +1,13 @@
 /**
- * SQLite-backed auth-lease store via `bun:sqlite` (§7.3.1 reference store,
- * dependency-free). Bun-specific by design (top-level `bun:sqlite` import),
- * so it lives in its own module — the runtime-neutral `LeaseStore` interface,
- * `LeaseRecord`, and `MemoryLeaseStore` stay in `lease-store.ts` for the
- * Workers/edge core (runtime neutrality is enforced by
- * `test/runtime-neutrality.test.ts`).
+ * SQLite-backed auth-lease store over the shared synchronous driver.
  */
-import { Database } from 'bun:sqlite';
 import type { ScopeMap } from '@syncular/core';
 import type { LeaseIdFactory, LeaseRecord, LeaseStore } from './lease-store.js';
+import { type SqliteDatabase } from './sqlite-driver.js';
 export declare class SqliteLeaseStore implements LeaseStore {
     #private;
-    readonly db: Database;
-    constructor(db?: Database | string, options?: {
+    readonly db: SqliteDatabase;
+    constructor(db?: SqliteDatabase | string, options?: {
         readonly leaseId?: LeaseIdFactory;
     });
     get(partition: string, clientId: string): Promise<LeaseRecord | undefined>;

package/dist/sqlite-lease-store.js

@@ -1,12 +1,4 @@
-/**
- * SQLite-backed auth-lease store via `bun:sqlite` (§7.3.1 reference store,
- * dependency-free). Bun-specific by design (top-level `bun:sqlite` import),
- * so it lives in its own module — the runtime-neutral `LeaseStore` interface,
- * `LeaseRecord`, and `MemoryLeaseStore` stay in `lease-store.ts` for the
- * Workers/edge core (runtime neutrality is enforced by
- * `test/runtime-neutrality.test.ts`).
- */
-import { Database } from 'bun:sqlite';
+import { SqliteAdapterRequiredError, } from './sqlite-driver.js';
 function defaultLeaseId() {
     return `lease_${crypto.randomUUID()}`;
 }
@@ -14,7 +6,10 @@ export class SqliteLeaseStore {
     db;
     #newId;
     constructor(db = ':memory:', options) {
-        this.db = typeof db === 'string' ? new Database(db) : db;
+        if (typeof db === 'string') {
+            throw new SqliteAdapterRequiredError();
+        }
+        this.db = db;
         this.#newId = options?.leaseId ?? defaultLeaseId;
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS sync_leases(

package/dist/sqlite-node-driver.d.ts

@@ -0,0 +1,10 @@
+import { DatabaseSync } from 'node:sqlite';
+import type { SqliteDatabase, SqliteRunResult, SqliteStatement, SqliteValue } from './sqlite-driver.js';
+export declare class NodeSqliteDatabase implements SqliteDatabase {
+    readonly native: DatabaseSync;
+    constructor(path?: string);
+    exec(sql: string): void;
+    run(sql: string, bindings?: readonly SqliteValue[]): SqliteRunResult;
+    query<Row, Params extends readonly SqliteValue[]>(sql: string): SqliteStatement<Row, Params>;
+    close(): void;
+}

package/dist/sqlite-node-driver.js

@@ -0,0 +1,30 @@
+import { DatabaseSync } from 'node:sqlite';
+function bind(value) {
+    return typeof value === 'boolean' ? (value ? 1 : 0) : value;
+}
+function row(value) {
+    return (value ?? null);
+}
+export class NodeSqliteDatabase {
+    native;
+    constructor(path = ':memory:') {
+        this.native = new DatabaseSync(path);
+    }
+    exec(sql) {
+        this.native.exec(sql);
+    }
+    run(sql, bindings = []) {
+        return this.native.prepare(sql).run(...bindings.map(bind));
+    }
+    query(sql) {
+        const statement = this.native.prepare(sql);
+        return {
+            run: (...params) => statement.run(...params.map(bind)),
+            get: (...params) => row(statement.get(...params.map(bind))),
+            all: (...params) => statement.all(...params.map(bind)),
+        };
+    }
+    close() {
+        this.native.close();
+    }
+}

package/dist/sqlite-node.d.ts

@@ -0,0 +1,24 @@
+import { SqliteBlobStore as SharedSqliteBlobStore } from './sqlite-blob-store.js';
+import type { SqliteDatabase } from './sqlite-driver.js';
+import { type SqliteImageBuilder } from './sqlite-image.js';
+import { SqliteLeaseStore as SharedSqliteLeaseStore } from './sqlite-lease-store.js';
+import { SqliteSegmentStore as SharedSqliteSegmentStore } from './sqlite-segment-store.js';
+import { SqliteServerStorage as SharedSqliteServerStorage } from './sqlite-storage.js';
+export declare class SqliteServerStorage extends SharedSqliteServerStorage {
+    constructor(value?: SqliteDatabase | string);
+}
+export declare class SqliteSegmentStore extends SharedSqliteSegmentStore {
+    constructor(value?: SqliteDatabase | string, options?: {
+        ttlMs?: number;
+    });
+}
+export declare class SqliteBlobStore extends SharedSqliteBlobStore {
+    constructor(value?: SqliteDatabase | string);
+}
+export declare class SqliteLeaseStore extends SharedSqliteLeaseStore {
+    constructor(value?: SqliteDatabase | string, options?: {
+        readonly leaseId?: () => string;
+    });
+}
+export declare const buildSqliteImage: SqliteImageBuilder;
+export { NodeSqliteDatabase } from './sqlite-node-driver.js';

package/dist/sqlite-node.js

@@ -0,0 +1,50 @@
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { SqliteBlobStore as SharedSqliteBlobStore } from './sqlite-blob-store.js';
+import { writeSqliteImage } from './sqlite-image.js';
+import { SqliteLeaseStore as SharedSqliteLeaseStore } from './sqlite-lease-store.js';
+import { NodeSqliteDatabase } from './sqlite-node-driver.js';
+import { SqliteSegmentStore as SharedSqliteSegmentStore } from './sqlite-segment-store.js';
+import { SqliteServerStorage as SharedSqliteServerStorage } from './sqlite-storage.js';
+function database(value) {
+    return typeof value === 'string' ? new NodeSqliteDatabase(value) : value;
+}
+export class SqliteServerStorage extends SharedSqliteServerStorage {
+    constructor(value = ':memory:') {
+        super(database(value));
+    }
+}
+export class SqliteSegmentStore extends SharedSqliteSegmentStore {
+    constructor(value = ':memory:', options) {
+        super(database(value), options);
+    }
+}
+export class SqliteBlobStore extends SharedSqliteBlobStore {
+    constructor(value = ':memory:') {
+        super(database(value));
+    }
+}
+export class SqliteLeaseStore extends SharedSqliteLeaseStore {
+    constructor(value = ':memory:', options) {
+        super(database(value), options);
+    }
+}
+export const buildSqliteImage = (input) => {
+    const directory = mkdtempSync(join(tmpdir(), 'syncular-server-image-'));
+    const path = join(directory, 'segment.db');
+    const db = new NodeSqliteDatabase(path);
+    try {
+        try {
+            writeSqliteImage(db, input);
+        }
+        finally {
+            db.close();
+        }
+        return new Uint8Array(readFileSync(path));
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+};
+export { NodeSqliteDatabase } from './sqlite-node-driver.js';

package/dist/sqlite-segment-store.d.ts

@@ -1,18 +1,12 @@
 /**
- * SQLite-backed segment store via `bun:sqlite` (dev/bench convenience,
- * dependency-free). Bun-specific by design: it imports `bun:sqlite` at the
- * top level, so it lives in its own module — importing it opts into the Bun
- * runtime. The runtime-neutral `SegmentStore` interface, `MemorySegmentStore`,
- * and `segmentIdFor` stay in `segment-store.ts` so the Workers/edge core can
- * import them without pulling in `bun:sqlite` (runtime neutrality is enforced
- * by `test/runtime-neutrality.test.ts`).
+ * SQLite-backed segment store over the shared synchronous driver.
  */
-import { Database } from 'bun:sqlite';
 import { type SegmentFindKey, type SegmentMetadata, type SegmentRecord, type SegmentStore, type SegmentStoreStats } from './segment-store.js';
+import { type SqliteDatabase } from './sqlite-driver.js';
 export declare class SqliteSegmentStore implements SegmentStore {
     #private;
-    readonly db: Database;
-    constructor(db?: Database | string, options?: {
+    readonly db: SqliteDatabase;
+    constructor(db?: SqliteDatabase | string, options?: {
         ttlMs?: number;
     });
     put(metadata: SegmentMetadata, bytes: Uint8Array, nowMs: number): Promise<SegmentRecord>;

package/dist/sqlite-segment-store.js

@@ -1,19 +1,16 @@
 /**
- * SQLite-backed segment store via `bun:sqlite` (dev/bench convenience,
- * dependency-free). Bun-specific by design: it imports `bun:sqlite` at the
- * top level, so it lives in its own module — importing it opts into the Bun
- * runtime. The runtime-neutral `SegmentStore` interface, `MemorySegmentStore`,
- * and `segmentIdFor` stay in `segment-store.ts` so the Workers/edge core can
- * import them without pulling in `bun:sqlite` (runtime neutrality is enforced
- * by `test/runtime-neutrality.test.ts`).
+ * SQLite-backed segment store over the shared synchronous driver.
  */
-import { Database } from 'bun:sqlite';
 import { DEFAULT_SEGMENT_TTL_MS, segmentIdFor, } from './segment-store.js';
+import { SqliteAdapterRequiredError, } from './sqlite-driver.js';
 export class SqliteSegmentStore {
     db;
     #ttlMs;
     constructor(db = ':memory:', options) {
-        this.db = typeof db === 'string' ? new Database(db) : db;
+        if (typeof db === 'string') {
+            throw new SqliteAdapterRequiredError();
+        }
+        this.db = db;
         this.#ttlMs = options?.ttlMs ?? DEFAULT_SEGMENT_TTL_MS;
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS sync_segments(

package/dist/sqlite-storage.d.ts

@@ -1,18 +1,10 @@
-/**
- * SQLite storage via `bun:sqlite` (dev-speed, dependency-free).
- *
- * Scope fanout is index-first: both the commit log and the
- * current-row table carry a (table, variable, value) inverted index; reads
- * select candidates from the index and verify the full multi-variable
- * match against the stored scope map — never a log scan.
- */
-import { Database } from 'bun:sqlite';
 import type { CompiledSchema, CompiledTable } from './schema.js';
-import type { ClientCursorInfo, ClientRecord, CommitMetadata, CommitMetadataQuery, CommitWindowQuery, IndexRowScanQuery, RowScanQuery, ScopeActivityQuery, ScopeCommitActivity, ServerStorage, StorageTransaction, StoredCommit, StoredPushResult, StoredRow } from './storage.js';
+import { type SqliteDatabase } from './sqlite-driver.js';
+import type { AuthoritativeQueryRequest, AuthoritativeQueryResult, ClientCursorInfo, ClientRecord, CommitMetadata, CommitMetadataQuery, CommitWindowQuery, IndexRowScanQuery, PrunedReactionCounts, ReactionClaimQuery, ReactionFailureUpdate, ReactionListQuery, ReactionPruneQuery, RowScanQuery, ScopeActivityQuery, ScopeCommitActivity, ServerStorage, StorageTransaction, StoredCommit, StoredPushResult, StoredReaction, StoredRow } from './storage.js';
 export declare class SqliteServerStorage implements ServerStorage {
     #private;
-    readonly db: Database;
-    constructor(db?: Database | string);
+    readonly db: SqliteDatabase;
+    constructor(db?: SqliteDatabase | string);
     /** Resolve a table's compiled schema; row operations require `ensureSchema`. */
     table(name: string): CompiledTable;
     ensureSchema(schema: CompiledSchema): Promise<void>;
@@ -20,12 +12,21 @@ export declare class SqliteServerStorage implements ServerStorage {
     /** Internal: write a row + refresh its scope-index entries. */
     writeRow(partition: string, table: string, row: StoredRow): void;
     getMaxCommitSeq(partition: string): Promise<number>;
+    queryAuthoritative(partition: string, query: AuthoritativeQueryRequest): Promise<AuthoritativeQueryResult>;
     getHorizonSeq(partition: string): Promise<number>;
     setHorizonSeq(partition: string, seq: number): Promise<void>;
     pruneCommitsThrough(partition: string, seq: number): Promise<number>;
     getCommitSeqBefore(partition: string, createdBeforeMs: number): Promise<number>;
     getRow(partition: string, table: string, rowId: string): Promise<StoredRow | undefined>;
     getPushResult(partition: string, clientId: string, clientCommitId: string): Promise<StoredPushResult | undefined>;
+    claimReactions(partition: string, query: ReactionClaimQuery): Promise<StoredReaction[]>;
+    completeReaction(partition: string, idempotencyKey: string, leaseOwner: string, completedAtMs: number): Promise<boolean>;
+    extendReactionLease(partition: string, idempotencyKey: string, leaseOwner: string, leaseExpiresAtMs: number): Promise<boolean>;
+    failReaction(partition: string, idempotencyKey: string, update: ReactionFailureUpdate): Promise<boolean>;
+    retryReaction(partition: string, idempotencyKey: string, nowMs: number): Promise<boolean>;
+    getReaction(partition: string, idempotencyKey: string): Promise<StoredReaction | undefined>;
+    listReactions(partition: string, query: ReactionListQuery): Promise<StoredReaction[]>;
+    pruneReactions(partition: string, query: ReactionPruneQuery): Promise<PrunedReactionCounts>;
     readCommitWindow(partition: string, query: CommitWindowQuery): Promise<StoredCommit[]>;
     scanRows(partition: string, query: RowScanQuery): Promise<StoredRow[]>;
     scanRowsByIndex(partition: string, query: IndexRowScanQuery): Promise<StoredRow[]>;