lakesync 0.1.0

package/dist/client.js

@@ -0,0 +1,2048 @@
+import {
+  TAG_BROADCAST,
+  TAG_SYNC_PULL,
+  TAG_SYNC_PUSH,
+  decodeBroadcastFrame,
+  decodeSyncResponse,
+  encodeSyncPull,
+  encodeSyncPush
+} from "./chunk-BNJOGBYK.js";
+import {
+  Err,
+  HLC,
+  LWWResolver,
+  LakeSyncError,
+  Ok,
+  SchemaError,
+  assertValidIdentifier,
+  bigintReplacer,
+  bigintReviver,
+  extractDelta,
+  isActionError,
+  quoteIdentifier,
+  toError,
+  unwrapOrThrow
+} from "./chunk-ICNT7I3K.js";
+import "./chunk-7D4SUZUM.js";
+
+// ../client/src/db/idb-persistence.ts
+import { openDB } from "idb";
+var IDB_DB_NAME = "lakesync-snapshots";
+var IDB_DB_VERSION = 1;
+var STORE_NAME = "snapshots";
+var cachedDb = null;
+async function getDb() {
+  if (cachedDb) return cachedDb;
+  cachedDb = await openDB(IDB_DB_NAME, IDB_DB_VERSION, {
+    upgrade(db) {
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME);
+      }
+    }
+  });
+  return cachedDb;
+}
+async function loadSnapshot(dbName) {
+  const idb = await getDb();
+  const data = await idb.get(STORE_NAME, dbName);
+  if (data instanceof Uint8Array) return data;
+  return null;
+}
+async function saveSnapshot(dbName, data) {
+  const idb = await getDb();
+  await idb.put(STORE_NAME, data, dbName);
+}
+async function deleteSnapshot(dbName) {
+  const idb = await getDb();
+  await idb.delete(STORE_NAME, dbName);
+}
+
+// ../client/src/db/local-db.ts
+import initSqlJs from "sql.js";
+
+// ../client/src/db/types.ts
+var DbError = class extends LakeSyncError {
+  constructor(message, cause) {
+    super(message, "DB_ERROR", cause);
+  }
+};
+
+// ../client/src/db/local-db.ts
+function mapResultRows(results) {
+  if (results.length === 0 || !results[0]) {
+    return [];
+  }
+  const { columns, values } = results[0];
+  return values.map((row) => {
+    const obj = {};
+    for (let i = 0; i < columns.length; i++) {
+      const col = columns[i];
+      if (col !== void 0) {
+        obj[col] = row[i];
+      }
+    }
+    return obj;
+  });
+}
+function wrapDbError(label, fn) {
+  try {
+    return Ok(fn());
+  } catch (err) {
+    return Err(new DbError(label, toError(err)));
+  }
+}
+var LocalDB = class _LocalDB {
+  #db;
+  #config;
+  #backend;
+  constructor(db, config, backend) {
+    this.#db = db;
+    this.#config = config;
+    this.#backend = backend;
+  }
+  /** The database name from configuration */
+  get name() {
+    return this.#config.name;
+  }
+  /** The resolved storage backend for this instance */
+  get backend() {
+    return this.#backend;
+  }
+  /**
+   * Open a new LocalDB instance.
+   *
+   * Initialises the sql.js WASM engine and creates a database. When the
+   * backend is `"idb"`, any existing snapshot is loaded from IndexedDB.
+   * If no backend is specified, auto-detects based on `indexedDB` availability.
+   */
+  static async open(config) {
+    try {
+      const backend = resolveBackend(config.backend);
+      const SQL = await initSqlJs();
+      let data = null;
+      if (backend === "idb") {
+        data = await loadSnapshot(config.name);
+      }
+      const db = data ? new SQL.Database(data) : new SQL.Database();
+      return Ok(new _LocalDB(db, config, backend));
+    } catch (err) {
+      return Err(new DbError(`Failed to open database "${config.name}"`, toError(err)));
+    }
+  }
+  /**
+   * Execute a SQL statement (INSERT, UPDATE, DELETE, CREATE, etc.).
+   *
+   * Returns `Ok(void)` on success, or `Err(DbError)` on failure.
+   */
+  async exec(sql, params) {
+    return wrapDbError(`Failed to execute SQL: ${sql}`, () => {
+      this.#db.run(sql, params);
+    });
+  }
+  /**
+   * Query the database and return typed rows as an array of objects.
+   *
+   * Each row is mapped from sql.js column-array format into a keyed object.
+   */
+  async query(sql, params) {
+    return wrapDbError(`Failed to query SQL: ${sql}`, () => {
+      const results = this.#db.exec(sql, params);
+      return mapResultRows(results);
+    });
+  }
+  /**
+   * Execute a function within a database transaction.
+   *
+   * Begins a transaction, executes the callback with a `Transaction` object,
+   * commits on success, or rolls back if the callback throws.
+   */
+  async transaction(fn) {
+    const tx = this.#createTransaction();
+    const beginResult = wrapDbError("Failed to begin transaction", () => {
+      this.#db.run("BEGIN");
+    });
+    if (!beginResult.ok) return beginResult;
+    try {
+      const result = fn(tx);
+      this.#db.run("COMMIT");
+      return Ok(result);
+    } catch (err) {
+      try {
+        this.#db.run("ROLLBACK");
+      } catch (_rollbackErr) {
+      }
+      return Err(new DbError("Transaction failed", toError(err)));
+    }
+  }
+  /**
+   * Export the current database state and persist it to IndexedDB.
+   *
+   * No-op when the backend is `"memory"`.
+   */
+  async save() {
+    if (this.#backend !== "idb") {
+      return Ok(void 0);
+    }
+    try {
+      const data = this.#db.export();
+      await saveSnapshot(this.#config.name, data);
+      return Ok(void 0);
+    } catch (err) {
+      return Err(
+        new DbError(`Failed to save database "${this.#config.name}" to IndexedDB`, toError(err))
+      );
+    }
+  }
+  /**
+   * Close the database and release resources.
+   *
+   * When the backend is `"idb"`, the database snapshot is persisted
+   * to IndexedDB before closing.
+   */
+  async close() {
+    if (this.#backend === "idb") {
+      await this.save();
+    }
+    this.#db.close();
+  }
+  #createTransaction() {
+    const db = this.#db;
+    return {
+      exec(sql, params) {
+        return wrapDbError(`Transaction exec failed: ${sql}`, () => {
+          db.run(sql, params);
+        });
+      },
+      query(sql, params) {
+        return wrapDbError(`Transaction query failed: ${sql}`, () => {
+          const results = db.exec(sql, params);
+          return mapResultRows(results);
+        });
+      }
+    };
+  }
+};
+function resolveBackend(configured) {
+  if (configured === "memory") return "memory";
+  if (configured === "idb") return "idb";
+  if (typeof indexedDB !== "undefined") return "idb";
+  return "memory";
+}
+
+// ../client/src/db/schema-registry.ts
+var COLUMN_TYPE_MAP = {
+  string: "TEXT",
+  number: "REAL",
+  boolean: "INTEGER",
+  json: "TEXT",
+  null: "TEXT"
+};
+async function ensureMetaTable(db) {
+  return db.exec(`
+		CREATE TABLE IF NOT EXISTS _lakesync_meta (
+			table_name TEXT PRIMARY KEY,
+			schema_version INTEGER NOT NULL DEFAULT 1,
+			schema_json TEXT NOT NULL,
+			updated_at TEXT NOT NULL
+		)
+	`);
+}
+async function registerSchema(db, schema) {
+  const tableCheck = assertValidIdentifier(schema.table);
+  if (!tableCheck.ok) return tableCheck;
+  for (const col of schema.columns) {
+    const colCheck = assertValidIdentifier(col.name);
+    if (!colCheck.ok) return colCheck;
+  }
+  const metaResult = await ensureMetaTable(db);
+  if (!metaResult.ok) return metaResult;
+  return db.transaction((tx) => {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const schemaJson = JSON.stringify(schema);
+    unwrapOrThrow(
+      tx.exec(
+        `INSERT INTO _lakesync_meta (table_name, schema_version, schema_json, updated_at)
+				 VALUES (?, 1, ?, ?)
+				 ON CONFLICT(table_name) DO UPDATE SET
+				   schema_json = excluded.schema_json,
+				   updated_at = excluded.updated_at`,
+        [schema.table, schemaJson, now]
+      )
+    );
+    const quotedTable = quoteIdentifier(schema.table);
+    const columnDefs = schema.columns.map((col) => `${quoteIdentifier(col.name)} ${COLUMN_TYPE_MAP[col.type]}`).join(", ");
+    const createSql = columnDefs ? `CREATE TABLE IF NOT EXISTS ${quotedTable} (_rowId TEXT PRIMARY KEY, ${columnDefs})` : `CREATE TABLE IF NOT EXISTS ${quotedTable} (_rowId TEXT PRIMARY KEY)`;
+    unwrapOrThrow(tx.exec(createSql));
+  });
+}
+async function getSchema(db, table) {
+  const metaResult = await ensureMetaTable(db);
+  if (!metaResult.ok) return metaResult;
+  const queryResult = await db.query(
+    "SELECT schema_json FROM _lakesync_meta WHERE table_name = ?",
+    [table]
+  );
+  if (!queryResult.ok) return queryResult;
+  const firstRow = queryResult.value[0];
+  if (!firstRow) {
+    return Ok(null);
+  }
+  try {
+    const schema = JSON.parse(firstRow.schema_json);
+    return Ok(schema);
+  } catch (err) {
+    return Err(
+      new DbError(
+        `Failed to parse schema JSON for table "${table}"`,
+        err instanceof Error ? err : void 0
+      )
+    );
+  }
+}
+async function migrateSchema(db, oldSchema, newSchema) {
+  if (oldSchema.table !== newSchema.table) {
+    return Err(
+      new SchemaError(
+        `Table name mismatch: old schema references "${oldSchema.table}" but new schema references "${newSchema.table}"`
+      )
+    );
+  }
+  const tableName = newSchema.table;
+  const tableCheck = assertValidIdentifier(tableName);
+  if (!tableCheck.ok) return tableCheck;
+  for (const col of newSchema.columns) {
+    const colCheck = assertValidIdentifier(col.name);
+    if (!colCheck.ok) return colCheck;
+  }
+  const oldColumnMap = /* @__PURE__ */ new Map();
+  for (const col of oldSchema.columns) {
+    oldColumnMap.set(col.name, col.type);
+  }
+  const newColumnMap = /* @__PURE__ */ new Map();
+  for (const col of newSchema.columns) {
+    newColumnMap.set(col.name, col.type);
+  }
+  for (const col of oldSchema.columns) {
+    if (!newColumnMap.has(col.name)) {
+      return Err(
+        new SchemaError(
+          `Cannot remove column "${col.name}" from table "${tableName}". Only additive migrations are supported.`
+        )
+      );
+    }
+  }
+  for (const col of newSchema.columns) {
+    const oldType = oldColumnMap.get(col.name);
+    if (oldType !== void 0 && oldType !== col.type) {
+      return Err(
+        new SchemaError(
+          `Cannot change type of column "${col.name}" in table "${tableName}" from "${oldType}" to "${col.type}". Type changes are not supported.`
+        )
+      );
+    }
+  }
+  const addedColumns = newSchema.columns.filter((col) => !oldColumnMap.has(col.name));
+  const metaResult = await ensureMetaTable(db);
+  if (!metaResult.ok) return metaResult;
+  return db.transaction((tx) => {
+    const quotedTable = quoteIdentifier(tableName);
+    for (const col of addedColumns) {
+      unwrapOrThrow(
+        tx.exec(
+          `ALTER TABLE ${quotedTable} ADD COLUMN ${quoteIdentifier(col.name)} ${COLUMN_TYPE_MAP[col.type]}`
+        )
+      );
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const schemaJson = JSON.stringify(newSchema);
+    unwrapOrThrow(
+      tx.exec(
+        `UPDATE _lakesync_meta
+				 SET schema_json = ?,
+				     schema_version = schema_version + 1,
+				     updated_at = ?
+				 WHERE table_name = ?`,
+        [schemaJson, now, tableName]
+      )
+    );
+  });
+}
+
+// ../client/src/queue/idb-action-queue.ts
+import { openDB as openDB2 } from "idb";
+var DB_NAME = "lakesync-action-queue";
+var DB_VERSION = 1;
+var STORE_NAME2 = "entries";
+function serialiseAction(action) {
+  return { ...action, hlc: action.hlc.toString() };
+}
+function deserialiseAction(serialised) {
+  return { ...serialised, hlc: BigInt(serialised.hlc) };
+}
+function serialiseEntry(entry) {
+  return { ...entry, action: serialiseAction(entry.action) };
+}
+function deserialiseEntry(serialised) {
+  return { ...serialised, action: deserialiseAction(serialised.action) };
+}
+async function wrapIdbOp(operation, fn) {
+  try {
+    return Ok(await fn());
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return Err(new LakeSyncError(`Failed to ${operation}: ${message}`, "QUEUE_ERROR"));
+  }
+}
+var IDBActionQueue = class {
+  dbPromise;
+  counter = 0;
+  /**
+   * Create a new IDB-backed action queue.
+   *
+   * @param dbName - Optional database name. Defaults to `'lakesync-action-queue'`.
+   */
+  constructor(dbName = DB_NAME) {
+    this.dbPromise = openDB2(dbName, DB_VERSION, {
+      upgrade(db) {
+        const store = db.createObjectStore(STORE_NAME2, { keyPath: "id" });
+        store.createIndex("status", "status");
+        store.createIndex("createdAt", "createdAt");
+      }
+    });
+  }
+  /** Add an action to the queue. */
+  async push(action) {
+    return wrapIdbOp("push to action queue", async () => {
+      const db = await this.dbPromise;
+      const entry = {
+        id: `idb-action-${Date.now()}-${++this.counter}`,
+        action,
+        status: "pending",
+        createdAt: Date.now(),
+        retryCount: 0
+      };
+      await db.put(STORE_NAME2, serialiseEntry(entry));
+      return entry;
+    });
+  }
+  /** Peek at pending entries (ordered by createdAt). */
+  async peek(limit) {
+    return wrapIdbOp("peek action queue", async () => {
+      const db = await this.dbPromise;
+      const tx = db.transaction(STORE_NAME2, "readonly");
+      const index = tx.objectStore(STORE_NAME2).index("createdAt");
+      const results = [];
+      let cursor = await index.openCursor();
+      while (cursor && results.length < limit) {
+        const serialised = cursor.value;
+        if (serialised.status === "pending") {
+          const entry = deserialiseEntry(serialised);
+          if (entry.retryAfter === void 0 || entry.retryAfter <= Date.now()) {
+            results.push(entry);
+          }
+        }
+        cursor = await cursor.continue();
+      }
+      return results;
+    });
+  }
+  /** Mark entries as currently being sent. */
+  async markSending(ids) {
+    return wrapIdbOp("mark sending", async () => {
+      const db = await this.dbPromise;
+      const tx = db.transaction(STORE_NAME2, "readwrite");
+      const store = tx.objectStore(STORE_NAME2);
+      for (const id of ids) {
+        const serialised = await store.get(id);
+        if (serialised?.status === "pending") {
+          serialised.status = "sending";
+          await store.put(serialised);
+        }
+      }
+      await tx.done;
+    });
+  }
+  /** Acknowledge successful delivery (removes entries). */
+  async ack(ids) {
+    return wrapIdbOp("ack", async () => {
+      const db = await this.dbPromise;
+      const tx = db.transaction(STORE_NAME2, "readwrite");
+      for (const id of ids) {
+        await tx.objectStore(STORE_NAME2).delete(id);
+      }
+      await tx.done;
+    });
+  }
+  /** Negative acknowledge — reset to pending with incremented retryCount and exponential backoff. */
+  async nack(ids) {
+    return wrapIdbOp("nack", async () => {
+      const db = await this.dbPromise;
+      const tx = db.transaction(STORE_NAME2, "readwrite");
+      const store = tx.objectStore(STORE_NAME2);
+      for (const id of ids) {
+        const serialised = await store.get(id);
+        if (serialised) {
+          serialised.status = "pending";
+          serialised.retryCount++;
+          const backoffMs = Math.min(1e3 * 2 ** serialised.retryCount, 3e4);
+          serialised.retryAfter = Date.now() + backoffMs;
+          await store.put(serialised);
+        }
+      }
+      await tx.done;
+    });
+  }
+  /** Get the number of pending + sending entries. */
+  async depth() {
+    return wrapIdbOp("get depth", async () => {
+      const db = await this.dbPromise;
+      const all = await db.getAll(STORE_NAME2);
+      return all.filter((e) => e.status === "pending" || e.status === "sending").length;
+    });
+  }
+  /** Remove all entries. */
+  async clear() {
+    return wrapIdbOp("clear action queue", async () => {
+      const db = await this.dbPromise;
+      await db.clear(STORE_NAME2);
+    });
+  }
+};
+
+// ../client/src/queue/idb-queue.ts
+import { openDB as openDB3 } from "idb";
+var DB_NAME2 = "lakesync-queue";
+var DB_VERSION2 = 1;
+var STORE_NAME3 = "entries";
+function serialiseDelta(delta) {
+  return { ...delta, hlc: delta.hlc.toString() };
+}
+function deserialiseDelta(serialised) {
+  return { ...serialised, hlc: BigInt(serialised.hlc) };
+}
+function serialiseEntry2(entry) {
+  return { ...entry, delta: serialiseDelta(entry.delta) };
+}
+function deserialiseEntry2(serialised) {
+  return { ...serialised, delta: deserialiseDelta(serialised.delta) };
+}
+async function wrapIdbOp2(operation, fn) {
+  try {
+    return Ok(await fn());
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return Err(new LakeSyncError(`Failed to ${operation}: ${message}`, "QUEUE_ERROR"));
+  }
+}
+var IDBQueue = class {
+  dbPromise;
+  counter = 0;
+  /**
+   * Create a new IDB-backed sync queue.
+   *
+   * @param dbName - Optional database name. Defaults to `'lakesync-queue'`.
+   *                 Useful for tests or running multiple independent queues.
+   */
+  constructor(dbName = DB_NAME2) {
+    this.dbPromise = openDB3(dbName, DB_VERSION2, {
+      upgrade(db) {
+        const store = db.createObjectStore(STORE_NAME3, { keyPath: "id" });
+        store.createIndex("status", "status");
+        store.createIndex("createdAt", "createdAt");
+      }
+    });
+  }
+  /** Add a delta to the queue */
+  async push(delta) {
+    return wrapIdbOp2("push to queue", async () => {
+      const db = await this.dbPromise;
+      const entry = {
+        id: `idb-${Date.now()}-${++this.counter}`,
+        delta,
+        status: "pending",
+        createdAt: Date.now(),
+        retryCount: 0
+      };
+      await db.put(STORE_NAME3, serialiseEntry2(entry));
+      return entry;
+    });
+  }
+  /** Peek at pending entries (ordered by createdAt) */
+  async peek(limit) {
+    return wrapIdbOp2("peek queue", async () => {
+      const db = await this.dbPromise;
+      const tx = db.transaction(STORE_NAME3, "readonly");
+      const index = tx.objectStore(STORE_NAME3).index("createdAt");
+      const results = [];
+      let cursor = await index.openCursor();
+      while (cursor && results.length < limit) {
+        const serialised = cursor.value;
+        if (serialised.status === "pending") {
+          const entry = deserialiseEntry2(serialised);
+          if (entry.retryAfter === void 0 || entry.retryAfter <= Date.now()) {
+            results.push(entry);
+          }
+        }
+        cursor = await cursor.continue();
+      }
+      return results;
+    });
+  }
+  /** Mark entries as currently being sent */
+  async markSending(ids) {
+    return wrapIdbOp2("mark sending", async () => {
+      const db = await this.dbPromise;
+      const tx = db.transaction(STORE_NAME3, "readwrite");
+      const store = tx.objectStore(STORE_NAME3);
+      for (const id of ids) {
+        const serialised = await store.get(id);
+        if (serialised?.status === "pending") {
+          serialised.status = "sending";
+          await store.put(serialised);
+        }
+      }
+      await tx.done;
+    });
+  }
+  /** Acknowledge successful delivery (removes entries) */
+  async ack(ids) {
+    return wrapIdbOp2("ack", async () => {
+      const db = await this.dbPromise;
+      const tx = db.transaction(STORE_NAME3, "readwrite");
+      for (const id of ids) {
+        await tx.objectStore(STORE_NAME3).delete(id);
+      }
+      await tx.done;
+    });
+  }
+  /** Negative acknowledge — reset to pending with incremented retryCount and exponential backoff */
+  async nack(ids) {
+    return wrapIdbOp2("nack", async () => {
+      const db = await this.dbPromise;
+      const tx = db.transaction(STORE_NAME3, "readwrite");
+      const store = tx.objectStore(STORE_NAME3);
+      for (const id of ids) {
+        const serialised = await store.get(id);
+        if (serialised) {
+          serialised.status = "pending";
+          serialised.retryCount++;
+          const backoffMs = Math.min(1e3 * 2 ** serialised.retryCount, 3e4);
+          serialised.retryAfter = Date.now() + backoffMs;
+          await store.put(serialised);
+        }
+      }
+      await tx.done;
+    });
+  }
+  /** Get the number of pending + sending entries */
+  async depth() {
+    return wrapIdbOp2("get depth", async () => {
+      const db = await this.dbPromise;
+      const all = await db.getAll(STORE_NAME3);
+      return all.filter((e) => e.status !== "acked").length;
+    });
+  }
+  /** Remove all entries */
+  async clear() {
+    return wrapIdbOp2("clear queue", async () => {
+      const db = await this.dbPromise;
+      await db.clear(STORE_NAME3);
+    });
+  }
+};
+
+// ../client/src/queue/memory-action-queue.ts
+var MemoryActionQueue = class {
+  entries = /* @__PURE__ */ new Map();
+  counter = 0;
+  /** Add an action to the queue. */
+  async push(action) {
+    const entry = {
+      id: `mem-action-${++this.counter}`,
+      action,
+      status: "pending",
+      createdAt: Date.now(),
+      retryCount: 0
+    };
+    this.entries.set(entry.id, entry);
+    return Ok(entry);
+  }
+  /** Peek at pending entries (ordered by createdAt), skipping entries with future retryAfter. */
+  async peek(limit) {
+    const now = Date.now();
+    const pending = [...this.entries.values()].filter((e) => e.status === "pending" && (e.retryAfter === void 0 || e.retryAfter <= now)).sort((a, b) => a.createdAt - b.createdAt).slice(0, limit);
+    return Ok(pending);
+  }
+  /** Mark entries as currently being sent. */
+  async markSending(ids) {
+    for (const id of ids) {
+      const entry = this.entries.get(id);
+      if (entry?.status === "pending") {
+        entry.status = "sending";
+      }
+    }
+    return Ok(void 0);
+  }
+  /** Acknowledge successful delivery (removes entries). */
+  async ack(ids) {
+    for (const id of ids) {
+      this.entries.delete(id);
+    }
+    return Ok(void 0);
+  }
+  /** Negative acknowledge — reset to pending with incremented retryCount and exponential backoff. */
+  async nack(ids) {
+    for (const id of ids) {
+      const entry = this.entries.get(id);
+      if (entry) {
+        entry.status = "pending";
+        entry.retryCount++;
+        const backoffMs = Math.min(1e3 * 2 ** entry.retryCount, 3e4);
+        entry.retryAfter = Date.now() + backoffMs;
+      }
+    }
+    return Ok(void 0);
+  }
+  /** Get the number of pending + sending entries. */
+  async depth() {
+    const count = [...this.entries.values()].filter(
+      (e) => e.status === "pending" || e.status === "sending"
+    ).length;
+    return Ok(count);
+  }
+  /** Remove all entries. */
+  async clear() {
+    this.entries.clear();
+    return Ok(void 0);
+  }
+};
+
+// ../client/src/queue/memory-queue.ts
+var MemoryQueue = class {
+  entries = /* @__PURE__ */ new Map();
+  counter = 0;
+  /** Add a delta to the queue */
+  async push(delta) {
+    const entry = {
+      id: `mem-${++this.counter}`,
+      delta,
+      status: "pending",
+      createdAt: Date.now(),
+      retryCount: 0
+    };
+    this.entries.set(entry.id, entry);
+    return Ok(entry);
+  }
+  /** Peek at pending entries (ordered by createdAt), skipping entries with future retryAfter */
+  async peek(limit) {
+    const now = Date.now();
+    const pending = [...this.entries.values()].filter((e) => e.status === "pending" && (e.retryAfter === void 0 || e.retryAfter <= now)).sort((a, b) => a.createdAt - b.createdAt).slice(0, limit);
+    return Ok(pending);
+  }
+  /** Mark entries as currently being sent */
+  async markSending(ids) {
+    for (const id of ids) {
+      const entry = this.entries.get(id);
+      if (entry?.status === "pending") {
+        entry.status = "sending";
+      }
+    }
+    return Ok(void 0);
+  }
+  /** Acknowledge successful delivery (removes entries) */
+  async ack(ids) {
+    for (const id of ids) {
+      this.entries.delete(id);
+    }
+    return Ok(void 0);
+  }
+  /** Negative acknowledge — reset to pending with incremented retryCount and exponential backoff */
+  async nack(ids) {
+    for (const id of ids) {
+      const entry = this.entries.get(id);
+      if (entry) {
+        entry.status = "pending";
+        entry.retryCount++;
+        const backoffMs = Math.min(1e3 * 2 ** entry.retryCount, 3e4);
+        entry.retryAfter = Date.now() + backoffMs;
+      }
+    }
+    return Ok(void 0);
+  }
+  /** Get the number of pending + sending entries */
+  async depth() {
+    const count = [...this.entries.values()].filter((e) => e.status !== "acked").length;
+    return Ok(count);
+  }
+  /** Remove all entries */
+  async clear() {
+    this.entries.clear();
+    return Ok(void 0);
+  }
+};
+
+// ../client/src/sync/applier.ts
+async function applyRemoteDeltas(db, deltas, resolver, pendingQueue) {
+  if (deltas.length === 0) {
+    return Ok(0);
+  }
+  const cursorTableResult = await db.exec(`
+		CREATE TABLE IF NOT EXISTS _sync_cursor (
+			table_name TEXT PRIMARY KEY,
+			last_synced_hlc TEXT NOT NULL
+		)
+	`);
+  if (!cursorTableResult.ok) {
+    return Err(
+      new LakeSyncError(
+        "Failed to create _sync_cursor table",
+        "APPLY_ERROR",
+        cursorTableResult.error
+      )
+    );
+  }
+  const beginResult = await db.exec("BEGIN");
+  if (!beginResult.ok) {
+    return Err(
+      new LakeSyncError(
+        "Failed to begin transaction for remote delta application",
+        "APPLY_ERROR",
+        beginResult.error
+      )
+    );
+  }
+  const peekResult = await pendingQueue.peek(Number.MAX_SAFE_INTEGER);
+  if (!peekResult.ok) {
+    await db.exec("ROLLBACK");
+    return Err(
+      new LakeSyncError(
+        "Failed to peek pending queue for conflict detection",
+        "APPLY_ERROR",
+        peekResult.error
+      )
+    );
+  }
+  const pendingMap = /* @__PURE__ */ new Map();
+  for (const entry of peekResult.value) {
+    pendingMap.set(`${entry.delta.table}:${entry.delta.rowId}`, entry);
+  }
+  let appliedCount = 0;
+  const maxHlcPerTable = /* @__PURE__ */ new Map();
+  for (const remoteDelta of deltas) {
+    const result = await applyOneDelta(db, remoteDelta, resolver, pendingQueue, pendingMap);
+    if (!result.ok) {
+      await db.exec("ROLLBACK");
+      return result;
+    }
+    if (result.value) {
+      appliedCount++;
+    }
+    const currentMax = maxHlcPerTable.get(remoteDelta.table);
+    if (currentMax === void 0 || HLC.compare(remoteDelta.hlc, currentMax) > 0) {
+      maxHlcPerTable.set(remoteDelta.table, remoteDelta.hlc);
+    }
+  }
+  for (const [tableName, hlc] of maxHlcPerTable) {
+    const cursorResult = await db.exec(
+      "INSERT OR REPLACE INTO _sync_cursor (table_name, last_synced_hlc) VALUES (?, ?)",
+      [tableName, hlc.toString()]
+    );
+    if (!cursorResult.ok) {
+      await db.exec("ROLLBACK");
+      return Err(
+        new LakeSyncError(
+          `Failed to update sync cursor for table "${tableName}"`,
+          "APPLY_ERROR",
+          cursorResult.error
+        )
+      );
+    }
+  }
+  const commitResult = await db.exec("COMMIT");
+  if (!commitResult.ok) {
+    await db.exec("ROLLBACK");
+    return Err(
+      new LakeSyncError(
+        "Failed to commit transaction for remote delta application",
+        "APPLY_ERROR",
+        commitResult.error
+      )
+    );
+  }
+  return Ok(appliedCount);
+}
+async function applyOneDelta(db, remoteDelta, resolver, pendingQueue, pendingMap) {
+  const conflictingEntry = pendingMap.get(`${remoteDelta.table}:${remoteDelta.rowId}`);
+  if (conflictingEntry) {
+    const localDelta = conflictingEntry.delta;
+    const resolveResult = resolver.resolve(localDelta, remoteDelta);
+    if (!resolveResult.ok) {
+      return Err(
+        new LakeSyncError(
+          `Conflict resolution failed for row "${remoteDelta.rowId}" in table "${remoteDelta.table}"`,
+          "APPLY_ERROR",
+          resolveResult.error
+        )
+      );
+    }
+    const resolved = resolveResult.value;
+    const remoteWon = resolved.clientId === remoteDelta.clientId && resolved.hlc === remoteDelta.hlc;
+    if (remoteWon) {
+      const applyResult2 = await applySqlDelta(db, resolved);
+      if (!applyResult2.ok) {
+        return applyResult2;
+      }
+      const ackResult = await pendingQueue.ack([conflictingEntry.id]);
+      if (!ackResult.ok) {
+        return Err(
+          new LakeSyncError(
+            `Failed to ack local queue entry "${conflictingEntry.id}" after remote win`,
+            "APPLY_ERROR",
+            ackResult.error
+          )
+        );
+      }
+      return Ok(true);
+    }
+    return Ok(false);
+  }
+  const applyResult = await applySqlDelta(db, remoteDelta);
+  if (!applyResult.ok) {
+    return applyResult;
+  }
+  return Ok(true);
+}
+function validateDeltaIdentifiers(delta) {
+  const tableCheck = assertValidIdentifier(delta.table);
+  if (!tableCheck.ok) {
+    return Err(new LakeSyncError(tableCheck.error.message, "APPLY_ERROR"));
+  }
+  for (const col of delta.columns) {
+    const colCheck = assertValidIdentifier(col.column);
+    if (!colCheck.ok) {
+      return Err(new LakeSyncError(colCheck.error.message, "APPLY_ERROR"));
+    }
+  }
+  return Ok(void 0);
+}
+async function applySqlDelta(db, delta) {
+  const identifierCheck = validateDeltaIdentifiers(delta);
+  if (!identifierCheck.ok) return identifierCheck;
+  const quotedTable = quoteIdentifier(delta.table);
+  switch (delta.op) {
+    case "INSERT": {
+      const colNames = delta.columns.map((c) => quoteIdentifier(c.column));
+      const allColumns = ["_rowId", ...colNames];
+      const placeholders = allColumns.map(() => "?").join(", ");
+      const values = [delta.rowId, ...delta.columns.map((c) => c.value)];
+      const sql = `INSERT INTO ${quotedTable} (${allColumns.join(", ")}) VALUES (${placeholders})`;
+      const result = await db.exec(sql, values);
+      if (!result.ok) {
+        return Err(
+          new LakeSyncError(
+            `Failed to apply INSERT for row "${delta.rowId}" in table "${delta.table}"`,
+            "APPLY_ERROR",
+            result.error
+          )
+        );
+      }
+      return Ok(true);
+    }
+    case "UPDATE": {
+      if (delta.columns.length === 0) {
+        return Ok(true);
+      }
+      const setClauses = delta.columns.map((c) => `${quoteIdentifier(c.column)} = ?`).join(", ");
+      const values = [...delta.columns.map((c) => c.value), delta.rowId];
+      const sql = `UPDATE ${quotedTable} SET ${setClauses} WHERE _rowId = ?`;
+      const result = await db.exec(sql, values);
+      if (!result.ok) {
+        return Err(
+          new LakeSyncError(
+            `Failed to apply UPDATE for row "${delta.rowId}" in table "${delta.table}"`,
+            "APPLY_ERROR",
+            result.error
+          )
+        );
+      }
+      return Ok(true);
+    }
+    case "DELETE": {
+      const sql = `DELETE FROM ${quotedTable} WHERE _rowId = ?`;
+      const result = await db.exec(sql, [delta.rowId]);
+      if (!result.ok) {
+        return Err(
+          new LakeSyncError(
+            `Failed to apply DELETE for row "${delta.rowId}" in table "${delta.table}"`,
+            "APPLY_ERROR",
+            result.error
+          )
+        );
+      }
+      return Ok(true);
+    }
+  }
+}
+
+// ../client/src/sync/tracker.ts
+function rowWithoutId(row) {
+  const result = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (key !== "_rowId") {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+var SyncTracker = class {
+  constructor(db, queue, hlc, clientId) {
+    this.db = db;
+    this.queue = queue;
+    this.hlc = hlc;
+    this.clientId = clientId;
+  }
+  schemaCache = /* @__PURE__ */ new Map();
+  async getCachedSchema(table) {
+    if (this.schemaCache.has(table)) {
+      const cached = this.schemaCache.get(table);
+      return Ok(cached ?? void 0);
+    }
+    const result = await getSchema(this.db, table);
+    if (result.ok) {
+      this.schemaCache.set(table, result.value);
+      return Ok(result.value ?? void 0);
+    }
+    return result;
+  }
+  /**
+   * Insert a new row into the specified table.
+   *
+   * Writes the row to SQLite and pushes an INSERT delta to the queue.
+   *
+   * @param table - The target table name
+   * @param rowId - The unique row identifier
+   * @param data - Column name/value pairs for the new row
+   * @returns Ok on success, or Err with a LakeSyncError on failure
+   */
+  async insert(table, rowId, data) {
+    const tableCheck = assertValidIdentifier(table);
+    if (!tableCheck.ok) return tableCheck;
+    for (const col of Object.keys(data)) {
+      const colCheck = assertValidIdentifier(col);
+      if (!colCheck.ok) return colCheck;
+    }
+    const schemaResult = await this.getCachedSchema(table);
+    if (!schemaResult.ok) return schemaResult;
+    const schema = schemaResult.value;
+    const columns = Object.keys(data);
+    const allColumns = ["_rowId", ...columns.map((c) => quoteIdentifier(c))];
+    const placeholders = allColumns.map(() => "?").join(", ");
+    const columnList = allColumns.join(", ");
+    const values = [rowId, ...columns.map((col) => data[col])];
+    const sql = `INSERT INTO ${quoteIdentifier(table)} (${columnList}) VALUES (${placeholders})`;
+    const execResult = await this.db.exec(sql, values);
+    if (!execResult.ok) return execResult;
+    const hlc = this.hlc.now();
+    const delta = await extractDelta(null, data, {
+      table,
+      rowId,
+      clientId: this.clientId,
+      hlc,
+      schema
+    });
+    if (delta) {
+      const pushResult = await this.queue.push(delta);
+      if (!pushResult.ok) return pushResult;
+    }
+    return Ok(void 0);
+  }
+  /**
+   * Update an existing row in the specified table.
+   *
+   * Reads the current row state, applies partial updates, and pushes
+   * an UPDATE delta containing only the changed columns.
+   *
+   * @param table - The target table name
+   * @param rowId - The unique row identifier
+   * @param data - Column name/value pairs to update (partial)
+   * @returns Ok on success, Err if the row is not found or on failure
+   */
+  async update(table, rowId, data) {
+    const tableCheck = assertValidIdentifier(table);
+    if (!tableCheck.ok) return tableCheck;
+    for (const col of Object.keys(data)) {
+      const colCheck = assertValidIdentifier(col);
+      if (!colCheck.ok) return colCheck;
+    }
+    const schemaResult = await this.getCachedSchema(table);
+    if (!schemaResult.ok) return schemaResult;
+    const schema = schemaResult.value;
+    const queryResult = await this.db.query(
+      `SELECT * FROM ${quoteIdentifier(table)} WHERE _rowId = ?`,
+      [rowId]
+    );
+    if (!queryResult.ok) return queryResult;
+    const rows = queryResult.value;
+    if (rows.length === 0 || !rows[0]) {
+      return Err(
+        new LakeSyncError(`Row "${rowId}" not found in table "${table}"`, "ROW_NOT_FOUND")
+      );
+    }
+    const before = rowWithoutId(rows[0]);
+    const columns = Object.keys(data);
+    const setClauses = columns.map((col) => `${quoteIdentifier(col)} = ?`).join(", ");
+    const values = [...columns.map((col) => data[col]), rowId];
+    const sql = `UPDATE ${quoteIdentifier(table)} SET ${setClauses} WHERE _rowId = ?`;
+    const execResult = await this.db.exec(sql, values);
+    if (!execResult.ok) return execResult;
+    const after = { ...before, ...data };
+    const hlc = this.hlc.now();
+    const delta = await extractDelta(before, after, {
+      table,
+      rowId,
+      clientId: this.clientId,
+      hlc,
+      schema
+    });
+    if (delta) {
+      const pushResult = await this.queue.push(delta);
+      if (!pushResult.ok) return pushResult;
+    }
+    return Ok(void 0);
+  }
+  /**
+   * Delete a row from the specified table.
+   *
+   * Reads the current row state for delta extraction, removes the row
+   * from SQLite, and pushes a DELETE delta to the queue.
+   *
+   * @param table - The target table name
+   * @param rowId - The unique row identifier
+   * @returns Ok on success, Err if the row is not found or on failure
+   */
+  async delete(table, rowId) {
+    const tableCheck = assertValidIdentifier(table);
+    if (!tableCheck.ok) return tableCheck;
+    const schemaResult = await this.getCachedSchema(table);
+    if (!schemaResult.ok) return schemaResult;
+    const schema = schemaResult.value;
+    const queryResult = await this.db.query(
+      `SELECT * FROM ${quoteIdentifier(table)} WHERE _rowId = ?`,
+      [rowId]
+    );
+    if (!queryResult.ok) return queryResult;
+    const rows = queryResult.value;
+    if (rows.length === 0 || !rows[0]) {
+      return Err(
+        new LakeSyncError(`Row "${rowId}" not found in table "${table}"`, "ROW_NOT_FOUND")
+      );
+    }
+    const before = rowWithoutId(rows[0]);
+    const execResult = await this.db.exec(
+      `DELETE FROM ${quoteIdentifier(table)} WHERE _rowId = ?`,
+      [rowId]
+    );
+    if (!execResult.ok) return execResult;
+    const hlc = this.hlc.now();
+    const delta = await extractDelta(before, null, {
+      table,
+      rowId,
+      clientId: this.clientId,
+      hlc,
+      schema
+    });
+    if (delta) {
+      const pushResult = await this.queue.push(delta);
+      if (!pushResult.ok) return pushResult;
+    }
+    return Ok(void 0);
+  }
+  /**
+   * Query the local database.
+   *
+   * Pass-through to the underlying LocalDB query method.
+   *
+   * @param sql - The SQL query to execute
+   * @param params - Optional bind parameters
+   * @returns The query results as typed rows, or a DbError on failure
+   */
+  async query(sql, params) {
+    return this.db.query(sql, params);
+  }
+};
+
+// ../client/src/sync/coordinator.ts
+var AUTO_SYNC_INTERVAL_MS = 1e4;
+var REALTIME_HEARTBEAT_MS = 6e4;
+var SyncCoordinator = class {
+  tracker;
+  queue;
+  hlc;
+  transport;
+  db;
+  resolver = new LWWResolver();
+  _clientId;
+  maxRetries;
+  syncMode;
+  autoSyncIntervalMs;
+  realtimeHeartbeatMs;
+  lastSyncedHlc = HLC.encode(0, 0);
+  _lastSyncTime = null;
+  syncIntervalId = null;
+  visibilityHandler = null;
+  syncing = false;
+  actionQueue;
+  maxActionRetries;
+  listeners = {
+    onChange: [],
+    onSyncComplete: [],
+    onError: [],
+    onActionComplete: []
+  };
+  constructor(db, transport, config) {
+    this.db = db;
+    this.transport = transport;
+    this.hlc = config?.hlc ?? new HLC();
+    this.queue = config?.queue ?? new IDBQueue();
+    this._clientId = config?.clientId ?? `client-${crypto.randomUUID()}`;
+    this.maxRetries = config?.maxRetries ?? 10;
+    this.syncMode = config?.syncMode ?? "full";
+    this.autoSyncIntervalMs = config?.autoSyncIntervalMs ?? AUTO_SYNC_INTERVAL_MS;
+    this.realtimeHeartbeatMs = config?.realtimeHeartbeatMs ?? REALTIME_HEARTBEAT_MS;
+    this.actionQueue = config?.actionQueue ?? null;
+    this.maxActionRetries = config?.maxActionRetries ?? 5;
+    this.tracker = new SyncTracker(db, this.queue, this.hlc, this._clientId);
+    if (this.transport.onBroadcast) {
+      this.transport.onBroadcast((deltas, serverHlc) => {
+        void this.handleBroadcast(deltas, serverHlc);
+      });
+    }
+  }
+  /** Register an event listener */
+  on(event, listener) {
+    this.listeners[event].push(listener);
+  }
+  /** Remove an event listener */
+  off(event, listener) {
+    const arr = this.listeners[event];
+    const idx = arr.indexOf(listener);
+    if (idx !== -1) arr.splice(idx, 1);
+  }
+  emit(event, ...args) {
+    for (const fn of this.listeners[event]) {
+      try {
+        fn(...args);
+      } catch {
+      }
+    }
+  }
+  /** Push pending deltas to the gateway via the transport */
+  async pushToGateway() {
+    const peekResult = await this.queue.peek(100);
+    if (!peekResult.ok || peekResult.value.length === 0) return;
+    const deadLettered = peekResult.value.filter((e) => e.retryCount >= this.maxRetries);
+    const entries = peekResult.value.filter((e) => e.retryCount < this.maxRetries);
+    if (deadLettered.length > 0) {
+      console.warn(
+        `[SyncCoordinator] Dead-lettering ${deadLettered.length} entries after ${this.maxRetries} retries`
+      );
+      await this.queue.ack(deadLettered.map((e) => e.id));
+      this.emit(
+        "onError",
+        new Error(`Dead-lettered ${deadLettered.length} entries after ${this.maxRetries} retries`)
+      );
+    }
+    if (entries.length === 0) return;
+    const ids = entries.map((e) => e.id);
+    await this.queue.markSending(ids);
+    const pushResult = await this.transport.push({
+      clientId: this._clientId,
+      deltas: entries.map((e) => e.delta),
+      lastSeenHlc: this.hlc.now()
+    });
+    if (pushResult.ok) {
+      await this.queue.ack(ids);
+      this.lastSyncedHlc = pushResult.value.serverHlc;
+      this._lastSyncTime = /* @__PURE__ */ new Date();
+    } else {
+      await this.queue.nack(ids);
+    }
+  }
+  /**
+   * Pull deltas from a named adapter source.
+   *
+   * Convenience wrapper around {@link pullFromGateway} that passes the
+   * `source` field through to the gateway, triggering an adapter-sourced
+   * pull instead of a buffer pull.
+   */
+  async pullFrom(source) {
+    return this.pullFromGateway(source);
+  }
+  /** Pull remote deltas from the gateway and apply them */
+  async pullFromGateway(source) {
+    const pullResult = await this.transport.pull({
+      clientId: this._clientId,
+      sinceHlc: this.lastSyncedHlc,
+      maxDeltas: 1e3,
+      source
+    });
+    if (!pullResult.ok || pullResult.value.deltas.length === 0) return 0;
+    const { deltas, serverHlc } = pullResult.value;
+    const applyResult = await applyRemoteDeltas(this.db, deltas, this.resolver, this.queue);
+    if (applyResult.ok) {
+      this.lastSyncedHlc = serverHlc;
+      this._lastSyncTime = /* @__PURE__ */ new Date();
+      if (applyResult.value > 0) {
+        this.emit("onChange", applyResult.value);
+      }
+      return applyResult.value;
+    }
+    return 0;
+  }
+  /**
+   * Handle a server-initiated broadcast of deltas.
+   *
+   * Applies the deltas using the same conflict resolution and idempotency
+   * logic as a regular pull. Advances `lastSyncedHlc` and emits `onChange`.
+   */
+  async handleBroadcast(deltas, serverHlc) {
+    if (deltas.length === 0) return;
+    try {
+      const applyResult = await applyRemoteDeltas(this.db, deltas, this.resolver, this.queue);
+      if (applyResult.ok) {
+        if (HLC.compare(serverHlc, this.lastSyncedHlc) > 0) {
+          this.lastSyncedHlc = serverHlc;
+        }
+        this._lastSyncTime = /* @__PURE__ */ new Date();
+        if (applyResult.value > 0) {
+          this.emit("onChange", applyResult.value);
+        }
+      }
+    } catch (err) {
+      this.emit("onError", err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  /** Get the queue depth */
+  async queueDepth() {
+    const result = await this.queue.depth();
+    return result.ok ? result.value : 0;
+  }
+  /** Get the client identifier */
+  get clientId() {
+    return this._clientId;
+  }
+  /** Get the last successful sync time, or null if never synced */
+  get lastSyncTime() {
+    return this._lastSyncTime;
+  }
+  /**
+   * Start auto-sync: periodic interval + visibility change handler.
+   * Synchronises (push + pull) on tab focus and every 10 seconds.
+   */
+  startAutoSync() {
+    this.transport.connect?.();
+    const intervalMs = this.transport.supportsRealtime ? this.realtimeHeartbeatMs : this.autoSyncIntervalMs;
+    this.syncIntervalId = setInterval(() => {
+      void this.syncOnce();
+    }, intervalMs);
+    this.setupVisibilitySync();
+  }
+  /** Register a visibility change listener to sync on tab focus. */
+  setupVisibilitySync() {
+    this.visibilityHandler = () => {
+      if (typeof document !== "undefined" && document.visibilityState === "visible") {
+        void this.syncOnce();
+      }
+    };
+    if (typeof document !== "undefined") {
+      document.addEventListener("visibilitychange", this.visibilityHandler);
+    }
+  }
+  /**
+   * Perform initial sync via checkpoint download.
+   *
+   * Called on first sync when `lastSyncedHlc` is zero. Downloads the
+   * server's checkpoint (which is pre-filtered by JWT claims server-side),
+   * applies the deltas locally, and advances the sync cursor to the
+   * snapshot's HLC. If no checkpoint is available or the transport does
+   * not support checkpoints, falls back to incremental pull.
+   */
+  async initialSync() {
+    if (!this.transport.checkpoint) return;
+    const result = await this.transport.checkpoint();
+    if (!result.ok || result.value === null) return;
+    const { deltas, snapshotHlc } = result.value;
+    if (deltas.length > 0) {
+      await applyRemoteDeltas(this.db, deltas, this.resolver, this.queue);
+    }
+    this.lastSyncedHlc = snapshotHlc;
+    this._lastSyncTime = /* @__PURE__ */ new Date();
+  }
+  /** Perform a single sync cycle (push + pull + actions, depending on syncMode). */
+  async syncOnce() {
+    if (this.syncing) return;
+    this.syncing = true;
+    try {
+      if (this.syncMode !== "pushOnly") {
+        if (this.lastSyncedHlc === HLC.encode(0, 0)) {
+          await this.initialSync();
+        }
+        await this.pullFromGateway();
+      }
+      if (this.syncMode !== "pullOnly") {
+        await this.pushToGateway();
+      }
+      await this.processActionQueue();
+      this.emit("onSyncComplete");
+    } catch (err) {
+      this.emit("onError", err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      this.syncing = false;
+    }
+  }
+  /**
+   * Submit an action for execution.
+   *
+   * Pushes the action to the ActionQueue and triggers immediate processing.
+   * The action will be sent to the gateway on the next sync cycle or
+   * immediately if not currently syncing.
+   *
+   * @param params - Partial action (connector, actionType, params). ActionId and HLC are generated.
+   */
+  async executeAction(params) {
+    if (!this.actionQueue) {
+      this.emit("onError", new Error("No action queue configured"));
+      return;
+    }
+    const hlc = this.hlc.now();
+    const { generateActionId } = await import("./src-WYBF5LOI.js");
+    const actionId = await generateActionId({
+      clientId: this._clientId,
+      hlc,
+      connector: params.connector,
+      actionType: params.actionType,
+      params: params.params
+    });
+    const action = {
+      actionId,
+      clientId: this._clientId,
+      hlc,
+      connector: params.connector,
+      actionType: params.actionType,
+      params: params.params,
+      idempotencyKey: params.idempotencyKey
+    };
+    await this.actionQueue.push(action);
+    void this.processActionQueue();
+  }
+  /**
+   * Process pending actions from the action queue.
+   *
+   * Peeks at pending entries, sends them to the gateway via
+   * `transport.executeAction()`, and acks/nacks based on the result.
+   * Dead-letters entries after `maxActionRetries` failures.
+   * Triggers an immediate `syncOnce()` on success to pull fresh state.
+   */
+  async processActionQueue() {
+    if (!this.actionQueue || !this.transport.executeAction) return;
+    const peekResult = await this.actionQueue.peek(100);
+    if (!peekResult.ok || peekResult.value.length === 0) return;
+    const deadLettered = peekResult.value.filter((e) => e.retryCount >= this.maxActionRetries);
+    const entries = peekResult.value.filter((e) => e.retryCount < this.maxActionRetries);
+    if (deadLettered.length > 0) {
+      console.warn(
+        `[SyncCoordinator] Dead-lettering ${deadLettered.length} actions after ${this.maxActionRetries} retries`
+      );
+      await this.actionQueue.ack(deadLettered.map((e) => e.id));
+      for (const entry of deadLettered) {
+        this.emit("onActionComplete", entry.action.actionId, {
+          actionId: entry.action.actionId,
+          code: "DEAD_LETTERED",
+          message: `Action dead-lettered after ${this.maxActionRetries} retries`,
+          retryable: false
+        });
+      }
+    }
+    if (entries.length === 0) return;
+    const ids = entries.map((e) => e.id);
+    await this.actionQueue.markSending(ids);
+    const transportResult = await this.transport.executeAction({
+      clientId: this._clientId,
+      actions: entries.map((e) => e.action)
+    });
+    if (transportResult.ok) {
+      await this.actionQueue.ack(ids);
+      for (const result of transportResult.value.results) {
+        this.emit("onActionComplete", result.actionId, result);
+      }
+      const retryableIds = [];
+      const ackableIds = [];
+      for (let i = 0; i < transportResult.value.results.length; i++) {
+        const result = transportResult.value.results[i];
+        if (isActionError(result) && result.retryable) {
+          retryableIds.push(ids[i]);
+        } else {
+          ackableIds.push(ids[i]);
+        }
+      }
+    } else {
+      await this.actionQueue.nack(ids);
+    }
+  }
+  /**
+   * Discover available connectors and their supported action types.
+   *
+   * Delegates to the transport's `describeActions()` method. Returns
+   * empty connectors when the transport does not support discovery.
+   */
+  async describeActions() {
+    if (!this.transport.describeActions) {
+      return { ok: true, value: { connectors: {} } };
+    }
+    return this.transport.describeActions();
+  }
+  /** Stop auto-sync and clean up listeners */
+  stopAutoSync() {
+    if (this.syncIntervalId !== null) {
+      clearInterval(this.syncIntervalId);
+      this.syncIntervalId = null;
+    }
+    if (this.visibilityHandler) {
+      if (typeof document !== "undefined") {
+        document.removeEventListener("visibilitychange", this.visibilityHandler);
+      }
+      this.visibilityHandler = null;
+    }
+    this.transport.disconnect?.();
+  }
+};
+
+// ../client/src/sync/schema-sync.ts
+var SchemaSynchroniser = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Compare local schema version with server and apply migrations if behind.
+   *
+   * If the local version is already equal to or ahead of the server version,
+   * this is a no-op. Otherwise, the local schema is migrated to match the
+   * server schema via `migrateSchema()`, which runs ALTER TABLE ... ADD COLUMN
+   * for each new column.
+   *
+   * @param table - The table name to synchronise
+   * @param serverSchema - The server's current TableSchema
+   * @param serverVersion - The server's schema version number
+   * @returns Ok on success, or Err with a LakeSyncError on failure
+   */
+  async synchronise(table, serverSchema, serverVersion) {
+    const localSchemaResult = await getSchema(this.db, table);
+    if (!localSchemaResult.ok) return localSchemaResult;
+    const localSchema = localSchemaResult.value;
+    if (!localSchema) {
+      return Err(
+        new SchemaError(
+          `Cannot synchronise schema for table "${table}": no local schema registered`
+        )
+      );
+    }
+    const localVersionResult = await this.getLocalVersion(table);
+    if (!localVersionResult.ok) return localVersionResult;
+    const localVersion = localVersionResult.value;
+    if (localVersion >= serverVersion) {
+      return Ok(void 0);
+    }
+    const migrateResult = await migrateSchema(this.db, localSchema, serverSchema);
+    if (!migrateResult.ok) return migrateResult;
+    const updateResult = await this.setLocalVersion(table, serverVersion);
+    if (!updateResult.ok) return updateResult;
+    return Ok(void 0);
+  }
+  /**
+   * Retrieve the local schema version for a given table from `_lakesync_meta`.
+   *
+   * @param table - The table name to look up
+   * @returns The schema version number, or 0 if the table is not registered
+   */
+  async getLocalVersion(table) {
+    const result = await this.db.query(
+      "SELECT schema_version FROM _lakesync_meta WHERE table_name = ?",
+      [table]
+    );
+    if (!result.ok) return result;
+    const rows = result.value;
+    if (rows.length === 0 || !rows[0]) {
+      return Ok(0);
+    }
+    return Ok(rows[0].schema_version);
+  }
+  /**
+   * Set the local schema version for a given table in `_lakesync_meta`.
+   *
+   * @param table - The table name to update
+   * @param version - The version number to set
+   * @returns Ok on success, or Err with a DbError on failure
+   */
+  async setLocalVersion(table, version) {
+    return this.db.exec("UPDATE _lakesync_meta SET schema_version = ? WHERE table_name = ?", [
+      version,
+      table
+    ]);
+  }
+};
+
+// ../client/src/sync/transport-http.ts
+var HttpTransport = class {
+  baseUrl;
+  gatewayId;
+  token;
+  _fetch;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.gatewayId = config.gatewayId;
+    this.token = config.token;
+    this._fetch = config.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  /**
+   * Push local deltas to the remote gateway.
+   *
+   * Sends a POST request with the push payload as BigInt-safe JSON.
+   */
+  async push(msg) {
+    const url = `${this.baseUrl}/sync/${this.gatewayId}/push`;
+    try {
+      const response = await this._fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.token}`
+        },
+        body: JSON.stringify(msg, bigintReplacer)
+      });
+      if (!response.ok) {
+        const text = await response.text().catch(() => "Unknown error");
+        return Err(new LakeSyncError(`Push failed (${response.status}): ${text}`, "TRANSPORT_ERROR"));
+      }
+      const raw = await response.text();
+      const data = JSON.parse(raw, bigintReviver);
+      return Ok(data);
+    } catch (error) {
+      const cause = toError(error);
+      return Err(new LakeSyncError(`Push request failed: ${cause.message}`, "TRANSPORT_ERROR", cause));
+    }
+  }
+  /**
+   * Pull remote deltas from the gateway.
+   *
+   * Sends a GET request with query parameters for the pull cursor.
+   */
+  async pull(msg) {
+    const params = new URLSearchParams({
+      since: msg.sinceHlc.toString(),
+      clientId: msg.clientId,
+      limit: msg.maxDeltas.toString()
+    });
+    if (msg.source) {
+      params.set("source", msg.source);
+    }
+    const url = `${this.baseUrl}/sync/${this.gatewayId}/pull?${params}`;
+    try {
+      const response = await this._fetch(url, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${this.token}`
+        }
+      });
+      if (!response.ok) {
+        const text = await response.text().catch(() => "Unknown error");
+        return Err(new LakeSyncError(`Pull failed (${response.status}): ${text}`, "TRANSPORT_ERROR"));
+      }
+      const raw = await response.text();
+      const data = JSON.parse(raw, bigintReviver);
+      return Ok(data);
+    } catch (error) {
+      const cause = toError(error);
+      return Err(new LakeSyncError(`Pull request failed: ${cause.message}`, "TRANSPORT_ERROR", cause));
+    }
+  }
+  /**
+   * Execute imperative actions against external systems via the gateway.
+   *
+   * Sends a POST request with the action payload as BigInt-safe JSON.
+   */
+  async executeAction(msg) {
+    const url = `${this.baseUrl}/sync/${this.gatewayId}/action`;
+    try {
+      const response = await this._fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.token}`
+        },
+        body: JSON.stringify(msg, bigintReplacer)
+      });
+      if (!response.ok) {
+        const text = await response.text().catch(() => "Unknown error");
+        return Err(new LakeSyncError(`Action failed (${response.status}): ${text}`, "TRANSPORT_ERROR"));
+      }
+      const raw = await response.text();
+      const data = JSON.parse(raw, bigintReviver);
+      return Ok(data);
+    } catch (error) {
+      const cause = toError(error);
+      return Err(new LakeSyncError(`Action request failed: ${cause.message}`, "TRANSPORT_ERROR", cause));
+    }
+  }
+  /**
+   * Discover available connectors and their supported action types.
+   *
+   * Sends a GET request to the actions discovery endpoint.
+   */
+  async describeActions() {
+    const url = `${this.baseUrl}/sync/${this.gatewayId}/actions`;
+    try {
+      const response = await this._fetch(url, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${this.token}`
+        }
+      });
+      if (!response.ok) {
+        const text = await response.text().catch(() => "Unknown error");
+        return Err(
+          new LakeSyncError(`Describe actions failed (${response.status}): ${text}`, "TRANSPORT_ERROR")
+        );
+      }
+      const data = await response.json();
+      return Ok(data);
+    } catch (error) {
+      const cause = toError(error);
+      return Err(
+        new LakeSyncError(`Describe actions request failed: ${cause.message}`, "TRANSPORT_ERROR", cause)
+      );
+    }
+  }
+  /**
+   * Download checkpoint for initial sync.
+   *
+   * Requests the streaming checkpoint format via Accept header and reads
+   * length-prefixed proto frames from the response body.
+   */
+  async checkpoint() {
+    const url = `${this.baseUrl}/sync/${this.gatewayId}/checkpoint`;
+    try {
+      const response = await this._fetch(url, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          Accept: "application/x-lakesync-checkpoint-stream"
+        }
+      });
+      if (response.status === 404) {
+        return Ok(null);
+      }
+      if (!response.ok) {
+        const text = await response.text().catch(() => "Unknown error");
+        return Err(
+          new LakeSyncError(`Checkpoint failed (${response.status}): ${text}`, "TRANSPORT_ERROR")
+        );
+      }
+      const deltas = await readStreamingCheckpointDeltas(response);
+      const hlcHeader = response.headers.get("X-Checkpoint-Hlc");
+      const snapshotHlc = hlcHeader ? BigInt(hlcHeader) : 0n;
+      return Ok({ deltas, snapshotHlc });
+    } catch (error) {
+      const cause = toError(error);
+      return Err(
+        new LakeSyncError(`Checkpoint request failed: ${cause.message}`, "TRANSPORT_ERROR", cause)
+      );
+    }
+  }
+};
+async function readStreamingCheckpointDeltas(response) {
+  const reader = response.body.getReader();
+  const allDeltas = [];
+  let buffer = new Uint8Array(0);
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    const newBuffer = new Uint8Array(buffer.length + value.length);
+    newBuffer.set(buffer);
+    newBuffer.set(value, buffer.length);
+    buffer = newBuffer;
+    while (buffer.length >= 4) {
+      const frameLength = new DataView(buffer.buffer, buffer.byteOffset).getUint32(0, false);
+      if (buffer.length < 4 + frameLength) break;
+      const frameData = buffer.slice(4, 4 + frameLength);
+      buffer = buffer.slice(4 + frameLength);
+      const decoded = decodeSyncResponse(frameData);
+      if (decoded.ok) {
+        allDeltas.push(...decoded.value.deltas);
+      }
+    }
+  }
+  return allDeltas;
+}
+
+// ../client/src/sync/transport-local.ts
+var LocalTransport = class {
+  constructor(gateway) {
+    this.gateway = gateway;
+  }
+  /** Push local deltas to the in-process gateway */
+  async push(msg) {
+    return this.gateway.handlePush(msg);
+  }
+  /** Pull remote deltas from the in-process gateway */
+  async pull(msg) {
+    const result = this.gateway.handlePull(msg);
+    return result instanceof Promise ? result : result;
+  }
+  /** Local transport has no checkpoint — returns null */
+  async checkpoint() {
+    return Ok(null);
+  }
+  /** Execute actions against the in-process gateway. */
+  async executeAction(msg) {
+    if (!this.gateway.handleAction) {
+      return Err(new LakeSyncError("Local gateway does not support actions", "TRANSPORT_ERROR"));
+    }
+    const result = await this.gateway.handleAction(msg);
+    if (!result.ok) {
+      return Err(new LakeSyncError(result.error.message, result.error.code));
+    }
+    return Ok(result.value);
+  }
+  /** Discover available connectors and their supported action types. */
+  async describeActions() {
+    if (!this.gateway.describeActions) {
+      return Ok({ connectors: {} });
+    }
+    return Ok(this.gateway.describeActions());
+  }
+};
+
+// ../client/src/sync/transport-ws.ts
+var DEFAULT_RECONNECT_BASE_MS = 1e3;
+var DEFAULT_RECONNECT_MAX_MS = 3e4;
+var WebSocketTransport = class {
+  config;
+  reconnectBaseMs;
+  reconnectMaxMs;
+  httpTransport;
+  ws = null;
+  reconnectTimer = null;
+  reconnectAttempts = 0;
+  _connected = false;
+  intentionalClose = false;
+  /** Pending request/response promise (push or pull). */
+  pending = null;
+  /** Broadcast callback registered by the SyncCoordinator. */
+  broadcastCallback = null;
+  constructor(config) {
+    this.config = config;
+    this.reconnectBaseMs = config.reconnectBaseMs ?? DEFAULT_RECONNECT_BASE_MS;
+    this.reconnectMaxMs = config.reconnectMaxMs ?? DEFAULT_RECONNECT_MAX_MS;
+    this.httpTransport = config.httpConfig ? new HttpTransport(config.httpConfig) : null;
+    if (config.onBroadcast) {
+      this.broadcastCallback = config.onBroadcast;
+    }
+  }
+  /** Whether the WebSocket is currently connected. */
+  get connected() {
+    return this._connected;
+  }
+  /** Whether this transport supports real-time server push. */
+  get supportsRealtime() {
+    return true;
+  }
+  /** Register callback for server-initiated broadcasts. */
+  onBroadcast(callback) {
+    this.broadcastCallback = callback;
+  }
+  /** Open the WebSocket connection. */
+  connect() {
+    if (this.ws) return;
+    this.intentionalClose = false;
+    this.openWebSocket();
+  }
+  /** Close the WebSocket connection and stop reconnecting. */
+  disconnect() {
+    this.intentionalClose = true;
+    if (this.reconnectTimer !== null) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close(1e3, "Client disconnect");
+      this.ws = null;
+    }
+    this._connected = false;
+    this.reconnectAttempts = 0;
+    if (this.pending) {
+      this.pending.resolve(Err(new LakeSyncError("WebSocket disconnected", "TRANSPORT_ERROR")));
+      this.pending = null;
+    }
+  }
+  /**
+   * Push local deltas to the gateway via WebSocket.
+   */
+  async push(msg) {
+    const encoded = encodeSyncPush({
+      clientId: msg.clientId,
+      deltas: msg.deltas,
+      lastSeenHlc: msg.lastSeenHlc
+    });
+    if (!encoded.ok) {
+      return Err(new LakeSyncError(`Failed to encode push: ${encoded.error.message}`, "TRANSPORT_ERROR"));
+    }
+    const frame = new Uint8Array(1 + encoded.value.length);
+    frame[0] = TAG_SYNC_PUSH;
+    frame.set(encoded.value, 1);
+    const response = await this.sendAndAwaitResponse(frame);
+    if (!response.ok) return response;
+    return Ok({
+      serverHlc: response.value.serverHlc,
+      accepted: response.value.deltas.length === 0 ? msg.deltas.length : response.value.deltas.length
+    });
+  }
+  /**
+   * Pull remote deltas from the gateway via WebSocket.
+   */
+  async pull(msg) {
+    const encoded = encodeSyncPull({
+      clientId: msg.clientId,
+      sinceHlc: msg.sinceHlc,
+      maxDeltas: msg.maxDeltas
+    });
+    if (!encoded.ok) {
+      return Err(new LakeSyncError(`Failed to encode pull: ${encoded.error.message}`, "TRANSPORT_ERROR"));
+    }
+    const frame = new Uint8Array(1 + encoded.value.length);
+    frame[0] = TAG_SYNC_PULL;
+    frame.set(encoded.value, 1);
+    return this.sendAndAwaitResponse(frame);
+  }
+  /**
+   * Download checkpoint via HTTP (large binary payloads are better over HTTP).
+   */
+  async checkpoint() {
+    if (!this.httpTransport) {
+      return Ok(null);
+    }
+    return this.httpTransport.checkpoint();
+  }
+  // -----------------------------------------------------------------------
+  // Internal
+  // -----------------------------------------------------------------------
+  openWebSocket() {
+    const url = `${this.config.url}?token=${encodeURIComponent(this.config.token)}`;
+    this.ws = new WebSocket(url);
+    this.ws.binaryType = "arraybuffer";
+    this.ws.onopen = () => {
+      this._connected = true;
+      this.reconnectAttempts = 0;
+    };
+    this.ws.onmessage = (event) => {
+      if (!(event.data instanceof ArrayBuffer)) return;
+      const bytes = new Uint8Array(event.data);
+      if (bytes.length < 2) return;
+      const tag = bytes[0];
+      if (tag === TAG_BROADCAST) {
+        const decoded = decodeBroadcastFrame(bytes);
+        if (decoded.ok && this.broadcastCallback) {
+          this.broadcastCallback(decoded.value.deltas, decoded.value.serverHlc);
+        }
+      } else {
+        const decoded = decodeSyncResponse(bytes);
+        if (this.pending) {
+          if (decoded.ok) {
+            this.pending.resolve(Ok(decoded.value));
+          } else {
+            this.pending.resolve(
+              Err(
+                new LakeSyncError(
+                  `Failed to decode response: ${decoded.error.message}`,
+                  "TRANSPORT_ERROR"
+                )
+              )
+            );
+          }
+          this.pending = null;
+        }
+      }
+    };
+    this.ws.onclose = () => {
+      this._connected = false;
+      this.ws = null;
+      if (this.pending) {
+        this.pending.resolve(
+          Err(new LakeSyncError("WebSocket closed before response", "TRANSPORT_ERROR"))
+        );
+        this.pending = null;
+      }
+      if (!this.intentionalClose) {
+        this.scheduleReconnect();
+      }
+    };
+    this.ws.onerror = () => {
+    };
+  }
+  scheduleReconnect() {
+    const delay = Math.min(this.reconnectBaseMs * 2 ** this.reconnectAttempts, this.reconnectMaxMs);
+    this.reconnectAttempts++;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.openWebSocket();
+    }, delay);
+  }
+  sendAndAwaitResponse(frame) {
+    return new Promise((resolve) => {
+      if (!this.ws || !this._connected) {
+        resolve(Err(new LakeSyncError("WebSocket not connected", "TRANSPORT_ERROR")));
+        return;
+      }
+      if (this.pending) {
+        this.pending.resolve(
+          Err(new LakeSyncError("New request superseded pending request", "TRANSPORT_ERROR"))
+        );
+      }
+      this.pending = {
+        resolve,
+        reject: (reason) => {
+          resolve(Err(new LakeSyncError(reason.message, "TRANSPORT_ERROR")));
+        }
+      };
+      try {
+        this.ws.send(frame);
+      } catch (error) {
+        const cause = toError(error);
+        this.pending = null;
+        resolve(Err(new LakeSyncError(`WebSocket send failed: ${cause.message}`, "TRANSPORT_ERROR")));
+      }
+    });
+  }
+};
+export {
+  DbError,
+  HttpTransport,
+  IDBActionQueue,
+  IDBQueue,
+  LocalDB,
+  LocalTransport,
+  MemoryActionQueue,
+  MemoryQueue,
+  SchemaSynchroniser,
+  SyncCoordinator,
+  SyncTracker,
+  WebSocketTransport,
+  applyRemoteDeltas,
+  deleteSnapshot,
+  getSchema,
+  loadSnapshot,
+  migrateSchema,
+  registerSchema,
+  saveSnapshot,
+  unwrapOrThrow
+};
+//# sourceMappingURL=client.js.map