@syncular/server 0.15.46 → 0.15.48

package/src/postgres-storage.ts

@@ -85,6 +85,7 @@ import type {
   IndexRowScanQuery,
   NewCommit,
   NewReaction,
+  PartitionRegistryEntry,
   PrunedReactionCounts,
   ReactionClaimQuery,
   ReactionFailure,
@@ -136,6 +137,12 @@ CREATE TABLE IF NOT EXISTS sync_partitions(
   max_commit_seq BIGINT NOT NULL DEFAULT 0,
   horizon_seq BIGINT NOT NULL DEFAULT 0
 );
+CREATE TABLE IF NOT EXISTS sync_partition_registry(
+  partition TEXT PRIMARY KEY,
+  log_epoch TEXT NOT NULL,
+  epoch_required BOOLEAN NOT NULL DEFAULT FALSE,
+  last_authenticated_at_ms BIGINT NOT NULL
+);
 CREATE TABLE IF NOT EXISTS sync_row_scopes(
   partition TEXT NOT NULL, tbl TEXT NOT NULL,
   var TEXT NOT NULL, value TEXT NOT NULL, row_id TEXT NOT NULL,
@@ -189,10 +196,13 @@ 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,
+  wire_version INTEGER NOT NULL DEFAULT 1,
   cursor BIGINT NOT NULL, subscriptions JSONB NOT NULL,
   updated_at_ms BIGINT NOT NULL,
   PRIMARY KEY(partition, client_id)
 );
+ALTER TABLE sync_clients
+  ADD COLUMN IF NOT EXISTS wire_version INTEGER NOT NULL DEFAULT 1;
 CREATE TABLE IF NOT EXISTS sync_blob_refs(
   partition TEXT NOT NULL, tbl TEXT NOT NULL, row_id TEXT NOT NULL,
   blob_id TEXT NOT NULL,
@@ -998,6 +1008,86 @@ export class PostgresServerStorage implements ServerStorage {
     this.#schemaVersion = schema.version;
   }
 
+  async touchPartition(
+    partition: string,
+    authenticatedAtMs: number,
+    initialLogEpoch: string,
+  ): Promise<PartitionRegistryEntry> {
+    if (initialLogEpoch.length === 0) {
+      throw new Error('initial log epoch must be non-empty');
+    }
+    const { rows } = await this.#exec.query<{
+      log_epoch: string;
+      epoch_required: boolean;
+      last_authenticated_at_ms: unknown;
+    }>(
+      `INSERT INTO sync_partition_registry(
+         partition, log_epoch, last_authenticated_at_ms
+       ) VALUES ($1,$2,$3)
+       ON CONFLICT(partition) DO UPDATE SET
+         last_authenticated_at_ms=EXCLUDED.last_authenticated_at_ms
+       RETURNING log_epoch, epoch_required, last_authenticated_at_ms`,
+      [partition, initialLogEpoch, authenticatedAtMs],
+    );
+    const row = rows[0];
+    if (row === undefined)
+      throw new Error('partition registry write did not persist');
+    return {
+      partition,
+      logEpoch: row.log_epoch,
+      epochRequired: row.epoch_required,
+      lastAuthenticatedAtMs: asNumber(row.last_authenticated_at_ms),
+    };
+  }
+
+  async rotatePartitionLogEpoch(
+    partition: string,
+    logEpoch: string,
+    authenticatedAtMs: number,
+  ): Promise<PartitionRegistryEntry> {
+    if (logEpoch.length === 0) throw new Error('log epoch must be non-empty');
+    await this.#exec.transaction(async (client) => {
+      await client.query(
+        `INSERT INTO sync_partition_registry(
+           partition, log_epoch, epoch_required, last_authenticated_at_ms
+         ) VALUES ($1,$2,TRUE,$3)
+         ON CONFLICT(partition) DO UPDATE SET
+           log_epoch=EXCLUDED.log_epoch,
+           epoch_required=TRUE,
+           last_authenticated_at_ms=EXCLUDED.last_authenticated_at_ms`,
+        [partition, logEpoch, authenticatedAtMs],
+      );
+      await client.query('DELETE FROM sync_clients WHERE partition=$1', [
+        partition,
+      ]);
+    });
+    return {
+      partition,
+      logEpoch,
+      epochRequired: true,
+      lastAuthenticatedAtMs: authenticatedAtMs,
+    };
+  }
+
+  async listPartitionRegistry(): Promise<PartitionRegistryEntry[]> {
+    const { rows } = await this.#exec.query<{
+      partition: string;
+      log_epoch: string;
+      epoch_required: boolean;
+      last_authenticated_at_ms: unknown;
+    }>(
+      `SELECT partition, log_epoch, epoch_required, last_authenticated_at_ms
+         FROM sync_partition_registry ORDER BY partition`,
+      [],
+    );
+    return rows.map((row) => ({
+      partition: row.partition,
+      logEpoch: row.log_epoch,
+      epochRequired: row.epoch_required,
+      lastAuthenticatedAtMs: asNumber(row.last_authenticated_at_ms),
+    }));
+  }
+
   /**
    * Open a real Postgres transaction. The push handler drives the returned
    * `StorageTransaction` imperatively (getRow/upsert/…/commit), but the
@@ -1496,11 +1586,12 @@ export class PostgresServerStorage implements ServerStorage {
     const { rows } = await this.#exec.query<{
       client_id: string;
       actor_id: string;
+      wire_version: unknown;
       cursor: unknown;
       subscriptions: unknown;
       updated_at_ms: unknown;
     }>(
-      'SELECT client_id, actor_id, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=$1 AND client_id=$2',
+      'SELECT client_id, actor_id, wire_version, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=$1 AND client_id=$2',
       [partition, clientId],
     );
     const record = rows[0];
@@ -1508,6 +1599,7 @@ export class PostgresServerStorage implements ServerStorage {
     return {
       clientId: record.client_id,
       actorId: record.actor_id,
+      wireVersion: asNumber(record.wire_version),
       cursor: asNumber(record.cursor),
       updatedAtMs: asNumber(record.updated_at_ms),
       subscriptions: asJson<ClientSubscription[]>(record.subscriptions),
@@ -1519,16 +1611,18 @@ export class PostgresServerStorage implements ServerStorage {
     record: ClientRecord,
   ): Promise<void> {
     await this.#exec.query(
-      `INSERT INTO sync_clients(partition, client_id, actor_id, cursor, subscriptions, updated_at_ms)
-       VALUES ($1,$2,$3,$4,$5,$6)
+      `INSERT INTO sync_clients(partition, client_id, actor_id, wire_version, cursor, subscriptions, updated_at_ms)
+       VALUES ($1,$2,$3,$4,$5,$6,$7)
        ON CONFLICT (partition, client_id) DO UPDATE
-         SET actor_id=EXCLUDED.actor_id, cursor=EXCLUDED.cursor,
+         SET actor_id=EXCLUDED.actor_id, wire_version=EXCLUDED.wire_version,
+             cursor=EXCLUDED.cursor,
              subscriptions=EXCLUDED.subscriptions,
              updated_at_ms=EXCLUDED.updated_at_ms`,
       [
         partition,
         record.clientId,
         record.actorId,
+        record.wireVersion,
         record.cursor,
         JSON.stringify(record.subscriptions),
         record.updatedAtMs,
@@ -1608,16 +1702,18 @@ export class PostgresServerStorage implements ServerStorage {
     const { rows } = await this.#exec.query<{
       client_id: string;
       actor_id: string;
+      wire_version: unknown;
       cursor: unknown;
       subscriptions: unknown;
       updated_at_ms: unknown;
     }>(
-      'SELECT client_id, actor_id, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=$1 ORDER BY updated_at_ms DESC',
+      'SELECT client_id, actor_id, wire_version, cursor, subscriptions, updated_at_ms FROM sync_clients WHERE partition=$1 ORDER BY updated_at_ms DESC',
       [partition],
     );
     return rows.map((r) => ({
       clientId: r.client_id,
       actorId: r.actor_id,
+      wireVersion: asNumber(r.wire_version),
       cursor: asNumber(r.cursor),
       updatedAtMs: asNumber(r.updated_at_ms),
       subscriptions: (typeof r.subscriptions === 'string'
@@ -1742,13 +1838,6 @@ export class PostgresServerStorage implements ServerStorage {
   }
 
   async listPartitions(): Promise<string[]> {
-    // Union: the registry row appears on first commit, the client row on
-    // first pull — a partition with only one of the two still shows up.
-    const { rows } = await this.#exec.query<{ partition: string }>(
-      `SELECT partition FROM sync_partitions
-       UNION SELECT partition FROM sync_clients ORDER BY partition`,
-      [],
-    );
-    return rows.map((r) => r.partition);
+    return (await this.listPartitionRegistry()).map((entry) => entry.partition);
   }
 }

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;
@@ -212,12 +212,14 @@ async function* sqliteImageSegment(
   asOf: number,
   digest: string,
   trace: PullSectionTrace | undefined,
+  logEpoch: string,
 ): AsyncGenerator<ResponseFrame, boolean> {
   const { storage, segments, partition } = ctx;
   const now = clockOf(ctx)();
   const existing = await segments.find(
     {
       partition,
+      logEpoch,
       table: plan.table.name,
       schemaVersion: schema.version,
       mediaType: 'sqlite',
@@ -286,6 +288,7 @@ async function* sqliteImageSegment(
   const record = await segments.put(
     {
       partition,
+      logEpoch,
       table: plan.table.name,
       schemaVersion: schema.version,
       mediaType: 'sqlite',
@@ -320,6 +323,7 @@ async function* bootstrapSegments(
   asOf: number,
   startRowCursor: string | null,
   trace: PullSectionTrace | undefined,
+  logEpoch: string,
 ): AsyncGenerator<
   ResponseFrame,
   { complete: boolean; rowCursor: string | null }
@@ -347,6 +351,7 @@ async function* bootstrapSegments(
       asOf,
       digest,
       trace,
+      logEpoch,
     );
     if (imaged) return { complete: true, rowCursor: null };
   }
@@ -393,6 +398,7 @@ async function* bootstrapSegments(
       const record = await segments.put(
         {
           partition,
+          logEpoch,
           table: plan.table.name,
           schemaVersion: schema.version,
           mediaType: 'rows',
@@ -435,8 +441,12 @@ export async function* subscriptionSection(
   maxSeq: number,
   horizonSeq: number,
   trace?: PullSectionTrace,
+  logEpoch?: string,
 ): AsyncGenerator<ResponseFrame, SubscriptionResult> {
   const sub = plan.frame;
+  if (logEpoch === undefined || logEpoch.length === 0) {
+    throw new Error('subscriptionSection requires a non-empty log epoch');
+  }
 
   if (plan.status === 'revoked') {
     yield {
@@ -496,6 +506,7 @@ export async function* subscriptionSection(
       asOf,
       startCursor,
       trace,
+      logEpoch,
     );
     if (outcome.complete) {
       yield { type: 'SUB_END', nextCursor: asOf };

package/src/realtime.ts

@@ -31,7 +31,11 @@ import {
   type WakeReason,
 } from '@syncular/core';
 import type { SyncRequestContext, SyncServerConfig } from './context';
-import { REMOTE_COMMAND_CLIENT_ID_PREFIX, RESOLVER_OUTAGE } from './context';
+import {
+  REMOTE_COMMAND_CLIENT_ID_PREFIX,
+  RESOLVER_OUTAGE,
+  touchAuthenticatedPartition,
+} from './context';
 import { SyncError, syncError } from './errors';
 import { emitEvent, type SyncularServerEvents } from './events';
 import { createSyncResponseStream } from './handler';
@@ -215,6 +219,9 @@ export class RealtimeSession {
   readonly partition: string;
   readonly actorId: string;
   readonly clientId: string;
+  readonly logEpoch: string;
+  /** Response/delta layout selected by the most recent socket round. */
+  wireVersion: number;
   /** Highest contiguously applied commitSeq acknowledged by the client. */
   cursor: number;
   /** Suppress deltas until the client catches up via pull + ack (§8.2). */
@@ -256,12 +263,16 @@ export class RealtimeSession {
     clock: () => number,
     maxDeltaBytes: number,
     storage: ServerStorage,
+    logEpoch: string,
+    wireVersion: number,
     events: SyncularServerEvents | undefined,
   ) {
     this.sessionId = crypto.randomUUID();
     this.partition = options.partition;
     this.actorId = options.actorId;
     this.clientId = options.clientId;
+    this.logEpoch = logEpoch;
+    this.wireVersion = wireVersion;
     this.cursor = cursor;
     this.lastKnownSeq = latestSeq;
     this.wakePending = cursor < latestSeq;
@@ -515,6 +526,11 @@ export class RealtimeSession {
       if (this.#activeRound === token) this.#activeRound = undefined;
     };
     try {
+      const requestedWireVersion =
+        (requestBytes[4] ?? 0) | ((requestBytes[5] ?? 0) << 8);
+      if (requestedWireVersion === 1 || requestedWireVersion === 2) {
+        this.wireVersion = requestedWireVersion;
+      }
       let stream: AsyncIterable<Uint8Array> | undefined;
       try {
         // §8.7: the round's clientId must match the connection's —
@@ -543,7 +559,9 @@ export class RealtimeSession {
               ? error
               : syncError(error.code, error.message);
           finishRound(); // END is in this one chunk
-          await this.#sendRoundChunk(errorResponseBytes(sync));
+          await this.#sendRoundChunk(
+            errorResponseBytes(sync, this.wireVersion, this.logEpoch),
+          );
           return;
         }
         throw error;
@@ -712,7 +730,14 @@ export class RealtimeSession {
       this.sendWake('catchup-required');
       return;
     }
-    const frames: ResponseFrame[] = [{ type: 'RESP_HEADER' }];
+    const frames: ResponseFrame[] = [
+      {
+        type: 'RESP_HEADER',
+        ...(this.wireVersion >= 2
+          ? { logEpoch: this.logEpoch, resetRequired: false }
+          : {}),
+      },
+    ];
     for (const section of sections) {
       frames.push({
         type: 'SUB_START',
@@ -733,7 +758,7 @@ export class RealtimeSession {
       frames.push({ type: 'SUB_END', nextCursor: commit.commitSeq });
     }
     const bytes = encodeMessage({
-      wireVersion: PROTOCOL_WIRE_VERSION,
+      wireVersion: this.wireVersion,
       msgKind: 'response',
       frames,
     });
@@ -963,6 +988,11 @@ export class RealtimeHub {
   async connect(options: RealtimeConnectOptions): Promise<RealtimeSession> {
     const { storage } = this.#config;
     const clock = this.#config.clock ?? Date.now;
+    const registry = await touchAuthenticatedPartition({
+      ...this.#config,
+      partition: options.partition,
+      actorId: options.actorId,
+    });
     if (options.clientId.startsWith(REMOTE_COMMAND_CLIENT_ID_PREFIX)) {
       throw syncError(
         'sync.invalid_client_id',
@@ -995,6 +1025,8 @@ export class RealtimeHub {
       clock,
       this.#config.maxDeltaBytes ?? DEFAULT_MAX_DELTA_BYTES,
       storage,
+      registry.logEpoch,
+      record?.wireVersion ?? PROTOCOL_WIRE_VERSION,
       this.#config.events,
     );
     this.#sessions.add(session);
@@ -1079,12 +1111,19 @@ export function createRealtimeHub(config: RealtimeHubConfig): RealtimeHub {
 /** §8.7 failures: the socket has no HTTP status surface, so a
  * request-level failure becomes a minimal RESP_HEADER/ERROR/END
  * response message delivered as the round's response stream. */
-function errorResponseBytes(error: SyncError): Uint8Array {
+function errorResponseBytes(
+  error: SyncError,
+  wireVersion: number,
+  logEpoch: string,
+): Uint8Array {
   return encodeMessage({
-    wireVersion: PROTOCOL_WIRE_VERSION,
+    wireVersion,
     msgKind: 'response',
     frames: [
-      { type: 'RESP_HEADER' },
+      {
+        type: 'RESP_HEADER',
+        ...(wireVersion >= 2 ? { logEpoch, resetRequired: false } : {}),
+      },
       {
         type: 'ERROR',
         code: error.code,

package/src/restore.ts

@@ -0,0 +1,28 @@
+import type { PartitionRegistryEntry, ServerStorage } from './storage';
+
+export interface RotatePartitionLogEpochOptions {
+  readonly storage: ServerStorage;
+  readonly partition: string;
+  readonly nowMs?: number;
+  /** Deterministic operator/test override. Defaults to a random UUID. */
+  readonly logEpoch?: string;
+}
+
+/**
+ * Fence clients from a prior authoritative database timeline after restore.
+ * Call while traffic and realtime delivery remain stopped (§2.1).
+ */
+export function rotatePartitionLogEpoch(
+  options: RotatePartitionLogEpochOptions,
+): Promise<PartitionRegistryEntry> {
+  if (options.partition.length === 0) {
+    throw new TypeError('partition must be non-empty');
+  }
+  const logEpoch = options.logEpoch ?? crypto.randomUUID();
+  if (logEpoch.length === 0) throw new TypeError('logEpoch must be non-empty');
+  return options.storage.rotatePartitionLogEpoch(
+    options.partition,
+    logEpoch,
+    options.nowMs ?? Date.now(),
+  );
+}

package/src/s3-segment-store.ts

@@ -152,7 +152,13 @@ function parseRecordJson(json: string, source: string): SegmentRecord {
     throw new Error(`S3SegmentStore: corrupt record in ${source}`);
   }
   const r = parsed as Record<string, unknown>;
-  const strings = ['segmentId', 'partition', 'table', 'scopeDigest'] as const;
+  const strings = [
+    'segmentId',
+    'partition',
+    'logEpoch',
+    'table',
+    'scopeDigest',
+  ] as const;
   const numbers = [
     'schemaVersion',
     'asOfCommitSeq',
@@ -182,6 +188,7 @@ function parseRecordJson(json: string, source: string): SegmentRecord {
   return {
     segmentId: r.segmentId as string,
     partition: r.partition as string,
+    logEpoch: r.logEpoch as string,
     table: r.table as string,
     schemaVersion: r.schemaVersion as number,
     mediaType: r.mediaType,
@@ -223,6 +230,7 @@ export class S3SegmentStore implements SegmentStore {
   async #findKeyFor(key: SegmentFindKey): Promise<string> {
     const canonical = JSON.stringify([
       key.partition,
+      key.logEpoch,
       key.table,
       key.schemaVersion,
       key.mediaType,
@@ -431,6 +439,7 @@ export class S3SegmentStore implements SegmentStore {
     const record = parseRecordJson(await response.text(), 'reuse pointer');
     if (
       record.partition !== key.partition ||
+      record.logEpoch !== key.logEpoch ||
       record.table !== key.table ||
       record.schemaVersion !== key.schemaVersion ||
       record.mediaType !== key.mediaType ||

package/src/seed.ts

@@ -186,8 +186,52 @@ export async function seedMutations(
     };
   });
 
+  const requestContext = {
+    ...config,
+    partition: target.partition,
+    actorId: target.actorId,
+  };
+  const acquisition = decodeMessage(
+    await handleSyncRequest(
+      encodeMessage({
+        wireVersion: PROTOCOL_WIRE_VERSION,
+        msgKind: 'request',
+        frames: [
+          {
+            type: 'REQ_HEADER',
+            clientId,
+            schemaVersion: config.schema.version,
+          },
+          {
+            type: 'PULL_HEADER',
+            limitCommits: 0,
+            limitSnapshotRows: 0,
+            maxSnapshotPages: 0,
+            accept: 0b0011,
+          },
+        ],
+      }),
+      requestContext,
+    ),
+  );
+  const acquisitionHeader = acquisition.frames[0];
+  if (
+    acquisition.msgKind !== 'response' ||
+    acquisitionHeader?.type !== 'RESP_HEADER' ||
+    acquisitionHeader.logEpoch === undefined
+  ) {
+    throw new SyncError(
+      'sync.invalid_request',
+      'seedMutations: epoch acquisition returned an invalid response',
+    );
+  }
   const frames: RequestFrame[] = [
-    { type: 'REQ_HEADER', clientId, schemaVersion: config.schema.version },
+    {
+      type: 'REQ_HEADER',
+      clientId,
+      schemaVersion: config.schema.version,
+      logEpoch: acquisitionHeader.logEpoch,
+    },
     { type: 'PUSH_COMMIT', clientCommitId, operations },
     // A pull that asks for nothing: the round exists for its push half.
     {
@@ -221,9 +265,7 @@ export async function seedMutations(
       frames,
     }),
     {
-      ...config,
-      partition: target.partition,
-      actorId: target.actorId,
+      ...requestContext,
       events:
         config.events === undefined
           ? capture

package/src/segment-download.ts

@@ -9,7 +9,11 @@
  */
 import type { ScopeMap } from '@syncular/core';
 import type { SyncRequestContext } from './context';
-import { clockOf, RESOLVER_OUTAGE } from './context';
+import {
+  clockOf,
+  RESOLVER_OUTAGE,
+  touchAuthenticatedPartition,
+} from './context';
 import { SyncError, syncError } from './errors';
 import { emitEvent } from './events';
 import { compileSchema } from './schema';
@@ -96,8 +100,13 @@ async function downloadSegment(
   ctx: SyncRequestContext,
   request: SegmentDownloadRequest,
 ): Promise<SegmentDownloadResult> {
+  const registry = await touchAuthenticatedPartition(ctx);
   const entry = await ctx.segments.get(request.segmentId);
-  if (entry === undefined || entry.record.partition !== ctx.partition) {
+  if (
+    entry === undefined ||
+    entry.record.partition !== ctx.partition ||
+    entry.record.logEpoch !== registry.logEpoch
+  ) {
     throw syncError('sync.not_found', 'unknown segment (§5.5)');
   }
   if (entry.record.expiresAtMs <= clockOf(ctx)()) {

package/src/segment-store.ts

@@ -12,6 +12,8 @@ export const DEFAULT_SEGMENT_TTL_MS = 24 * 60 * 60 * 1000;
 
 export interface SegmentMetadata {
   readonly partition: string;
+  /** Partition log continuity that produced these bytes (§2.1). */
+  readonly logEpoch: string;
   readonly table: string;
   readonly schemaVersion: number;
   readonly mediaType: 'rows' | 'sqlite';
@@ -36,6 +38,7 @@ export interface SegmentRecord extends SegmentMetadata {
  */
 export interface SegmentFindKey {
   readonly partition: string;
+  readonly logEpoch: string;
   readonly table: string;
   readonly schemaVersion: number;
   readonly mediaType: 'rows' | 'sqlite';
@@ -126,6 +129,7 @@ export class MemorySegmentStore implements SegmentStore {
     for (const { record } of this.#entries.values()) {
       if (
         record.partition === key.partition &&
+        record.logEpoch === key.logEpoch &&
         record.table === key.table &&
         record.schemaVersion === key.schemaVersion &&
         record.mediaType === key.mediaType &&

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,46 @@
+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(value: string | Database = ':memory:') {
+    this.native = typeof value === 'string' ? new Database(value) : value;
+  }
+
+  static deserialize(bytes: Uint8Array): BunSqliteDatabase {
+    return new BunSqliteDatabase(Database.deserialize(bytes));
+  }
+
+  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();
+  }
+}