@delali/sirannon-db 0.1.7 → 0.2.0

package/dist/client/index.mjs

@@ -1,1490 +1,1340 @@
-// src/client/subscription.ts
-var RemoteSubscriptionBuilderImpl = class {
-  constructor(table, transport) {
-    this.table = table;
-    this.transport = transport;
-  }
-  conditions = {};
-  filter(conditions) {
-    this.conditions = { ...this.conditions, ...conditions };
-    return this;
-  }
-  subscribe(callback, options) {
-    const filter = Object.keys(this.conditions).length > 0 ? this.conditions : void 0;
-    return this.transport.subscribe(this.table, filter, callback, options);
-  }
-};
+import { DatabaseClient, createEndpointTransport, toBaseUrl, DEFAULT_HTTP_REQUEST_TIMEOUT_MS, postJson, decodeTaggedValues, RemoteError, encodeTaggedValues, toWsUrl, STAGED_STREAM_CAPABILITY, verifyDeviceSyncCapabilities, unrefTimer, WebSocketTransport } from '../chunk-H237TXZW.mjs';
+export { HttpTransport, RemoteDatabase, RemoteError, RemoteLiveQuery, RemoteSubscriptionBuilderImpl, SQL_REFUSED_MESSAGE, ServerCapabilities, WebSocketTransport } from '../chunk-H237TXZW.mjs';
+
+// src/core/sync/canonicalise.ts
+function canonicaliseForChecksum(value) {
+  return canonicaliseValue(value);
+}
+function canonicaliseValue(v) {
+  if (v === null || v === void 0) return "null";
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (typeof v === "string") return JSON.stringify(v);
+  if (typeof v === "bigint") return `{"__sint":"${v.toString()}"}`;
+  if (typeof v === "number") {
+    if (Number.isInteger(v)) return `{"__sint":"${v.toString()}"}`;
+    if (Number.isFinite(v)) return JSON.stringify(v);
+    return "null";
+  }
+  if (typeof v === "object") {
+    if (v instanceof Uint8Array) {
+      const buf = Buffer.isBuffer(v) ? v : Buffer.from(v);
+      return `{"__blob":"${buf.toString("base64")}"}`;
+    }
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(v)) {
+      return `{"__blob":"${v.toString("base64")}"}`;
+    }
+    if (Array.isArray(v)) {
+      return `[${v.map(canonicaliseValue).join(",")}]`;
+    }
+    const obj = v;
+    const parts = [];
+    for (const key of Object.keys(obj).sort()) {
+      const val = obj[key];
+      if (val === void 0) continue;
+      parts.push(`${JSON.stringify(key)}:${canonicaliseValue(val)}`);
+    }
+    return `{${parts.join(",")}}`;
+  }
+  return "null";
+}
 
-// src/client/types.ts
-var RemoteError = class extends Error {
-  code;
-  constructor(code, message) {
+// src/core/errors.ts
+var SirannonError = class extends Error {
+  constructor(message, code) {
     super(message);
-    this.name = "RemoteError";
     this.code = code;
+    this.name = "SirannonError";
   }
 };
-
-// src/client/database-proxy.ts
-var DEFAULT_LOAD_BATCH_SIZE = 1e3;
-function isAsyncIterable(value) {
-  return typeof value[Symbol.asyncIterator] === "function";
-}
-var RemoteDatabase = class {
-  constructor(id, transport, onDispose) {
-    this.id = id;
-    this.transport = transport;
-    this.onDispose = onDispose;
-  }
-  /**
-   * Execute a SELECT and return all matching rows.
-   *
-   * ```ts
-   * const users = await db.query<{ id: number; name: string }>(
-   *   'SELECT * FROM users WHERE age > ?',
-   *   [21],
-   * )
-   * ```
-   */
-  async query(sql, params, options) {
-    const response = await this.transport.query(sql, params, options?.readConcern);
-    return response.rows;
-  }
-  /**
-   * Execute a mutation (INSERT, UPDATE, DELETE) and return
-   * the number of affected rows and last insert row ID.
-   */
-  async execute(sql, params) {
-    return this.transport.execute(sql, params);
-  }
-  /**
-   * Execute multiple statements as a single atomic transaction.
-   * Returns an array of results, one per statement.
-   *
-   * The whole list travels in one request and commits or rolls back as a
-   * unit, so the client is never in the loop between statements.
-   */
-  async transaction(statements) {
-    const response = await this.transport.transaction(statements);
-    return response.results;
+var MigrationError = class extends SirannonError {
+  constructor(message, version, code = "MIGRATION_ERROR") {
+    super(message, code);
+    this.version = version;
+    this.name = "MigrationError";
   }
-  /**
-   * Run the same statement once per parameter set as a single atomic
-   * transaction that commits with one fsync. Returns one result per
-   * parameter set, in order. Use this for a burst of same-shape writes
-   * (an import, a bulk insert) that must all commit or all roll back.
-   */
-  async batch(sql, paramsBatch, writeConcern) {
-    const response = await this.transport.batch(sql, paramsBatch, writeConcern);
-    return response.results;
+};
+
+// 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";
   }
-  /**
-   * Load a whole dataset through the same statement, batching it into requests
-   * for you and paying the one fsyncing WAL checkpoint once, after the final
-   * batch. The configured durability is restored after every batch, so an
-   * import that stops partway never leaves the writer at the relaxed level.
-   * Prefer this over {@link load} for anything larger than a single request:
-   * it runs the finalize itself, so there is no checkpoint flag to forget.
-   *
-   * Accepts a synchronous or asynchronous iterable of parameter sets, so rows
-   * can stream from a file or the network without being held in memory at
-   * once. Returns the total rows loaded and changes applied.
-   *
-   * ```ts
-   * const summary = await db.loadAll(
-   *   'INSERT INTO events (id, payload) VALUES (?, ?)',
-   *   rowStream,
-   *   { batchSize: 5000, durability: 'off' },
-   * )
-   * ```
-   */
-  async loadAll(sql, rows, options) {
-    const batchSize = options?.batchSize ?? DEFAULT_LOAD_BATCH_SIZE;
-    if (!Number.isInteger(batchSize) || batchSize <= 0) {
-      throw new RemoteError("INVALID_ARGUMENT", "loadAll batchSize must be a positive integer");
-    }
-    const durability = options?.durability;
-    const total = { rowsLoaded: 0, changes: 0 };
-    const send = async (paramsBatch, checkpoint) => {
-      const summary = await this.transport.load(sql, paramsBatch, durability, checkpoint);
-      total.rowsLoaded += summary.rowsLoaded;
-      total.changes += summary.changes;
-    };
-    let batch = [];
-    let previous = null;
-    const rotate = async () => {
-      if (previous !== null) await send(previous, false);
-      previous = batch;
-      batch = [];
-    };
-    if (isAsyncIterable(rows)) {
-      for await (const row of rows) {
-        batch.push(row);
-        if (batch.length >= batchSize) await rotate();
-      }
+};
+
+// src/core/sync/hlc.ts
+var MAX_LOGICAL = 65535;
+var HLC = class _HLC {
+  wallMs;
+  logical;
+  nodeId;
+  constructor(nodeId) {
+    this.nodeId = nodeId;
+    this.wallMs = 0;
+    this.logical = 0;
+  }
+  /** Generate a new HLC timestamp, advancing the clock. */
+  now() {
+    const physicalMs = Date.now();
+    if (physicalMs > this.wallMs) {
+      this.wallMs = physicalMs;
+      this.logical = 0;
     } else {
-      for (const row of rows) {
-        batch.push(row);
-        if (batch.length >= batchSize) await rotate();
+      this.logical += 1;
+      if (this.logical > MAX_LOGICAL) {
+        throw new ReplicationError("HLC logical counter overflow");
       }
     }
-    if (batch.length > 0) {
-      if (previous !== null) await send(previous, false);
-      await send(batch, true);
-    } else if (previous !== null) {
-      await send(previous, true);
-    }
-    return total;
-  }
-  /**
-   * Load one batch of rows through the same statement with writer durability
-   * relaxed for the duration, then restored before this resolves. This is the
-   * low-level primitive; prefer {@link loadAll} for a dataset that spans more
-   * than one request, since it runs the finalize itself rather than relying on
-   * a `checkpoint` flag.
-   *
-   * Returns the total rows loaded and changes applied. When splitting a dataset
-   * across many `load` calls by hand, pass `checkpoint: false` on every call
-   * but the last so the one fsyncing WAL checkpoint runs once at the end; the
-   * configured durability is restored after each call regardless.
-   */
-  async load(sql, paramsBatch, durability, checkpoint) {
-    return this.transport.load(sql, paramsBatch, durability, checkpoint);
-  }
-  /**
-   * Start building a CDC subscription for the given table.
-   * Chain `.filter()` to narrow the events, then call `.subscribe()`
-   * with a callback to begin receiving real-time change events.
-   *
-   * ```ts
-   * const sub = await db
-   *   .on('orders')
-   *   .filter({ status: 'pending' })
-   *   .subscribe(event => console.log(event))
-   *
-   * // Later:
-   * sub.unsubscribe()
-   * ```
-   */
-  on(table) {
-    return new RemoteSubscriptionBuilderImpl(table, this.transport);
-  }
-  /**
-   * Close the transport for this database. After calling `close()`,
-   * all pending requests are rejected and new calls will throw.
-   */
-  close() {
-    this.transport.close();
-    this.onDispose?.();
-  }
-};
-
-// src/core/cdc/encoding.ts
-var BLOB_TAG = "__sirannon_blob";
-var INT_TAG = "__sirannon_int";
-var SAFE_INT_BOUND = 9007199254740991n;
-var HEX_BYTES_RE = /^[0-9a-fA-F]*$/;
-var INT_PAYLOAD_RE = /^-?\d{1,19}$/;
-function encodeTaggedValues(value) {
-  if (typeof value === "bigint" || isBinaryValue(value)) {
-    return encodeTaggedLeaf(value);
-  }
-  if (value === null || typeof value !== "object") return value;
-  if (Array.isArray(value)) {
-    return value.map(encodeTaggedValues);
-  }
-  if (typeof value.toJSON === "function") {
-    return value;
-  }
-  const obj = value;
-  const out = {};
-  for (const k of Object.keys(obj)) {
-    out[k] = encodeTaggedValues(obj[k]);
-  }
-  return out;
-}
-function encodeTaggedLeaf(value) {
-  if (typeof value === "bigint") {
-    if (value >= -SAFE_INT_BOUND && value <= SAFE_INT_BOUND) {
-      return Number(value);
+    return _HLC.encode(this.wallMs, this.logical, this.nodeId);
+  }
+  /** Merge a remote HLC timestamp into the local clock and return the updated value. */
+  receive(remote) {
+    const r = _HLC.decode(remote);
+    const physicalMs = Date.now();
+    if (physicalMs > this.wallMs && physicalMs > r.wallMs) {
+      this.wallMs = physicalMs;
+      this.logical = 0;
+    } else if (r.wallMs > this.wallMs) {
+      this.wallMs = r.wallMs;
+      this.logical = r.logical + 1;
+    } else if (this.wallMs > r.wallMs) {
+      this.logical += 1;
+    } else {
+      this.logical = Math.max(this.logical, r.logical) + 1;
     }
-    return { [INT_TAG]: value.toString() };
-  }
-  if (isBinaryValue(value)) {
-    return { [BLOB_TAG]: encodeHexBytes(value) };
-  }
-  return value;
-}
-function decodeTaggedValues(value) {
-  if (value === null || typeof value !== "object") return value;
-  if (isBinaryValue(value)) return value;
-  if (Array.isArray(value)) {
-    return value.map(decodeTaggedValues);
-  }
-  const obj = value;
-  const keys = Object.keys(obj);
-  if (keys.length === 1) {
-    const tag = keys[0];
-    const tagValue = obj[tag];
-    if (tag === BLOB_TAG && typeof tagValue === "string") {
-      return decodeHexBytes(tagValue);
-    }
-    if (tag === INT_TAG && typeof tagValue === "string") {
-      if (!INT_PAYLOAD_RE.test(tagValue)) {
-        throw new Error("Invalid tagged integer payload");
-      }
-      return BigInt(tagValue);
+    if (this.logical > MAX_LOGICAL) {
+      throw new ReplicationError("HLC logical counter overflow");
     }
+    return _HLC.encode(this.wallMs, this.logical, this.nodeId);
   }
-  const out = {};
-  for (const k of keys) {
-    out[k] = decodeTaggedValues(obj[k]);
-  }
-  return out;
-}
-function isBinaryValue(value) {
-  return value instanceof Uint8Array || typeof Buffer !== "undefined" && Buffer.isBuffer(value);
-}
-function encodeHexBytes(bytes) {
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(bytes).toString("hex").toUpperCase();
-  }
-  let hex = "";
-  for (const byte of bytes) {
-    hex += byte.toString(16).padStart(2, "0");
+  /** Lexicographic comparison of two encoded HLC strings. Returns -1, 0, or 1. */
+  static compare(a, b) {
+    if (a < b) return -1;
+    if (a > b) return 1;
+    return 0;
   }
-  return hex.toUpperCase();
-}
-function decodeHexBytes(hex) {
-  if (hex.length % 2 !== 0 || !HEX_BYTES_RE.test(hex)) {
-    throw new Error("Invalid CDC BLOB hex payload");
-  }
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(hex, "hex");
-  }
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < hex.length; i += 2) {
-    const byte = Number.parseInt(hex.slice(i, i + 2), 16);
-    if (Number.isNaN(byte)) {
-      throw new Error("Invalid CDC BLOB hex payload");
+  /** Parse an encoded HLC string into its wall-clock, logical, and nodeId components. */
+  static decode(hlc) {
+    const parts = hlc.split("-");
+    if (parts.length < 3) {
+      throw new ReplicationError(`Invalid HLC format: ${hlc}`);
     }
-    bytes[i / 2] = byte;
-  }
-  return bytes;
-}
-
-// src/client/transport/http.ts
-var HttpTransport = class {
-  baseUrl;
-  headers;
-  closed = false;
-  constructor(baseUrl, headers) {
-    this.baseUrl = baseUrl.replace(/\/$/, "");
-    this.headers = {
-      "content-type": "application/json",
-      ...headers
+    return {
+      wallMs: Number.parseInt(parts[0], 16),
+      logical: Number.parseInt(parts[1], 16),
+      nodeId: parts.slice(2).join("-")
     };
   }
-  async query(sql, params, readConcern) {
-    const response = await this.post("/query", {
-      sql,
-      params: encodeTaggedValues(params),
-      readConcern
-    });
-    return { rows: decodeTaggedValues(response.rows ?? []) };
-  }
-  async execute(sql, params) {
-    return this.post("/execute", { sql, params: encodeTaggedValues(params) });
-  }
-  async transaction(statements) {
-    return this.post("/transaction", {
-      statements: statements.map((stmt) => ({ sql: stmt.sql, params: encodeTaggedValues(stmt.params) }))
-    });
-  }
-  async batch(sql, paramsBatch, writeConcern) {
-    return this.post("/batch", {
-      sql,
-      paramsBatch: paramsBatch.map((entry) => encodeTaggedValues(entry)),
-      writeConcern
-    });
-  }
-  async load(sql, paramsBatch, durability, checkpoint) {
-    return this.post("/load", {
-      sql,
-      paramsBatch: paramsBatch.map((entry) => encodeTaggedValues(entry)),
-      durability,
-      checkpoint
-    });
-  }
-  async subscribe(_table, _filter, _callback) {
-    throw new RemoteError(
-      "TRANSPORT_ERROR",
-      'Subscriptions require WebSocket transport. Create the client with { transport: "websocket" } to use real-time subscriptions.'
-    );
-  }
-  close() {
-    this.closed = true;
+  static encode(wallMs, logical, nodeId) {
+    const wallHex = wallMs.toString(16).padStart(12, "0");
+    const logicalHex = logical.toString(16).padStart(4, "0");
+    return `${wallHex}-${logicalHex}-${nodeId}`;
   }
-  async post(path, body) {
-    if (this.closed) {
-      throw new RemoteError("TRANSPORT_ERROR", "Transport is closed");
+};
+
+// src/core/sync/conflict/lww.ts
+var LWWResolver = class {
+  resolve(ctx) {
+    if (ctx.remoteChange.operation === "delete") {
+      return { action: "accept_remote" };
     }
-    const url = `${this.baseUrl}${path}`;
-    let response;
-    try {
-      response = await fetch(url, {
-        method: "POST",
-        headers: this.headers,
-        body: JSON.stringify(body)
-      });
-    } catch (err) {
-      throw new RemoteError(
-        "CONNECTION_ERROR",
-        `Failed to connect to ${url}: ${err instanceof Error ? err.message : String(err)}`
-      );
+    if (ctx.localHlc === null) {
+      return { action: "accept_remote" };
     }
-    let data;
-    try {
-      data = await response.json();
-    } catch {
-      throw new RemoteError("INVALID_RESPONSE", `Server returned non-JSON response (HTTP ${response.status})`);
+    const cmp = HLC.compare(ctx.remoteHlc, ctx.localHlc);
+    if (cmp > 0) {
+      return { action: "accept_remote" };
+    }
+    if (cmp < 0) {
+      return { action: "keep_local" };
     }
-    if (!response.ok) {
-      const errorData = data;
-      throw new RemoteError(
-        errorData.error?.code ?? "UNKNOWN_ERROR",
-        errorData.error?.message ?? `HTTP ${response.status}`
-      );
+    if (ctx.remoteChange.nodeId > (ctx.localChange?.nodeId ?? "")) {
+      return { action: "accept_remote" };
     }
-    return data;
+    return { action: "keep_local" };
   }
 };
 
-// src/client/transport/ws.ts
-var DEFAULT_REQUEST_TIMEOUT = 3e4;
-var WebSocketTransport = class {
-  ws = null;
-  url;
-  autoReconnect;
-  reconnectInterval;
-  requestTimeout;
-  protocols;
-  pendingRequests = /* @__PURE__ */ new Map();
-  activeSubscriptions = /* @__PURE__ */ new Map();
-  idCounter = 0;
-  closed = false;
-  connectPromise = null;
-  reconnectTimer = null;
-  constructor(url, options) {
-    this.url = url;
-    this.autoReconnect = options?.autoReconnect ?? true;
-    this.reconnectInterval = options?.reconnectInterval ?? 1e3;
-    this.requestTimeout = options?.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT;
-    this.protocols = options?.protocols;
-  }
-  async query(sql, params) {
-    await this.ensureConnected();
-    const id = this.nextId();
-    const response = await this.request({
-      type: "query",
-      id,
-      sql,
-      params: encodeTaggedValues(params)
-    });
-    return { rows: decodeTaggedValues(response.rows ?? []) };
-  }
-  async execute(sql, params) {
-    await this.ensureConnected();
-    const id = this.nextId();
-    return this.request({
-      type: "execute",
-      id,
-      sql,
-      params: encodeTaggedValues(params)
-    });
-  }
-  async transaction(statements) {
-    await this.ensureConnected();
-    const id = this.nextId();
-    return this.request({
-      type: "transaction",
-      id,
-      statements: statements.map((stmt) => ({
-        sql: stmt.sql,
-        params: encodeTaggedValues(stmt.params)
-      }))
-    });
-  }
-  async batch(sql, paramsBatch, writeConcern) {
-    await this.ensureConnected();
-    const id = this.nextId();
-    return this.request({
-      type: "batch",
-      id,
-      sql,
-      paramsBatch: paramsBatch.map((entry) => encodeTaggedValues(entry)),
-      ...writeConcern ? { writeConcern } : {}
-    });
-  }
-  async load(sql, paramsBatch, durability, checkpoint) {
-    await this.ensureConnected();
-    const id = this.nextId();
-    return this.request({
-      type: "load",
-      id,
-      sql,
-      paramsBatch: paramsBatch.map((entry) => encodeTaggedValues(entry)),
-      ...durability ? { durability } : {},
-      ...checkpoint !== void 0 ? { checkpoint } : {}
-    });
-  }
-  async subscribe(table, filter, callback, options) {
-    await this.ensureConnected();
-    const id = this.nextId();
-    this.activeSubscriptions.set(id, {
-      table,
-      filter,
-      callback,
-      onReset: options?.onReset,
-      lastSeq: void 0,
-      epoch: void 0
-    });
-    try {
-      const msg = {
-        type: "subscribe",
-        id,
-        table,
-        ...filter ? { filter: encodeTaggedValues(filter) } : {}
-      };
-      await this.request(msg);
-    } catch (err) {
-      this.activeSubscriptions.delete(id);
-      throw err;
-    }
-    return {
-      unsubscribe: () => {
-        this.activeSubscriptions.delete(id);
-        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-          this.ws.send(JSON.stringify({ type: "unsubscribe", id }));
-        }
+// src/core/sync/conflict/field-merge.ts
+var FieldMergeResolver = class {
+  getColumnVersions;
+  lww = new LWWResolver();
+  constructor(getColumnVersions) {
+    this.getColumnVersions = getColumnVersions;
+  }
+  async resolve(ctx) {
+    const columnVersions = await this.getColumnVersions(ctx.table, ctx.rowId);
+    if (columnVersions.size === 0) {
+      return this.lww.resolve(ctx);
+    }
+    const localData = ctx.localChange?.newData ?? ctx.localChange?.oldData ?? {};
+    const remoteData = ctx.remoteChange.newData ?? {};
+    const oldData = ctx.remoteChange.oldData ?? {};
+    const localChanged = /* @__PURE__ */ new Set();
+    const remoteChanged = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(localData)) {
+      if (canonicaliseForChecksum(localData[key]) !== canonicaliseForChecksum(oldData[key])) {
+        localChanged.add(key);
       }
-    };
-  }
-  close() {
-    this.closed = true;
-    this.cancelReconnect();
-    this.rejectAllPending(new RemoteError("TRANSPORT_ERROR", "Transport closed"));
-    this.activeSubscriptions.clear();
-    if (this.ws) {
-      this.ws.close(1e3, "Client closed");
-      this.ws = null;
-    }
-    this.connectPromise = null;
-  }
-  nextId() {
-    return `c_${++this.idCounter}_${Date.now()}`;
-  }
-  async ensureConnected() {
-    if (this.closed) {
-      throw new RemoteError("TRANSPORT_ERROR", "Transport is closed");
-    }
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      return;
-    }
-    if (!this.connectPromise) {
-      this.connectPromise = this.connect().finally(() => {
-        this.connectPromise = null;
-      });
     }
-    return this.connectPromise;
-  }
-  connect() {
-    return new Promise((resolve, reject) => {
-      let settled = false;
-      const ws = this.protocols === void 0 ? new WebSocket(this.url) : new WebSocket(this.url, this.protocols);
-      const onOpen = () => {
-        settled = true;
-        this.ws = ws;
-        resolve();
-      };
-      const onError = () => {
-        if (!settled) {
-          settled = true;
-          reject(new RemoteError("CONNECTION_ERROR", `Failed to connect to ${this.url}`));
-        }
-      };
-      const onClose = (event) => {
-        ws.removeEventListener("open", onOpen);
-        ws.removeEventListener("error", onError);
-        if (!settled) {
-          settled = true;
-          reject(
-            new RemoteError("CONNECTION_ERROR", `Connection closed during handshake: ${event.code} ${event.reason}`)
-          );
-          return;
-        }
-        this.ws = null;
-        this.handleDisconnect();
-      };
-      const onMessage = (event) => {
-        this.handleMessage(String(event.data));
-      };
-      ws.addEventListener("open", onOpen);
-      ws.addEventListener("error", onError);
-      ws.addEventListener("close", onClose);
-      ws.addEventListener("message", onMessage);
-    });
-  }
-  handleMessage(raw) {
-    let msg;
-    try {
-      msg = JSON.parse(raw);
-    } catch {
-      return;
+    for (const key of Object.keys(remoteData)) {
+      if (canonicaliseForChecksum(remoteData[key]) !== canonicaliseForChecksum(oldData[key])) {
+        remoteChanged.add(key);
+      }
     }
-    switch (msg.type) {
-      case "result": {
-        const pending = this.pendingRequests.get(msg.id);
-        if (pending) {
-          clearTimeout(pending.timer);
-          this.pendingRequests.delete(msg.id);
-          pending.resolve(msg.data);
-        }
-        break;
+    const overlapping = /* @__PURE__ */ new Set();
+    for (const key of remoteChanged) {
+      if (localChanged.has(key)) {
+        overlapping.add(key);
       }
-      case "subscribed": {
-        const sub = this.activeSubscriptions.get(msg.id);
-        if (sub) {
-          if (msg.epoch !== void 0) {
-            sub.epoch = msg.epoch;
-          }
-          let baseline;
-          if (msg.seq !== void 0) {
-            try {
-              baseline = BigInt(msg.seq);
-            } catch {
-              baseline = void 0;
-            }
-          }
-          if (msg.resync) {
-            sub.lastSeq = baseline;
-            try {
-              sub.onReset?.();
-            } catch {
-            }
-          } else if (sub.lastSeq === void 0 && baseline !== void 0) {
-            sub.lastSeq = baseline;
-          }
-        }
-        const pending = this.pendingRequests.get(msg.id);
-        if (pending) {
-          clearTimeout(pending.timer);
-          this.pendingRequests.delete(msg.id);
-          pending.resolve(void 0);
-        }
-        break;
+    }
+    if (overlapping.size === 0 && (localChanged.size > 0 || remoteChanged.size > 0)) {
+      const merged2 = { ...localData };
+      for (const key of remoteChanged) {
+        merged2[key] = remoteData[key];
       }
-      case "error": {
-        const pending = this.pendingRequests.get(msg.id);
-        if (pending) {
-          clearTimeout(pending.timer);
-          this.pendingRequests.delete(msg.id);
-          pending.reject(new RemoteError(msg.error.code, msg.error.message));
+      return { action: "merge", mergedData: merged2 };
+    }
+    const merged = { ...localData };
+    let anyRemoteWins = false;
+    for (const key of overlapping) {
+      const cv = columnVersions.get(key);
+      if (!cv) {
+        const rowLww = this.lww.resolve(ctx);
+        if (rowLww.action === "accept_remote") {
+          merged[key] = remoteData[key];
+          anyRemoteWins = true;
         }
-        break;
+        continue;
       }
-      case "change": {
-        const sub = this.activeSubscriptions.get(msg.id);
-        if (sub) {
-          try {
-            const event = {
-              type: msg.event.type,
-              table: msg.event.table,
-              row: decodeTaggedValues(msg.event.row),
-              oldRow: msg.event.oldRow === void 0 ? void 0 : decodeTaggedValues(msg.event.oldRow),
-              seq: BigInt(msg.event.seq),
-              timestamp: msg.event.timestamp
-            };
-            if (sub.lastSeq === void 0 || event.seq > sub.lastSeq) {
-              sub.lastSeq = event.seq;
-            }
-            sub.callback(event);
-          } catch {
-          }
-        }
-        break;
+      const cmp = HLC.compare(ctx.remoteHlc, cv.hlc);
+      if (cmp > 0) {
+        merged[key] = remoteData[key];
+        anyRemoteWins = true;
+      } else if (cmp === 0 && ctx.remoteChange.nodeId > cv.nodeId) {
+        merged[key] = remoteData[key];
+        anyRemoteWins = true;
       }
     }
-  }
-  handleDisconnect() {
-    this.rejectAllPending(new RemoteError("CONNECTION_ERROR", "WebSocket disconnected"));
-    if (this.autoReconnect && !this.closed && this.activeSubscriptions.size > 0) {
-      this.scheduleReconnect();
-    }
-  }
-  scheduleReconnect() {
-    if (this.reconnectTimer !== null || this.closed) {
-      return;
-    }
-    this.reconnectTimer = setTimeout(async () => {
-      this.reconnectTimer = null;
-      if (this.closed) return;
-      try {
-        await this.ensureConnected();
-        await this.resubscribeAll();
-      } catch {
-        if (!this.closed && this.activeSubscriptions.size > 0) {
-          this.scheduleReconnect();
-        }
-      }
-    }, this.reconnectInterval);
-  }
-  async resubscribeAll() {
-    const entries = [...this.activeSubscriptions.entries()];
-    for (const [id, sub] of entries) {
-      if (this.closed) break;
-      try {
-        const msg = {
-          type: "subscribe",
-          id,
-          table: sub.table,
-          ...sub.filter ? { filter: encodeTaggedValues(sub.filter) } : {},
-          ...sub.lastSeq !== void 0 ? { sinceSeq: sub.lastSeq.toString() } : {},
-          ...sub.epoch !== void 0 ? { epoch: sub.epoch } : {}
-        };
-        await this.request(msg);
-      } catch {
-        this.activeSubscriptions.delete(id);
+    for (const key of remoteChanged) {
+      if (!overlapping.has(key)) {
+        merged[key] = remoteData[key];
+        anyRemoteWins = true;
       }
     }
+    if (anyRemoteWins) {
+      return { action: "merge", mergedData: merged };
+    }
+    return { action: "keep_local" };
   }
-  request(msg) {
-    return new Promise((resolve, reject) => {
-      const { id } = msg;
-      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-        reject(new RemoteError("CONNECTION_ERROR", "WebSocket is not connected"));
-        return;
-      }
-      const timer = this.requestTimeout > 0 ? setTimeout(() => {
-        this.pendingRequests.delete(id);
-        reject(new RemoteError("TIMEOUT", `Request timed out after ${this.requestTimeout}ms`));
-      }, this.requestTimeout) : void 0;
-      this.pendingRequests.set(id, {
-        resolve,
-        reject,
-        timer
-      });
-      this.ws.send(JSON.stringify(msg));
-    });
+};
+
+// src/core/sync/conflict/primary-wins.ts
+var PrimaryWinsResolver = class {
+  primaryNodeId;
+  lww = new LWWResolver();
+  constructor(primaryNodeId) {
+    this.primaryNodeId = primaryNodeId;
   }
-  rejectAllPending(error) {
-    for (const [, pending] of this.pendingRequests) {
-      clearTimeout(pending.timer);
-      pending.reject(error);
+  resolve(ctx) {
+    if (ctx.remoteChange.nodeId === this.primaryNodeId) {
+      return { action: "accept_remote" };
     }
-    this.pendingRequests.clear();
-  }
-  cancelReconnect() {
-    if (this.reconnectTimer !== null) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
+    if (ctx.localChange?.nodeId === this.primaryNodeId) {
+      return { action: "keep_local" };
     }
+    return this.lww.resolve(ctx);
   }
 };
 
 // src/client/client.ts
-var CLUSTER_DISCOVERY_FETCH_TIMEOUT_MS = 2e3;
-function clusterRoutingFingerprint(state) {
-  const readEndpoints = state.readEndpoints.map((endpoint) => ({
-    url: endpoint.url,
-    readConcerns: [...endpoint.readConcerns].sort()
-  })).sort((left, right) => left.url.localeCompare(right.url));
-  return JSON.stringify({
-    currentPrimary: state.currentPrimary,
-    primaryTerm: state.primaryTerm,
-    readEndpoints
-  });
-}
-function clusterRoutingChanged(previous, next) {
-  return previous === void 0 || clusterRoutingFingerprint(previous) !== clusterRoutingFingerprint(next);
-}
-function isTopologyConfig(urlOrOpts) {
-  if (typeof urlOrOpts !== "object") {
-    return false;
-  }
-  return "primary" in urlOrOpts || "replicas" in urlOrOpts && Array.isArray(urlOrOpts.replicas) && urlOrOpts.replicas.length > 0 || "endpoints" in urlOrOpts && Array.isArray(urlOrOpts.endpoints) && urlOrOpts.endpoints.length > 0 || urlOrOpts.discovery === "coordinator";
-}
-function toBaseUrl(url) {
-  return normaliseEndpointUrl(url);
-}
-function toServerBaseUrl(url, databaseId) {
-  const base = toBaseUrl(url);
-  if (!databaseId) return base.replace(/\/db\/[^/]+$/i, "");
-  return base.replace(new RegExp(`/db/${escapeRegExp(encodeURIComponent(databaseId))}$`, "i"), "");
-}
-function toWsUrl(baseUrl) {
-  return baseUrl.replace(/^http:\/\//i, "ws://").replace(/^https:\/\//i, "wss://");
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var TOPOLOGY_KEYS = ["endpoints", "primary", "replicas", "readPreference", "discovery", "readConcern"];
+function normaliseClientUrl(url) {
+  const value = url;
+  if (typeof value === "string") return toBaseUrl(value);
+  const named = typeof value === "object" && value !== null ? TOPOLOGY_KEYS.find((key) => key in value) : void 0;
+  const subject = named === void 0 ? "Topology-aware routing" : `The '${named}' option`;
+  throw new RemoteError(
+    "INVALID_ARGUMENT",
+    `SirannonClient connects to a single server URL and never routes between nodes. ${subject} moved to the '@delali/sirannon-db/client/topology' entry point, which a browser bundle must not import.`
+  );
 }
-function normaliseEndpointUrl(rawUrl) {
-  let parsed;
-  try {
-    parsed = new URL(rawUrl);
-  } catch {
-    throw new TypeError(`Endpoint URL '${rawUrl}' is invalid`);
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new TypeError(`Endpoint URL '${rawUrl}' must use http or https`);
-  }
-  if (parsed.username || parsed.password) {
-    throw new TypeError(`Endpoint URL '${rawUrl}' must not contain credentials`);
+var SirannonClient = class extends DatabaseClient {
+  baseUrl;
+  constructor(url, options) {
+    super(options);
+    this.baseUrl = normaliseClientUrl(url);
   }
-  if (parsed.hash) {
-    throw new TypeError(`Endpoint URL '${rawUrl}' must not contain a fragment`);
+  createTransport(databaseId) {
+    return createEndpointTransport(this.settings, this.baseUrl, databaseId);
   }
-  if (parsed.search) {
-    throw new TypeError(`Endpoint URL '${rawUrl}' must not contain a query string`);
+  resolveServerUrl() {
+    return this.baseUrl;
   }
-  parsed.pathname = parsed.pathname.replace(/\/+$/, "");
-  return parsed.toString().replace(/\/$/, "");
+};
+
+// 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 isReadConcernLevel(value) {
-  return value === "local" || value === "majority" || value === "linearizable";
+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("");
 }
-function parseDiscoveredReadConcerns(value) {
-  if (!Array.isArray(value)) {
-    throw new RemoteError("INVALID_RESPONSE", "Cluster metadata readConcerns must be an array");
+
+// src/core/sync/validators.ts
+var IDENTIFIER_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var SEQ_STRING_RE = /^\d{1,19}$/;
+
+// src/client/snapshot-loader.ts
+var DEFAULT_SNAPSHOT_PAGE_ROWS = 500;
+function validateManifest(raw) {
+  const record = raw;
+  if (record === null || typeof record !== "object" || typeof record.startSeq !== "string" || !SEQ_STRING_RE.test(record.startSeq) || typeof record.epoch !== "string" || record.epoch.length === 0 || !Array.isArray(record.schema) || record.schema.some((ddl) => typeof ddl !== "string") || !Array.isArray(record.tables) || !Array.isArray(record.migrations)) {
+    throw new RemoteError("INVALID_RESPONSE", "Snapshot manifest is malformed");
   }
-  const concerns = [];
-  for (const concern of value) {
-    if (!isReadConcernLevel(concern)) {
-      throw new RemoteError("INVALID_RESPONSE", "Cluster metadata contains an invalid read concern");
+  for (const migration of record.migrations) {
+    if (typeof migration !== "object" || migration === null || !Number.isSafeInteger(migration.version) || typeof migration.name !== "string" || migration.checksum !== null && typeof migration.checksum !== "string") {
+      throw new RemoteError("INVALID_RESPONSE", "Snapshot manifest migration entry is malformed");
     }
-    if (!concerns.includes(concern)) {
-      concerns.push(concern);
+  }
+  for (const table of record.tables) {
+    if (typeof table !== "object" || table === null || !IDENTIFIER_RE.test(String(table.name)) || typeof table.rowCount !== "number") {
+      throw new RemoteError("INVALID_RESPONSE", "Snapshot manifest table entry is malformed");
     }
   }
-  return concerns;
+  return record;
+}
+function validatePage(raw) {
+  const record = raw;
+  if (record === null || typeof record !== "object" || !Array.isArray(record.rows) || typeof record.checksum !== "string" || typeof record.done !== "boolean" || record.nextKey !== null && !Array.isArray(record.nextKey)) {
+    throw new RemoteError("INVALID_RESPONSE", "Snapshot page is malformed");
+  }
+  return record;
 }
-function toDiscoveredServerBaseUrl(endpoint, databaseId) {
+async function downloadDatabaseSnapshot(port, options) {
+  const baseUrl = toBaseUrl(options.url);
+  const encodedId = encodeURIComponent(options.databaseId);
+  const pageSize = options.pageSize ?? DEFAULT_SNAPSHOT_PAGE_ROWS;
+  const timeoutMs = options.requestTimeoutMs ?? DEFAULT_HTTP_REQUEST_TIMEOUT_MS;
+  const manifest = validateManifest(
+    await postJson(`${baseUrl}/db/${encodedId}/snapshot`, {}, options.headers, timeoutMs)
+  );
+  const tables = manifest.tables.map((table) => table.name);
+  const totalRows = manifest.tables.reduce((sum, table) => sum + table.rowCount, 0);
+  await port.beginSnapshotLoad(tables);
+  let loadedRows = 0;
   try {
-    return toServerBaseUrl(endpoint, databaseId);
+    await port.applySnapshotSchema(manifest.schema);
+    for (const table of manifest.tables) {
+      let afterKey;
+      let tableLoadedRows = 0;
+      for (; ; ) {
+        const page = validatePage(
+          await postJson(
+            `${baseUrl}/db/${encodedId}/snapshot/page`,
+            { table: table.name, ...afterKey !== void 0 ? { afterKey } : {}, limit: pageSize },
+            options.headers,
+            timeoutMs
+          )
+        );
+        if (page.rows.length > 0) {
+          const rows = decodeTaggedValues(page.rows);
+          if (sha256Hex(canonicaliseForChecksum(rows)) !== page.checksum) {
+            throw new RemoteError(
+              "SNAPSHOT_CHECKSUM_MISMATCH",
+              `Snapshot page checksum mismatch for table '${table.name}'`
+            );
+          }
+          await port.loadSnapshotPage(table.name, rows);
+          tableLoadedRows += rows.length;
+          loadedRows += rows.length;
+          options.onProgress?.({
+            table: table.name,
+            tableLoadedRows,
+            tableTotalRows: table.rowCount,
+            loadedRows,
+            totalRows
+          });
+        }
+        if (page.done) break;
+        if (page.nextKey === null) {
+          throw new RemoteError("INVALID_RESPONSE", `Snapshot page for table '${table.name}' has no resume key`);
+        }
+        afterKey = page.nextKey;
+      }
+    }
+    await port.replaceMigrationHistory(manifest.migrations);
+    const startSeq = BigInt(manifest.startSeq);
+    await port.setPullState(startSeq, manifest.epoch);
+    await port.endSnapshotLoad(tables);
+    return { startSeq, epoch: manifest.epoch, tables, loadedRows };
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new RemoteError("INVALID_RESPONSE", `Cluster metadata contains an unsafe endpoint: ${message}`);
+    try {
+      await port.abortSnapshotLoad();
+    } catch {
+    }
+    throw err;
   }
 }
-function parseClusterRouting(data, databaseId) {
-  if (typeof data !== "object" || data === null || Array.isArray(data)) {
-    throw new RemoteError("INVALID_RESPONSE", "Cluster metadata must be an object");
-  }
-  const record = data;
-  if (record.databaseId !== databaseId) {
-    throw new RemoteError("INVALID_RESPONSE", "Cluster metadata database id does not match the request");
+function highestMigrationVersion(rows) {
+  let highest = 0;
+  for (const row of rows) {
+    if (row.version > highest) highest = row.version;
   }
-  if (record.primaryTerm !== void 0 && typeof record.primaryTerm !== "string") {
-    throw new RemoteError("INVALID_RESPONSE", "Cluster metadata primaryTerm must be a string");
+  return highest;
+}
+
+// src/core/migrations/checksum.ts
+var FNV_OFFSET_BASIS = 0xcbf29ce484222325n;
+var FNV_PRIME = 0x100000001b3n;
+var MASK_64 = 0xffffffffffffffffn;
+function migrationChecksum(sql) {
+  const bytes = new TextEncoder().encode(sql.replace(/\r\n?/g, "\n").trim());
+  let hash = FNV_OFFSET_BASIS;
+  for (let i = 0; i < bytes.length; i++) {
+    hash = (hash ^ BigInt(bytes[i])) * FNV_PRIME & MASK_64;
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+
+// src/core/migrations/types.ts
+var MIGRATION_NAME_RE = /^\w+$/;
+
+// src/core/migrations/baseline.ts
+var SQLITE_USER_VERSION_MAX = 2147483647;
+
+// src/server/sync-protocol.ts
+function isValidSchemaVersion(candidate) {
+  return typeof candidate === "number" && Number.isSafeInteger(candidate) && candidate >= 0 && candidate <= SQLITE_USER_VERSION_MAX;
+}
+
+// src/client/migration-sync.ts
+function validateMigrationList(raw) {
+  const record = raw;
+  if (record === null || typeof record !== "object" || !isValidSchemaVersion(record.serverVersion) || !Array.isArray(record.migrations)) {
+    throw new RemoteError("INVALID_RESPONSE", "Migration list response is malformed");
   }
-  let currentPrimary = null;
-  if (record.currentPrimary !== void 0 && record.currentPrimary !== null) {
-    if (typeof record.currentPrimary !== "object" || Array.isArray(record.currentPrimary)) {
-      throw new RemoteError("INVALID_RESPONSE", "Cluster metadata currentPrimary must be an object or null");
+  for (const entry of record.migrations) {
+    const candidate = entry;
+    if (candidate === null || typeof candidate !== "object" || !isValidSchemaVersion(candidate.version) || candidate.version === 0 || typeof candidate.name !== "string" || !MIGRATION_NAME_RE.test(candidate.name) || candidate.checksum !== null && typeof candidate.checksum !== "string" || candidate.up !== void 0 && typeof candidate.up !== "string") {
+      throw new RemoteError("INVALID_RESPONSE", "Migration list entry is malformed");
     }
-    const primary = record.currentPrimary;
-    if (typeof primary.endpoint !== "string") {
-      throw new RemoteError("INVALID_RESPONSE", "Cluster metadata currentPrimary.endpoint must be a string");
+  }
+  return record;
+}
+async function fetchServerMigrations(options, after) {
+  const url = `${options.url}/db/${encodeURIComponent(options.databaseId)}/migrations`;
+  const body = { after };
+  return validateMigrationList(await postJson(url, body, options.headers, options.requestTimeoutMs));
+}
+function historiesDiverge(local, server, localVersion, serverVersion) {
+  const serverByVersion = new Map(server.map((entry) => [entry.version, entry]));
+  for (const row of local) {
+    if (row.version > serverVersion) continue;
+    const counterpart = serverByVersion.get(row.version);
+    if (counterpart === void 0) return true;
+    if (row.checksum !== null && counterpart.checksum !== null && row.checksum !== counterpart.checksum) {
+      return true;
     }
-    currentPrimary = toDiscoveredServerBaseUrl(primary.endpoint, databaseId);
   }
-  const readEndpointsRaw = record.readEndpoints;
-  if (readEndpointsRaw !== void 0 && !Array.isArray(readEndpointsRaw)) {
-    throw new RemoteError("INVALID_RESPONSE", "Cluster metadata readEndpoints must be an array");
+  const localVersions = new Set(local.map((row) => row.version));
+  for (const entry of server) {
+    if (entry.version <= localVersion && !localVersions.has(entry.version)) return true;
   }
-  const readEndpoints = (readEndpointsRaw ?? []).map((endpointInfo) => {
-    if (typeof endpointInfo !== "object" || endpointInfo === null || Array.isArray(endpointInfo)) {
-      throw new RemoteError("INVALID_RESPONSE", "Cluster metadata read endpoint must be an object");
-    }
-    const endpoint = endpointInfo;
-    if (typeof endpoint.endpoint !== "string") {
-      throw new RemoteError("INVALID_RESPONSE", "Cluster metadata read endpoint URL must be a string");
+  return false;
+}
+function toPendingMigrations(server, localVersion) {
+  const pending = [];
+  for (const entry of server) {
+    if (entry.version <= localVersion) continue;
+    if (entry.up === void 0 || entry.checksum === null) return null;
+    if (migrationChecksum(entry.up) !== entry.checksum) return null;
+    pending.push({ version: entry.version, name: entry.name, up: entry.up });
+  }
+  return pending;
+}
+async function syncDeviceMigrations(db, options) {
+  const local = await db.appliedMigrations();
+  const localVersion = highestMigrationVersion(local);
+  const list = await fetchServerMigrations(options, localVersion);
+  if (historiesDiverge(local, list.migrations, localVersion, list.serverVersion)) {
+    return { status: "resync-required", schemaVersion: localVersion, serverVersion: list.serverVersion };
+  }
+  if (localVersion > list.serverVersion) {
+    return { status: "ahead", schemaVersion: localVersion, serverVersion: list.serverVersion };
+  }
+  if (localVersion === list.serverVersion) {
+    return { status: "in-sync", schemaVersion: localVersion, serverVersion: list.serverVersion };
+  }
+  const pending = toPendingMigrations(list.migrations, localVersion);
+  if (pending === null || pending.length === 0) {
+    return { status: "resync-required", schemaVersion: localVersion, serverVersion: list.serverVersion };
+  }
+  try {
+    await db.migrate(pending);
+  } catch (err) {
+    if (err instanceof MigrationError && (err.code === "MIGRATION_CHECKSUM_MISMATCH" || err.code === "MIGRATION_BASELINE_GAP")) {
+      return { status: "resync-required", schemaVersion: localVersion, serverVersion: list.serverVersion };
     }
-    return {
-      url: toDiscoveredServerBaseUrl(endpoint.endpoint, databaseId),
-      readConcerns: parseDiscoveredReadConcerns(endpoint.readConcerns)
-    };
-  });
+    throw err;
+  }
+  const schemaVersion = highestMigrationVersion(await db.appliedMigrations());
   return {
-    currentPrimary,
-    primaryTerm: record.primaryTerm ?? null,
-    readEndpoints
+    status: schemaVersion === list.serverVersion ? "migrated" : "resync-required",
+    schemaVersion,
+    serverVersion: list.serverVersion
   };
 }
-var SirannonClient = class {
-  baseUrl;
-  wsBaseUrl;
-  transport;
-  headers;
-  webSocketProtocols;
-  autoReconnect;
-  reconnectInterval;
-  requestTimeout;
-  databases = /* @__PURE__ */ new Map();
-  closed = false;
-  topologyEnabled;
-  primaryUrl;
-  replicaUrls;
-  readPreference;
-  discovery;
-  readConcern;
-  starterEndpoints;
-  clusterRouting = /* @__PURE__ */ new Map();
-  topologyTransports = /* @__PURE__ */ new Map();
-  latencies = [];
-  latencyMeasuredAt = 0;
-  latencyMeasuring = null;
-  LATENCY_TTL_MS = 6e4;
-  removedReplicas = /* @__PURE__ */ new Set();
-  constructor(urlOrOpts, options) {
-    if (isTopologyConfig(urlOrOpts)) {
-      const topoOpts = urlOrOpts;
-      this.topologyEnabled = true;
-      this.primaryUrl = topoOpts.primary ? toBaseUrl(topoOpts.primary) : void 0;
-      this.replicaUrls = (topoOpts.replicas ?? []).map(toBaseUrl);
-      this.readPreference = topoOpts.readPreference ?? "primary";
-      this.discovery = topoOpts.discovery ?? "static";
-      this.readConcern = topoOpts.readConcern;
-      this.starterEndpoints = (topoOpts.endpoints ?? []).map(toBaseUrl);
-      this.baseUrl = this.primaryUrl ?? this.replicaUrls[0] ?? this.starterEndpoints[0] ?? "";
-      this.wsBaseUrl = toWsUrl(this.baseUrl);
-      this.transport = topoOpts.transport ?? "websocket";
-      this.headers = topoOpts.headers;
-      this.webSocketProtocols = topoOpts.webSocketProtocols;
-      this.autoReconnect = topoOpts.autoReconnect ?? true;
-      this.reconnectInterval = topoOpts.reconnectInterval ?? 1e3;
-      this.requestTimeout = topoOpts.requestTimeout;
-    } else {
-      this.topologyEnabled = false;
-      this.primaryUrl = void 0;
-      this.replicaUrls = [];
-      this.readPreference = "primary";
-      this.discovery = "static";
-      this.readConcern = void 0;
-      this.starterEndpoints = [];
-      this.baseUrl = toBaseUrl(urlOrOpts);
-      this.wsBaseUrl = toWsUrl(this.baseUrl);
-      this.transport = options?.transport ?? "websocket";
-      this.headers = options?.headers;
-      this.webSocketProtocols = options?.webSocketProtocols;
-      this.autoReconnect = options?.autoReconnect ?? true;
-      this.reconnectInterval = options?.reconnectInterval ?? 1e3;
-      this.requestTimeout = options?.requestTimeout;
-    }
-  }
-  database(id) {
-    if (this.closed) {
-      throw new Error("Client is closed");
-    }
-    const existing = this.databases.get(id);
-    if (existing) {
-      return existing;
-    }
-    const transport = this.createTransport(id);
-    const db = new RemoteDatabase(id, transport, () => {
-      this.databases.delete(id);
+
+// src/client/sync-pull-stream.ts
+var DEFAULT_IMMEDIATE_ACK_AFTER_CHANGES = 500;
+var STAGE_BATCH_EVENTS = 500;
+var PullStream = class {
+  constructor(config, hooks) {
+    this.config = config;
+    this.hooks = hooks;
+  }
+  transport = null;
+  subscriptions = [];
+  ackTimer = null;
+  deviceId = null;
+  lastAckedSeq = null;
+  ackBaseSeq = null;
+  inbox = [];
+  pumping = false;
+  failed = false;
+  serverWindow = null;
+  stagedSeq = null;
+  pullSeq = null;
+  pullEpoch;
+  stagedStream = false;
+  async open(deviceId, schemaVersion) {
+    this.deviceId = deviceId;
+    this.lastAckedSeq = null;
+    this.inbox = [];
+    this.failed = false;
+    let recoveryApplyError = null;
+    const port = this.hooks.port();
+    if (port !== null) {
+      const recovered = await port.recoverStagedPull(this.config.resolver, this.hooks.onChange);
+      this.stagedSeq = recovered.resumeSeq;
+      if (recovered.appliedSeq !== null && (this.pullSeq === null || recovered.appliedSeq > this.pullSeq)) {
+        this.pullSeq = recovered.appliedSeq;
+      }
+      recoveryApplyError = recovered.applyError;
+      if (recoveryApplyError !== null) {
+        await this.adoptRecordedCursor(port);
+      }
+    }
+    this.ackBaseSeq = this.resumeWatermark();
+    const encodedId = encodeURIComponent(this.config.databaseId);
+    const transport = new WebSocketTransport(`${this.config.wsBaseUrl}/db/${encodedId}`, {
+      headers: this.config.headers,
+      requestTimeout: this.config.requestTimeout
     });
-    this.databases.set(id, db);
-    return db;
-  }
-  close() {
-    this.closed = true;
-    const openDatabases = [...this.databases.values()];
-    this.databases.clear();
-    for (const db of openDatabases) {
-      db.close();
+    this.transport = transport;
+    const [firstTable] = this.config.tables;
+    if (firstTable !== void 0) {
+      const subscription = await transport.subscribe(firstTable, void 0, (event) => this.handlePullEvent(event), {
+        deviceId,
+        schemaVersion,
+        tables: this.config.tables,
+        sinceSeq: this.resumeWatermark() ?? void 0,
+        getResumeSeq: () => this.resumeWatermark() ?? void 0,
+        epoch: this.pullEpoch,
+        stagedStream: this.stagedStream,
+        onReset: () => this.hooks.onResyncRequired(),
+        onSubscribed: (info) => this.handleSubscribed(info)
+      });
+      this.subscriptions.push(subscription);
+    }
+    if (recoveryApplyError !== null) {
+      this.hooks.onApplyFailure(recoveryApplyError);
     }
   }
-  createTransport(databaseId) {
-    if (!this.topologyEnabled) {
-      return this.createTransportForUrl(this.baseUrl, this.wsBaseUrl, databaseId);
-    }
-    const transport = new TopologyAwareTransport(databaseId, this);
-    this.topologyTransports.set(databaseId, transport);
-    return transport;
-  }
-  createTransportForUrl(baseUrl, wsBaseUrl, databaseId) {
-    const encodedId = encodeURIComponent(databaseId);
-    if (this.transport === "http") {
-      return new HttpTransport(`${baseUrl}/db/${encodedId}`, this.headers);
-    }
-    return new WebSocketTransport(`${wsBaseUrl}/db/${encodedId}`, {
-      autoReconnect: this.autoReconnect,
-      reconnectInterval: this.reconnectInterval,
-      protocols: this.webSocketProtocols,
-      requestTimeout: this.requestTimeout
-    });
+  teardown() {
+    if (this.ackTimer !== null) {
+      clearTimeout(this.ackTimer);
+      this.ackTimer = null;
+    }
+    for (const subscription of this.subscriptions) {
+      subscription.unsubscribe();
+    }
+    this.subscriptions = [];
+    if (this.transport) {
+      this.transport.close();
+      this.transport = null;
+    }
+    this.inbox = [];
   }
-  _createTransportForEndpoint(url, databaseId) {
-    const base = toBaseUrl(url);
-    const ws = toWsUrl(base);
-    return this.createTransportForUrl(base, ws, databaseId);
-  }
-  async _getReadEndpoint(databaseId, readConcern) {
-    if (this.discovery === "coordinator" && databaseId) {
-      const routing = await this.ensureClusterRouting(databaseId);
-      const concern = readConcern ?? this.readConcern ?? "majority";
-      if (concern === "linearizable") {
-        if (routing.currentPrimary) return routing.currentPrimary;
-        throw new RemoteError("NO_SAFE_PRIMARY", "No current primary is available for linearizable reads");
-      }
-      const readable = routing.readEndpoints.filter((endpoint) => endpoint.readConcerns.includes(concern));
-      const preferredReadable = this.readPreference === "replica" && routing.currentPrimary ? readable.filter((endpoint) => endpoint.url !== routing.currentPrimary) : readable;
-      if (this.readPreference !== "primary" && preferredReadable.length > 0) {
-        if (this.readPreference === "nearest") {
-          return preferredReadable[0].url;
-        }
-        const idx = Math.floor(Math.random() * preferredReadable.length);
-        return preferredReadable[idx].url;
-      }
-      if (routing.currentPrimary) return routing.currentPrimary;
-      const localReadable = routing.readEndpoints.find((endpoint) => endpoint.readConcerns.includes("local"));
-      if (localReadable) return localReadable.url;
-      throw new RemoteError("ROUTING_ERROR", "No usable read endpoint is available");
-    }
-    if (this.readPreference === "primary") {
-      return this.primaryUrl ?? this.baseUrl;
-    }
-    const availableReplicas = this.replicaUrls.filter((r) => !this.removedReplicas.has(r));
-    if (this.readPreference === "replica") {
-      if (availableReplicas.length === 0) {
-        return this.primaryUrl ?? this.baseUrl;
-      }
-      const idx = Math.floor(Math.random() * availableReplicas.length);
-      return availableReplicas[idx];
-    }
-    if (this.readPreference === "nearest") {
-      await this.ensureLatencyMeasured();
-      const reachable = this.latencies.filter((l) => l.reachable && !this.removedReplicas.has(l.url));
-      if (reachable.length === 0) {
-        return this.primaryUrl ?? this.baseUrl;
-      }
-      reachable.sort((a, b) => a.latencyMs - b.latencyMs);
-      return reachable[0].url;
+  async persist() {
+    const port = this.hooks.port();
+    if (port === null || this.pullSeq === null) return;
+    try {
+      await port.setPullState(this.pullSeq, this.pullEpoch);
+    } catch (err) {
+      this.hooks.recordError(err);
     }
-    return this.primaryUrl ?? this.baseUrl;
   }
-  async _getWriteEndpoint(databaseId) {
-    if (this.discovery === "coordinator" && databaseId) {
-      const routing = await this.ensureClusterRouting(databaseId);
-      if (!routing.currentPrimary) {
-        throw new RemoteError("NO_SAFE_PRIMARY", "No current primary is available");
+  async adoptRecordedCursor(port) {
+    try {
+      const recorded = await port.getPullState();
+      if (recorded !== null && (this.pullSeq === null || recorded.seq > this.pullSeq)) {
+        this.pullSeq = recorded.seq;
       }
-      return routing.currentPrimary;
+    } catch (err) {
+      this.hooks.recordError(err);
     }
-    return this.primaryUrl ?? this.baseUrl;
-  }
-  _getReadConcern() {
-    return this.readConcern;
-  }
-  _usesCoordinatorDiscovery() {
-    return this.discovery === "coordinator";
   }
-  _removeReplica(url) {
-    this.removedReplicas.add(url);
+  resumeWatermark() {
+    if (this.stagedSeq !== null && (this.pullSeq === null || this.stagedSeq > this.pullSeq)) {
+      return this.stagedSeq;
+    }
+    return this.pullSeq;
   }
-  async ensureLatencyMeasured() {
-    const now = Date.now();
-    if (this.latencies.length > 0 && now - this.latencyMeasuredAt < this.LATENCY_TTL_MS) {
-      return;
+  handleSubscribed(info) {
+    if (info.maxUnacknowledgedChanges !== void 0 && info.maxUnacknowledgedChanges > 0) {
+      this.serverWindow = info.maxUnacknowledgedChanges;
     }
-    if (this.latencyMeasuring) {
-      await this.latencyMeasuring;
+    if (info.resync) {
+      this.hooks.onResyncRequired();
       return;
     }
-    this.latencyMeasuring = this.measureLatencies();
-    try {
-      await this.latencyMeasuring;
-    } finally {
-      this.latencyMeasuring = null;
+    if (info.epoch !== void 0) {
+      this.pullEpoch = info.epoch;
     }
-  }
-  async measureLatencies() {
-    const allEndpoints = [];
-    if (this.primaryUrl) {
-      allEndpoints.push(this.primaryUrl);
+    if (this.pullSeq === null && this.stagedSeq === null && info.seq !== void 0) {
+      this.pullSeq = info.seq;
     }
-    for (const r of this.replicaUrls) {
-      allEndpoints.push(r);
+    if (this.ackBaseSeq === null) {
+      this.ackBaseSeq = this.resumeWatermark();
     }
-    const results = await Promise.all(
-      allEndpoints.map(async (url) => {
-        const start = performance.now();
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 5e3);
-        const unrefable = timeout;
-        if (typeof unrefable.unref === "function") {
-          unrefable.unref();
+  }
+  handlePullEvent(event) {
+    if (this.failed) return;
+    this.inbox.push(event);
+    void this.pump();
+  }
+  async pump() {
+    if (this.pumping) return;
+    this.pumping = true;
+    try {
+      while (this.inbox.length > 0 && !this.failed) {
+        const port = this.hooks.port();
+        if (port === null) {
+          this.inbox = [];
+          return;
         }
+        const batch = this.inbox.splice(0, STAGE_BATCH_EVENTS);
+        const closesTransaction = batch.some((event) => event.txEnd === true);
         try {
-          const init = { signal: controller.signal };
-          const response = await fetch(`${url}/health`, init);
-          if (!response.ok) {
-            return { url, latencyMs: Number.MAX_SAFE_INTEGER, reachable: false };
+          const staged = await port.stagePulledChanges(batch);
+          if (staged !== null && (this.stagedSeq === null || staged > this.stagedSeq)) {
+            this.stagedSeq = staged;
           }
-          return { url, latencyMs: performance.now() - start, reachable: true };
-        } catch {
-          return { url, latencyMs: Number.MAX_SAFE_INTEGER, reachable: false };
-        } finally {
-          clearTimeout(timeout);
-        }
-      })
-    );
-    this.latencies = results;
-    this.latencyMeasuredAt = Date.now();
-  }
-  async _refreshClusterRouting(databaseId) {
-    const candidates = this.clusterDiscoveryCandidates(databaseId);
-    const encodedId = encodeURIComponent(databaseId);
-    for (const endpoint of candidates) {
-      const base = toServerBaseUrl(endpoint, databaseId);
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), CLUSTER_DISCOVERY_FETCH_TIMEOUT_MS);
-      const unrefable = timeout;
-      unrefable.unref?.();
-      let next = null;
-      try {
-        const response = await fetch(`${base}/db/${encodedId}/cluster`, {
-          headers: this.headers,
-          signal: controller.signal
-        });
-        if (!response.ok) {
-          continue;
-        }
-        const data = await response.json();
-        next = parseClusterRouting(data, databaseId);
-      } catch (err) {
-        if (err instanceof RemoteError && err.code === "INVALID_RESPONSE") {
-          throw err;
-        }
-      } finally {
-        clearTimeout(timeout);
-      }
-      if (!next) {
-        continue;
-      }
-      const previous = this.clusterRouting.get(databaseId);
-      this.clusterRouting.set(databaseId, next);
-      if (clusterRoutingChanged(previous, next)) {
-        try {
-          await this.notifyClusterRoutingChanged(databaseId);
-        } catch (err) {
-          if (previous) {
-            this.clusterRouting.set(databaseId, previous);
-          } else {
-            this.clusterRouting.delete(databaseId);
+          if (closesTransaction) {
+            const appliedThrough = await port.applyStagedPull(this.config.resolver, this.hooks.onChange);
+            if (appliedThrough !== null) {
+              if (this.pullSeq === null || appliedThrough > this.pullSeq) {
+                this.pullSeq = appliedThrough;
+              }
+              this.hooks.onApplySuccess();
+            }
           }
-          throw err;
+        } catch (err) {
+          this.failed = true;
+          this.inbox = [];
+          await this.adoptRecordedCursor(port);
+          this.hooks.onApplyFailure(err);
+          return;
         }
+        this.scheduleAckFlush();
+      }
+    } finally {
+      this.pumping = false;
+    }
+  }
+  scheduleAckFlush() {
+    const configured = this.config.immediateAckAfterChanges ?? (this.serverWindow === null ? DEFAULT_IMMEDIATE_ACK_AFTER_CHANGES : Math.max(1, Math.floor(this.serverWindow / 2)));
+    const threshold = BigInt(configured);
+    const base = this.lastAckedSeq ?? this.ackBaseSeq;
+    const watermark = this.resumeWatermark();
+    const outstanding = watermark !== null && base !== null ? watermark - base : 0n;
+    if (outstanding > threshold) {
+      if (this.ackTimer !== null) {
+        clearTimeout(this.ackTimer);
+        this.ackTimer = null;
       }
+      void this.flushAck();
       return;
     }
-    throw new RemoteError("ROUTING_ERROR", `Could not discover cluster routing for database '${databaseId}'`);
-  }
-  async ensureClusterRouting(databaseId) {
-    const existing = this.clusterRouting.get(databaseId);
-    if (existing) return existing;
-    await this._refreshClusterRouting(databaseId);
-    const refreshed = this.clusterRouting.get(databaseId);
-    if (!refreshed) {
-      throw new RemoteError("ROUTING_ERROR", `Could not discover cluster routing for database '${databaseId}'`);
+    if (this.ackTimer !== null) return;
+    this.ackTimer = setTimeout(() => {
+      this.ackTimer = null;
+      void this.flushAck();
+    }, this.config.ackIntervalMs);
+    unrefTimer(this.ackTimer);
+  }
+  async flushAck() {
+    if (!this.hooks.isRunning()) return;
+    const deviceId = this.deviceId;
+    const transport = this.transport;
+    const seq = this.resumeWatermark();
+    if (deviceId === null || transport === null || seq === null) return;
+    if (this.lastAckedSeq !== null && seq <= this.lastAckedSeq) return;
+    try {
+      await this.persist();
+      await transport.ack(deviceId, seq);
+      this.lastAckedSeq = seq;
+    } catch (err) {
+      this.hooks.recordError(err);
+      this.scheduleAckFlush();
     }
-    return refreshed;
-  }
-  clusterDiscoveryCandidates(databaseId) {
-    const candidates = /* @__PURE__ */ new Set();
-    for (const endpoint of this.starterEndpoints) candidates.add(endpoint);
-    if (this.primaryUrl) candidates.add(this.primaryUrl);
-    for (const endpoint of this.replicaUrls) candidates.add(endpoint);
-    const existing = this.clusterRouting.get(databaseId);
-    if (existing?.currentPrimary) candidates.add(existing.currentPrimary);
-    for (const endpoint of existing?.readEndpoints ?? []) candidates.add(endpoint.url);
-    if (this.baseUrl) candidates.add(this.baseUrl);
-    return [...candidates];
   }
-  _unregisterTopologyTransport(databaseId, transport) {
-    if (this.topologyTransports.get(databaseId) === transport) {
-      this.topologyTransports.delete(databaseId);
-    }
+};
+
+// src/client/sync-push.ts
+function encodeSyncBatch(batch) {
+  return {
+    sourceNodeId: batch.sourceNodeId,
+    batchId: batch.batchId,
+    fromSeq: batch.fromSeq.toString(),
+    toSeq: batch.toSeq.toString(),
+    hlcRange: { min: batch.hlcRange.min, max: batch.hlcRange.max },
+    changes: batch.changes.map((change) => ({
+      table: change.table,
+      operation: change.operation,
+      rowId: change.rowId,
+      primaryKey: encodeTaggedValues(change.primaryKey),
+      hlc: change.hlc,
+      txId: change.txId,
+      nodeId: change.nodeId,
+      newData: change.newData === null ? null : encodeTaggedValues(change.newData),
+      oldData: change.oldData === null ? null : encodeTaggedValues(change.oldData)
+    })),
+    checksum: batch.checksum
+  };
+}
+async function pushSyncBatch(baseUrl, databaseId, batch, headers, timeoutMs, schemaVersion) {
+  const url = `${baseUrl}/db/${encodeURIComponent(databaseId)}/changes`;
+  const body = {
+    batch: encodeSyncBatch(batch),
+    ...schemaVersion !== void 0 ? { schemaVersion } : {}
+  };
+  const data = await postJson(url, body, headers, timeoutMs);
+  const result = data;
+  if (typeof result.applied !== "number" || typeof result.skipped !== "number" || typeof result.conflicts !== "number") {
+    throw new RemoteError("INVALID_RESPONSE", "Changes response must carry applied, skipped, and conflicts counts");
   }
-  async notifyClusterRoutingChanged(databaseId) {
-    const transport = this.topologyTransports.get(databaseId);
-    if (!transport) return;
-    await transport._handleClusterRoutingChanged();
+  return { applied: result.applied, skipped: result.skipped, conflicts: result.conflicts };
+}
+
+// src/client/sync-push-loop.ts
+var PushLoop = class {
+  constructor(config, hooks) {
+    this.config = config;
+    this.hooks = hooks;
+  }
+  timer = null;
+  pushing = false;
+  consecutiveFailures = 0;
+  nextAttemptAt = 0;
+  cursor = 0n;
+  start() {
+    if (this.timer !== null) return;
+    this.timer = setInterval(() => {
+      void this.drain();
+    }, this.config.intervalMs);
+    unrefTimer(this.timer);
+  }
+  stop() {
+    if (this.timer === null) return;
+    clearInterval(this.timer);
+    this.timer = null;
   }
-};
-var TopologyAwareTransport = class {
-  databaseId;
-  client;
-  closed = false;
-  readTransport = null;
-  writeTransport = null;
-  subscriptionTransport = null;
-  readTransportRequest = null;
-  writeTransportRequest = null;
-  subscriptionTransportRequest = null;
-  subscriptionOperation = Promise.resolve();
-  activeSubscriptions = /* @__PURE__ */ new Map();
-  nextSubscriptionId = 0;
-  currentReadUrl = "";
-  currentWriteUrl = "";
-  currentSubscriptionUrl = "";
-  constructor(databaseId, client) {
-    this.databaseId = databaseId;
-    this.client = client;
-  }
-  async query(sql, params) {
-    const readConcern = this.client._getReadConcern();
-    const transport = await this.getReadTransport(readConcern);
-    const endpointUsed = this.currentReadUrl;
-    try {
-      return await transport.query(sql, params, readConcern ? { level: readConcern } : void 0);
-    } catch (err) {
-      if (this.client._usesCoordinatorDiscovery() && shouldRefreshRouting(err)) {
-        await this.client._refreshClusterRouting(this.databaseId);
-        this.readTransport = null;
-        this.currentReadUrl = "";
-        const refreshed = await this.getReadTransport(readConcern);
-        return refreshed.query(sql, params, readConcern ? { level: readConcern } : void 0);
-      }
-      const isTransportError = err instanceof Error && (err.name !== "RemoteError" || err.code === "CONNECTION_ERROR");
-      const writeEndpoint = await this.client._getWriteEndpoint(this.databaseId);
-      if (isTransportError && endpointUsed && endpointUsed !== writeEndpoint) {
-        this.client._removeReplica(endpointUsed);
-        if (this.currentReadUrl === endpointUsed) {
-          this.readTransport = null;
-          this.currentReadUrl = "";
-        }
-        const fallback = await this.getReadTransport();
-        return fallback.query(sql, params);
+  /**
+   * Empties the outbox before a snapshot replaces the database, so local work
+   * reaches the server before the copy overwrites it. A schema refusal is
+   * reconciled once; a device that still cannot push returns rather than
+   * looping, leaving the snapshot to bring it back into line.
+   */
+  async drainFully(port) {
+    let retriedAfterMigration = false;
+    for (; ; ) {
+      try {
+        if (!await this.pushNextBatch(port)) return;
+      } catch (err) {
+        if (!(err instanceof RemoteError) || err.code !== "MIGRATION_REQUIRED") throw err;
+        if (retriedAfterMigration) return;
+        retriedAfterMigration = true;
+        const status = await this.hooks.reconcileSchema().catch(() => "resync-required");
+        if (status === "ahead") throw err;
+        if (status === "resync-required") return;
       }
-      throw err;
     }
   }
-  async execute(sql, params) {
-    const transport = await this.getWriteTransport();
+  async drain() {
+    const port = this.hooks.port();
+    if (this.pushing || !this.hooks.isRunning() || port === null) return;
+    if (Date.now() < this.nextAttemptAt) return;
+    this.pushing = true;
     try {
-      return await transport.execute(sql, params);
-    } catch (err) {
-      if (this.client._usesCoordinatorDiscovery() && shouldRefreshRouting(err)) {
-        await this.client._refreshClusterRouting(this.databaseId);
-        this.writeTransport = null;
-        this.currentWriteUrl = "";
+      while (this.hooks.isRunning()) {
+        const pushed = await this.pushNextBatch(port);
+        if (!pushed) break;
+        this.consecutiveFailures = 0;
+        this.nextAttemptAt = 0;
+        this.hooks.onDrained();
       }
-      throw err;
+    } catch (err) {
+      await this.handleFailure(err);
+    } finally {
+      this.pushing = false;
     }
   }
-  async transaction(statements) {
-    const transport = await this.getWriteTransport();
+  async handleFailure(err) {
+    this.hooks.recordError(err);
+    this.consecutiveFailures += 1;
+    const delay = Math.min(this.config.intervalMs * 2 ** this.consecutiveFailures, this.config.maxRetryDelayMs);
+    this.nextAttemptAt = Date.now() + delay;
+    if (!(err instanceof RemoteError) || err.code !== "MIGRATION_REQUIRED" || !this.hooks.isRunning()) return;
     try {
-      return await transport.transaction(statements);
-    } catch (err) {
-      if (this.client._usesCoordinatorDiscovery() && shouldRefreshRouting(err)) {
-        await this.client._refreshClusterRouting(this.databaseId);
-        this.writeTransport = null;
-        this.currentWriteUrl = "";
+      const status = await this.hooks.reconcileSchema();
+      if (status === "migrated" || status === "in-sync") {
+        this.consecutiveFailures = 0;
+        this.nextAttemptAt = 0;
       }
-      throw err;
-    }
+    } catch (reconcileErr) {
+      this.hooks.recordError(reconcileErr);
+    }
+  }
+  async pushNextBatch(port) {
+    const batch = await port.readOutboxBatch(this.cursor, this.config.batchSize);
+    if (batch === null) return false;
+    await pushSyncBatch(
+      this.config.baseUrl,
+      this.config.databaseId,
+      batch,
+      this.config.headers,
+      this.config.requestTimeout,
+      this.hooks.schemaVersion()
+    );
+    this.cursor = batch.toSeq;
+    await port.setPushCursor(batch.toSeq);
+    port.protectUnpushedChanges(batch.toSeq);
+    return true;
   }
-  async batch(sql, paramsBatch, writeConcern) {
-    const transport = await this.getWriteTransport();
+};
+
+// src/client/sync-resync-scheduler.ts
+var ResyncScheduler = class {
+  constructor(config, hooks) {
+    this.config = config;
+    this.hooks = hooks;
+  }
+  required = false;
+  timer = null;
+  consecutiveFailures = 0;
+  get retryScheduled() {
+    return this.timer !== null;
+  }
+  markRequired() {
+    this.required = true;
+    void this.hooks.port()?.setResyncRequired(true).catch((err) => this.hooks.recordError(err));
     try {
-      return await transport.batch(sql, paramsBatch, writeConcern);
-    } catch (err) {
-      if (this.client._usesCoordinatorDiscovery() && shouldRefreshRouting(err)) {
-        await this.client._refreshClusterRouting(this.databaseId);
-        this.writeTransport = null;
-        this.currentWriteUrl = "";
-      }
-      throw err;
+      this.config.onResyncRequired?.();
+    } catch {
     }
   }
-  async load(sql, paramsBatch, durability, checkpoint) {
-    const transport = await this.getWriteTransport();
+  schedule() {
+    if (this.config.autoResync === false) return;
+    if (this.timer !== null || this.hooks.isSnapshotting()) return;
+    const delay = this.consecutiveFailures === 0 ? 0 : Math.min(this.config.retryDelayMs * 2 ** (this.consecutiveFailures - 1), this.config.maxRetryDelayMs);
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.attempt();
+    }, delay);
+    unrefTimer(this.timer);
+  }
+  cancel() {
+    if (this.timer === null) return;
+    clearTimeout(this.timer);
+    this.timer = null;
+  }
+  recordSuccess() {
+    this.required = false;
+    this.consecutiveFailures = 0;
+  }
+  recordFailure() {
+    this.required = true;
+    this.consecutiveFailures += 1;
+  }
+  complete(outcome) {
     try {
-      return await transport.load(sql, paramsBatch, durability, checkpoint);
-    } catch (err) {
-      if (this.client._usesCoordinatorDiscovery() && shouldRefreshRouting(err)) {
-        await this.client._refreshClusterRouting(this.databaseId);
-        this.writeTransport = null;
-        this.currentWriteUrl = "";
-      }
-      throw err;
+      this.config.onSnapshotComplete?.(outcome);
+    } catch {
     }
   }
-  async subscribe(table, filter, callback, options) {
+  async attempt() {
+    if (!this.hooks.isRunning() || !this.required) return;
     try {
-      return await this.subscribeOnCurrentEndpoint(table, filter, callback, options);
-    } catch (err) {
-      if (this.client._usesCoordinatorDiscovery() && shouldRefreshRouting(err)) {
-        const hadActiveSubscriptions = this.activeSubscriptions.size > 0;
-        if (!hadActiveSubscriptions) {
-          this.closeSubscriptionTransport();
+      await this.hooks.download();
+    } catch {
+      this.schedule();
+    }
+  }
+};
+
+// src/client/sync-controller.ts
+var DEFAULT_BATCH_SIZE = 100;
+var DEFAULT_PUSH_INTERVAL_MS = 1e3;
+var DEFAULT_ACK_INTERVAL_MS = 2e3;
+var DEFAULT_MAX_PUSH_RETRY_DELAY_MS = 3e4;
+var DEFAULT_SNAPSHOT_RETRY_DELAY_MS = 5e3;
+var DEFAULT_MAX_SNAPSHOT_RETRY_DELAY_MS = 3e5;
+var SyncController = class {
+  constructor(db, options) {
+    this.db = db;
+    this.options = options;
+    this.baseUrl = toBaseUrl(options.url);
+    this.pushIntervalMs = options.pushIntervalMs ?? DEFAULT_PUSH_INTERVAL_MS;
+    this.maxPushRetryDelayMs = options.maxPushRetryDelayMs ?? DEFAULT_MAX_PUSH_RETRY_DELAY_MS;
+    this.push = new PushLoop(
+      {
+        baseUrl: this.baseUrl,
+        databaseId: options.databaseId,
+        headers: options.headers,
+        requestTimeout: options.requestTimeout,
+        batchSize: options.batchSize ?? DEFAULT_BATCH_SIZE,
+        intervalMs: this.pushIntervalMs,
+        maxRetryDelayMs: this.maxPushRetryDelayMs
+      },
+      {
+        isRunning: () => this.state === "running",
+        port: () => this.port,
+        schemaVersion: () => this.schemaVersion ?? 0,
+        reconcileSchema: () => this.reconcileSchema(),
+        recordError: (err) => this.recordError(err),
+        onDrained: () => {
+          this.lastError = null;
         }
-        await this.client._refreshClusterRouting(this.databaseId);
-        if (!hadActiveSubscriptions) {
-          this.closeSubscriptionTransport();
+      }
+    );
+    this.pull = new PullStream(
+      {
+        wsBaseUrl: toWsUrl(this.baseUrl),
+        databaseId: options.databaseId,
+        tables: options.tables,
+        headers: options.headers,
+        ackIntervalMs: options.ackIntervalMs ?? DEFAULT_ACK_INTERVAL_MS,
+        requestTimeout: options.requestTimeout,
+        immediateAckAfterChanges: options.immediateAckAfterChanges,
+        resolver: options.resolver
+      },
+      {
+        isRunning: () => this.state === "running",
+        port: () => this.port,
+        onChange: options.onChange,
+        onResyncRequired: () => this.markResyncRequired(),
+        onApplyFailure: (err) => this.handleApplyFailure(err),
+        onApplySuccess: () => {
+          this.consecutivePullFailures = 0;
+        },
+        recordError: (err) => this.recordError(err)
+      }
+    );
+    this.resync = new ResyncScheduler(
+      {
+        autoResync: options.autoResync,
+        retryDelayMs: options.snapshotRetryDelayMs ?? DEFAULT_SNAPSHOT_RETRY_DELAY_MS,
+        maxRetryDelayMs: options.maxSnapshotRetryDelayMs ?? DEFAULT_MAX_SNAPSHOT_RETRY_DELAY_MS,
+        onResyncRequired: options.onResyncRequired,
+        onSnapshotComplete: options.onSnapshotComplete
+      },
+      {
+        isRunning: () => this.state === "running",
+        isSnapshotting: () => this.state === "snapshotting",
+        port: () => this.port,
+        recordError: (err) => this.recordError(err),
+        download: () => this.downloadSnapshot({
+          pageSize: options.snapshotPageSize,
+          onProgress: options.onSnapshotProgress
+        })
+      }
+    );
+  }
+  baseUrl;
+  pushIntervalMs;
+  maxPushRetryDelayMs;
+  pull;
+  push;
+  resync;
+  port = null;
+  deviceId = null;
+  capabilities = null;
+  schemaVersion = null;
+  state = "stopped";
+  pullRetryTimer = null;
+  consecutivePullFailures = 0;
+  lastError = null;
+  async start() {
+    if (this.state === "running" || this.state === "starting") return;
+    this.state = "starting";
+    try {
+      await this.verifyCapabilities();
+      this.pull.stagedStream = this.capabilities?.includes(STAGED_STREAM_CAPABILITY) ?? false;
+      this.port ??= this.db.deviceSync();
+      this.deviceId = (await this.port.identity()).nodeId;
+      this.push.cursor = await this.port.getPushCursor();
+      this.port.protectUnpushedChanges(this.push.cursor);
+      const pullState = await this.port.getPullState();
+      this.pull.pullSeq = pullState?.seq ?? null;
+      this.pull.pullEpoch = pullState?.epoch;
+      if (await this.port.snapshotLoadPending() || await this.port.getResyncRequired()) {
+        this.resync.markRequired();
+      }
+      if (!this.resync.required) {
+        try {
+          await this.reconcileSchema();
+        } catch (err) {
+          this.recordError(err);
+          this.schemaVersion = await this.localSchemaVersion();
         }
-        return this.subscribeOnCurrentEndpoint(table, filter, callback, options);
       }
+      if (!this.resync.required) {
+        await this.openPull();
+      }
+      this.state = "running";
+    } catch (err) {
+      this.teardownStream();
+      this.state = "stopped";
       throw err;
     }
+    this.push.start();
+    void this.push.drain();
+    if (this.resync.required) {
+      this.resync.schedule();
+    }
   }
-  async _handleClusterRoutingChanged() {
-    if (!this.client._usesCoordinatorDiscovery()) return;
-    if (this.activeSubscriptions.size === 0) return;
-    await this.withSubscriptionOperation(() => this.migrateSubscriptionsToCurrentEndpoint());
-  }
-  close() {
-    this.closed = true;
-    const sameTransport = this.readTransport !== null && this.readTransport === this.writeTransport;
-    const subscriptionIsRead = this.subscriptionTransport !== null && this.subscriptionTransport === this.readTransport;
-    const subscriptionIsWrite = this.subscriptionTransport !== null && this.subscriptionTransport === this.writeTransport;
-    for (const subscription of this.activeSubscriptions.values()) {
-      subscription.active = false;
-      subscription.remote = null;
-    }
-    this.activeSubscriptions.clear();
-    if (this.readTransport) {
-      this.readTransport.close();
-      this.readTransport = null;
-    }
-    if (this.writeTransport && !sameTransport) {
-      this.writeTransport.close();
-    }
-    this.writeTransport = null;
-    if (this.subscriptionTransport && !subscriptionIsRead && !subscriptionIsWrite) {
-      this.subscriptionTransport.close();
-    }
-    this.subscriptionTransport = null;
-    this.currentSubscriptionUrl = "";
-    this.client._unregisterTopologyTransport(this.databaseId, this);
-  }
-  async subscribeOnCurrentEndpoint(table, filter, callback, options) {
-    return this.withSubscriptionOperation(async () => {
-      const transport = await this.getSubscriptionTransport(this.client._getReadConcern());
-      const remote = await transport.subscribe(table, filter, callback, options);
-      const subscription = {
-        id: ++this.nextSubscriptionId,
-        table,
-        filter,
-        callback,
-        onReset: options?.onReset,
-        remote,
-        active: true
-      };
-      this.activeSubscriptions.set(subscription.id, subscription);
-      return this.createSubscriptionHandle(subscription);
-    });
+  pause() {
+    if (this.state !== "running") return;
+    this.teardownStream();
+    this.state = "paused";
+    void this.pull.persist();
   }
-  createSubscriptionHandle(subscription) {
+  async resume() {
+    if (this.state !== "paused") return;
+    this.state = "stopped";
+    await this.start();
+  }
+  async stop() {
+    if (this.state === "stopped") return;
+    this.teardownStream();
+    this.state = "stopped";
+    await this.pull.persist();
+  }
+  async status() {
+    const pendingPushCount = this.port ? await this.port.countOutboxPending(this.push.cursor) : 0;
     return {
-      unsubscribe: () => {
-        if (!subscription.active) return;
-        subscription.active = false;
-        this.activeSubscriptions.delete(subscription.id);
-        const remote = subscription.remote;
-        subscription.remote = null;
-        remote?.unsubscribe();
-      }
+      state: this.state,
+      deviceId: this.deviceId,
+      serverCapabilities: this.capabilities,
+      schemaVersion: this.schemaVersion,
+      pendingPushCount,
+      lastPushedSeq: this.push.cursor,
+      lastPulledSeq: this.pull.pullSeq,
+      pushCaughtUp: pendingPushCount === 0,
+      resyncRequired: this.resync.required,
+      lastError: this.lastError
     };
   }
-  async migrateSubscriptionsToCurrentEndpoint() {
-    this.assertOpen();
-    const subscriptions = [...this.activeSubscriptions.values()].filter((subscription) => subscription.active);
-    if (subscriptions.length === 0) return;
-    const readConcern = this.client._getReadConcern();
-    const endpoint = await this.client._getReadEndpoint(this.databaseId, readConcern);
-    this.assertOpen();
-    if (this.subscriptionTransport && this.currentSubscriptionUrl === endpoint) {
-      return;
-    }
-    const nextTransport = this.client._createTransportForEndpoint(endpoint, this.databaseId);
-    const nextSubscriptions = /* @__PURE__ */ new Map();
+  triggerPush() {
+    void this.push.drain();
+  }
+  async verifyCapabilities() {
+    if (this.capabilities !== null) return;
     try {
-      for (const subscription of subscriptions) {
-        if (!subscription.active) continue;
-        const remote = await nextTransport.subscribe(subscription.table, subscription.filter, subscription.callback, {
-          onReset: subscription.onReset
-        });
-        if (!subscription.active) {
-          remote.unsubscribe();
-          continue;
-        }
-        nextSubscriptions.set(subscription.id, remote);
-      }
+      this.capabilities = await verifyDeviceSyncCapabilities({
+        url: this.baseUrl,
+        headers: this.options.headers,
+        requestTimeoutMs: this.options.requestTimeout
+      });
     } catch (err) {
-      for (const remote of nextSubscriptions.values()) {
-        remote.unsubscribe();
-      }
-      nextTransport.close();
-      throw toSubscriptionRoutingError(err, this.databaseId);
-    }
-    const oldTransport = this.subscriptionTransport;
-    this.subscriptionTransport = nextTransport;
-    this.currentSubscriptionUrl = endpoint;
-    for (const subscription of subscriptions) {
-      const nextRemote = nextSubscriptions.get(subscription.id);
-      if (!nextRemote) continue;
-      const previousRemote = subscription.remote;
-      if (!subscription.active) {
-        nextRemote.unsubscribe();
-        continue;
-      }
-      subscription.remote = nextRemote;
-      previousRemote?.unsubscribe();
-    }
-    if (oldTransport) {
-      oldTransport.close();
+      if (err instanceof RemoteError && err.code === "SYNC_UNSUPPORTED") throw err;
+      this.recordError(err);
     }
   }
-  async getReadTransport(readConcern) {
-    this.assertOpen();
-    while (this.readTransportRequest) {
-      await this.readTransportRequest.catch(() => void 0);
-      this.assertOpen();
-    }
-    const request = this.resolveReadTransport(readConcern);
-    this.readTransportRequest = request;
-    try {
-      return await request;
-    } finally {
-      if (this.readTransportRequest === request) {
-        this.readTransportRequest = null;
-      }
-    }
+  async localSchemaVersion() {
+    return highestMigrationVersion(await this.db.appliedMigrations());
   }
-  async resolveReadTransport(readConcern) {
-    const endpoint = await this.client._getReadEndpoint(this.databaseId, readConcern);
-    this.assertOpen();
-    if (this.readTransport && this.currentReadUrl === endpoint) {
-      return this.readTransport;
-    }
-    const nextTransport = this.client._createTransportForEndpoint(endpoint, this.databaseId);
-    const oldTransport = this.readTransport;
-    this.readTransport = nextTransport;
-    this.currentReadUrl = endpoint;
-    if (oldTransport) {
-      oldTransport.close();
+  async reconcileSchema() {
+    const result = await syncDeviceMigrations(this.db, {
+      url: this.baseUrl,
+      databaseId: this.options.databaseId,
+      headers: this.options.headers,
+      requestTimeoutMs: this.options.requestTimeout
+    });
+    this.schemaVersion = result.schemaVersion;
+    if (result.status === "resync-required") {
+      this.markResyncRequired();
+    } else if (result.status === "ahead") {
+      this.lastError = {
+        code: "SCHEMA_AHEAD",
+        message: `Device schema version ${result.schemaVersion} is ahead of server version ${result.serverVersion}`
+      };
     }
-    return this.readTransport;
+    return result.status;
   }
-  async getWriteTransport() {
-    this.assertOpen();
-    while (this.writeTransportRequest) {
-      await this.writeTransportRequest.catch(() => void 0);
-      this.assertOpen();
-    }
-    const request = this.resolveWriteTransport();
-    this.writeTransportRequest = request;
-    try {
-      return await request;
-    } finally {
-      if (this.writeTransportRequest === request) {
-        this.writeTransportRequest = null;
-      }
-    }
+  markResyncRequired() {
+    this.resync.markRequired();
+    this.resync.schedule();
   }
-  async resolveWriteTransport() {
-    const endpoint = await this.client._getWriteEndpoint(this.databaseId);
-    this.assertOpen();
-    if (this.writeTransport && this.currentWriteUrl === endpoint) {
-      return this.writeTransport;
+  async downloadSnapshot(options) {
+    if (this.state === "snapshotting") {
+      throw new Error("A snapshot download is already in progress");
     }
-    const nextTransport = this.client._createTransportForEndpoint(endpoint, this.databaseId);
-    const oldTransport = this.writeTransport;
-    this.writeTransport = nextTransport;
-    this.currentWriteUrl = endpoint;
-    if (oldTransport) {
-      oldTransport.close();
+    if (this.state !== "running" && this.state !== "paused") {
+      throw new Error("Snapshot download requires a started sync controller");
     }
-    return this.writeTransport;
-  }
-  async getSubscriptionTransport(readConcern) {
-    this.assertOpen();
-    if (this.subscriptionTransport) {
-      return this.subscriptionTransport;
+    const port = this.port;
+    if (port === null) {
+      throw new Error("Snapshot download requires a started sync controller");
     }
-    while (this.subscriptionTransportRequest) {
-      await this.subscriptionTransportRequest.catch(() => void 0);
-      this.assertOpen();
-      if (this.subscriptionTransport) {
-        return this.subscriptionTransport;
+    this.teardownStream();
+    this.state = "snapshotting";
+    try {
+      await this.push.drainFully(port);
+      await downloadDatabaseSnapshot(port, {
+        url: this.baseUrl,
+        databaseId: this.options.databaseId,
+        headers: this.options.headers,
+        pageSize: options?.pageSize,
+        requestTimeoutMs: this.options.requestTimeout,
+        onProgress: options?.onProgress ?? this.options.onSnapshotProgress
+      });
+      this.schemaVersion = await this.localSchemaVersion();
+      await port.setResyncRequired(false);
+      this.resync.recordSuccess();
+      this.lastError = null;
+    } catch (err) {
+      const failure = describeError(err);
+      this.lastError = failure;
+      this.resync.recordFailure();
+      const databaseUsable = await this.snapshotGateOpen(port);
+      this.state = "stopped";
+      try {
+        await this.start();
+      } catch {
+        this.state = "paused";
       }
+      this.resync.complete({ ok: false, error: failure, databaseUsable, retrying: this.resync.retryScheduled });
+      throw err;
     }
-    const request = this.resolveSubscriptionTransport(readConcern);
-    this.subscriptionTransportRequest = request;
+    this.state = "stopped";
     try {
-      return await request;
+      await this.start();
     } finally {
-      if (this.subscriptionTransportRequest === request) {
-        this.subscriptionTransportRequest = null;
-      }
-    }
-  }
-  async resolveSubscriptionTransport(readConcern) {
-    if (this.subscriptionTransport) {
-      return this.subscriptionTransport;
-    }
-    const endpoint = await this.client._getReadEndpoint(this.databaseId, readConcern);
-    this.assertOpen();
-    if (this.subscriptionTransport) {
-      return this.subscriptionTransport;
-    }
-    this.subscriptionTransport = this.client._createTransportForEndpoint(endpoint, this.databaseId);
-    this.currentSubscriptionUrl = endpoint;
-    return this.subscriptionTransport;
-  }
-  closeSubscriptionTransport() {
-    if (this.subscriptionTransport) {
-      this.subscriptionTransport.close();
-      this.subscriptionTransport = null;
+      this.resync.complete({ ok: true, error: null, databaseUsable: true, retrying: false });
     }
-    this.currentSubscriptionUrl = "";
   }
-  async withSubscriptionOperation(operation) {
-    const previous = this.subscriptionOperation;
-    let release = () => {
-    };
-    this.subscriptionOperation = new Promise((resolve) => {
-      release = resolve;
-    });
-    await previous.catch(() => void 0);
+  /**
+   * Answers whether the local database serves reads and writes again. A failure
+   * before the wipe begins leaves it intact, while one after it leaves every
+   * statement refused with `SNAPSHOT_IN_PROGRESS` until a later copy succeeds,
+   * so the application learns which of the two it is rather than assuming.
+   */
+  async snapshotGateOpen(port) {
     try {
-      return await operation();
-    } finally {
-      release();
+      return !await port.snapshotLoadPending();
+    } catch {
+      return false;
+    }
+  }
+  recordError(err) {
+    this.lastError = describeError(err);
+  }
+  handleApplyFailure(err) {
+    this.recordError(err);
+    this.pull.teardown();
+    const live = this.state === "running" || this.state === "starting";
+    if (!live || this.pullRetryTimer !== null) return;
+    const delay = Math.min(this.pushIntervalMs * 2 ** this.consecutivePullFailures, this.maxPushRetryDelayMs);
+    this.consecutivePullFailures += 1;
+    this.pullRetryTimer = setTimeout(() => {
+      this.pullRetryTimer = null;
+      void this.reopenPull();
+    }, delay);
+    unrefTimer(this.pullRetryTimer);
+  }
+  async reopenPull() {
+    if (this.state !== "running" || this.deviceId === null || this.resync.required) return;
+    try {
+      await this.openPull();
+    } catch (err) {
+      this.handleApplyFailure(err);
     }
   }
-  assertOpen() {
-    if (this.closed) {
-      throw new RemoteError("TRANSPORT_ERROR", "Transport is closed");
-    }
+  /**
+   * Opens the pull subscription, reconciling migrations when the server refuses
+   * it because this device is behind. A device that only reads never pushes, so
+   * the subscribe refusal is the sole point at which it can learn that the
+   * server has migrated; without this it would retry the same refused
+   * subscription forever and silently receive nothing.
+   */
+  async openPull() {
+    const deviceId = this.deviceId;
+    if (deviceId === null) return;
+    let refusal;
+    try {
+      await this.pull.open(deviceId, this.schemaVersion ?? 0);
+      return;
+    } catch (err) {
+      if (!(err instanceof RemoteError) || err.code !== "MIGRATION_REQUIRED") throw err;
+      this.recordError(err);
+      refusal = err;
+    }
+    const status = await this.reconcileSchema();
+    if (this.resync.required) return;
+    if (status === "ahead") throw refusal;
+    this.pull.teardown();
+    this.lastError = null;
+    await this.pull.open(deviceId, this.schemaVersion ?? 0);
+  }
+  teardownStream() {
+    this.push.stop();
+    this.resync.cancel();
+    if (this.pullRetryTimer !== null) {
+      clearTimeout(this.pullRetryTimer);
+      this.pullRetryTimer = null;
+    }
+    this.pull.teardown();
   }
 };
-function toSubscriptionRoutingError(err, databaseId) {
-  const detail = err instanceof Error ? err.message : String(err);
-  return new RemoteError(
-    "ROUTING_ERROR",
-    `Could not re-establish active subscriptions on refreshed routing for database '${databaseId}': ${detail}`
-  );
-}
-function shouldRefreshRouting(err) {
-  if (!(err instanceof RemoteError)) {
-    return false;
-  }
-  return err.code === "STALE_PRIMARY" || err.code === "AUTHORITY_LOST" || err.code === "COORDINATOR_UNAVAILABLE" || err.code === "NO_SAFE_PRIMARY" || err.code === "CONNECTION_ERROR";
+function describeError(err) {
+  const code = err instanceof Error && "code" in err ? String(err.code) : "UNKNOWN_ERROR";
+  return { code, message: err instanceof Error ? err.message : String(err) };
 }
 
-export { HttpTransport, RemoteDatabase, RemoteError, RemoteSubscriptionBuilderImpl, SirannonClient, WebSocketTransport };
+export { FieldMergeResolver, LWWResolver, PrimaryWinsResolver, SirannonClient, SyncController, downloadDatabaseSnapshot, encodeSyncBatch, pushSyncBatch };