@syncular/server 0.15.46 → 0.15.47

package/README.md

@@ -29,7 +29,7 @@ The supported set, and what deliberately does **not** get an adapter:
 
 | Runtime | Adapter | Transport | Storage | Status |
 | --- | --- | --- | --- | --- |
-| **Bun / Node** | `@syncular/server-hono` | HTTP (`POST /sync`, segments, blobs) **+ WS realtime** (§8, host-driven upgrade) | any: `SqliteServerStorage`, `PostgresServerStorage`, memory | **Supported now** — the reference deployment; runs the full conformance catalog on both bindings. |
+| **Bun / Node 22.13+** | `@syncular/server-hono` | HTTP (`POST /sync`, segments, blobs) **+ WS realtime** (§8, host-driven upgrade) | `SqliteServerStorage` through `@syncular/server/sqlite`, Postgres, memory | **Supported now** — the reference deployment; runs the full conformance catalog on both bindings. |
 | **Cloudflare Workers** | `@syncular/server-workers` | HTTP binding via Hono (Workers-native) **+ optional WS realtime** (§8) | `D1ServerStorage` behind one per-partition Durable Object queue; R2-as-S3 for segments/blobs | **Supported now** — D1 sync writes always traverse the DO; WebSocket upgrades remain optional. |
 | Raw Deno / edge-misc | — | — | — | **Not adapted** (policy below). |
 
@@ -76,9 +76,9 @@ or the storage projection cannot migrate:
 ```ts
 import {
   ensureSyncServerReady,
-  SqliteServerStorage,
   type SyncServerConfig,
 } from '@syncular/server';
+import { SqliteServerStorage } from '@syncular/server/sqlite';
 
 const config: SyncServerConfig = {
   schema,
@@ -91,6 +91,12 @@ await ensureSyncServerReady(config);
 Bun.serve({ fetch: app.fetch });
 ```
 
+`@syncular/server/sqlite` selects `bun:sqlite` on Bun and the built-in
+`node:sqlite` module on Node. It covers server storage, segment storage, blob
+storage, leases, and SQLite-image generation without an external SQLite
+package. The runtime-specific database wrappers are `BunSqliteDatabase` and
+`NodeSqliteDatabase` when a host needs direct access to the native handle.
+
 The helper accepts the generated `ServerSchema`, compiles it, and calls the
 storage backend's low-level `ensureSchema(CompiledSchema)`. A failure is a
 `SyncServerReadinessError` with stable code `sync.schema_not_ready`, a `phase`
@@ -974,7 +980,8 @@ same table+scope during a storm, your TTL is shorter than the storm.
 
 ## Postgres storage (the production database path)
 
-`SqliteServerStorage` (bun:sqlite) is the dev-speed default. For
+`SqliteServerStorage` from `@syncular/server/sqlite` uses `bun:sqlite` or
+Node's built-in `node:sqlite`. For
 production, `PostgresServerStorage` implements the same `ServerStorage`
 contract against Postgres, with the inverted scope index carried through
 as **covering indexes** so scope fanout is an index range scan, never a

package/dist/context.d.ts

@@ -148,7 +148,8 @@ export interface SyncServerConfig {
      * §5.3 sqlite-image builder, injected so the pull path never
      * statically imports `bun:sqlite`. Absent ⇒ the sqlite-image lane is off
      * (bit-2 clients are served the rows lane) — the Workers/edge posture. A
-     * Bun/Node host wires `buildSqliteImage` from `@syncular/server`.
+     * Bun or Node host wires `buildSqliteImage` from
+     * `@syncular/server/sqlite`.
      */
     readonly sqliteImageBuilder?: SqliteImageBuilder;
     readonly realtime?: RealtimeNotifier;

package/dist/index-bun.d.ts

@@ -0,0 +1,2 @@
+export * from './index.js';
+export { buildSqliteImage, BunSqliteDatabase, SqliteBlobStore, SqliteLeaseStore, SqliteSegmentStore, SqliteServerStorage, } from './sqlite-bun.js';

package/dist/index-bun.js

@@ -0,0 +1,2 @@
+export * from './index.js';
+export { buildSqliteImage, BunSqliteDatabase, SqliteBlobStore, SqliteLeaseStore, SqliteSegmentStore, SqliteServerStorage, } from './sqlite-bun.js';

package/dist/index-node.d.ts

@@ -0,0 +1,2 @@
+export * from './index.js';
+export { buildSqliteImage, NodeSqliteDatabase, SqliteBlobStore, SqliteLeaseStore, SqliteSegmentStore, SqliteServerStorage, } from './sqlite-node.js';

package/dist/index-node.js

@@ -0,0 +1,2 @@
+export * from './index.js';
+export { buildSqliteImage, NodeSqliteDatabase, SqliteBlobStore, SqliteLeaseStore, SqliteSegmentStore, SqliteServerStorage, } from './sqlite-node.js';

package/dist/index.d.ts

@@ -41,9 +41,10 @@ export * from './seed.js';
 export * from './segment-download.js';
 export * from './segment-store.js';
 export * from './signed-url.js';
-export * from './sqlite-blob-store.js';
 export * from './sqlite-dialect.js';
-export * from './sqlite-image.js';
+export * from './sqlite-driver.js';
+export { IMAGE_METADATA_TABLE, IMAGE_VERSION_COLUMN, type SqliteImageBuilder, type SqliteImageInput, } from './sqlite-image.js';
+export * from './sqlite-blob-store.js';
 export * from './sqlite-lease-store.js';
 export * from './sqlite-segment-store.js';
 export * from './sqlite-storage.js';

package/dist/index.js

@@ -45,13 +45,10 @@ export * from './seed.js';
 export * from './segment-download.js';
 export * from './segment-store.js';
 export * from './signed-url.js';
-// Bun-specific storages (top-level `bun:sqlite`): re-exported for Bun/Node
-// hosts. Workers/edge builds tree-shake them (and their `bun:sqlite` import)
-// away — the runtime-neutral core closure is enforced by
-// `test/runtime-neutrality.test.ts`.
-export * from './sqlite-blob-store.js';
 export * from './sqlite-dialect.js';
-export * from './sqlite-image.js';
+export * from './sqlite-driver.js';
+export { IMAGE_METADATA_TABLE, IMAGE_VERSION_COLUMN, } from './sqlite-image.js';
+export * from './sqlite-blob-store.js';
 export * from './sqlite-lease-store.js';
 export * from './sqlite-segment-store.js';
 export * from './sqlite-storage.js';

package/dist/pull.js

@@ -19,7 +19,7 @@ async function resolveImageBuilder(ctx) {
     if (cachedDefaultBuilder === undefined) {
         const hasBun = globalThis.Bun !== undefined;
         cachedDefaultBuilder = hasBun
-            ? (await import('./sqlite-image.js')).buildSqliteImage
+            ? (await import('./sqlite-bun.js')).buildSqliteImage
             : null;
     }
     return cachedDefaultBuilder ?? undefined;

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

@@ -1,16 +1,11 @@
 /**
- * SQLite-backed blob store via `bun:sqlite` (dev/bench convenience,
- * dependency-free). Bun-specific by design (top-level `bun:sqlite` import),
- * so it lives in its own module — the runtime-neutral `BlobStore` interface,
- * `MemoryBlobStore`, `blobIdFor`, and `isBlobId` stay in `blob-store.ts` for
- * the Workers/edge core (runtime neutrality is enforced by
- * `test/runtime-neutrality.test.ts`).
+ * SQLite-backed blob store over the shared synchronous driver.
  */
-import { Database } from 'bun:sqlite';
 import type { BlobRecord, BlobStore, BlobStoreStats } from './blob-store.js';
+import { type SqliteDatabase } from './sqlite-driver.js';
 export declare class SqliteBlobStore implements BlobStore {
-    readonly db: Database;
-    constructor(db?: Database | string);
+    readonly db: SqliteDatabase;
+    constructor(db?: SqliteDatabase | string);
     put(partition: string, blobId: string, bytes: Uint8Array, nowMs: number, mediaType?: string): Promise<BlobRecord>;
     has(partition: string, blobId: string): Promise<boolean>;
     get(partition: string, blobId: string): Promise<{

package/dist/sqlite-blob-store.js

@@ -1,16 +1,11 @@
-/**
- * SQLite-backed blob store via `bun:sqlite` (dev/bench convenience,
- * dependency-free). Bun-specific by design (top-level `bun:sqlite` import),
- * so it lives in its own module — the runtime-neutral `BlobStore` interface,
- * `MemoryBlobStore`, `blobIdFor`, and `isBlobId` stay in `blob-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';
 export class SqliteBlobStore {
     db;
     constructor(db = ':memory:') {
-        this.db = typeof db === 'string' ? new Database(db) : db;
+        if (typeof db === 'string') {
+            throw new SqliteAdapterRequiredError();
+        }
+        this.db = db;
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS sync_blobs(
         partition TEXT NOT NULL, blob_id TEXT NOT NULL,

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

@@ -0,0 +1,11 @@
+import { Database } from 'bun:sqlite';
+import type { SqliteDatabase, SqliteRunResult, SqliteStatement, SqliteValue } from './sqlite-driver.js';
+export declare class BunSqliteDatabase implements SqliteDatabase {
+    readonly native: Database;
+    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>;
+    serialize(): Uint8Array;
+    close(): void;
+}

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`
@@ -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`
@@ -181,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';