@korajs/store 1.0.0-beta.11 → 1.0.0-beta.13

package/dist/chunk-SJP2HTYZ.js

@@ -0,0 +1,1003 @@
+import {
+  encodeStoredFilterValue
+} from "./chunk-J5AGXF3D.js";
+import {
+  QueryError
+} from "./chunk-DUKTWVZW.js";
+
+// src/lww/row-version.ts
+import { HybridLogicalClock } from "@korajs/core";
+var EMPTY_ROW_VERSION = "";
+function serializeRowVersion(timestamp) {
+  return HybridLogicalClock.serialize(timestamp);
+}
+function rowVersionFromRecord(row) {
+  const version = row._version;
+  if (typeof version === "string" && version.length > 0) {
+    return HybridLogicalClock.deserialize(version);
+  }
+  return { wallTime: row._updated_at, logical: 0, nodeId: "" };
+}
+function isIncomingNewerThanRow(incoming, row) {
+  return HybridLogicalClock.compare(incoming, rowVersionFromRecord(row)) > 0;
+}
+function lwwVersionWhereClause(remoteVersion) {
+  return {
+    sql: "(_version = ? OR _version < ?)",
+    params: [EMPTY_ROW_VERSION, remoteVersion]
+  };
+}
+
+// src/query/sql-builder.ts
+import { quoteIdent } from "@korajs/core";
+function buildSelectQuery(descriptor, fields) {
+  const params = [];
+  const parts = [`SELECT * FROM ${quoteIdent(descriptor.collection)}`];
+  const whereClause = buildWhereClauseParts(descriptor.where, fields, params);
+  const deletedFilter = "_deleted = 0";
+  if (whereClause) {
+    parts.push(`WHERE ${deletedFilter} AND ${whereClause}`);
+  } else {
+    parts.push(`WHERE ${deletedFilter}`);
+  }
+  if (descriptor.orderBy.length > 0) {
+    const orderParts = descriptor.orderBy.map((o) => {
+      validateFieldName(o.field, fields);
+      return `${quoteIdent(resolveColumnName(o.field, fields))} ${sqlSortDirection(o.direction, o.field)}`;
+    });
+    parts.push(`ORDER BY ${orderParts.join(", ")}`);
+  }
+  const limit = descriptor.limit !== void 0 ? assertQueryCount(descriptor.limit, "limit") : null;
+  const offset = descriptor.offset !== void 0 ? assertQueryCount(descriptor.offset, "offset") : null;
+  if (limit !== null) {
+    parts.push("LIMIT ?");
+    params.push(limit);
+  }
+  if (offset !== null) {
+    if (limit === null) parts.push("LIMIT -1");
+    parts.push("OFFSET ?");
+    params.push(offset);
+  }
+  return { sql: parts.join(" "), params };
+}
+function buildCountQuery(descriptor, fields) {
+  const params = [];
+  const parts = [`SELECT COUNT(*) as count FROM ${quoteIdent(descriptor.collection)}`];
+  const whereClause = buildWhereClauseParts(descriptor.where, fields, params);
+  const deletedFilter = "_deleted = 0";
+  if (whereClause) {
+    parts.push(`WHERE ${deletedFilter} AND ${whereClause}`);
+  } else {
+    parts.push(`WHERE ${deletedFilter}`);
+  }
+  return { sql: parts.join(" "), params };
+}
+function buildInsertQuery(collection, record) {
+  const columns = Object.keys(record);
+  const placeholders = columns.map(() => "?");
+  const params = Object.values(record);
+  const quotedColumns = columns.map((col) => quoteIdent(col));
+  const sql = `INSERT INTO ${quoteIdent(collection)} (${quotedColumns.join(", ")}) VALUES (${placeholders.join(", ")})`;
+  return { sql, params };
+}
+function buildUpdateQuery(collection, id, changes) {
+  const setClauses = Object.keys(changes).map((col) => `${quoteIdent(col)} = ?`);
+  const params = [...Object.values(changes), id];
+  const sql = `UPDATE ${quoteIdent(collection)} SET ${setClauses.join(", ")} WHERE id = ?`;
+  return { sql, params };
+}
+function buildFieldFastForwardUpdateQuery(collection, id, fieldChanges, remoteVersion, wallTime, options) {
+  const fieldClauses = Object.keys(fieldChanges).map((col) => `${quoteIdent(col)} = ?`);
+  const setClauses = [
+    ...fieldClauses,
+    "_version = CASE WHEN _version >= ? THEN _version ELSE ? END",
+    "_updated_at = CASE WHEN _updated_at >= ? THEN _updated_at ELSE ? END"
+  ];
+  const params = [
+    ...Object.values(fieldChanges),
+    remoteVersion,
+    remoteVersion,
+    wallTime,
+    wallTime
+  ];
+  if (options?.maxCreatedAt !== void 0) {
+    setClauses.push("_created_at = CASE WHEN _created_at >= ? THEN _created_at ELSE ? END");
+    params.push(options.maxCreatedAt, options.maxCreatedAt);
+  }
+  params.push(id);
+  const sql = `UPDATE ${quoteIdent(collection)} SET ${setClauses.join(", ")} WHERE id = ?`;
+  return { sql, params };
+}
+function buildSoftDeleteQuery(collection, id, updatedAt, version) {
+  if (version !== void 0) {
+    return {
+      sql: `UPDATE ${quoteIdent(collection)} SET _deleted = 1, _updated_at = ?, _version = ? WHERE id = ?`,
+      params: [updatedAt, version, id]
+    };
+  }
+  return {
+    sql: `UPDATE ${quoteIdent(collection)} SET _deleted = 1, _updated_at = ? WHERE id = ?`,
+    params: [updatedAt, id]
+  };
+}
+function buildLwwUpdateQuery(collection, id, changes, remoteVersion) {
+  const setClauses = Object.keys(changes).map((col) => `${quoteIdent(col)} = ?`);
+  const lww = lwwVersionWhereClause(remoteVersion);
+  const sql = `UPDATE ${quoteIdent(collection)} SET ${setClauses.join(", ")} WHERE id = ? AND ${lww.sql}`;
+  const params = [...Object.values(changes), id, ...lww.params];
+  return { sql, params };
+}
+function buildLwwSoftDeleteQuery(collection, id, updatedAt, version) {
+  const lww = lwwVersionWhereClause(version);
+  return {
+    sql: `UPDATE ${quoteIdent(collection)} SET _deleted = 1, _updated_at = ?, _version = ? WHERE id = ? AND ${lww.sql}`,
+    params: [updatedAt, version, id, ...lww.params]
+  };
+}
+function buildWhereClause(where, fields) {
+  const params = [];
+  const result = buildWhereClauseParts(where, fields, params);
+  if (!result) return null;
+  return { sql: result, params };
+}
+var VALID_OPERATORS = /* @__PURE__ */ new Set(["$eq", "$ne", "$gt", "$gte", "$lt", "$lte", "$in"]);
+function buildWhereClauseParts(where, fields, params) {
+  const conditions = [];
+  for (const [fieldName, value] of Object.entries(where)) {
+    validateFieldName(fieldName, fields);
+    const descriptor = fields[fieldName];
+    const column = resolveColumnName(fieldName, fields);
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      const ops = value;
+      for (const [op, opValue] of Object.entries(ops)) {
+        if (!VALID_OPERATORS.has(op)) {
+          throw new QueryError(`Unknown operator "${op}" on field "${fieldName}"`, {
+            field: fieldName,
+            operator: op,
+            validOperators: [...VALID_OPERATORS]
+          });
+        }
+        conditions.push(buildOperatorCondition(fieldName, column, op, opValue, descriptor, params));
+      }
+    } else {
+      conditions.push(buildOperatorCondition(fieldName, column, "$eq", value, descriptor, params));
+    }
+  }
+  if (conditions.length === 0) return null;
+  return conditions.join(" AND ");
+}
+function buildOperatorCondition(fieldName, columnName, operator, value, descriptor, params) {
+  const sqlValue = toSqlFilterValue(value, descriptor);
+  const column = quoteIdent(columnName);
+  switch (operator) {
+    case "$eq":
+      if (sqlValue === null) {
+        return `${column} IS NULL`;
+      }
+      params.push(sqlValue);
+      return `${column} = ?`;
+    case "$ne":
+      if (sqlValue === null) {
+        return `${column} IS NOT NULL`;
+      }
+      params.push(sqlValue);
+      return `${column} != ?`;
+    case "$gt":
+      params.push(sqlValue);
+      return `${column} > ?`;
+    case "$gte":
+      params.push(sqlValue);
+      return `${column} >= ?`;
+    case "$lt":
+      params.push(sqlValue);
+      return `${column} < ?`;
+    case "$lte":
+      params.push(sqlValue);
+      return `${column} <= ?`;
+    case "$in": {
+      if (!Array.isArray(sqlValue)) {
+        throw new QueryError(`$in operator requires an array value for field "${fieldName}"`, {
+          field: fieldName,
+          received: typeof sqlValue
+        });
+      }
+      const placeholders = sqlValue.map(() => "?");
+      for (const item of sqlValue) {
+        params.push(toSqlFilterValue(item, descriptor));
+      }
+      return `${column} IN (${placeholders.join(", ")})`;
+    }
+    default:
+      throw new QueryError(`Unknown operator "${operator}"`, { operator });
+  }
+}
+function toSqlFilterValue(value, descriptor) {
+  if (descriptor?.kind === "boolean" && typeof value === "boolean") return value ? 1 : 0;
+  return encodeStoredFilterValue(value, descriptor);
+}
+var VIRTUAL_TIMESTAMP_FIELDS = Object.freeze({
+  createdAt: "_created_at",
+  updatedAt: "_updated_at"
+});
+var VIRTUAL_TIMESTAMP_FIELD_NAMES = Object.freeze([
+  "createdAt",
+  "updatedAt"
+]);
+var SORT_DIRECTIONS = Object.freeze({
+  asc: "ASC",
+  desc: "DESC"
+});
+function resolveColumnName(fieldName, fields) {
+  if (Object.hasOwn(fields, fieldName)) return fieldName;
+  if (fieldName === "createdAt" || fieldName === "updatedAt") {
+    return VIRTUAL_TIMESTAMP_FIELDS[fieldName];
+  }
+  return fieldName;
+}
+function sqlSortDirection(direction, field) {
+  const key = typeof direction === "string" ? direction.toLowerCase() : "";
+  const keyword = Object.hasOwn(SORT_DIRECTIONS, key) ? SORT_DIRECTIONS[key] : void 0;
+  if (keyword === void 0) {
+    throw new QueryError(`Invalid sort direction for field "${field}". Use 'asc' or 'desc'.`, {
+      field,
+      direction: typeof direction === "string" ? direction.slice(0, 64) : typeof direction
+    });
+  }
+  return keyword;
+}
+function assertQueryCount(value, clause) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new QueryError(
+      `Invalid ${clause}: expected a non-negative safe integer. Pass a whole number, for example .${clause}(10).`,
+      { clause, received: typeof value === "number" ? value : typeof value }
+    );
+  }
+  return value;
+}
+function validateFieldName(fieldName, fields) {
+  const allowedFields = /* @__PURE__ */ new Set([
+    ...Object.keys(fields),
+    "id",
+    ...VIRTUAL_TIMESTAMP_FIELD_NAMES,
+    "_created_at",
+    "_updated_at"
+  ]);
+  if (!allowedFields.has(fieldName)) {
+    throw new QueryError(
+      `Unknown field "${fieldName}" in query. Available fields: ${[...allowedFields].join(", ")}`,
+      { field: fieldName }
+    );
+  }
+}
+
+// src/sync/sync-state.ts
+import { createVersionVector } from "@korajs/core";
+var LAST_ACKED_SERVER_VECTOR_META_KEY = "last_acked_server_vector";
+var DELTA_CURSOR_META_KEY = "delta_cursor";
+var DELIVERY_WATERMARK_META_KEY = "delivery_watermark";
+var NODE_TOKEN_META_KEY = "sync_node_token";
+var AUTHORITATIVE_NODE_IDS_META_KEY = "sync_authoritative_node_ids";
+function serializeVersionVectorToMeta(vector) {
+  const record = {};
+  for (const [nodeId, seq] of vector) {
+    record[nodeId] = seq;
+  }
+  return JSON.stringify(record);
+}
+function deserializeVersionVectorFromMeta(value) {
+  const parsed = JSON.parse(value);
+  const vector = createVersionVector();
+  for (const [nodeId, seq] of Object.entries(parsed)) {
+    if (typeof seq === "number" && seq >= 0) {
+      vector.set(nodeId, seq);
+    }
+  }
+  return vector;
+}
+function mergeVersionVectors(a, b) {
+  const merged = new Map(a);
+  for (const [nodeId, seq] of b) {
+    merged.set(nodeId, Math.max(merged.get(nodeId) ?? 0, seq));
+  }
+  return merged;
+}
+async function collectOperationsAheadOfServer(localVector, serverVector, fetchRange) {
+  const missing = [];
+  for (const [nodeId, localSeq] of localVector) {
+    const serverSeq = serverVector.get(nodeId) ?? 0;
+    if (localSeq > serverSeq) {
+      const ops = await fetchRange(nodeId, serverSeq + 1, localSeq);
+      missing.push(...ops);
+    }
+  }
+  missing.sort((a, b) => a.sequenceNumber - b.sequenceNumber);
+  return missing;
+}
+async function loadLastAckedServerVector(adapter) {
+  const rows = await adapter.query("SELECT value FROM _kora_meta WHERE key = ?", [
+    LAST_ACKED_SERVER_VECTOR_META_KEY
+  ]);
+  const row = rows[0];
+  if (!row?.value) {
+    return createVersionVector();
+  }
+  try {
+    return deserializeVersionVectorFromMeta(row.value);
+  } catch {
+    return createVersionVector();
+  }
+}
+async function saveLastAckedServerVector(adapter, vector) {
+  await adapter.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
+    LAST_ACKED_SERVER_VECTOR_META_KEY,
+    serializeVersionVectorToMeta(vector)
+  ]);
+}
+async function loadNodeToken(adapter, nodeId) {
+  if (nodeId !== void 0) {
+    const own = await adapter.query("SELECT value FROM _kora_meta WHERE key = ?", [
+      nodeTokenKey(nodeId)
+    ]);
+    if (own[0]) return own[0].value;
+    const meta = await adapter.query("SELECT value FROM _kora_meta WHERE key = 'node_id'");
+    if (meta[0]?.value !== nodeId) return null;
+  }
+  const rows = await adapter.query("SELECT value FROM _kora_meta WHERE key = ?", [
+    NODE_TOKEN_META_KEY
+  ]);
+  return rows[0]?.value ?? null;
+}
+function nodeTokenKey(nodeId) {
+  return `${NODE_TOKEN_META_KEY}:${nodeId}`;
+}
+async function saveNodeToken(adapter, token, nodeId) {
+  await adapter.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
+    nodeId === void 0 ? NODE_TOKEN_META_KEY : nodeTokenKey(nodeId),
+    token
+  ]);
+}
+async function loadDeltaCursor(adapter) {
+  const rows = await adapter.query("SELECT value FROM _kora_meta WHERE key = ?", [
+    DELTA_CURSOR_META_KEY
+  ]);
+  return rows[0]?.value ?? null;
+}
+async function saveDeltaCursor(adapter, cursor) {
+  if (cursor === null) {
+    await adapter.execute("DELETE FROM _kora_meta WHERE key = ?", [DELTA_CURSOR_META_KEY]);
+    return;
+  }
+  await adapter.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
+    DELTA_CURSOR_META_KEY,
+    cursor
+  ]);
+}
+function deliveryWatermarkKey(signature) {
+  return signature === "" ? DELIVERY_WATERMARK_META_KEY : `${DELIVERY_WATERMARK_META_KEY}:${signature}`;
+}
+async function loadDeliveryWatermark(adapter, signature) {
+  const rows = await adapter.query("SELECT value FROM _kora_meta WHERE key = ?", [
+    deliveryWatermarkKey(signature)
+  ]);
+  const value = rows[0]?.value;
+  if (value === void 0 || value === null) {
+    return 0;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+}
+async function saveDeliveryWatermark(adapter, signature, watermark) {
+  await adapter.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
+    deliveryWatermarkKey(signature),
+    String(watermark)
+  ]);
+}
+async function deleteDeliveryWatermark(adapter, signature) {
+  await adapter.execute("DELETE FROM _kora_meta WHERE key = ?", [deliveryWatermarkKey(signature)]);
+}
+async function loadAllDeliveryWatermarks(adapter) {
+  const rows = await adapter.query(
+    "SELECT key, value FROM _kora_meta WHERE key = ? OR key LIKE ?",
+    [DELIVERY_WATERMARK_META_KEY, `${DELIVERY_WATERMARK_META_KEY}:%`]
+  );
+  const result = {};
+  const prefix = `${DELIVERY_WATERMARK_META_KEY}:`;
+  for (const row of rows) {
+    const signature = row.key === DELIVERY_WATERMARK_META_KEY ? "" : row.key.slice(prefix.length);
+    const parsed = Number(row.value);
+    if (Number.isFinite(parsed) && parsed >= 0) {
+      result[signature] = parsed;
+    }
+  }
+  return result;
+}
+async function saveAuthoritativeNodeIds(adapter, nodeIds) {
+  await adapter.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
+    AUTHORITATIVE_NODE_IDS_META_KEY,
+    JSON.stringify(nodeIds)
+  ]);
+}
+var REVOKED_AUTHORITATIVE_NODE_IDS_META_KEY = "sync_revoked_authoritative_node_ids";
+async function saveRevokedAuthoritativeNodeIds(adapter, nodeIds) {
+  await adapter.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
+    REVOKED_AUTHORITATIVE_NODE_IDS_META_KEY,
+    JSON.stringify(nodeIds)
+  ]);
+}
+async function loadRevokedAuthoritativeNodeIds(adapter) {
+  const rows = await adapter.query("SELECT value FROM _kora_meta WHERE key = ?", [
+    REVOKED_AUTHORITATIVE_NODE_IDS_META_KEY
+  ]);
+  const raw = rows[0]?.value;
+  if (raw === void 0) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) return parsed.filter((id) => typeof id === "string");
+  } catch {
+  }
+  return [];
+}
+async function loadAuthoritativeNodeIds(adapter) {
+  const rows = await adapter.query("SELECT value FROM _kora_meta WHERE key = ?", [
+    AUTHORITATIVE_NODE_IDS_META_KEY
+  ]);
+  const raw = rows[0]?.value;
+  if (raw === void 0) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed) && parsed.every((id) => typeof id === "string")) {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+
+// src/sync/sync-durability.ts
+var OWN_ACKED_THROUGH_META_KEY = "own_acked_through";
+var ACCEPTED_DOWNLINK_SCOPE_META_KEY = "accepted_downlink_scope";
+var UNAPPLIED_OPS_DDL = "CREATE TABLE IF NOT EXISTS _kora_unapplied_ops (\n  op_id TEXT PRIMARY KEY NOT NULL,\n  collection TEXT NOT NULL,\n  delivery_seq INTEGER,\n  code TEXT NOT NULL,\n  message TEXT NOT NULL,\n  payload TEXT NOT NULL,\n  quarantined_at INTEGER NOT NULL\n)";
+var ensuredAdapters = /* @__PURE__ */ new WeakSet();
+async function ensureUnappliedTable(adapter) {
+  if (ensuredAdapters.has(adapter)) return;
+  await adapter.execute(UNAPPLIED_OPS_DDL);
+  ensuredAdapters.add(adapter);
+}
+async function saveUnappliedOperations(adapter, entries, watermark) {
+  await ensureUnappliedTable(adapter);
+  await adapter.transaction(async (tx) => {
+    for (const entry of entries) {
+      await tx.execute(
+        "INSERT OR REPLACE INTO _kora_unapplied_ops (op_id, collection, delivery_seq, code, message, payload, quarantined_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
+        [
+          entry.operation.id,
+          entry.operation.collection,
+          entry.deliverySequence,
+          entry.code,
+          entry.message,
+          JSON.stringify(entry.operation),
+          entry.quarantinedAt
+        ]
+      );
+    }
+    if (watermark) {
+      await tx.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
+        deliveryWatermarkKey(watermark.signature),
+        String(watermark.watermark)
+      ]);
+    }
+  });
+}
+async function loadUnappliedOperations(adapter) {
+  await ensureUnappliedTable(adapter);
+  const rows = await adapter.query(
+    "SELECT op_id, delivery_seq, code, message, payload, quarantined_at FROM _kora_unapplied_ops ORDER BY delivery_seq ASC, quarantined_at ASC"
+  );
+  return rows.map((row) => ({
+    operation: JSON.parse(row.payload),
+    deliverySequence: row.delivery_seq === null ? null : Number(row.delivery_seq),
+    code: row.code,
+    message: row.message,
+    quarantinedAt: Number(row.quarantined_at)
+  }));
+}
+async function removeUnappliedOperations(adapter, operationIds) {
+  if (operationIds.length === 0) return;
+  await ensureUnappliedTable(adapter);
+  const placeholders = operationIds.map(() => "?").join(", ");
+  await adapter.execute(
+    `DELETE FROM _kora_unapplied_ops WHERE op_id IN (${placeholders})`,
+    operationIds
+  );
+}
+function ownAckedThroughKey(nodeId) {
+  return `${OWN_ACKED_THROUGH_META_KEY}:${nodeId}`;
+}
+function parseLegacyPrefix(value) {
+  if (value === void 0 || value === null) return null;
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed.nodeId !== "string") return null;
+    const sequence = typeof parsed.sequence === "number" && parsed.sequence >= 0 ? parsed.sequence : null;
+    return sequence === null ? null : { nodeId: parsed.nodeId, sequence };
+  } catch {
+    return null;
+  }
+}
+async function loadOwnAckedThrough(adapter, nodeId) {
+  const rows = await adapter.query("SELECT value FROM _kora_meta WHERE key = ?", [
+    OWN_ACKED_THROUGH_META_KEY
+  ]);
+  const legacy = parseLegacyPrefix(rows[0]?.value);
+  if (legacy && legacy.nodeId === nodeId) return legacy.sequence;
+  const own = await adapter.query("SELECT value FROM _kora_meta WHERE key = ?", [
+    ownAckedThroughKey(nodeId)
+  ]);
+  const value = own[0]?.value;
+  if (value === void 0 || value === null) return null;
+  const sequence = Number(value);
+  return Number.isInteger(sequence) && sequence >= 0 ? sequence : null;
+}
+async function saveOwnAckedThrough(adapter, nodeId, sequence) {
+  await adapter.transaction(async (tx) => {
+    const rows = await tx.query("SELECT value FROM _kora_meta WHERE key = ?", [
+      OWN_ACKED_THROUGH_META_KEY
+    ]);
+    const legacy = parseLegacyPrefix(rows[0]?.value);
+    if (legacy === null || legacy.nodeId === nodeId) {
+      await tx.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
+        OWN_ACKED_THROUGH_META_KEY,
+        JSON.stringify({ nodeId, sequence })
+      ]);
+      return;
+    }
+    await tx.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
+      ownAckedThroughKey(nodeId),
+      String(sequence)
+    ]);
+  });
+}
+async function loadAcceptedDownlinkScope(adapter) {
+  const rows = await adapter.query("SELECT value FROM _kora_meta WHERE key = ?", [
+    ACCEPTED_DOWNLINK_SCOPE_META_KEY
+  ]);
+  const value = rows[0]?.value;
+  if (value === void 0 || value === null) return null;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed !== null && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function saveAcceptedDownlinkScope(adapter, scope) {
+  if (scope === null) {
+    await adapter.execute("DELETE FROM _kora_meta WHERE key = ?", [
+      ACCEPTED_DOWNLINK_SCOPE_META_KEY
+    ]);
+    return;
+  }
+  await adapter.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
+    ACCEPTED_DOWNLINK_SCOPE_META_KEY,
+    JSON.stringify(scope)
+  ]);
+}
+
+// src/sync/local-sync-records.ts
+var TERMINAL_REJECTIONS_TABLE = "_kora_terminal_rejections";
+var LOCAL_NODES_TABLE = "_kora_local_nodes";
+var ACCEPTED_CYCLE_META_KEY = "sync_accepted_cycle";
+var TERMINAL_SEED_META_KEY = "terminal_rejections_seeded_v1";
+var NON_TERMINAL_REJECTION_CODES = /* @__PURE__ */ new Set([
+  "SEQUENCE_CONFLICT",
+  "NODE_ID_MISMATCH",
+  "OUT_OF_UPLINK_SCOPE"
+]);
+var TERMINAL_REJECTIONS_DDL = `CREATE TABLE IF NOT EXISTS ${TERMINAL_REJECTIONS_TABLE} (
+  operation_id TEXT PRIMARY KEY NOT NULL,
+  node_id TEXT,
+  sequence_number INTEGER,
+  code TEXT NOT NULL,
+  rejected_at INTEGER NOT NULL
+)`;
+var LOCAL_NODES_DDL = `CREATE TABLE IF NOT EXISTS ${LOCAL_NODES_TABLE} (
+  node_id TEXT PRIMARY KEY NOT NULL,
+  created_at INTEGER NOT NULL,
+  accepted INTEGER NOT NULL DEFAULT 0,
+  held INTEGER NOT NULL DEFAULT 0,
+  refused_cycle INTEGER,
+  principal TEXT,
+  binding TEXT,
+  refused_principals TEXT
+)`;
+var LOCAL_NODE_BINDINGS = ["fresh", "server", "app"];
+var MAX_REFUSED_PRINCIPALS = 32;
+var ADOPTION_SCHEDULE_META_KEY = "sync_adoption_schedule_v1";
+var migratedAdapters = /* @__PURE__ */ new WeakSet();
+async function ensureLocalSyncRecordTables(adapter) {
+  await adapter.execute(TERMINAL_REJECTIONS_DDL);
+  await adapter.execute(LOCAL_NODES_DDL);
+  if (migratedAdapters.has(adapter)) return;
+  const columns = await adapter.query(`PRAGMA table_info(${LOCAL_NODES_TABLE})`);
+  for (const column of ["principal", "binding", "refused_principals"]) {
+    if (!columns.some((existing) => existing.name === column)) {
+      await adapter.execute(`ALTER TABLE ${LOCAL_NODES_TABLE} ADD COLUMN ${column} TEXT`);
+    }
+  }
+  migratedAdapters.add(adapter);
+}
+async function recordTerminalRejections(adapter, entries) {
+  const recordable = entries.filter((entry) => !NON_TERMINAL_REJECTION_CODES.has(entry.code));
+  if (recordable.length === 0) return;
+  await ensureLocalSyncRecordTables(adapter);
+  await adapter.transaction(async (tx) => {
+    for (const entry of recordable) {
+      await tx.execute(
+        `INSERT OR IGNORE INTO ${TERMINAL_REJECTIONS_TABLE} (operation_id, node_id, sequence_number, code, rejected_at) VALUES (?, ?, ?, ?, ?)`,
+        [entry.operationId, entry.nodeId, entry.sequenceNumber, entry.code, entry.rejectedAt]
+      );
+    }
+  });
+}
+async function findTerminalRejections(adapter, operationIds) {
+  const found = /* @__PURE__ */ new Set();
+  if (operationIds.length === 0) return found;
+  const CHUNK = 500;
+  for (let i = 0; i < operationIds.length; i += CHUNK) {
+    const chunk = operationIds.slice(i, i + CHUNK);
+    const rows = await adapter.query(
+      `SELECT operation_id FROM ${TERMINAL_REJECTIONS_TABLE} WHERE operation_id IN (${chunk.map(() => "?").join(", ")})`,
+      chunk
+    );
+    for (const row of rows) found.add(row.operation_id);
+  }
+  return found;
+}
+async function seedTerminalRejectionsOnce(adapter) {
+  await ensureLocalSyncRecordTables(adapter);
+  const done = await adapter.query("SELECT value FROM _kora_meta WHERE key = ?", [
+    TERMINAL_SEED_META_KEY
+  ]);
+  if (done.length > 0) return;
+  const tables = await adapter.query(
+    "SELECT name FROM sqlite_master WHERE type = 'table' AND name = '_kora_sync_rejected'"
+  );
+  await adapter.transaction(async (tx) => {
+    if (tables.length > 0) {
+      const placeholders = [...NON_TERMINAL_REJECTION_CODES].map(() => "?").join(", ");
+      await tx.execute(
+        `INSERT OR IGNORE INTO ${TERMINAL_REJECTIONS_TABLE} (operation_id, node_id, sequence_number, code, rejected_at)
+         SELECT operation_id, NULL, NULL, code, rejected_at FROM _kora_sync_rejected
+         WHERE retriable = 0 AND code NOT IN (${placeholders})`,
+        [...NON_TERMINAL_REJECTION_CODES]
+      );
+    }
+    await tx.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
+      TERMINAL_SEED_META_KEY,
+      String(Date.now())
+    ]);
+  });
+}
+function rowToRecord(row) {
+  return {
+    nodeId: row.node_id,
+    createdAt: Number(row.created_at),
+    accepted: Number(row.accepted) === 1,
+    held: Number(row.held) === 1,
+    refusedCycle: row.refused_cycle === null ? null : Number(row.refused_cycle),
+    principal: typeof row.principal === "string" ? row.principal : null,
+    binding: typeof row.principal === "string" && LOCAL_NODE_BINDINGS.includes(row.binding) ? row.binding : null,
+    refusedPrincipals: parsePrincipalList(row.refused_principals)
+  };
+}
+function parsePrincipalList(value) {
+  if (typeof value !== "string" || value.length === 0) return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((entry) => typeof entry === "string") : [];
+  } catch {
+    return [];
+  }
+}
+async function registerLocalNode(adapter, nodeId) {
+  await ensureLocalSyncRecordTables(adapter);
+  const existing = await adapter.query(
+    `SELECT node_id FROM ${LOCAL_NODES_TABLE} WHERE node_id = ?`,
+    [nodeId]
+  );
+  if (existing.length > 0) return;
+  const accepted = await hasSyncHistory(adapter, nodeId);
+  await adapter.execute(
+    `INSERT OR IGNORE INTO ${LOCAL_NODES_TABLE} (node_id, created_at, accepted, held, refused_cycle) VALUES (?, ?, ?, 0, NULL)`,
+    [nodeId, Date.now(), accepted ? 1 : 0]
+  );
+}
+async function hasSyncHistory(adapter, nodeId) {
+  const rows = await adapter.query(
+    "SELECT key, value FROM _kora_meta WHERE key IN (?, ?, ?)",
+    [NODE_TOKEN_META_KEY, nodeTokenKey(nodeId), OWN_ACKED_THROUGH_META_KEY]
+  );
+  const nodeIdRows = await adapter.query(
+    "SELECT value FROM _kora_meta WHERE key = 'node_id'"
+  );
+  const isMetaNode = nodeIdRows[0]?.value === nodeId;
+  for (const row of rows) {
+    if (row.key === nodeTokenKey(nodeId)) return true;
+    if (row.key === NODE_TOKEN_META_KEY) {
+      if (isMetaNode) return true;
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(row.value);
+      if (row.key === OWN_ACKED_THROUGH_META_KEY) {
+        if (parsed.nodeId === nodeId && typeof parsed.sequence === "number" && parsed.sequence > 0)
+          return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+async function listLocalNodes(adapter) {
+  const rows = await adapter.query(
+    `SELECT node_id, created_at, accepted, held, refused_cycle, principal, binding, refused_principals FROM ${LOCAL_NODES_TABLE} ORDER BY created_at ASC, node_id ASC`
+  );
+  return rows.map(rowToRecord);
+}
+async function readAcceptedCycle(tx) {
+  const rows = await tx.query("SELECT value FROM _kora_meta WHERE key = ?", [
+    ACCEPTED_CYCLE_META_KEY
+  ]);
+  const value = Number(rows[0]?.value ?? 0);
+  return Number.isFinite(value) ? value : 0;
+}
+async function markLocalNodeAccepted(adapter, nodeId) {
+  await ensureLocalSyncRecordTables(adapter);
+  await adapter.transaction(async (tx) => {
+    const cycle = await readAcceptedCycle(tx);
+    await tx.execute(
+      `INSERT INTO ${LOCAL_NODES_TABLE} (node_id, created_at, accepted, held, refused_cycle) VALUES (?, ?, 1, 0, NULL)
+       ON CONFLICT(node_id) DO UPDATE SET accepted = 1, held = 0, refused_cycle = NULL`,
+      [nodeId, Date.now()]
+    );
+    await tx.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
+      ACCEPTED_CYCLE_META_KEY,
+      String(cycle + 1)
+    ]);
+  });
+}
+async function markLocalNodeRefused(adapter, nodeId, held) {
+  await ensureLocalSyncRecordTables(adapter);
+  await adapter.transaction(async (tx) => {
+    const cycle = await readAcceptedCycle(tx);
+    await tx.execute(
+      `INSERT INTO ${LOCAL_NODES_TABLE} (node_id, created_at, accepted, held, refused_cycle) VALUES (?, ?, 0, ?, ?)
+       ON CONFLICT(node_id) DO UPDATE SET held = MAX(held, excluded.held), refused_cycle = excluded.refused_cycle`,
+      [nodeId, Date.now(), held ? 1 : 0, cycle]
+    );
+  });
+}
+async function forgetLocalNode(adapter, nodeId) {
+  await ensureLocalSyncRecordTables(adapter);
+  await adapter.execute(
+    `DELETE FROM ${LOCAL_NODES_TABLE} WHERE node_id = ? AND held = 0 AND node_id NOT IN (SELECT value FROM _kora_meta WHERE key = 'node_id')`,
+    [nodeId]
+  );
+}
+async function setLocalNodePrincipal(adapter, nodeId, principal, binding) {
+  await ensureLocalSyncRecordTables(adapter);
+  await adapter.execute(
+    `INSERT INTO ${LOCAL_NODES_TABLE} (node_id, created_at, accepted, held, refused_cycle, principal, binding) VALUES (?, ?, 0, 0, NULL, ?, ?)
+       ON CONFLICT(node_id) DO UPDATE SET principal = excluded.principal, binding = excluded.binding`,
+    [nodeId, Date.now(), principal, binding]
+  );
+}
+function isGuessedBinding(node) {
+  return node.principal !== null && (node.binding === null || node.binding === "app");
+}
+async function findLocalNode(adapter, nodeId) {
+  const rows = await adapter.query(
+    `SELECT node_id, created_at, accepted, held, refused_cycle, principal, binding, refused_principals FROM ${LOCAL_NODES_TABLE} WHERE node_id = ?`,
+    [nodeId]
+  );
+  const row = rows[0];
+  return row ? rowToRecord(row) : null;
+}
+async function confirmLocalNodePrincipal(adapter, nodeId, principal) {
+  await ensureLocalSyncRecordTables(adapter);
+  await adapter.transaction(async (tx) => {
+    const node = await findLocalNode(tx, nodeId);
+    if (node && node.principal !== null && node.principal !== principal && !isGuessedBinding(node))
+      return;
+    await tx.execute(
+      `INSERT INTO ${LOCAL_NODES_TABLE} (node_id, created_at, accepted, held, refused_cycle, principal, binding) VALUES (?, ?, 0, 0, NULL, ?, 'server')
+       ON CONFLICT(node_id) DO UPDATE SET principal = excluded.principal, binding = 'server', refused_principals = NULL`,
+      [nodeId, Date.now(), principal]
+    );
+  });
+}
+async function recordLocalNodeRefusedFor(adapter, nodeId, principal) {
+  await ensureLocalSyncRecordTables(adapter);
+  await adapter.transaction(async (tx) => {
+    const node = await findLocalNode(tx, nodeId);
+    if (!node) return;
+    if (node.principal !== null && !isGuessedBinding(node)) return;
+    const refused = node.refusedPrincipals.filter((entry) => entry !== principal);
+    refused.push(principal);
+    await tx.execute(
+      `UPDATE ${LOCAL_NODES_TABLE} SET principal = NULL, binding = NULL, refused_principals = ? WHERE node_id = ?`,
+      [JSON.stringify(refused.slice(-MAX_REFUSED_PRINCIPALS)), nodeId]
+    );
+  });
+}
+async function assignLocalNodePrincipal(adapter, nodeId, principal) {
+  await ensureLocalSyncRecordTables(adapter);
+  let assigned = false;
+  await adapter.transaction(async (tx) => {
+    const node = await findLocalNode(tx, nodeId);
+    if (!node || node.principal !== null || node.refusedPrincipals.includes(principal)) return;
+    await tx.execute(
+      `UPDATE ${LOCAL_NODES_TABLE} SET principal = ?, binding = 'app', held = 0, refused_cycle = NULL WHERE node_id = ?`,
+      [principal, nodeId]
+    );
+    assigned = true;
+  });
+  return assigned;
+}
+async function dropLocalNode(adapter, nodeId) {
+  await ensureLocalSyncRecordTables(adapter);
+  await adapter.execute(
+    `DELETE FROM ${LOCAL_NODES_TABLE} WHERE node_id = ? AND node_id NOT IN (SELECT value FROM _kora_meta WHERE key = 'node_id')`,
+    [nodeId]
+  );
+}
+async function loadAdoptionSchedule(adapter) {
+  const rows = await adapter.query("SELECT value FROM _kora_meta WHERE key = ?", [
+    ADOPTION_SCHEDULE_META_KEY
+  ]);
+  const empty = { progress: 0, parked: {} };
+  const raw = rows[0]?.value;
+  if (!raw) return empty;
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      progress: typeof parsed.progress === "number" ? parsed.progress : 0,
+      parked: parsed.parked && typeof parsed.parked === "object" ? parsed.parked : {}
+    };
+  } catch {
+    return empty;
+  }
+}
+async function saveAdoptionSchedule(adapter, schedule) {
+  await adapter.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
+    ADOPTION_SCHEDULE_META_KEY,
+    JSON.stringify(schedule)
+  ]);
+}
+async function loadAcceptedCycle(adapter) {
+  const rows = await adapter.query("SELECT value FROM _kora_meta WHERE key = ?", [
+    ACCEPTED_CYCLE_META_KEY
+  ]);
+  const value = Number(rows[0]?.value ?? 0);
+  return Number.isFinite(value) ? value : 0;
+}
+async function hasUnsyncedOwnOperations(db) {
+  const tables = new Set(
+    (await db.query("SELECT name FROM sqlite_master WHERE type = 'table'")).map(
+      (row) => row.name
+    )
+  );
+  const opsTables = [...tables].filter((name) => name.startsWith("_kora_ops_"));
+  if (opsTables.length === 0 || !tables.has("_kora_meta")) return false;
+  const nodes = /* @__PURE__ */ new Set();
+  if (tables.has(LOCAL_NODES_TABLE)) {
+    for (const row of await db.query(
+      `SELECT node_id FROM ${LOCAL_NODES_TABLE}`
+    )) {
+      nodes.add(row.node_id);
+    }
+  }
+  const meta = await db.query(
+    "SELECT key, value FROM _kora_meta WHERE key = 'node_id' OR key = ? OR key LIKE ?",
+    [OWN_ACKED_THROUGH_META_KEY, `${OWN_ACKED_THROUGH_META_KEY}:%`]
+  );
+  const prefixes = /* @__PURE__ */ new Map();
+  for (const row of meta) {
+    if (row.key === "node_id") {
+      nodes.add(row.value);
+    } else if (row.key === OWN_ACKED_THROUGH_META_KEY) {
+      try {
+        const parsed = JSON.parse(row.value);
+        if (typeof parsed.nodeId === "string") {
+          nodes.add(parsed.nodeId);
+          if (typeof parsed.sequence === "number") prefixes.set(parsed.nodeId, parsed.sequence);
+        }
+      } catch {
+      }
+    } else {
+      const nodeId = row.key.slice(OWN_ACKED_THROUGH_META_KEY.length + 1);
+      const sequence = Number(row.value);
+      if (!prefixes.has(nodeId) && Number.isInteger(sequence)) prefixes.set(nodeId, sequence);
+    }
+  }
+  const exclude = tables.has(TERMINAL_REJECTIONS_TABLE) ? ` AND id NOT IN (SELECT operation_id FROM ${TERMINAL_REJECTIONS_TABLE})` : "";
+  for (const nodeId of nodes) {
+    const prefix = prefixes.get(nodeId) ?? 0;
+    for (const table of opsTables) {
+      const rows = await db.query(
+        `SELECT COUNT(*) AS n FROM "${table.replace(/"/g, '""')}" WHERE node_id = ? AND sequence_number > ?${exclude}`,
+        [nodeId, prefix]
+      );
+      if (Number(rows[0]?.n ?? 0) > 0) return true;
+    }
+  }
+  return false;
+}
+
+export {
+  EMPTY_ROW_VERSION,
+  serializeRowVersion,
+  rowVersionFromRecord,
+  isIncomingNewerThanRow,
+  buildSelectQuery,
+  buildCountQuery,
+  buildInsertQuery,
+  buildUpdateQuery,
+  buildFieldFastForwardUpdateQuery,
+  buildSoftDeleteQuery,
+  buildLwwUpdateQuery,
+  buildLwwSoftDeleteQuery,
+  buildWhereClause,
+  VIRTUAL_TIMESTAMP_FIELDS,
+  VIRTUAL_TIMESTAMP_FIELD_NAMES,
+  LAST_ACKED_SERVER_VECTOR_META_KEY,
+  DELTA_CURSOR_META_KEY,
+  DELIVERY_WATERMARK_META_KEY,
+  NODE_TOKEN_META_KEY,
+  serializeVersionVectorToMeta,
+  deserializeVersionVectorFromMeta,
+  mergeVersionVectors,
+  collectOperationsAheadOfServer,
+  loadLastAckedServerVector,
+  saveLastAckedServerVector,
+  loadNodeToken,
+  nodeTokenKey,
+  saveNodeToken,
+  loadDeltaCursor,
+  saveDeltaCursor,
+  loadDeliveryWatermark,
+  saveDeliveryWatermark,
+  deleteDeliveryWatermark,
+  loadAllDeliveryWatermarks,
+  saveAuthoritativeNodeIds,
+  saveRevokedAuthoritativeNodeIds,
+  loadRevokedAuthoritativeNodeIds,
+  loadAuthoritativeNodeIds,
+  saveUnappliedOperations,
+  loadUnappliedOperations,
+  removeUnappliedOperations,
+  loadOwnAckedThrough,
+  saveOwnAckedThrough,
+  loadAcceptedDownlinkScope,
+  saveAcceptedDownlinkScope,
+  TERMINAL_REJECTIONS_TABLE,
+  ensureLocalSyncRecordTables,
+  recordTerminalRejections,
+  findTerminalRejections,
+  seedTerminalRejectionsOnce,
+  registerLocalNode,
+  listLocalNodes,
+  markLocalNodeAccepted,
+  markLocalNodeRefused,
+  forgetLocalNode,
+  setLocalNodePrincipal,
+  confirmLocalNodePrincipal,
+  recordLocalNodeRefusedFor,
+  assignLocalNodePrincipal,
+  dropLocalNode,
+  loadAdoptionSchedule,
+  saveAdoptionSchedule,
+  loadAcceptedCycle,
+  hasUnsyncedOwnOperations
+};
+//# sourceMappingURL=chunk-SJP2HTYZ.js.map