@delali/sirannon-db 0.1.7 → 0.2.0

package/dist/backup-scheduler/index.d.ts

@@ -1,4 +1,4 @@
-import { e as SQLiteConnection, f as BackupScheduleOptions } from '../types-D_hQW1hr.js';
+import { e as SQLiteConnection, f as BackupScheduleOptions } from '../types-zhnRXrsb.js';
 
 declare class BackupManager {
     backup(conn: SQLiteConnection, destPath: string): Promise<void>;

package/dist/backup-scheduler/index.mjs

@@ -1,2 +1,2 @@
-export { BackupScheduler } from '../chunk-VLTICJOD.mjs';
-import '../chunk-YPYVQJ4C.mjs';
+export { BackupScheduler } from '../chunk-PIKHN33N.mjs';
+import '../chunk-UC3SCMIN.mjs';

package/dist/baseline-Br77Fnhb.d.ts

@@ -0,0 +1,6 @@
+interface BaselineFileOption {
+    version: number;
+    through: number;
+}
+
+export type { BaselineFileOption as B };

package/dist/{change-tracker-CbmaMO-N.d.ts → change-tracker-DKRVUC3l.d.ts}

@@ -1,10 +1,9 @@
-import { e as SQLiteConnection, C as ChangeEvent } from './types-D_hQW1hr.js';
+import { e as SQLiteConnection, h as ChangeEvent } from './types-zhnRXrsb.js';
 
 interface ChangeTrackerOptions {
     retention?: number;
     changesTable?: string;
     pollBatchSize?: number;
-    replication?: boolean;
 }
 
 declare class ChangeTracker {
@@ -13,11 +12,12 @@ declare class ChangeTracker {
     private readonly retentionMs;
     private readonly changesTable;
     private readonly pollBatchSize;
-    private readonly replication;
     private changesTableReady;
+    private changesTableEnsured;
     private watchedTablesCache;
     private readonly stmtCache;
     private pruneBoundary;
+    private lastPollAtTxBoundary;
     constructor(options?: ChangeTrackerOptions);
     watch(conn: SQLiteConnection, table: string): Promise<void>;
     unwatch(conn: SQLiteConnection, table: string): Promise<void>;
@@ -69,6 +69,7 @@ declare class ChangeTracker {
      */
     pruneDroppedTables(conn: SQLiteConnection, tables: readonly string[]): Promise<void>;
     poll(conn: SQLiteConnection): Promise<ChangeEvent[]>;
+    get pollEndedAtTxBoundary(): boolean;
     /** The highest seq already polled; live subscribers receive events beyond it. */
     get cursor(): bigint;
     /**
@@ -77,9 +78,9 @@ declare class ChangeTracker {
      * resuming subscriber without disturbing the shared poll cursor.
      */
     readSince(conn: SQLiteConnection, table: string, afterSeq: bigint, upToSeq: bigint, limit: number): Promise<ChangeEvent[]>;
+    readSinceTables(conn: SQLiteConnection, tables: readonly string[], afterSeq: bigint, upToSeq: bigint, limit: number): Promise<ChangeEvent[]>;
     /** The lowest retained seq, or `null` when the change log is empty. */
     getMinSeq(conn: SQLiteConnection): Promise<bigint | null>;
-    private rowToEvent;
     advanceToLatest(conn: SQLiteConnection): Promise<void>;
     cleanup(conn: SQLiteConnection): Promise<number>;
     setPruneBoundary(seq: bigint): void;
@@ -89,10 +90,6 @@ declare class ChangeTracker {
     private assertIdentifier;
     private detectChangesTable;
     private ensureChangesTable;
-    private getColumns;
-    private getPkColumns;
-    private dropTriggers;
-    private getStmt;
     private installTriggers;
 }
 

package/dist/{chunk-DJLX6CAE.mjs → chunk-4ISB7XMA.mjs}

@@ -1,4 +1,5 @@
 // src/core/worker/protocol.ts
+var WORKER_CANCELLED_CODE = "WRITER_WORKER_CANCELLED";
 function serializeError(err) {
   if (err instanceof Error) {
     const code = err.code;
@@ -17,4 +18,4 @@ function deserializeError(error) {
   return err;
 }
 
-export { deserializeError, serializeError };
+export { WORKER_CANCELLED_CODE, deserializeError, serializeError };

package/dist/chunk-5NOIGN5Y.mjs

@@ -0,0 +1,18 @@
+import { SirannonError } from './chunk-UC3SCMIN.mjs';
+
+// src/core/sync/errors.ts
+var ReplicationError = class extends SirannonError {
+  constructor(message, code = "REPLICATION_ERROR", details) {
+    super(message, code);
+    this.details = details;
+    this.name = "ReplicationError";
+  }
+};
+var BatchValidationError = class extends ReplicationError {
+  constructor(message) {
+    super(message, "BATCH_VALIDATION_ERROR");
+    this.name = "BatchValidationError";
+  }
+};
+
+export { BatchValidationError, ReplicationError };

package/dist/chunk-67M7KAH6.mjs

@@ -0,0 +1,90 @@
+import { MigrationError } from './chunk-UC3SCMIN.mjs';
+
+// src/core/migrations/baseline.ts
+var SQLITE_USER_VERSION_MAX = 2147483647;
+function resolveEffectiveBaseline(sorted) {
+  const baselines = [];
+  for (const migration of sorted) {
+    const baseline = migration.baseline;
+    if (baseline === void 0) continue;
+    if (!Number.isSafeInteger(baseline.through) || baseline.through < 1) {
+      throw new MigrationError(
+        `Baseline migration ${migration.version}_${migration.name} has an invalid through version: ${baseline.through}`,
+        migration.version,
+        "MIGRATION_VALIDATION_ERROR"
+      );
+    }
+    if (baseline.through >= migration.version) {
+      throw new MigrationError(
+        `Baseline migration ${migration.version}_${migration.name} must use a version above the history it supersedes (through ${baseline.through})`,
+        migration.version,
+        "MIGRATION_VALIDATION_ERROR"
+      );
+    }
+    baselines.push(migration);
+  }
+  if (baselines.length === 0) return void 0;
+  for (const baseline of baselines) {
+    const through = baseline.baseline;
+    if (through === void 0) continue;
+    for (const migration of sorted) {
+      if (migration === baseline) continue;
+      if (migration.version > through.through && migration.version < baseline.version) {
+        throw new MigrationError(
+          `Migration ${migration.version}_${migration.name} falls inside baseline ${baseline.version}_${baseline.name}'s superseded range (above ${through.through}, below ${baseline.version})`,
+          migration.version,
+          "MIGRATION_VALIDATION_ERROR"
+        );
+      }
+    }
+  }
+  return baselines[baselines.length - 1];
+}
+function applyBaselineOption(migrations, baseline) {
+  if (baseline === void 0) return migrations;
+  const target = migrations.find((m) => m.version === baseline.version);
+  if (target === void 0) {
+    throw new MigrationError(
+      `Baseline version ${baseline.version} does not match any migration in the set`,
+      baseline.version,
+      "MIGRATION_VALIDATION_ERROR"
+    );
+  }
+  target.baseline = { through: baseline.through };
+  return migrations;
+}
+function planPendingMigrations(sorted, effectiveBaseline, appliedVersions) {
+  const baseline = effectiveBaseline?.baseline;
+  if (effectiveBaseline === void 0 || baseline === void 0) {
+    return sorted.filter((m) => !appliedVersions.has(m.version));
+  }
+  const through = baseline.through;
+  if (appliedVersions.size === 0) {
+    return [effectiveBaseline, ...sorted.filter((m) => m.baseline === void 0 && m.version > through)];
+  }
+  if (appliedVersions.has(effectiveBaseline.version)) {
+    return sorted.filter((m) => m.baseline === void 0 && m.version > through && !appliedVersions.has(m.version));
+  }
+  let highestApplied = 0;
+  for (const version of appliedVersions) {
+    if (version > highestApplied) highestApplied = version;
+  }
+  const pendingBelow = highestApplied >= through ? [] : sorted.filter((m) => m.baseline === void 0 && m.version <= through && !appliedVersions.has(m.version));
+  let highestReachable = highestApplied;
+  for (const migration of pendingBelow) {
+    if (migration.version > highestReachable) highestReachable = migration.version;
+  }
+  if (highestReachable < through) {
+    throw new MigrationError(
+      `Database history reaches version ${highestReachable} but baseline ${effectiveBaseline.version}_${effectiveBaseline.name} supersedes history through version ${through}; the migrations bridging the gap are missing from the input`,
+      effectiveBaseline.version,
+      "MIGRATION_BASELINE_GAP"
+    );
+  }
+  const pendingAbove = sorted.filter(
+    (m) => m.baseline === void 0 && m.version > through && !appliedVersions.has(m.version)
+  );
+  return [...pendingBelow, ...pendingAbove];
+}
+
+export { SQLITE_USER_VERSION_MAX, applyBaselineOption, planPendingMigrations, resolveEffectiveBaseline };

package/dist/{chunk-GEZUUIKV.mjs → chunk-D7LAYTKN.mjs}

@@ -1,4 +1,4 @@
-import { ForbiddenSqlError } from './chunk-YPYVQJ4C.mjs';
+import { ForbiddenSqlError } from './chunk-UC3SCMIN.mjs';
 
 // src/core/internal-tables.ts
 var INTERNAL_TABLE_PREFIX = "_sirannon_";
@@ -9,7 +9,10 @@ var PEER_STATE_TABLE = "_sirannon_peer_state";
 var APPLIED_CHANGES_TABLE = "_sirannon_applied_changes";
 var COLUMN_VERSIONS_TABLE = "_sirannon_column_versions";
 var SYNC_STATE_TABLE = "_sirannon_sync_state";
+var DEVICE_CURSORS_TABLE = "_sirannon_device_cursors";
+var STAGED_CHANGES_TABLE = "_sirannon_staged_changes";
 var CDC_TRIGGER_PREFIX = "_sirannon_trg_";
+var LIVE_PROBE_TABLE_PREFIX = "_sirannon_live_probe_";
 var SIRANNON_PREFIX = "_sirannon";
 var SQLITE_PREFIX = "sqlite_";
 var SIRANNON_MESSAGE = "Access to internal tables is not permitted: identifiers beginning with '_sirannon' are reserved";
@@ -265,4 +268,4 @@ function decodeHexBytes(hex) {
   return bytes;
 }
 
-export { APPLIED_CHANGES_TABLE, CDC_TRIGGER_PREFIX, CHANGES_TABLE, COLUMN_VERSIONS_TABLE, INTERNAL_TABLE_PREFIX, META_TABLE, MIGRATIONS_TABLE, PEER_STATE_TABLE, SAFE_INT_BOUND_TEXT, SYNC_STATE_TABLE, assertSqlAllowed, decodeTaggedValues, encodeTaggedValues, encodeWireRowsInPlace, isReservedIdentifier };
+export { APPLIED_CHANGES_TABLE, CDC_TRIGGER_PREFIX, CHANGES_TABLE, COLUMN_VERSIONS_TABLE, DEVICE_CURSORS_TABLE, INTERNAL_TABLE_PREFIX, LIVE_PROBE_TABLE_PREFIX, META_TABLE, MIGRATIONS_TABLE, PEER_STATE_TABLE, SAFE_INT_BOUND_TEXT, STAGED_CHANGES_TABLE, SYNC_STATE_TABLE, assertSqlAllowed, decodeTaggedValues, encodeTaggedValues, encodeWireRowsInPlace, isReservedIdentifier };

package/dist/{chunk-4IGMIJQK.mjs → chunk-EBJXPQQO.mjs}

@@ -1,6 +1,6 @@
-import { deserializeError } from './chunk-DJLX6CAE.mjs';
-import { BackupManager, BackupScheduler } from './chunk-VLTICJOD.mjs';
-import { SirannonError } from './chunk-YPYVQJ4C.mjs';
+import { BackupManager, BackupScheduler } from './chunk-PIKHN33N.mjs';
+import { WORKER_CANCELLED_CODE, deserializeError } from './chunk-4ISB7XMA.mjs';
+import { SirannonError } from './chunk-UC3SCMIN.mjs';
 import { Worker } from 'worker_threads';
 import { existsSync } from 'fs';
 import { resolve, dirname, join, sep } from 'path';
@@ -142,24 +142,65 @@ var WriterWorker = class _WriterWorker {
     const entry = this.pending.get(res.id);
     if (!entry) return;
     this.pending.delete(res.id);
-    if (entry.timer) clearTimeout(entry.timer);
-    if (res.ok) entry.resolve(res.value);
-    else entry.reject(deserializeError(res.error));
+    clearPendingTimers(entry);
+    if (res.ok) {
+      entry.resolve(res.value);
+      return;
+    }
+    if (res.error.code === WORKER_CANCELLED_CODE) {
+      entry.reject(
+        new SirannonError(
+          `The writer worker could not take this operation within ${this.timeoutMs}ms; it was not applied and is safe to retry`,
+          "WRITE_OVERLOADED"
+        )
+      );
+      return;
+    }
+    entry.reject(deserializeError(res.error));
   }
   rejectPending(id, err) {
     const entry = this.pending.get(id);
     if (!entry) return;
     this.pending.delete(id);
-    if (entry.timer) clearTimeout(entry.timer);
+    clearPendingTimers(entry);
     entry.reject(err);
   }
+  unresponsiveError(waitedMs) {
+    return new SirannonError(
+      `Writer worker did not respond within ${waitedMs}ms; the operation's outcome is unknown`,
+      "WRITER_WORKER_TIMEOUT"
+    );
+  }
+  // On the deadline the host cancels the operation, which drops work the
+  // worker has not started, then allows one further timeout as a grace window.
+  // An operation still running when that window closes is rejected as
+  // indeterminate, because the write may or may not have reached the disk.
+  onDeadline(id) {
+    const entry = this.pending.get(id);
+    if (!entry) return;
+    const worker = this.worker;
+    if (!entry.cancellable || !worker) {
+      this.rejectPending(id, this.unresponsiveError(this.timeoutMs));
+      return;
+    }
+    try {
+      worker.postMessage({ kind: "cancel", id });
+    } catch {
+      this.rejectPending(id, this.unresponsiveError(this.timeoutMs));
+      return;
+    }
+    entry.graceTimer = setTimeout(() => {
+      this.rejectPending(id, this.unresponsiveError(this.timeoutMs * 2));
+    }, this.timeoutMs);
+    entry.graceTimer.unref?.();
+  }
   fault(errLike) {
     if (this.closed || this.fatal) return;
     const err = errLike instanceof Error ? errLike : new SirannonError(String(errLike), "WRITER_WORKER_ERROR");
     const dead = this.worker;
     this.worker = null;
     for (const entry of this.pending.values()) {
-      if (entry.timer) clearTimeout(entry.timer);
+      clearPendingTimers(entry);
       entry.reject(err);
     }
     this.pending.clear();
@@ -197,18 +238,11 @@ var WriterWorker = class _WriterWorker {
     return new Promise((resolve2, reject) => {
       let timer = null;
       if (this.timeoutMs > 0) {
-        timer = setTimeout(() => {
-          this.rejectPending(
-            id,
-            new SirannonError(
-              `Writer worker did not respond within ${this.timeoutMs}ms; the operation's outcome is unknown`,
-              "WRITER_WORKER_TIMEOUT"
-            )
-          );
-        }, this.timeoutMs);
+        timer = setTimeout(() => this.onDeadline(id), this.timeoutMs);
         timer.unref?.();
       }
-      this.pending.set(id, { resolve: resolve2, reject, timer });
+      const cancellable = request.kind !== "open" && request.kind !== "close";
+      this.pending.set(id, { resolve: resolve2, reject, timer, graceTimer: null, cancellable });
       try {
         worker.postMessage(message);
       } catch (err) {
@@ -247,7 +281,8 @@ var WriterWorker = class _WriterWorker {
         units: units.map((unit) => ({
           statements: unit.statements.map((statement) => ({
             sql: statement.sql,
-            params: statement.params ? [...statement.params] : []
+            params: statement.params ? [...statement.params] : [],
+            ...statement.trusted === true ? { trusted: true } : {}
           }))
         }))
       }),
@@ -289,12 +324,16 @@ var WriterWorker = class _WriterWorker {
     }
     this.worker = null;
     for (const entry of this.pending.values()) {
-      if (entry.timer) clearTimeout(entry.timer);
+      clearPendingTimers(entry);
       entry.reject(new SirannonError("Writer worker is closed", "WRITER_WORKER_CLOSED"));
     }
     this.pending.clear();
   }
 };
+function clearPendingTimers(entry) {
+  if (entry.timer) clearTimeout(entry.timer);
+  if (entry.graceTimer) clearTimeout(entry.graceTimer);
+}
 function nodeWriterContext() {
   const held = new AsyncLocalStorage();
   return {

package/dist/{chunk-BNUTBHHH.mjs → chunk-FHWTZFI4.mjs}

@@ -1,4 +1,4 @@
-import { SirannonError } from './chunk-YPYVQJ4C.mjs';
+import { SirannonError } from './chunk-UC3SCMIN.mjs';
 
 // src/core/driver/define.ts
 function defineDriver(config) {

package/dist/chunk-GVCNMPOS.mjs

@@ -0,0 +1,130 @@
+// src/core/sync/sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+function rotr(x, n) {
+  return x >>> n | x << 32 - n;
+}
+function sha256Hex(input) {
+  const data = new TextEncoder().encode(input);
+  const bitLength = data.length * 8;
+  const paddedLength = (data.length + 8 >> 6) + 1 << 6;
+  const padded = new Uint8Array(paddedLength);
+  padded.set(data);
+  padded[data.length] = 128;
+  const view = new DataView(padded.buffer);
+  view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296), false);
+  view.setUint32(paddedLength - 4, bitLength >>> 0, false);
+  const state = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  const w = new Uint32Array(64);
+  for (let offset = 0; offset < paddedLength; offset += 64) {
+    for (let i = 0; i < 16; i++) {
+      w[i] = view.getUint32(offset + i * 4, false);
+    }
+    for (let i = 16; i < 64; i++) {
+      const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ w[i - 15] >>> 3;
+      const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ w[i - 2] >>> 10;
+      w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, h] = state;
+    for (let i = 0; i < 64; i++) {
+      const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = h + s1 + ch + K[i] + w[i] >>> 0;
+      const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = s0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    state[0] = state[0] + a >>> 0;
+    state[1] = state[1] + b >>> 0;
+    state[2] = state[2] + c >>> 0;
+    state[3] = state[3] + d >>> 0;
+    state[4] = state[4] + e >>> 0;
+    state[5] = state[5] + f >>> 0;
+    state[6] = state[6] + g >>> 0;
+    state[7] = state[7] + h >>> 0;
+  }
+  return Array.from(state, (word) => word.toString(16).padStart(8, "0")).join("");
+}
+
+export { sha256Hex };