@delali/sirannon-db 0.1.7 → 0.2.0

package/dist/core/writer-worker.mjs

@@ -1,7 +1,7 @@
-import { serializeError } from '../chunk-DJLX6CAE.mjs';
-import { executeGroup } from '../chunk-CW6S3WL5.mjs';
-import '../chunk-GEZUUIKV.mjs';
-import { SirannonError } from '../chunk-YPYVQJ4C.mjs';
+import { executeGroup } from '../chunk-JZGINXTN.mjs';
+import '../chunk-D7LAYTKN.mjs';
+import { WORKER_CANCELLED_CODE, serializeError } from '../chunk-4ISB7XMA.mjs';
+import { SirannonError } from '../chunk-UC3SCMIN.mjs';
 import { parentPort } from 'worker_threads';
 
 var STATEMENT_CACHE_CAPACITY = 128;
@@ -93,7 +93,22 @@ async function dispatch(req) {
       return void 0;
   }
 }
+var cancelledIds = /* @__PURE__ */ new Set();
+var latestDispatchedId = 0;
 async function handle(req) {
+  latestDispatchedId = req.id;
+  if (cancelledIds.delete(req.id)) {
+    port.postMessage({
+      id: req.id,
+      ok: false,
+      error: {
+        message: "The caller abandoned this operation before the worker reached it, so it was not run",
+        name: "SirannonError",
+        code: WORKER_CANCELLED_CODE
+      }
+    });
+    return;
+  }
   try {
     const value = await dispatch(req);
     port.postMessage({ id: req.id, ok: true, value });
@@ -101,7 +116,14 @@ async function handle(req) {
     port.postMessage({ id: req.id, ok: false, error: serializeError(err) });
   }
 }
+function settleDeliveredMessages() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
 var tail = Promise.resolve();
-port.on("message", (req) => {
-  tail = tail.then(() => handle(req));
+port.on("message", (msg) => {
+  if (msg.kind === "cancel") {
+    if (msg.id > latestDispatchedId) cancelledIds.add(msg.id);
+    return;
+  }
+  tail = tail.then(settleDeliveredMessages).then(() => handle(msg));
 });

package/dist/{database-DuGp0Rtr.d.ts → database-BY0L5Q2n.d.ts}

@@ -1,5 +1,7 @@
-import { Q as QueryHookContext, k as ConnectionHookContext, l as BeforeSubscribeHook, H as HookConfig, M as MetricsConfig, m as QueryMetrics, n as ConnectionMetrics, o as CDCMetrics, a as SQLiteDriver, D as DatabaseOptions, P as Params, p as QueryOptions, E as ExecuteResult, q as BulkLoadOptions, h as BulkLoadResult, T as Transaction, e as SQLiteConnection, r as SubscriptionBuilder, f as BackupScheduleOptions, B as BeforeQueryHook, A as AfterQueryHook } from './types-D_hQW1hr.js';
-import { M as Migration, a as MigrationResult, R as RollbackResult } from './types-D4p4UyDK.js';
+import { i as QueryHookContext, j as ConnectionHookContext, k as BeforeSubscribeHook, H as HookConfig, l as MetricsConfig, m as QueryMetrics, n as ConnectionMetrics, o as CDCMetrics, h as ChangeEvent, a as SQLiteDriver, D as DatabaseOptions, P as Params, Q as QueryOptions, E as ExecuteResult, T as Transaction, e as SQLiteConnection, p as SubscriptionBuilder, M as Migration, q as MigrationResult, r as RollbackResult, f as BackupScheduleOptions, B as BeforeQueryHook, A as AfterQueryHook } from './types-zhnRXrsb.js';
+import { c as ReplicationChange, C as ConflictResolver, A as ApplyResult, R as ReplicationBatch } from './types-C_D8IhpO.js';
+import { A as AppliedMigrationRow, b as BulkLoadOptions, a as BulkLoadResult } from './server-options-1JHu8pid.js';
+import { L as LiveQueryOptions, a as LiveQuery } from './types-CL6piSnD.js';
 
 type HookEvent = 'beforeQuery' | 'afterQuery' | 'beforeConnect' | 'databaseOpen' | 'databaseClose' | 'beforeSubscribe';
 type SubscribeHookContext = Parameters<BeforeSubscribeHook>[0];
@@ -38,10 +40,56 @@ declare class MetricsCollector {
     get active(): boolean;
 }
 
+interface StagedRecovery {
+    resumeSeq: bigint | null;
+    appliedSeq: bigint | null;
+    /**
+     * The failure that stopped the recovery apply, or null. The staged rows
+     * are untouched by the failure and the resume watermark still covers
+     * them, so the caller opens the subscription anyway: a schema-gate refusal
+     * there is what tells a device it must migrate before this apply can
+     * succeed. The caller must then retry the recovery, because the resume
+     * watermark is past the transaction this apply left unapplied, so the
+     * server sends nothing that would prompt another attempt.
+     */
+    applyError: unknown | null;
+}
+
+interface DeviceSyncPullState {
+    seq: bigint;
+    epoch: string | undefined;
+}
+interface DeviceSyncPort {
+    identity(): Promise<{
+        nodeId: string;
+    }>;
+    applyPulledTransaction(changes: readonly ReplicationChange[], pullSeq: bigint, resolver?: ConflictResolver | ((table: string) => ConflictResolver)): Promise<ApplyResult>;
+    stagePulledChanges(events: readonly ChangeEvent[]): Promise<bigint | null>;
+    applyStagedPull(resolver?: ConflictResolver | ((table: string) => ConflictResolver), onChange?: (event: ChangeEvent) => void): Promise<bigint | null>;
+    recoverStagedPull(resolver?: ConflictResolver | ((table: string) => ConflictResolver), onChange?: (event: ChangeEvent) => void): Promise<StagedRecovery>;
+    readOutboxBatch(afterSeq: bigint, limit: number): Promise<ReplicationBatch | null>;
+    countOutboxPending(afterSeq: bigint): Promise<number>;
+    getPushCursor(): Promise<bigint>;
+    setPushCursor(seq: bigint): Promise<void>;
+    getPullState(): Promise<DeviceSyncPullState | null>;
+    getResyncRequired(): Promise<boolean>;
+    setResyncRequired(required: boolean): Promise<void>;
+    setPullState(seq: bigint, epoch?: string): Promise<void>;
+    protectUnpushedChanges(pushedSeq: bigint): void;
+    snapshotLoadPending(): Promise<boolean>;
+    beginSnapshotLoad(tables: readonly string[]): Promise<void>;
+    applySnapshotSchema(schema: readonly string[]): Promise<void>;
+    loadSnapshotPage(table: string, rows: readonly Record<string, unknown>[]): Promise<void>;
+    replaceMigrationHistory(rows: readonly AppliedMigrationRow[]): Promise<void>;
+    endSnapshotLoad(tables: readonly string[]): Promise<void>;
+    abortSnapshotLoad(): Promise<void>;
+}
+
 interface DatabaseInternals {
     parentHooks?: HookRegistry;
     metrics?: MetricsCollector;
 }
+
 declare class Database {
     readonly id: string;
     readonly path: string;
@@ -56,25 +104,18 @@ declare class Database {
     private readonly closeListeners;
     private _closed;
     private readonly cdc;
+    private readonly sync;
     private readonly hookRegistry;
     private readonly observer;
     private readonly backups;
+    private readonly reads;
     private constructor();
     static create(id: string, path: string, driver: SQLiteDriver, options?: DatabaseOptions, internals?: DatabaseInternals): Promise<Database>;
+    applyChanges(batch: ReplicationBatch, resolver?: ConflictResolver | ((table: string) => ConflictResolver)): Promise<ApplyResult>;
+    deviceSync(): DeviceSyncPort;
     query<T = Record<string, unknown>>(sql: string, params?: Params, options?: QueryOptions): Promise<T[]>;
-    /**
-     * Returns query rows already encoded for the wire (safe-range integers as
-     * plain numbers, larger integers and BLOBs as tagged envelopes) in a single
-     * pass. The server response path uses this so a read walks its values once
-     * rather than narrowing on the driver and re-scanning to tag.
-     */
     queryForWire(sql: string, params?: Params, options?: QueryOptions): Promise<unknown[]>;
     queryOne<T = Record<string, unknown>>(sql: string, params?: Params, options?: QueryOptions): Promise<T | undefined>;
-    /**
-     * On a single-connection driver the reader is the writer, so serialise the
-     * read through the writer lock to avoid a bulk load's uncommitted rows.
-     */
-    private runRead;
     execute(sql: string, params?: Params, options?: QueryOptions): Promise<ExecuteResult>;
     executeBatch(sql: string, paramsBatch: Params[], options?: QueryOptions): Promise<ExecuteResult[]>;
     private runInTransaction;
@@ -108,9 +149,12 @@ declare class Database {
      * lock and stalls the event loop on `busy_timeout`.
      */
     runCdcMaintenance(op: (writer: SQLiteConnection) => Promise<unknown>): Promise<void>;
+    ensureChangeStamping(): Promise<void>;
     unwatch(table: string): Promise<void>;
     on(table: string): SubscriptionBuilder;
+    live<T = Record<string, unknown>>(sql: string, params?: Params, options?: LiveQueryOptions): Promise<LiveQuery<T>>;
     migrate(migrations: Migration[]): Promise<MigrationResult>;
+    appliedMigrations(): Promise<AppliedMigrationRow[]>;
     rollback(migrations: Migration[], version?: number): Promise<RollbackResult>;
     backup(destPath: string): Promise<void>;
     scheduleBackup(options: BackupScheduleOptions): void;
@@ -122,6 +166,7 @@ declare class Database {
     get closed(): boolean;
     get readerCount(): number;
     private ensureOpen;
+    private ensureNotClosed;
 }
 
-export { Database as D, type HookDispose as H, MetricsCollector as M, type SubscribeHookContext as S, type HookEvent as a, type HookEventContextMap as b, type HookHandler as c, HookRegistry as d };
+export { Database as D, type HookDispose as H, MetricsCollector as M, type SubscribeHookContext as S, type HookEvent as a, type HookEventContextMap as b, type HookHandler as c, HookRegistry as d, type DeviceSyncPort as e };

package/dist/driver/better-sqlite3.d.ts

@@ -1,4 +1,4 @@
-import { a as SQLiteDriver } from '../types-D_hQW1hr.js';
+import { a as SQLiteDriver } from '../types-zhnRXrsb.js';
 
 interface BetterSqlite3Options {
     busyTimeout?: number;

package/dist/driver/better-sqlite3.mjs

@@ -1,9 +1,9 @@
-import { nodeResolveExtensionPath, nodeBackupEngine, nodeWriterContext, WriterWorker, createStatementCache, narrowSafeBigInt, narrowRowIntegers, narrowRowsIntegers } from '../chunk-4IGMIJQK.mjs';
-import { defineDriver } from '../chunk-BNUTBHHH.mjs';
-import '../chunk-DJLX6CAE.mjs';
-import { synchronousPragmaValue } from '../chunk-CJLYFDP5.mjs';
-import '../chunk-VLTICJOD.mjs';
-import '../chunk-YPYVQJ4C.mjs';
+import { nodeResolveExtensionPath, nodeBackupEngine, nodeWriterContext, WriterWorker, createStatementCache, narrowSafeBigInt, narrowRowIntegers, narrowRowsIntegers } from '../chunk-EBJXPQQO.mjs';
+import '../chunk-PIKHN33N.mjs';
+import { defineDriver } from '../chunk-FHWTZFI4.mjs';
+import '../chunk-4ISB7XMA.mjs';
+import { synchronousPragmaValue } from '../chunk-LFZ37BSX.mjs';
+import '../chunk-UC3SCMIN.mjs';
 
 // src/drivers/better-sqlite3/index.ts
 function createConnection(db) {

package/dist/driver/node.d.ts

@@ -1,4 +1,4 @@
-import { a as SQLiteDriver } from '../types-D_hQW1hr.js';
+import { a as SQLiteDriver } from '../types-zhnRXrsb.js';
 
 interface NodeSqliteOptions {
     busyTimeout?: number;

package/dist/driver/node.mjs

@@ -1,9 +1,9 @@
-import { nodeResolveExtensionPath, nodeBackupEngine, nodeWriterContext, createStatementCache, WriterWorker, narrowSafeBigInt, narrowRowIntegers, narrowRowsIntegers } from '../chunk-4IGMIJQK.mjs';
-import { defineDriver } from '../chunk-BNUTBHHH.mjs';
-import '../chunk-DJLX6CAE.mjs';
-import { synchronousPragmaValue } from '../chunk-CJLYFDP5.mjs';
-import '../chunk-VLTICJOD.mjs';
-import '../chunk-YPYVQJ4C.mjs';
+import { nodeResolveExtensionPath, nodeBackupEngine, nodeWriterContext, createStatementCache, WriterWorker, narrowSafeBigInt, narrowRowIntegers, narrowRowsIntegers } from '../chunk-EBJXPQQO.mjs';
+import '../chunk-PIKHN33N.mjs';
+import { defineDriver } from '../chunk-FHWTZFI4.mjs';
+import '../chunk-4ISB7XMA.mjs';
+import { synchronousPragmaValue } from '../chunk-LFZ37BSX.mjs';
+import '../chunk-UC3SCMIN.mjs';
 
 // src/drivers/node/index.ts
 function nodeSqlite(driverOptions) {

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

@@ -1,139 +1,4 @@
-/** Options for scheduled backups. */
-interface BackupScheduleOptions {
-    /** Cron expression (e.g., '0 * * * *' for hourly). */
-    cron: string;
-    /** Directory to store backup files. */
-    destDir: string;
-    /** Maximum number of backup files to keep. Default: 5. */
-    maxFiles?: number;
-    /**
-     * Sirannon evaluates the cron expression in this IANA time zone (e.g. 'America/New_York').
-     * When omitted, it uses the host's local time zone, which also sets the daylight saving rules that apply.
-     */
-    timezone?: string;
-    /** Called when a scheduled backup fails. Without this, errors are silently discarded. */
-    onError?: (error: Error) => void;
-}
-
-interface WorkerHostOptions {
-    writeTimeoutMs?: number;
-    maxRestarts?: number;
-}
-
-interface RunResult {
-    changes: number;
-    lastInsertRowId: number | bigint;
-}
-/**
- * Tells a caller running inside the operation that holds the writer from one
- * merely waiting on it. A runtime without async context tracking cannot answer
- * this, and answering it wrongly runs one caller's writes inside another
- * caller's transaction.
- */
-interface WriterContext {
-    run<T>(operation: () => T): T;
-    isActive(): boolean;
-    exit<T>(operation: () => T): T;
-}
-interface BackupEngine {
-    backup(conn: SQLiteConnection, destPath: string): Promise<void>;
-    schedule(conn: SQLiteConnection, options: BackupScheduleOptions, runExclusive: (op: () => Promise<void>) => Promise<void>): () => void;
-}
-interface BatchSummary {
-    rowsLoaded: number;
-    changes: number;
-}
-interface SQLiteStatement {
-    all<T = unknown>(...params: unknown[]): Promise<T[]>;
-    get<T = unknown>(...params: unknown[]): Promise<T | undefined>;
-    run(...params: unknown[]): Promise<RunResult>;
-    /**
-     * Like {@link all} but skips the safe-range BigInt narrowing, leaving every
-     * integer as a BigInt. The server wire path narrows and tags in one pass, so
-     * feeding it raw rows avoids a second walk. Optional: a driver that omits it
-     * falls back to {@link all}, still correct but with the extra narrowing walk.
-     */
-    allRaw?<T = unknown>(...params: unknown[]): Promise<T[]>;
-}
-interface GroupRunError {
-    message: string;
-    name?: string;
-    code?: string;
-}
-type GroupRunOutcome = {
-    ok: true;
-    results: RunResult[];
-} | {
-    ok: false;
-    error: GroupRunError;
-};
-interface SQLiteConnection {
-    exec(sql: string): Promise<void>;
-    prepare(sql: string): Promise<SQLiteStatement>;
-    transaction<T>(fn: (conn: SQLiteConnection) => Promise<T>): Promise<T>;
-    close(): Promise<void>;
-    runBatch?(sql: string, paramsBatch: readonly unknown[][]): Promise<RunResult[]>;
-    runBatchSummary?(sql: string, paramsBatch: readonly unknown[][]): Promise<BatchSummary>;
-    /**
-     * Runs several independent units in one transaction, one outcome per unit in
-     * order. A unit is one write or one whole transaction, and a unit that fails
-     * must not disturb the others.
-     */
-    runGroup?(units: readonly {
-        statements: readonly {
-            sql: string;
-            params?: readonly unknown[];
-        }[];
-    }[]): Promise<GroupRunOutcome[]>;
-}
-/**
- * SQLite `PRAGMA synchronous` level applied to a connection. `normal` is safe
- * from corruption in WAL mode but can lose the most recent commits on power
- * loss; `full` fsyncs every commit; `extra` adds a directory sync after the
- * rollback journal is unlinked in DELETE journal mode and equals `full` in
- * WAL mode; `off` hands writes to the OS without syncing and is sanctioned
- * only for re-runnable bulk loads.
- */
-type SynchronousLevel = 'off' | 'normal' | 'full' | 'extra';
-interface OpenOptions {
-    readonly?: boolean;
-    walMode?: boolean;
-    synchronous?: SynchronousLevel;
-}
-interface DriverCapabilities {
-    multipleConnections: boolean;
-    extensions: boolean;
-}
-/**
- * Lets a worker thread rebuild the driver, since the driver's `open` function
- * cannot cross the thread boundary. `specifier` must be importable from the
- * worker and `config` must survive a structured clone; the worker imports the
- * module and calls its `exportName` factory (default export otherwise) with it.
- */
-interface DriverWorkerEntry {
-    specifier: string;
-    exportName?: string;
-    config?: unknown;
-}
-interface SQLiteDriver {
-    readonly capabilities: DriverCapabilities;
-    open(path: string, options?: OpenOptions): Promise<SQLiteConnection>;
-    readonly worker?: DriverWorkerEntry;
-    /**
-     * Offloads writes to a worker thread. Only a driver whose runtime has
-     * threads implements this, which is what keeps the thread machinery out of
-     * bundles built for runtimes that do not.
-     */
-    startWriterHost?(path: string, options: OpenOptions, hostOptions?: WorkerHostOptions): Promise<SQLiteConnection>;
-    createWriterContext?(): WriterContext;
-    createBackupEngine?(): BackupEngine;
-    /**
-     * Makes an extension path absolute. Passing a bare name to `load_extension`
-     * would let the dynamic linker search its own paths and open a different
-     * library than the operator named.
-     */
-    resolveExtensionPath?(extensionPath: string): string;
-}
+import { a as SQLiteDriver } from '../types-zhnRXrsb.js';
 
 interface WaSqliteOptions {
     vfs?: 'IDBBatchAtomicVFS' | 'AccessHandlePoolVFS';

package/dist/{errors-5Nf5ZAEC.d.ts → errors-Bw5MdNCu.d.ts}

@@ -60,6 +60,10 @@ declare class MigrationError extends SirannonError {
 declare class HookDeniedError extends SirannonError {
     constructor(hookName: string, reason?: string);
 }
+declare class RequestDeniedError extends SirannonError {
+    readonly status: number;
+    constructor(status: number, code: string, message: string);
+}
 /**
  * Thrown when the change-data-capture pipeline encounters an unrecoverable
  * error, such as a failed event dispatch or a corrupt change record.
@@ -116,4 +120,4 @@ declare class ExtensionError extends SirannonError {
     constructor(path: string, cause?: string);
 }
 
-export { BackupError as B, CDCError as C, DatabaseAlreadyExistsError as D, ExtensionError as E, ForbiddenSqlError as F, HookDeniedError as H, MaxDatabasesError as M, QueryError as Q, ReadOnlyError as R, SirannonError as S, TransactionError as T, WriteOverloadError as W, ConnectionPoolError as a, DatabaseNotFoundError as b, MigrationError as c };
+export { BackupError as B, CDCError as C, DatabaseAlreadyExistsError as D, ExtensionError as E, ForbiddenSqlError as F, HookDeniedError as H, MaxDatabasesError as M, QueryError as Q, ReadOnlyError as R, SirannonError as S, TransactionError as T, WriteOverloadError as W, ConnectionPoolError as a, DatabaseNotFoundError as b, MigrationError as c, RequestDeniedError as d };

package/dist/file-migrations/index.d.ts

@@ -1,6 +1,9 @@
-import { M as Migration } from '../types-D4p4UyDK.js';
-import '../types-D_hQW1hr.js';
+import { B as BaselineFileOption } from '../baseline-Br77Fnhb.js';
+import { M as Migration } from '../types-zhnRXrsb.js';
 
+interface LoadMigrationsOptions {
+    baseline?: BaselineFileOption;
+}
 interface ScannedMigration {
     version: number;
     name: string;
@@ -9,7 +12,6 @@ interface ScannedMigration {
 }
 declare function scanDirectory(dirPath: string): ScannedMigration[];
 declare function readUpMigrations(scanned: ScannedMigration[]): Migration[];
-declare function readDownMigrations(scanned: ScannedMigration[], versions: number[]): Migration[];
-declare function loadMigrations(dirPath: string): Migration[];
+declare function loadMigrations(dirPath: string, options?: LoadMigrationsOptions): Migration[];
 
-export { type ScannedMigration, loadMigrations, readDownMigrations, readUpMigrations, scanDirectory };
+export { type LoadMigrationsOptions, type ScannedMigration, loadMigrations, readUpMigrations, scanDirectory };

package/dist/file-migrations/index.mjs

@@ -1,8 +1,9 @@
-import { MigrationError } from '../chunk-YPYVQJ4C.mjs';
+import { parseMigrationFilename, LAZY_DOWN_SQL } from '../chunk-LNY2VVHE.mjs';
+import { applyBaselineOption } from '../chunk-67M7KAH6.mjs';
+import { MigrationError } from '../chunk-UC3SCMIN.mjs';
 import { statSync, readdirSync, readFileSync } from 'fs';
 import { resolve, join } from 'path';
 
-var MIGRATION_FILENAME_PATTERN = /^(\d+)_(\w+)\.(up|down)\.sql$/;
 function hasControlCharacters(s) {
   for (let i = 0; i < s.length; i++) {
     if (s.charCodeAt(i) <= 31) return true;
@@ -35,14 +36,9 @@ function scanDirectory(dirPath) {
   const grouped = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     if (!entry.isFile()) continue;
-    const match = MIGRATION_FILENAME_PATTERN.exec(entry.name);
-    if (!match) continue;
-    const version = parseInt(match[1], 10);
-    const name = match[2];
-    const direction = match[3];
-    if (!Number.isFinite(version) || version <= 0 || !Number.isSafeInteger(version)) {
-      throw new MigrationError(`Invalid migration version: ${match[1]}`, version, "MIGRATION_VALIDATION_ERROR");
-    }
+    const parsed = parseMigrationFilename(entry.name);
+    if (!parsed) continue;
+    const { version, name, direction } = parsed;
     const existing = grouped.get(version);
     if (existing && existing.name !== name) {
       throw new MigrationError(
@@ -94,35 +90,44 @@ function readUpMigrations(scanned) {
     };
   });
 }
-function readDownMigrations(scanned, versions) {
-  const versionSet = new Set(versions);
-  const filtered = scanned.filter((s) => versionSet.has(s.version));
-  return filtered.map((entry) => {
-    if (!entry.downPath) {
-      throw new MigrationError(
-        `Migration version ${entry.version} (${entry.name}) has no .down.sql file`,
-        entry.version,
-        "MIGRATION_NO_DOWN"
-      );
-    }
-    const downSql = readFileSync(entry.downPath, "utf-8").trim();
-    if (downSql.length === 0) {
-      throw new MigrationError(
-        `Down migration file is empty: ${entry.downPath}`,
-        entry.version,
-        "MIGRATION_VALIDATION_ERROR"
-      );
+function readDownSql(downPath, version) {
+  let contents;
+  try {
+    contents = readFileSync(downPath, "utf-8");
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
+      throw new MigrationError(`Down migration file no longer exists: ${downPath}`, version, "MIGRATION_NO_DOWN");
     }
-    return {
-      version: entry.version,
-      name: entry.name,
-      up: "",
-      down: downSql
-    };
+    throw new MigrationError(
+      `Failed to read down migration file ${downPath}: ${err instanceof Error ? err.message : String(err)}`,
+      version,
+      "MIGRATION_ROLLBACK_ERROR"
+    );
+  }
+  const downSql = contents.trim();
+  if (downSql.length === 0) {
+    throw new MigrationError(`Down migration file is empty: ${downPath}`, version, "MIGRATION_VALIDATION_ERROR");
+  }
+  return downSql;
+}
+function attachLazyDown(migration, downPath) {
+  Object.defineProperty(migration, LAZY_DOWN_SQL, {
+    value: () => readDownSql(downPath, migration.version),
+    enumerable: false,
+    configurable: false,
+    writable: false
   });
 }
-function loadMigrations(dirPath) {
-  return readUpMigrations(scanDirectory(dirPath));
+function loadMigrations(dirPath, options) {
+  const scanned = scanDirectory(dirPath);
+  const migrations = readUpMigrations(scanned);
+  for (let i = 0; i < migrations.length; i++) {
+    const downPath = scanned[i].downPath;
+    if (downPath !== null) {
+      attachLazyDown(migrations[i], downPath);
+    }
+  }
+  return applyBaselineOption(migrations, options?.baseline);
 }
 
-export { loadMigrations, readDownMigrations, readUpMigrations, scanDirectory };
+export { loadMigrations, readUpMigrations, scanDirectory };

package/dist/operation-registry-9DcvxcE5.d.ts

@@ -0,0 +1,45 @@
+import { P as Params } from './types-zhnRXrsb.js';
+
+interface OperationStatement {
+    sql: string;
+    params?: Params;
+}
+type OperationArguments = Record<string, unknown>;
+interface ReadOperation<Identity = unknown> {
+    args?: readonly string[];
+    fromIdentity?: Readonly<Record<string, keyof Identity & string>>;
+    /**
+     * The columns every row of this read carries. Code generation emits a typed
+     * row from it, and reads the columns from the statement only when the
+     * operation takes no arguments, because arguments choose the statement.
+     */
+    columns?: readonly string[];
+    statement(args: OperationArguments): OperationStatement;
+}
+interface WriteOperation<Identity = unknown> {
+    args?: readonly string[];
+    fromIdentity?: Readonly<Record<string, keyof Identity & string>>;
+    statements(args: OperationArguments): OperationStatement | readonly OperationStatement[];
+}
+interface DatabaseOperations<Identity = unknown> {
+    reads?: Readonly<Record<string, ReadOperation<Identity>>>;
+    writes?: Readonly<Record<string, WriteOperation<Identity>>>;
+}
+type OperationRegistry<Identity = unknown> = Readonly<Record<string, DatabaseOperations<Identity>>>;
+/**
+ * A named operation a remote caller invokes, carrying the argument and row
+ * types of the registered operation. Only `name` exists at runtime; `types`
+ * is never assigned and is present so both type parameters are inferable at
+ * the call site. Code generation emits one reference per registered operation.
+ */
+interface OperationRef<Args = OperationArguments, Row = Record<string, unknown>> {
+    readonly name: string;
+    readonly types?: {
+        args: Args;
+        row: Row;
+    };
+}
+declare function operationRef<Args = OperationArguments, Row = Record<string, unknown>>(name: string): OperationRef<Args, Row>;
+declare function operationName(operation: string | OperationRef<never, never>): string;
+
+export { type DatabaseOperations as D, type OperationRef as O, type ReadOperation as R, type WriteOperation as W, type OperationRegistry as a, type OperationArguments as b, type OperationStatement as c, operationRef as d, operationName as o };

package/dist/primary-wins-DPAm2AKG.d.ts

@@ -0,0 +1,61 @@
+import { C as ConflictResolver, a as ConflictContext, b as ConflictResolution } from './types-C_D8IhpO.js';
+
+type ColumnVersionGetter = (table: string, rowId: string) => Promise<Map<string, {
+    hlc: string;
+    nodeId: string;
+}>>;
+/**
+ * Per-column conflict resolver that merges non-overlapping field changes.
+ *
+ * Given a conflict between a local and remote write on the same row, this
+ * resolver computes the set of columns each side changed relative to the
+ * common ancestor (oldData). If the changed column sets don't overlap, both
+ * sides' changes are merged into a single row, avoiding unnecessary data
+ * loss. When columns do overlap, per-column HLC versions (retrieved via the
+ * injected `getColumnVersions` callback) determine which side's value wins
+ * for each contested column. If no column version metadata exists, the
+ * resolver falls back to whole-row LWW.
+ */
+declare class FieldMergeResolver implements ConflictResolver {
+    private readonly getColumnVersions;
+    private readonly lww;
+    constructor(getColumnVersions: ColumnVersionGetter);
+    resolve(ctx: ConflictContext): Promise<ConflictResolution>;
+}
+
+/**
+ * Last-Writer-Wins conflict resolver.
+ *
+ * A remote delete is accepted whatever the timestamps say, so a delete wins over
+ * a concurrent update and a deleted row is never resurrected.
+ *
+ * Otherwise compares the remote HLC against the local HLC. The higher timestamp wins.
+ * When both timestamps are equal (concurrent writes within the same
+ * millisecond and logical tick), the tie is broken deterministically by
+ * comparing node IDs lexicographically, so that every node reaches the same
+ * resolution without coordination. This is the default resolver and the
+ * fallback used by PrimaryWinsResolver and FieldMergeResolver when they
+ * cannot make a more specific decision.
+ */
+declare class LWWResolver implements ConflictResolver {
+    resolve(ctx: ConflictContext): ConflictResolution;
+}
+
+/**
+ * Conflict resolver that unconditionally favors the designated primary node.
+ *
+ * If the remote change originated from the primary, it is accepted. If the
+ * local change originated from the primary, the remote is rejected. When
+ * neither side is the primary (e.g., two replicas syncing through a relay),
+ * the decision falls back to LWW ordering. This resolver is designed for
+ * primary-replica topologies where the primary is the authoritative source of
+ * truth and replica-side writes should never override it.
+ */
+declare class PrimaryWinsResolver implements ConflictResolver {
+    private readonly primaryNodeId;
+    private readonly lww;
+    constructor(primaryNodeId: string);
+    resolve(ctx: ConflictContext): ConflictResolution;
+}
+
+export { FieldMergeResolver as F, LWWResolver as L, PrimaryWinsResolver as P };