@syncular/server 0.15.46 → 0.15.47

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 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>;

package/dist/sqlite-storage.js

@@ -1,17 +1,17 @@
 /**
- * SQLite storage via `bun:sqlite` (dev-speed, dependency-free).
+ * SQLite server storage over the shared synchronous driver.
  *
  * 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 { bindAuthoritativePartition, prepareAuthoritativeQuery, } from './authoritative-query.js';
 import { syncError } from './errors.js';
 import { commitWindowPageSql, deleteRowSql, dropTableDdl, indexRowPageStatement, layoutsOf, migratePayload, parseLayouts, retiredTableNames, rewritePlan, rewriteRowSql, rewriteValues, SCHEMA_META_DDL_SQLITE, scanRowPageSql, schemaDdl, selectRowScopesSql, selectRowSql, selectRowsForRewriteSql, upsertSql, upsertValues, } from './relational-rows.js';
 import { matchesEffective } from './scopes.js';
 import { collectCommitWindowPage, deserializePushResult, SQLITE_DDL, serializePushResult, toStoredRow, } from './sqlite-dialect.js';
+import { SqliteAdapterRequiredError, } from './sqlite-driver.js';
 import { isSqliteConstraintError, StorageConstraintError, } from './storage-errors.js';
 import { assertScopeIndexedScan, resolveIndexRowScan } from './storage-query.js';
 function toStoredReaction(record) {
@@ -62,7 +62,7 @@ class SqliteTransaction {
     }
     getPushResult(clientId, clientCommitId) {
         this.#assertOpen();
-        // One shared bun:sqlite connection — this read runs inside this
+        // One shared SQLite connection: this read runs inside this
         // transaction's BEGIN IMMEDIATE.
         return this.#storage.getPushResult(this.#partition, clientId, clientCommitId);
     }
@@ -194,7 +194,7 @@ class SqliteTransaction {
 }
 export class SqliteServerStorage {
     db;
-    /** One bun:sqlite connection can own only one transaction at a time. */
+    /** One SQLite connection can own only one transaction at a time. */
     #transactionTail = Promise.resolve();
     /** Set by `ensureSchema`: app-table lookup for the relational row store. */
     #tables;
@@ -214,7 +214,10 @@ export class SqliteServerStorage {
         }
     }
     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(SQLITE_DDL);
     }
     /** Resolve a table's compiled schema; row operations require `ensureSchema`. */

package/dist/storage-errors.js

@@ -44,7 +44,10 @@ export function isSqliteConstraintError(error) {
         return true;
     }
     const errno = candidate?.errno;
-    return typeof errno === 'number' && (errno & 0xff) === 19;
+    if (typeof errno === 'number' && (errno & 0xff) === 19)
+        return true;
+    const errcode = candidate?.errcode;
+    return typeof errcode === 'number' && (errcode & 0xff) === 19;
 }
 /** PostgreSQL SQLSTATE class 23: integrity constraint violation. */
 export function isPostgresConstraintError(error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/server",
-  "version": "0.15.46",
+  "version": "0.15.47",
   "description": "Syncular server: handleSyncRequest + storage/auth interfaces for the sync protocol",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
@@ -27,13 +27,25 @@
   },
   "exports": {
     ".": {
-      "bun": "./src/index.ts",
+      "bun": "./src/index-bun.ts",
+      "node": {
+        "types": "./dist/index-node.d.ts",
+        "default": "./dist/index-node.js"
+      },
       "browser": "./dist/index.js",
       "import": {
         "types": "./dist/index.d.ts",
         "default": "./dist/index.js"
       }
     },
+    "./sqlite": {
+      "bun": "./src/sqlite-bun.ts",
+      "node": {
+        "types": "./dist/sqlite-node.d.ts",
+        "default": "./dist/sqlite-node.js"
+      },
+      "types": "./dist/sqlite-node.d.ts"
+    },
     "./pglite": {
       "bun": "./src/pg-executor-pglite.ts",
       "browser": "./dist/pg-executor-pglite.js",
@@ -52,8 +64,11 @@
     "!dist/**/*.test.js",
     "!dist/**/*.test.d.ts"
   ],
+  "scripts": {
+    "verify:node": "cd ../.. && bun build ./packages/server/test/sqlite-runtime/verify-node.mjs --target=node --conditions=bun --outfile=./packages/server/.verify-node.built.mjs && node ./packages/server/.verify-node.built.mjs"
+  },
   "dependencies": {
-    "@syncular/core": "0.15.46"
+    "@syncular/core": "0.15.47"
   },
   "devDependencies": {
     "@electric-sql/pglite": "^0.5.4"

package/src/context.ts

@@ -167,7 +167,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/src/index-bun.ts

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

package/src/index-node.ts

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

package/src/index.ts

@@ -73,13 +73,15 @@ export * from './seed';
 export * from './segment-download';
 export * from './segment-store';
 export * from './signed-url';
-// 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';
 export * from './sqlite-dialect';
-export * from './sqlite-image';
+export * from './sqlite-driver';
+export {
+  IMAGE_METADATA_TABLE,
+  IMAGE_VERSION_COLUMN,
+  type SqliteImageBuilder,
+  type SqliteImageInput,
+} from './sqlite-image';
+export * from './sqlite-blob-store';
 export * from './sqlite-lease-store';
 export * from './sqlite-segment-store';
 export * from './sqlite-storage';

package/src/pull.ts

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

package/src/sqlite-blob-store.ts

@@ -1,19 +1,20 @@
 /**
- * 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';
+import {
+  SqliteAdapterRequiredError,
+  type SqliteDatabase,
+} from './sqlite-driver';
 
 export class SqliteBlobStore implements BlobStore {
-  readonly db: Database;
+  readonly db: SqliteDatabase;
 
-  constructor(db: Database | string = ':memory:') {
-    this.db = typeof db === 'string' ? new Database(db) : db;
+  constructor(db: SqliteDatabase | string = ':memory:') {
+    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/src/sqlite-bun-driver.ts

@@ -0,0 +1,42 @@
+import { Database, type SQLQueryBindings } from 'bun:sqlite';
+import type {
+  SqliteDatabase,
+  SqliteRunResult,
+  SqliteStatement,
+  SqliteValue,
+} from './sqlite-driver';
+
+export class BunSqliteDatabase implements SqliteDatabase {
+  readonly native: Database;
+
+  constructor(path = ':memory:') {
+    this.native = new Database(path);
+  }
+
+  exec(sql: string): void {
+    this.native.exec(sql);
+  }
+
+  run(sql: string, bindings: readonly SqliteValue[] = []): SqliteRunResult {
+    return this.native.run(sql, [...bindings]);
+  }
+
+  query<Row, Params extends readonly SqliteValue[]>(
+    sql: string,
+  ): SqliteStatement<Row, Params> {
+    const statement = this.native.query<Row, SQLQueryBindings[]>(sql);
+    return {
+      run: (...params) => statement.run(...params),
+      get: (...params) => statement.get(...params),
+      all: (...params) => statement.all(...params),
+    };
+  }
+
+  serialize(): Uint8Array {
+    return new Uint8Array(this.native.serialize());
+  }
+
+  close(): void {
+    this.native.close();
+  }
+}

package/src/sqlite-bun.ts

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

package/src/sqlite-dialect.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
@@ -25,7 +25,7 @@ import type {
 } from './storage';
 
 /**
- * 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`
@@ -246,7 +246,7 @@ export interface SqliteChangeRecord {
   payload: Uint8Array | null;
 }
 
-/** `bun:sqlite` returns `Uint8Array`; D1 returns `ArrayBuffer` for BLOBs. */
+/** Native SQLite returns `Uint8Array`; D1 returns `ArrayBuffer` for BLOBs. */
 export function asUint8Array(value: unknown): Uint8Array {
   if (value instanceof Uint8Array) return value;
   if (value instanceof ArrayBuffer) return new Uint8Array(value);
@@ -280,7 +280,7 @@ export 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/src/sqlite-driver.ts

@@ -0,0 +1,44 @@
+/** 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 class SqliteAdapterRequiredError extends Error {
+  override readonly name = 'SqliteAdapterRequiredError';
+  readonly code = 'sync.sqlite_adapter_required';
+
+  constructor() {
+    super('SQLite paths require the @syncular/server/sqlite runtime adapter');
+  }
+}

package/src/sqlite-image.ts

@@ -2,15 +2,15 @@
  * 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, type RowColumn, type RowValue } from '@syncular/core';
 import type { CompiledTable } from './schema';
+import type { SqliteDatabase } from './sqlite-driver';
 import type { StoredRow } from './storage';
 
 /** The §5.6 version column as it appears inside a sqlite image (§5.3). */
@@ -63,62 +63,57 @@ 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 const buildSqliteImage: SqliteImageBuilder = (input) => {
+/** Populate a §5.3 image database for a whole-table snapshot. */
+export function writeSqliteImage(
+  db: SqliteDatabase,
+  input: SqliteImageInput,
+): void {
   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/src/sqlite-lease-store.ts

@@ -1,28 +1,29 @@
 /**
- * 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';
+import {
+  SqliteAdapterRequiredError,
+  type SqliteDatabase,
+} from './sqlite-driver';
 
 function defaultLeaseId(): string {
   return `lease_${crypto.randomUUID()}`;
 }
 
 export class SqliteLeaseStore implements LeaseStore {
-  readonly db: Database;
+  readonly db: SqliteDatabase;
   readonly #newId: LeaseIdFactory;
 
   constructor(
-    db: Database | string = ':memory:',
+    db: SqliteDatabase | string = ':memory:',
     options?: { readonly leaseId?: LeaseIdFactory },
   ) {
-    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(