@syncular/server 0.15.45 → 0.15.47

package/src/realtime.ts

@@ -31,7 +31,7 @@ import {
   type WakeReason,
 } from '@syncular/core';
 import type { SyncRequestContext, SyncServerConfig } from './context';
-import { RESOLVER_OUTAGE } from './context';
+import { REMOTE_COMMAND_CLIENT_ID_PREFIX, RESOLVER_OUTAGE } from './context';
 import { SyncError, syncError } from './errors';
 import { emitEvent, type SyncularServerEvents } from './events';
 import { createSyncResponseStream } from './handler';
@@ -963,6 +963,12 @@ export class RealtimeHub {
   async connect(options: RealtimeConnectOptions): Promise<RealtimeSession> {
     const { storage } = this.#config;
     const clock = this.#config.clock ?? Date.now;
+    if (options.clientId.startsWith(REMOTE_COMMAND_CLIENT_ID_PREFIX)) {
+      throw syncError(
+        'sync.invalid_client_id',
+        'clientId uses a reserved server-command namespace (§1.5)',
+      );
+    }
     const record = await storage.getClientRecord(
       options.partition,
       options.clientId,

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`
@@ -74,6 +74,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,
@@ -226,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);
@@ -260,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(

package/src/sqlite-node-driver.ts

@@ -0,0 +1,46 @@
+import { DatabaseSync, type SQLInputValue } from 'node:sqlite';
+import type {
+  SqliteDatabase,
+  SqliteRunResult,
+  SqliteStatement,
+  SqliteValue,
+} from './sqlite-driver';
+
+function bind(value: SqliteValue): SQLInputValue {
+  return typeof value === 'boolean' ? (value ? 1 : 0) : value;
+}
+
+function row<Row>(value: Record<string, unknown> | undefined): Row | null {
+  return (value ?? null) as Row | null;
+}
+
+export class NodeSqliteDatabase implements SqliteDatabase {
+  readonly native: DatabaseSync;
+
+  constructor(path = ':memory:') {
+    this.native = new DatabaseSync(path);
+  }
+
+  exec(sql: string): void {
+    this.native.exec(sql);
+  }
+
+  run(sql: string, bindings: readonly SqliteValue[] = []): SqliteRunResult {
+    return this.native.prepare(sql).run(...bindings.map(bind));
+  }
+
+  query<Row, Params extends readonly SqliteValue[]>(
+    sql: string,
+  ): SqliteStatement<Row, Params> {
+    const statement = this.native.prepare(sql);
+    return {
+      run: (...params) => statement.run(...params.map(bind)),
+      get: (...params) => row<Row>(statement.get(...params.map(bind))),
+      all: (...params) => statement.all(...params.map(bind)) as Row[],
+    };
+  }
+
+  close(): void {
+    this.native.close();
+  }
+}

package/src/sqlite-node.ts

@@ -0,0 +1,62 @@
+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';
+import type { SqliteDatabase } from './sqlite-driver';
+import { type SqliteImageBuilder, writeSqliteImage } from './sqlite-image';
+import { SqliteLeaseStore as SharedSqliteLeaseStore } from './sqlite-lease-store';
+import { NodeSqliteDatabase } from './sqlite-node-driver';
+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 NodeSqliteDatabase(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 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';

package/src/sqlite-segment-store.ts

@@ -1,13 +1,6 @@
 /**
- * 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,
   type SegmentFindKey,
@@ -17,16 +10,23 @@ import {
   type SegmentStoreStats,
   segmentIdFor,
 } from './segment-store';
+import {
+  SqliteAdapterRequiredError,
+  type SqliteDatabase,
+} from './sqlite-driver';
 
 export class SqliteSegmentStore implements SegmentStore {
-  readonly db: Database;
+  readonly db: SqliteDatabase;
   #ttlMs: number;
 
   constructor(
-    db: Database | string = ':memory:',
+    db: SqliteDatabase | string = ':memory:',
     options?: { ttlMs?: number },
   ) {
-    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(