@korajs/store 1.0.0-beta.12 → 1.0.0-beta.14

package/dist/chunk-UC2LGFPV.js

@@ -0,0 +1,810 @@
+import {
+  COMPACTED_THROUGH_TABLE,
+  FOLD_BASE_TABLE,
+  FOLD_SNAPSHOT_TABLE,
+  SEQ_CONFLICTS_TABLE
+} from "./chunk-KTVNANUH.js";
+import {
+  TERMINAL_REJECTIONS_TABLE
+} from "./chunk-QW4UU7NG.js";
+import {
+  deserializeOperation,
+  deserializeOperationWithCollection,
+  serializeOperation
+} from "./chunk-J5AGXF3D.js";
+
+// src/backup/backup.ts
+import { HybridLogicalClock as HybridLogicalClock2, KoraError, quoteIdent as quoteIdent2 } from "@korajs/core";
+
+// src/compaction/types.ts
+var COMPACTION_BASELINE_META_KEY = "compaction_baseline_at";
+
+// src/log-integrity/log-integrity.ts
+import { HybridLogicalClock, quoteIdent } from "@korajs/core";
+var LOG_QUARANTINE_TABLE = "_kora_log_quarantine";
+var QUARANTINE_DDL = `CREATE TABLE IF NOT EXISTS ${LOG_QUARANTINE_TABLE} (
+  collection TEXT NOT NULL,
+  operation_id TEXT NOT NULL,
+  node_id TEXT,
+  sequence_number INTEGER,
+  problem TEXT NOT NULL,
+  detail TEXT NOT NULL,
+  row_json TEXT NOT NULL,
+  quarantined_at INTEGER NOT NULL,
+  PRIMARY KEY (collection, operation_id)
+)`;
+var OPERATION_TYPES = /* @__PURE__ */ new Set(["insert", "update", "delete"]);
+var CANONICAL_TIMESTAMP = /^\d{15}:\d{5}:.+$/;
+var PAGE_SIZE = 500;
+var SUSPECT_WHERE = `id IS NULL OR node_id IS NULL OR record_id IS NULL
+ OR type NOT IN ('insert', 'update', 'delete')
+ OR typeof(sequence_number) != 'integer' OR sequence_number < 1
+ OR typeof(timestamp) != 'text' OR length(timestamp) < 23
+ OR substr(timestamp, 16, 1) != ':' OR substr(timestamp, 22, 1) != ':'
+ OR substr(timestamp, 1, 15) GLOB '*[^0-9]*' OR substr(timestamp, 17, 5) GLOB '*[^0-9]*'
+ OR causal_deps IS NULL
+ OR (CASE WHEN json_valid(causal_deps) THEN json_type(causal_deps) != 'array' ELSE 1 END)
+ OR (data IS NOT NULL AND (CASE WHEN json_valid(data) THEN json_type(data) != 'object' ELSE 1 END))
+ OR (previous_data IS NOT NULL AND (CASE WHEN json_valid(previous_data) THEN json_type(previous_data) != 'object' ELSE 1 END))`;
+async function scanLogIntegrity(adapter, schema, options) {
+  const repair = options.repair ?? true;
+  let mode = options.mode ?? "full";
+  await adapter.execute(QUARANTINE_DDL);
+  const actions = [];
+  let checkedRows = 0;
+  for (const collection of Object.keys(schema.collections)) {
+    const table = quoteIdent(`_kora_ops_${collection}`);
+    let rows = null;
+    if (mode === "quick") {
+      try {
+        rows = await adapter.query(
+          `SELECT rowid AS __rowid, * FROM ${table} WHERE ${SUSPECT_WHERE}`
+        );
+      } catch {
+        mode = "full";
+      }
+    }
+    if (rows !== null) {
+      for (const row of rows) {
+        checkedRows++;
+        const verdict = checkOperationRow(row);
+        if (verdict.kind !== "ok") actions.push({ collection, row, verdict });
+      }
+      continue;
+    }
+    let after = 0;
+    for (; ; ) {
+      const page = await adapter.query(
+        `SELECT rowid AS __rowid, * FROM ${table} WHERE rowid > ? ORDER BY rowid LIMIT ${PAGE_SIZE}`,
+        [after]
+      );
+      for (const row of page) {
+        checkedRows++;
+        const verdict = checkOperationRow(row);
+        if (verdict.kind !== "ok") actions.push({ collection, row, verdict });
+      }
+      if (page.length < PAGE_SIZE) break;
+      after = page[page.length - 1]?.__rowid ?? after;
+    }
+  }
+  const repaired = [];
+  const newlyQuarantined = [];
+  for (const { collection, row, verdict } of actions) {
+    if (verdict.kind === "ok") continue;
+    const entry = describeRow(collection, row, verdict.problem, verdict.detail);
+    if (verdict.kind === "repair") repaired.push(entry);
+    else newlyQuarantined.push(entry);
+  }
+  if (repair && actions.length > 0) {
+    const now = Date.now();
+    await adapter.transaction(async (tx) => {
+      for (const { collection, row, verdict } of actions) {
+        const table = quoteIdent(`_kora_ops_${collection}`);
+        if (verdict.kind === "repair") {
+          await tx.execute(`UPDATE ${table} SET timestamp = ? WHERE rowid = ?`, [
+            verdict.timestamp,
+            row.__rowid
+          ]);
+        } else if (verdict.kind === "quarantine") {
+          await quarantineRow(tx, collection, row, verdict.problem, verdict.detail, now);
+          await tx.execute(`DELETE FROM ${table} WHERE rowid = ?`, [row.__rowid]);
+        }
+      }
+    });
+  }
+  const quarantined = await loadQuarantine(adapter);
+  const gaps = await findOwnSequenceGaps(adapter, schema, options.localNodeIds);
+  const compactedAt = await loadCompactedAt(adapter);
+  const pendingQuarantine = repair ? 0 : newlyQuarantined.length;
+  return {
+    clean: quarantined.length === 0 && pendingQuarantine === 0 && gaps.length === 0,
+    mode,
+    checkedRows,
+    repaired,
+    newlyQuarantined,
+    quarantined,
+    gaps,
+    compactedAt,
+    repairApplied: repair
+  };
+}
+function checkOperationRow(row) {
+  if (!isNonEmptyString(row.id) || !isNonEmptyString(row.node_id) || !isNonEmptyString(row.record_id)) {
+    return {
+      kind: "quarantine",
+      problem: "identity-malformed",
+      detail: "id, node_id or record_id is missing"
+    };
+  }
+  if (!OPERATION_TYPES.has(row.type)) {
+    return {
+      kind: "quarantine",
+      problem: "type-invalid",
+      detail: `type ${JSON.stringify(row.type)}`
+    };
+  }
+  if (!Number.isInteger(row.sequence_number) || row.sequence_number < 1) {
+    return {
+      kind: "quarantine",
+      problem: "sequence-invalid",
+      detail: `sequence_number ${JSON.stringify(row.sequence_number)}`
+    };
+  }
+  if (!isJsonObjectOrNull(row.data) || !isJsonObjectOrNull(row.previous_data)) {
+    return {
+      kind: "quarantine",
+      problem: "data-malformed",
+      detail: "data or previous_data is not a JSON object"
+    };
+  }
+  if (!isJsonStringArray(row.causal_deps)) {
+    return {
+      kind: "quarantine",
+      problem: "causal-deps-malformed",
+      detail: `causal_deps ${truncate(String(row.causal_deps))}`
+    };
+  }
+  let timestamp = row.timestamp;
+  let repairedFrom = null;
+  if (!isCanonicalTimestamp(timestamp)) {
+    const recovered = recoverTimestamp(timestamp);
+    if (recovered === null) {
+      return {
+        kind: "quarantine",
+        problem: "timestamp-malformed",
+        detail: `timestamp ${truncate(String(timestamp))}`
+      };
+    }
+    repairedFrom = String(timestamp);
+    timestamp = recovered;
+  }
+  try {
+    const op = deserializeOperation({ ...row, timestamp });
+    const again = serializeOperation({ ...op, collection: "" });
+    if (again.timestamp !== timestamp) {
+      throw new Error(`timestamp ${again.timestamp} != ${timestamp}`);
+    }
+  } catch (error) {
+    return {
+      kind: "quarantine",
+      problem: "round-trip-failed",
+      detail: error instanceof Error ? error.message : String(error)
+    };
+  }
+  if (repairedFrom !== null) {
+    return {
+      kind: "repair",
+      problem: "timestamp-json",
+      detail: `timestamp ${truncate(repairedFrom)} -> ${timestamp}`,
+      timestamp
+    };
+  }
+  return { kind: "ok" };
+}
+function isCanonicalTimestamp(value) {
+  if (typeof value !== "string" || !CANONICAL_TIMESTAMP.test(value)) return false;
+  try {
+    return HybridLogicalClock.serialize(HybridLogicalClock.deserialize(value)) === value;
+  } catch {
+    return false;
+  }
+}
+function recoverTimestamp(value) {
+  if (typeof value !== "string" || !value.startsWith("{")) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    return null;
+  }
+  let candidate = parsed;
+  for (let depth = 0; depth < 8; depth++) {
+    if (candidate === null || typeof candidate !== "object") return null;
+    const { wallTime, logical, nodeId } = candidate;
+    if (Number.isInteger(wallTime) && Number.isInteger(logical) && isNonEmptyString(nodeId)) {
+      try {
+        return HybridLogicalClock.serialize({
+          wallTime,
+          logical,
+          nodeId
+        });
+      } catch {
+        return null;
+      }
+    }
+    if (wallTime !== null || !Number.isInteger(logical) || typeof nodeId !== "string") return null;
+    const match = /^(\d+),"nodeId":(".*")\}$/.exec(nodeId);
+    if (!match?.[1] || !match[2]) return null;
+    let innerNode;
+    try {
+      innerNode = JSON.parse(match[2]);
+    } catch {
+      return null;
+    }
+    candidate = { wallTime: logical, logical: Number(match[1]), nodeId: innerNode };
+  }
+  return null;
+}
+async function quarantineRow(tx, collection, row, problem, detail, now) {
+  const { __rowid: _rowid, ...original } = row;
+  await tx.execute(
+    `INSERT OR REPLACE INTO ${LOG_QUARANTINE_TABLE} (collection, operation_id, node_id, sequence_number, problem, detail, row_json, quarantined_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      collection,
+      typeof row.id === "string" ? row.id : `rowid:${row.__rowid}`,
+      typeof row.node_id === "string" ? row.node_id : null,
+      Number.isInteger(row.sequence_number) ? row.sequence_number : null,
+      problem,
+      detail,
+      JSON.stringify(original, bytesReplacer),
+      now
+    ]
+  );
+}
+async function loadQuarantine(adapter) {
+  const rows = await adapter.query(
+    `SELECT collection, operation_id, node_id, sequence_number, problem, detail FROM ${LOG_QUARANTINE_TABLE} ORDER BY quarantined_at ASC, collection ASC, operation_id ASC`
+  );
+  return rows.map((row) => ({
+    collection: row.collection,
+    operationId: row.operation_id,
+    nodeId: row.node_id,
+    sequenceNumber: row.sequence_number,
+    problem: row.problem,
+    detail: row.detail
+  }));
+}
+async function findOwnSequenceGaps(adapter, schema, nodeIds) {
+  const collections = Object.keys(schema.collections);
+  if (collections.length === 0) return [];
+  const gaps = [];
+  const union = collections.map((c) => `SELECT sequence_number FROM ${quoteIdent(`_kora_ops_${c}`)} WHERE node_id = ?`).join(" UNION ALL ");
+  for (const nodeId of [...new Set(nodeIds)]) {
+    const params = collections.map(() => nodeId);
+    const summary = await adapter.query(
+      `SELECT COUNT(DISTINCT sequence_number) AS n, MAX(sequence_number) AS m FROM (${union})`,
+      params
+    );
+    const count = summary[0]?.n ?? 0;
+    const max = summary[0]?.m ?? 0;
+    if (max === null || max === 0 || count === max) continue;
+    const present = await adapter.query(
+      `SELECT DISTINCT sequence_number FROM (${union}) ORDER BY sequence_number ASC`,
+      params
+    );
+    let expected = 1;
+    for (const { sequence_number: seq } of present) {
+      if (seq > expected) gaps.push({ nodeId, from: expected, to: seq - 1 });
+      expected = Math.max(expected, seq + 1);
+    }
+  }
+  return gaps;
+}
+async function loadCompactedAt(adapter) {
+  const rows = await adapter.query("SELECT value FROM _kora_meta WHERE key = ?", [
+    COMPACTION_BASELINE_META_KEY
+  ]);
+  const value = Number(rows[0]?.value);
+  return rows[0] && Number.isFinite(value) ? value : null;
+}
+function describeRow(collection, row, problem, detail) {
+  return {
+    collection,
+    operationId: typeof row.id === "string" ? row.id : "",
+    nodeId: typeof row.node_id === "string" ? row.node_id : null,
+    sequenceNumber: Number.isInteger(row.sequence_number) ? row.sequence_number : null,
+    problem,
+    detail
+  };
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isJsonObjectOrNull(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value !== "string") return false;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed);
+  } catch {
+    return false;
+  }
+}
+function isJsonStringArray(value) {
+  if (typeof value !== "string") return false;
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) && parsed.every((id) => typeof id === "string");
+  } catch {
+    return false;
+  }
+}
+function truncate(value) {
+  return value.length > 120 ? `${value.slice(0, 117)}...` : value;
+}
+function bytesReplacer(_key, value) {
+  if (value instanceof Uint8Array) return { $bytes: Array.from(value) };
+  return value;
+}
+
+// src/backup/backup.ts
+var BACKUP_VERSION = 2;
+var BackupFormatError = class extends KoraError {
+  constructor(message, code, context) {
+    super(message, code, context);
+    this.name = "BackupFormatError";
+  }
+};
+function encodeSection(name, content) {
+  const nameBytes = new TextEncoder().encode(name);
+  const result = new Uint8Array(8 + nameBytes.length + content.length);
+  const dv = new DataView(result.buffer);
+  dv.setUint32(0, nameBytes.length, true);
+  dv.setUint32(4, content.length, true);
+  result.set(nameBytes, 8);
+  result.set(content, 8 + nameBytes.length);
+  return result;
+}
+function encodeJsonSection(name, data) {
+  return encodeSection(name, new TextEncoder().encode(JSON.stringify(data, bytesReplacer2)));
+}
+function encodeNdjsonSection(name, items) {
+  const lines = items.map((item) => JSON.stringify(item, bytesReplacer2)).join("\n");
+  return encodeSection(name, new TextEncoder().encode(items.length > 0 ? `${lines}
+` : ""));
+}
+function parseSections(data) {
+  const sections = [];
+  const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  let offset = 0;
+  while (offset + 8 <= data.byteLength) {
+    const nameLen = dv.getUint32(offset, true);
+    const contentLen = dv.getUint32(offset + 4, true);
+    offset += 8;
+    if (offset + nameLen + contentLen > data.byteLength) break;
+    const name = new TextDecoder().decode(data.slice(offset, offset + nameLen));
+    offset += nameLen;
+    sections.push({ name, content: data.slice(offset, offset + contentLen) });
+    offset += contentLen;
+  }
+  return sections;
+}
+function findSection(sections, name) {
+  return sections.find((section) => section.name === name)?.content ?? null;
+}
+function parseJsonSection(sections, name) {
+  const content = findSection(sections, name);
+  if (!content) return null;
+  return JSON.parse(new TextDecoder().decode(content), bytesReviver);
+}
+function parseNdjson(content) {
+  if (!content) return [];
+  return new TextDecoder().decode(content).split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line, bytesReviver));
+}
+function concat(parts) {
+  const total = parts.reduce((sum, part) => sum + part.length, 0);
+  const result = new Uint8Array(total);
+  let pos = 0;
+  for (const part of parts) {
+    result.set(part, pos);
+    pos += part.length;
+  }
+  return result;
+}
+async function exportBackup(adapter, schema, nodeId, schemaVersion, options) {
+  const onProgress = options?.onProgress ?? (() => {
+  });
+  const includeRecords = options?.includeRecords ?? true;
+  const filter = options?.collections;
+  const collections = Object.keys(schema.collections).filter(
+    (name) => !filter || filter.includes(name)
+  );
+  const snapshot = {
+    vector: {},
+    operations: [],
+    terminal: [],
+    records: /* @__PURE__ */ new Map(),
+    bases: [],
+    snapshots: [],
+    compactedThrough: {},
+    compacted: false
+  };
+  onProgress({ phase: "reading", progress: 0, message: "Reading the local database" });
+  await adapter.transaction(async (tx) => {
+    const vector = await tx.query(
+      "SELECT node_id, sequence_number FROM _kora_version_vector"
+    );
+    for (const row of vector) snapshot.vector[row.node_id] = row.sequence_number;
+    snapshot.operations = await readOperations(tx, collections);
+    snapshot.terminal = await readTerminalRejections(tx);
+    snapshot.bases = await readFoldStateRows(tx, FOLD_BASE_TABLE, collections);
+    snapshot.snapshots = await readFoldStateRows(tx, FOLD_SNAPSHOT_TABLE, collections);
+    if (await hasTable(tx, COMPACTED_THROUGH_TABLE)) {
+      for (const row of await tx.query(
+        `SELECT node_id, sequence_number FROM ${COMPACTED_THROUGH_TABLE}`
+      )) {
+        snapshot.compactedThrough[row.node_id] = row.sequence_number;
+      }
+    }
+    snapshot.compacted = snapshot.bases.length > 0 || Object.keys(snapshot.compactedThrough).length > 0 || (await tx.query("SELECT value FROM _kora_meta WHERE key = ?", [
+      COMPACTION_BASELINE_META_KEY
+    ])).length > 0;
+    if (includeRecords) {
+      for (const collection of collections) {
+        snapshot.records.set(
+          collection,
+          await tx.query(`SELECT * FROM ${quoteIdent2(collection)}`)
+        );
+      }
+    }
+  });
+  onProgress({ phase: "reading", progress: 0.7, message: "Encoding" });
+  const content = [
+    encodeJsonSection("version_vector", snapshot.vector),
+    encodeNdjsonSection("operations", snapshot.operations),
+    encodeJsonSection("terminal_rejections", snapshot.terminal),
+    encodeNdjsonSection("fold_base", snapshot.bases),
+    encodeNdjsonSection("fold_snapshot", snapshot.snapshots),
+    encodeJsonSection("compacted_through", snapshot.compactedThrough)
+  ];
+  for (const [collection, rows] of snapshot.records) {
+    if (rows.length > 0) content.push(encodeNdjsonSection(`records:${collection}`, rows));
+  }
+  const body = concat(content);
+  const checksum = await computeSha256(body);
+  onProgress({ phase: "writing", progress: 1, message: "Finalizing" });
+  const manifest = {
+    version: BACKUP_VERSION,
+    createdAt: Date.now(),
+    nodeId,
+    schemaVersion,
+    operationCount: snapshot.operations.length,
+    collections,
+    includesRecords: includeRecords,
+    includesTombstones: true,
+    includesFoldState: true,
+    compacted: snapshot.compacted,
+    checksum
+  };
+  return concat([
+    encodeJsonSection("manifest", manifest),
+    body,
+    encodeSection("checksum", new TextEncoder().encode(checksum))
+  ]);
+}
+async function readOperations(tx, collections) {
+  const operations = [];
+  const seen = /* @__PURE__ */ new Set();
+  const retained = await hasTable(tx, SEQ_CONFLICTS_TABLE);
+  for (const collection of collections) {
+    const rows = await tx.query(
+      `SELECT * FROM ${quoteIdent2(`_kora_ops_${collection}`)} ORDER BY sequence_number ASC`
+    );
+    if (retained) {
+      rows.push(
+        ...await tx.query(
+          `SELECT id, node_id, type, record_id, data, previous_data, timestamp, sequence_number, causal_deps, schema_version FROM ${SEQ_CONFLICTS_TABLE} WHERE collection = ? AND reemitted_as IS NULL`,
+          [collection]
+        )
+      );
+    }
+    for (const row of rows) {
+      if (seen.has(row.id)) continue;
+      seen.add(row.id);
+      operations.push(deserializeOperationWithCollection(row, collection));
+    }
+  }
+  operations.sort((a, b) => HybridLogicalClock2.compare(a.timestamp, b.timestamp));
+  return operations;
+}
+async function readFoldStateRows(tx, table, collections) {
+  if (!await hasTable(tx, table)) return [];
+  const out = [];
+  for (const collection of collections) {
+    const rows = await tx.query(
+      `SELECT record_id, state FROM ${table} WHERE collection = ? ORDER BY record_id`,
+      [collection]
+    );
+    for (const row of rows) out.push({ collection, recordId: row.record_id, state: row.state });
+  }
+  return out;
+}
+async function readTerminalRejections(tx) {
+  if (!await hasTable(tx, TERMINAL_REJECTIONS_TABLE)) return [];
+  const rows = await tx.query(
+    `SELECT operation_id, node_id, sequence_number, code, rejected_at FROM ${TERMINAL_REJECTIONS_TABLE} ORDER BY operation_id`
+  );
+  return rows.map((row) => ({
+    operationId: row.operation_id,
+    nodeId: row.node_id,
+    sequenceNumber: row.sequence_number,
+    code: row.code,
+    rejectedAt: row.rejected_at
+  }));
+}
+async function hasTable(tx, name) {
+  const rows = await tx.query(
+    "SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?",
+    [name]
+  );
+  return rows.length > 0;
+}
+function readBackupManifest(data) {
+  const manifest = parseJsonSection(parseSections(data), "manifest");
+  if (!manifest) {
+    throw new BackupFormatError("Invalid backup: manifest section not found", "BACKUP_INVALID");
+  }
+  return manifest;
+}
+async function verifyBackupChecksum(data) {
+  const sections = parseSections(data);
+  const manifest = parseJsonSection(sections, "manifest");
+  if (!manifest?.checksum) return false;
+  const body = concat(
+    sections.filter((s) => s.name !== "manifest" && s.name !== "checksum").map((s) => encodeSection(s.name, s.content))
+  );
+  return await computeSha256(body) === manifest.checksum;
+}
+async function parseBackup(data, options) {
+  const sections = parseSections(data);
+  const manifest = parseJsonSection(sections, "manifest");
+  if (!manifest) {
+    throw new BackupFormatError("Invalid backup: manifest section not found", "BACKUP_INVALID");
+  }
+  if (manifest.version === 1) {
+    throw new BackupFormatError(
+      "This backup was written by Kora 1.0.0-beta.12 or earlier (format version 1), whose restore corrupted operation timestamps and copied the exporting device identity. Convert it first: `restoreBackup`/`importBackup(await convertBackupV1(data))`.",
+      "BACKUP_FORMAT_OUTDATED",
+      { version: 1, fix: "Call convertBackupV1(data) and import the result." }
+    );
+  }
+  if (manifest.version !== BACKUP_VERSION) {
+    throw new BackupFormatError(
+      `Unsupported backup version: ${String(manifest.version)} (this release reads version ${BACKUP_VERSION}).`,
+      "BACKUP_VERSION_UNSUPPORTED",
+      { version: manifest.version }
+    );
+  }
+  if (!await verifyBackupChecksum(data)) {
+    throw new BackupFormatError(
+      "Backup checksum mismatch: data may be corrupted",
+      "BACKUP_CHECKSUM_MISMATCH"
+    );
+  }
+  const keep = (collection) => !options?.collections || options.collections.includes(collection);
+  const operations = [];
+  for (const raw of parseNdjson(findSection(sections, "operations"))) {
+    if (!keep(raw.collection)) continue;
+    operations.push(canonicalOperation(raw));
+  }
+  operations.sort((a, b) => HybridLogicalClock2.compare(a.timestamp, b.timestamp));
+  const vector = /* @__PURE__ */ new Map();
+  for (const [nodeId, seq] of Object.entries(
+    parseJsonSection(sections, "version_vector") ?? {}
+  )) {
+    if (Number.isInteger(seq) && seq > 0) vector.set(nodeId, seq);
+  }
+  const records = /* @__PURE__ */ new Map();
+  if (manifest.includesRecords) {
+    for (const collection of manifest.collections) {
+      if (!keep(collection)) continue;
+      records.set(
+        collection,
+        parseNdjson(findSection(sections, `records:${collection}`))
+      );
+    }
+  }
+  const foldRows = (name) => parseNdjson(findSection(sections, name)).filter(
+    (row) => typeof row?.collection === "string" && typeof row.recordId === "string" && typeof row.state === "string" && keep(row.collection)
+  );
+  const compactedThrough = /* @__PURE__ */ new Map();
+  for (const [nodeId, seq] of Object.entries(
+    parseJsonSection(sections, "compacted_through") ?? {}
+  )) {
+    if (Number.isInteger(seq) && seq > 0) compactedThrough.set(nodeId, seq);
+  }
+  return {
+    manifest,
+    operations,
+    versionVector: vector,
+    terminalRejections: parseJsonSection(sections, "terminal_rejections") ?? [],
+    records,
+    foldBases: foldRows("fold_base"),
+    foldSnapshots: foldRows("fold_snapshot"),
+    compactedThrough
+  };
+}
+function canonicalOperation(raw) {
+  let row;
+  try {
+    row = serializeOperation(raw);
+  } catch (error) {
+    throw new BackupFormatError(
+      `Backup operation ${String(raw?.id)} is not a valid operation: ${error instanceof Error ? error.message : String(error)}`,
+      "BACKUP_OPERATION_INVALID",
+      { operationId: raw?.id }
+    );
+  }
+  const verdict = checkOperationRow(row);
+  if (verdict.kind !== "ok" || typeof raw.collection !== "string" || raw.collection === "") {
+    throw new BackupFormatError(
+      `Backup operation ${String(raw.id)} is not canonical (${verdict.kind === "ok" ? "no collection" : verdict.problem}).`,
+      "BACKUP_OPERATION_INVALID",
+      { operationId: raw.id }
+    );
+  }
+  return deserializeOperationWithCollection(row, raw.collection);
+}
+async function convertBackupV1(data, options) {
+  const sections = parseSections(data);
+  const manifest = parseJsonSection(sections, "manifest");
+  if (!manifest || manifest.version !== 1) {
+    throw new BackupFormatError("convertBackupV1 expects a version-1 backup.", "BACKUP_INVALID", {
+      version: manifest?.version
+    });
+  }
+  if (!await verifyBackupChecksum(data)) {
+    throw new BackupFormatError(
+      "Backup checksum mismatch: data may be corrupted",
+      "BACKUP_CHECKSUM_MISMATCH"
+    );
+  }
+  const operations = [];
+  const dropped = [];
+  for (const raw of parseNdjson(findSection(sections, "operations"))) {
+    const fixed = recoverV1Operation(raw);
+    if (fixed) operations.push(fixed);
+    else dropped.push(String(raw?.id));
+  }
+  if (dropped.length > 0 && !options?.dropUnrecoverable) {
+    throw new BackupFormatError(
+      `${dropped.length} operation(s) in this version-1 backup have unrecoverable timestamps (first: ${dropped[0]}). Pass { dropUnrecoverable: true } to convert without them.`,
+      "BACKUP_OPERATION_INVALID",
+      { operationIds: dropped.slice(0, 20) }
+    );
+  }
+  operations.sort((a, b) => HybridLogicalClock2.compare(a.timestamp, b.timestamp));
+  const content = [
+    encodeJsonSection(
+      "version_vector",
+      parseJsonSection(sections, "version_vector") ?? {}
+    ),
+    encodeNdjsonSection("operations", operations),
+    encodeJsonSection("terminal_rejections", [])
+  ];
+  for (const section of sections) {
+    if (section.name.startsWith("records:")) {
+      const rows = parseNdjson(section.content).map(decodeV1Bytes);
+      content.push(encodeNdjsonSection(section.name, rows));
+    }
+  }
+  const body = concat(content);
+  const checksum = await computeSha256(body);
+  const converted = {
+    version: BACKUP_VERSION,
+    createdAt: manifest.createdAt,
+    nodeId: manifest.nodeId,
+    schemaVersion: manifest.schemaVersion,
+    operationCount: operations.length,
+    collections: manifest.collections,
+    includesRecords: manifest.includesRecords,
+    includesTombstones: false,
+    checksum,
+    convertedFrom: 1
+  };
+  return concat([
+    encodeJsonSection("manifest", converted),
+    body,
+    encodeSection("checksum", new TextEncoder().encode(checksum))
+  ]);
+}
+function recoverV1Operation(raw) {
+  if (!raw || typeof raw !== "object" || typeof raw.id !== "string") return null;
+  const ts = raw.timestamp;
+  let timestamp = ts;
+  const valid = ts !== null && typeof ts === "object" && Number.isInteger(ts.wallTime) && Number.isInteger(ts.logical);
+  if (!valid) {
+    const recovered = recoverTimestamp(JSON.stringify(ts));
+    if (!recovered) return null;
+    timestamp = HybridLogicalClock2.deserialize(recovered);
+  }
+  try {
+    return canonicalOperation({ ...raw, timestamp });
+  } catch {
+    return null;
+  }
+}
+function decodeV1Bytes(row) {
+  const out = {};
+  for (const [key, value] of Object.entries(row)) {
+    out[key] = looksLikeSerializedBytes(value) ? toBytes(value) : value;
+  }
+  return out;
+}
+function looksLikeSerializedBytes(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const entries = Object.entries(value);
+  if (entries.length === 0) return false;
+  return entries.every(
+    ([key, byte], index) => key === String(index) && Number.isInteger(byte) && byte >= 0 && byte < 256
+  );
+}
+function toBytes(value) {
+  const length = Object.keys(value).length;
+  const bytes = new Uint8Array(length);
+  for (let i = 0; i < length; i++) bytes[i] = value[String(i)] ?? 0;
+  return bytes;
+}
+async function restoreBackup(adapter, schema, data, options) {
+  const { Store } = await import("./store-HNGX4KTT.js");
+  const store = new Store({ schema, adapter });
+  await store.open();
+  try {
+    return await store.importBackup(data, options);
+  } finally {
+    await store.close();
+  }
+}
+function bytesReplacer2(_key, value) {
+  if (value instanceof Uint8Array) return { $bytes: toBase64(value) };
+  return value;
+}
+function bytesReviver(_key, value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 1 && typeof value.$bytes === "string") {
+    return fromBase64(value.$bytes);
+  }
+  return value;
+}
+function toBase64(bytes) {
+  let binary = "";
+  const CHUNK = 32768;
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+  }
+  return btoa(binary);
+}
+function fromBase64(text) {
+  const binary = atob(text);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+async function computeSha256(data) {
+  const hashBuffer = await crypto.subtle.digest("SHA-256", new Uint8Array(data));
+  return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+export {
+  COMPACTION_BASELINE_META_KEY,
+  LOG_QUARANTINE_TABLE,
+  scanLogIntegrity,
+  BACKUP_VERSION,
+  BackupFormatError,
+  exportBackup,
+  readBackupManifest,
+  verifyBackupChecksum,
+  parseBackup,
+  convertBackupV1,
+  restoreBackup
+};
+//# sourceMappingURL=chunk-UC2LGFPV.js.map