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

package/dist/chunk-32EDKWMI.js

@@ -0,0 +1,876 @@
+import {
+  TERMINAL_REJECTIONS_TABLE,
+  buildInsertQuery
+} from "./chunk-SJP2HTYZ.js";
+import {
+  deserializeOperationWithCollection,
+  serializeOperation,
+  serializeRecord
+} from "./chunk-J5AGXF3D.js";
+
+// src/sync/rehash-operation.ts
+import { quoteIdent } from "@korajs/core";
+import { computeOperationId } from "@korajs/core/internal";
+async function rehashOperation(op) {
+  return computeOperationId(
+    {
+      nodeId: op.nodeId,
+      type: op.type,
+      collection: op.collection,
+      recordId: op.recordId,
+      data: op.data,
+      previousData: op.previousData,
+      timestamp: op.timestamp,
+      sequenceNumber: op.sequenceNumber,
+      causalDeps: op.causalDeps,
+      schemaVersion: op.schemaVersion,
+      ...op.atomicOps !== void 0 ? { atomicOps: op.atomicOps } : {}
+    },
+    op.hashVersion === 2 ? 2 : 1
+  );
+}
+async function renumberOperationRow(tx, collection, row, sequenceNumber) {
+  const table = quoteIdent(`_kora_ops_${collection}`);
+  const current = deserializeOperationWithCollection(row, collection);
+  const renumbered = { ...current, sequenceNumber };
+  if (current.hashVersion !== 2) {
+    await tx.execute(`UPDATE ${table} SET sequence_number = ? WHERE id = ?`, [
+      sequenceNumber,
+      row.id
+    ]);
+    return renumbered;
+  }
+  const id = await rehashOperation(renumbered);
+  const moved = { ...renumbered, id };
+  await replaceOperationRow(tx, collection, row.id, moved);
+  return moved;
+}
+async function replaceOperationRow(tx, collection, oldId, next) {
+  await tx.execute(`DELETE FROM ${quoteIdent(`_kora_ops_${collection}`)} WHERE id = ?`, [oldId]);
+  const insert = buildInsertQuery(
+    `_kora_ops_${collection}`,
+    serializeOperation(next)
+  );
+  await tx.execute(insert.sql, insert.params);
+}
+async function rewriteDependentsInTx(tx, collections, nodeId, idMapping, rewritable) {
+  if (rewritable.size === 0) return [];
+  const candidates = [];
+  for (const collection of collections) {
+    const rows = await tx.query(
+      `SELECT * FROM ${quoteIdent(`_kora_ops_${collection}`)} WHERE node_id = ?`,
+      [nodeId]
+    );
+    for (const row of rows) {
+      if (!rewritable.has(row.id)) continue;
+      candidates.push({ collection, row, op: deserializeOperationWithCollection(row, collection) });
+    }
+  }
+  candidates.sort((a, b) => a.op.sequenceNumber - b.op.sequenceNumber);
+  const rewritten = [];
+  for (const { collection, row, op } of candidates) {
+    if (!op.causalDeps.some((dep) => idMapping[dep] !== void 0)) continue;
+    const causalDeps = op.causalDeps.map((dep) => idMapping[dep] ?? dep);
+    const updated = { ...op, causalDeps };
+    const id = op.hashVersion === 2 ? await rehashOperation(updated) : op.id;
+    const next = { ...updated, id };
+    await replaceOperationRow(tx, collection, row.id, next);
+    if (id !== op.id) idMapping[op.id] = id;
+    rewritten.push(next);
+  }
+  return rewritten;
+}
+
+// src/store/sequence-allocator.ts
+async function allocateNextSequenceInTransaction(tx, nodeId) {
+  const rows = await tx.query(
+    `INSERT INTO _kora_version_vector (node_id, sequence_number) VALUES (?, 1)
+     ON CONFLICT(node_id) DO UPDATE SET sequence_number = sequence_number + 1
+     RETURNING sequence_number`,
+    [nodeId]
+  );
+  const seq = rows[0]?.sequence_number;
+  if (seq === void 0) {
+    throw new Error(`Failed to allocate sequence number for node "${nodeId}" in transaction`);
+  }
+  return seq;
+}
+
+// src/store/sequence-repair.ts
+import { quoteIdent as quoteIdent2 } from "@korajs/core";
+var SEQ_CONFLICTS_TABLE = "_kora_seq_conflicts";
+var REPAIR_DONE_META_KEY = "seq_unique_repair_v1";
+var CREATE_SEQ_CONFLICTS_SQL = `CREATE TABLE IF NOT EXISTS ${SEQ_CONFLICTS_TABLE} (
+  id TEXT PRIMARY KEY NOT NULL,
+  collection TEXT NOT NULL,
+  node_id TEXT NOT NULL,
+  type TEXT NOT NULL,
+  record_id TEXT NOT NULL,
+  data TEXT,
+  previous_data TEXT,
+  timestamp TEXT NOT NULL,
+  sequence_number INTEGER NOT NULL,
+  causal_deps TEXT NOT NULL,
+  schema_version INTEGER NOT NULL,
+  reason TEXT NOT NULL,
+  reemitted_as TEXT,
+  new_sequence_number INTEGER,
+  recorded_at INTEGER NOT NULL
+)`;
+function uniqueSequenceIndexName(collection) {
+  return `uidx_kora_ops_${collection.length}_${collection}_node_seq`;
+}
+async function repairSequenceUniqueness(adapter, schema, nodeId) {
+  await adapter.execute(CREATE_SEQ_CONFLICTS_SQL);
+  const collections = Object.keys(schema.collections);
+  const result = { resequenced: 0, retained: 0 };
+  const done = await adapter.query(
+    "SELECT value FROM _kora_meta WHERE key = ?",
+    [REPAIR_DONE_META_KEY]
+  );
+  if (done.length === 0 && collections.length > 0) {
+    await runRepair(adapter, collections, nodeId, result);
+  }
+  for (const collection of collections) {
+    const createIndex = `CREATE UNIQUE INDEX IF NOT EXISTS ${quoteIdent2(uniqueSequenceIndexName(collection))} ON ${quoteIdent2(`_kora_ops_${collection}`)} (node_id, sequence_number)`;
+    try {
+      await adapter.execute(createIndex);
+    } catch (error) {
+      if (!/UNIQUE/i.test(error instanceof Error ? error.message : String(error))) throw error;
+      await runRepair(adapter, collections, nodeId, result);
+      await adapter.execute(createIndex);
+    }
+  }
+  return result;
+}
+async function runRepair(adapter, collections, nodeId, result) {
+  let resequenced = 0;
+  let retained = 0;
+  await adapter.transaction(async (tx) => {
+    await raiseOwnCounterToLog(tx, collections, nodeId);
+    const repaired = await repairDuplicates(tx, collections, nodeId);
+    resequenced = repaired.resequenced;
+    retained = repaired.retained;
+    await tx.execute("INSERT OR REPLACE INTO _kora_meta (key, value) VALUES (?, ?)", [
+      REPAIR_DONE_META_KEY,
+      String(Date.now())
+    ]);
+  });
+  result.resequenced += resequenced;
+  result.retained += retained;
+  if (resequenced > 0 || retained > 0) {
+    console.warn(
+      `[kora] Repaired ${resequenced + retained} operation(s) that shared a sequence number (written by an earlier Kora version). ${resequenced} were given fresh sequence numbers; ${retained} from other devices were kept in ${SEQ_CONFLICTS_TABLE}. No data was removed.`
+    );
+  }
+}
+async function raiseOwnCounterToLog(tx, collections, nodeId) {
+  let maxSeq = 0;
+  for (const collection of collections) {
+    const rows = await tx.query(
+      `SELECT MAX(sequence_number) AS max_seq FROM ${quoteIdent2(`_kora_ops_${collection}`)} WHERE node_id = ?`,
+      [nodeId]
+    );
+    maxSeq = Math.max(maxSeq, rows[0]?.max_seq ?? 0);
+  }
+  if (maxSeq > 0) {
+    await tx.execute(
+      `INSERT INTO _kora_version_vector (node_id, sequence_number) VALUES (?, ?)
+     ON CONFLICT(node_id) DO UPDATE SET sequence_number = MAX(sequence_number, excluded.sequence_number)`,
+      [nodeId, maxSeq]
+    );
+  }
+}
+async function repairDuplicates(tx, collections, nodeId) {
+  const all = [];
+  for (const collection of collections) {
+    const rows = await tx.query(
+      `SELECT id, node_id, sequence_number FROM ${quoteIdent2(`_kora_ops_${collection}`)}`
+    );
+    for (const row of rows) all.push({ collection, ...row });
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of all) {
+    const key = `${row.node_id}\0${row.sequence_number}`;
+    const group = groups.get(key);
+    if (group) group.push(row);
+    else groups.set(key, [row]);
+  }
+  const losers = [];
+  for (const group of groups.values()) {
+    if (group.length < 2) continue;
+    const version2 = /* @__PURE__ */ new Set();
+    for (const member of group) {
+      if (await isVersion2Row(tx, member)) version2.add(member.id);
+    }
+    group.sort((a, b) => {
+      const va = version2.has(a.id) ? 0 : 1;
+      const vb = version2.has(b.id) ? 0 : 1;
+      if (va !== vb) return va - vb;
+      return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+    });
+    losers.push(...group.slice(1));
+  }
+  losers.sort(
+    (a, b) => a.sequence_number !== b.sequence_number ? a.sequence_number - b.sequence_number : a.id < b.id ? -1 : a.id > b.id ? 1 : 0
+  );
+  const result = { resequenced: 0, retained: 0 };
+  const now = Date.now();
+  for (const loser of losers) {
+    const table = quoteIdent2(`_kora_ops_${loser.collection}`);
+    const rows = await tx.query(`SELECT * FROM ${table} WHERE id = ?`, [loser.id]);
+    const row = rows[0];
+    if (!row) continue;
+    if (loser.node_id === nodeId) {
+      const newSeq = await allocateNextSequenceInTransaction(tx, nodeId);
+      const moved = await renumberOperationRow(tx, loser.collection, row, newSeq);
+      await insertConflictRow(
+        tx,
+        loser.collection,
+        row,
+        "duplicate-sequence",
+        moved.id,
+        newSeq,
+        now
+      );
+      result.resequenced++;
+    } else {
+      await insertConflictRow(tx, loser.collection, row, "duplicate-sequence", null, null, now);
+      await tx.execute(`DELETE FROM ${table} WHERE id = ?`, [loser.id]);
+      result.retained++;
+    }
+  }
+  return result;
+}
+async function isVersion2Row(tx, identity) {
+  const rows = await tx.query(
+    `SELECT * FROM ${quoteIdent2(`_kora_ops_${identity.collection}`)} WHERE id = ?`,
+    [identity.id]
+  );
+  const row = rows[0];
+  if (!row) return false;
+  return deserializeOperationWithCollection(row, identity.collection).hashVersion === 2;
+}
+async function insertConflictRow(tx, collection, row, reason, reemittedAs, newSequenceNumber, recordedAt) {
+  await tx.execute(
+    `INSERT OR IGNORE INTO ${SEQ_CONFLICTS_TABLE} (id, collection, node_id, type, record_id, data, previous_data, timestamp, sequence_number, causal_deps, schema_version, reason, reemitted_as, new_sequence_number, recorded_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      row.id,
+      collection,
+      row.node_id,
+      row.type,
+      row.record_id,
+      row.data,
+      row.previous_data,
+      row.timestamp,
+      row.sequence_number,
+      row.causal_deps,
+      row.schema_version,
+      reason,
+      reemittedAs,
+      newSequenceNumber,
+      recordedAt
+    ]
+  );
+}
+async function loadRetainedConflictRows(query, collection, recordId, types) {
+  const typeFilter = types && types.length > 0 ? ` AND type IN (${types.map(() => "?").join(", ")})` : "";
+  return 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 record_id = ? AND reemitted_as IS NULL${typeFilter}`,
+    [collection, recordId, ...types ?? []]
+  );
+}
+async function isOperationLogged(tx, collection, opId) {
+  const inLog = await tx.query(
+    `SELECT id FROM ${quoteIdent2(`_kora_ops_${collection}`)} WHERE id = ?`,
+    [opId]
+  );
+  if (inLog.length > 0) return true;
+  const retained = await tx.query(
+    `SELECT id FROM ${SEQ_CONFLICTS_TABLE} WHERE id = ? AND reemitted_as IS NULL`,
+    [opId]
+  );
+  return retained.length > 0;
+}
+
+// src/fold/record-folder.ts
+import {
+  FOLD_STATE_VERSION,
+  FoldStateError,
+  HybridLogicalClock,
+  adaptFoldState,
+  base64ToBytes,
+  createFoldState,
+  deserializeFoldState,
+  getFoldFieldVersionStrings,
+  isFoldStateLive,
+  joinStates,
+  materialize,
+  mergeOp,
+  mismatchedFoldFields,
+  quoteIdent as quoteIdent3,
+  toMergeTrace
+} from "@korajs/core";
+import * as Y from "yjs";
+var FOLD_STATE_TABLE = "_kora_fold_state";
+var FOLD_BASE_TABLE = "_kora_fold_base";
+var COMPACTED_THROUGH_TABLE = "_kora_compacted_through";
+var FOLD_SNAPSHOT_TABLE = "_kora_fold_snapshot";
+var PROVISIONAL_OPS_TABLE = "_kora_provisional_ops";
+var KEPT_REJECTION_CODES = ["HELD_DISCARDED"];
+var FOLD_MATERIALIZATION_META_KEY = "fold_materialization";
+var FOLD_MATERIALIZATION_CURRENT = `fold-v${FOLD_STATE_VERSION}`;
+var FOLD_MATERIALIZATION_LEGACY = "legacy";
+var FOLD_TABLES_DDL = [
+  `CREATE TABLE IF NOT EXISTS ${FOLD_STATE_TABLE} (collection TEXT NOT NULL, record_id TEXT NOT NULL, state TEXT NOT NULL, PRIMARY KEY (collection, record_id))`,
+  `CREATE TABLE IF NOT EXISTS ${FOLD_BASE_TABLE} (collection TEXT NOT NULL, record_id TEXT NOT NULL, state TEXT NOT NULL, PRIMARY KEY (collection, record_id))`,
+  `CREATE TABLE IF NOT EXISTS ${COMPACTED_THROUGH_TABLE} (node_id TEXT PRIMARY KEY, sequence_number INTEGER NOT NULL)`,
+  `CREATE TABLE IF NOT EXISTS ${FOLD_SNAPSHOT_TABLE} (collection TEXT NOT NULL, record_id TEXT NOT NULL, state TEXT NOT NULL, PRIMARY KEY (collection, record_id))`,
+  `CREATE TABLE IF NOT EXISTS ${PROVISIONAL_OPS_TABLE} (id TEXT PRIMARY KEY, collection TEXT NOT NULL, record_id TEXT NOT NULL, parent_id TEXT NOT NULL, operation TEXT NOT NULL)`,
+  `CREATE INDEX IF NOT EXISTS ${PROVISIONAL_OPS_TABLE}_record ON ${PROVISIONAL_OPS_TABLE} (collection, record_id)`
+];
+function mergeYjsUpdates(updates) {
+  const doc = new Y.Doc();
+  for (const update of updates) Y.applyUpdate(doc, update);
+  return Y.encodeStateAsUpdate(doc);
+}
+function sameBytes(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+function yjsSubsumes(a, b) {
+  return sameBytes(mergeYjsUpdates([b]), mergeYjsUpdates([a, b]));
+}
+async function isCompacted(tx, op) {
+  const rows = await tx.query(
+    `SELECT sequence_number FROM ${COMPACTED_THROUGH_TABLE} WHERE node_id = ?`,
+    [op.nodeId]
+  );
+  const through = rows[0]?.sequence_number;
+  return through !== void 0 && op.sequenceNumber <= through;
+}
+var RecordFolder = class {
+  constructor(schema, transforms = []) {
+    this.schema = schema;
+    this.transforms = transforms;
+  }
+  schema;
+  transforms;
+  authoritative = /* @__PURE__ */ new Set();
+  /** The schema transforms every merge applies (transforms at fold time, RT-84). */
+  getOperationTransforms() {
+    return this.transforms;
+  }
+  /**
+   * The fields an operation's merge can change: its own data's keys, or every field
+   * when the fold reads it through a schema transform (whose view may name others).
+   */
+  touchedFields(op) {
+    if (this.transforms.length > 0 && op.schemaVersion !== this.schema.version) return "all";
+    return new Set(Object.keys(op.data ?? {}));
+  }
+  /** Node ids whose writes win `merge('server-authoritative')` fields. */
+  getAuthoritativeNodeIds() {
+    return this.authoritative;
+  }
+  /** @internal Set by the store from persisted meta / the sync handshake. */
+  setAuthoritativeNodeIds(ids) {
+    this.authoritative = new Set(ids);
+  }
+  /** Fold options every merge of this database uses. */
+  options(traces = "none") {
+    return {
+      richtext: mergeYjsUpdates,
+      richtextSubsumes: yjsSubsumes,
+      traces,
+      ...this.authoritative.size > 0 ? { authoritativeNodeIds: this.authoritative } : {},
+      ...this.transforms.length > 0 ? { transforms: this.transforms } : {}
+    };
+  }
+  /** Whether the schema has a `merge('server-authoritative')` field in `collection`. */
+  hasAuthoritativeFields(collection) {
+    const definition = this.schema.collections[collection];
+    if (!definition) return false;
+    return Object.values(definition.fields).some(
+      (field) => field.mergeStrategy === "server-authoritative"
+    );
+  }
+  /**
+   * Merge one operation (already appended to the log) into its record and
+   * re-materialize the row.
+   *
+   * @param tx - The write transaction that appended the operation
+   * @param op - The operation
+   * @param mode - 'remote' emits merge traces; 'local' does not (a local write is
+   *   computed from the row it updates, so it is never concurrent with it)
+   */
+  async applyInTx(tx, op, mode) {
+    const scopeEntry = op.type === "insert";
+    if (mode === "remote") {
+      const retired = await this.deleteProvisional(tx, op.collection, op.recordId, op.causalDeps);
+      const replaced = await this.dropSnapshotForCarriedState(tx, op);
+      if (retired > 0 || replaced) {
+        await this.refoldInTx(tx, op.collection, op.recordId, { clearRetraction: scopeEntry });
+        return { changed: true, traces: [] };
+      }
+    }
+    const fresh = mode === "local" && op.type === "insert";
+    const prior = fresh ? { state: createFoldState(op.collection, op.recordId), rebuilt: false } : await this.loadOrRebuild(tx, op.collection, op.recordId, op.id);
+    let result;
+    try {
+      result = mergeOp(
+        prior.state,
+        op,
+        this.schema,
+        this.options(mode === "remote" ? "conflicts" : "none")
+      );
+    } catch (error) {
+      if (!(error instanceof FoldStateError)) throw error;
+      await this.refoldInTx(tx, op.collection, op.recordId, { clearRetraction: scopeEntry });
+      return { changed: true, traces: [] };
+    }
+    if (!result.changed && !prior.rebuilt && !scopeEntry) {
+      return { changed: false, traces: await this.toMergeTraces(tx, result.traces) };
+    }
+    await this.saveState(tx, result.state);
+    const revived = isDeadState(prior.state) && !isDeadState(result.state);
+    const fields = prior.rebuilt || revived || op.foldState !== void 0 ? "all" : this.touchedFields(op);
+    await this.materializeRow(tx, result.state, fields, {
+      clearRetraction: scopeEntry,
+      ...fresh ? { absent: true } : {}
+    });
+    return { changed: result.changed, traces: await this.toMergeTraces(tx, result.traces) };
+  }
+  /**
+   * Fold a record from its base state and its log, leaving out operations the
+   * server terminally rejected, and re-materialize its row (all fields).
+   *
+   * @returns The new state (null when nothing of the record remains)
+   */
+  async refoldInTx(tx, collection, recordId, options = {}) {
+    const state = await this.foldFromLog(tx, collection, recordId);
+    if (state === null) {
+      await tx.execute(`DELETE FROM ${FOLD_STATE_TABLE} WHERE collection = ? AND record_id = ?`, [
+        collection,
+        recordId
+      ]);
+      await tx.execute(`UPDATE ${quoteIdent3(collection)} SET _deleted = 1 WHERE id = ?`, [recordId]);
+      return null;
+    }
+    await this.saveState(tx, state);
+    await this.materializeRow(tx, state, "all", {
+      clearRetraction: options.clearRetraction ?? false
+    });
+    return state;
+  }
+  /**
+   * `join(base, snapshot, fold(log - terminally rejected, provisional effects))`, or
+   * null when none exists. Base and snapshot are adapted to the current fold plan
+   * (RT-63): a field whose kind changed is rebuilt from its materialized value.
+   */
+  async foldFromLog(tx, collection, recordId) {
+    const ops = [
+      ...await this.loadRecordOperations(tx, collection, recordId),
+      ...await this.loadProvisional(tx, collection, recordId)
+    ];
+    const rejected = await this.loadTerminalRejections(
+      tx,
+      ops.map((op) => op.id)
+    );
+    const base = await this.loadBase(tx, collection, recordId);
+    const snapshot = await this.loadSnapshot(tx, collection, recordId);
+    let state = base !== null && snapshot !== null ? joinStates(base, snapshot, this.schema) : base ?? snapshot;
+    for (const op of ops) {
+      if (rejected.has(op.id)) continue;
+      state = mergeOp(
+        state ?? createFoldState(collection, recordId),
+        op,
+        this.schema,
+        this.options()
+      ).state;
+    }
+    return state;
+  }
+  /** The record's operations (log + retained sequence-conflict rows). */
+  async loadRecordOperations(tx, collection, recordId) {
+    const rows = [
+      ...await tx.query(
+        `SELECT * FROM ${quoteIdent3(`_kora_ops_${collection}`)} WHERE record_id = ?`,
+        [recordId]
+      ),
+      ...await loadRetainedConflictRows(
+        (sql, params) => tx.query(sql, params),
+        collection,
+        recordId
+      )
+    ];
+    return rows.map((row) => deserializeOperationWithCollection(row, collection));
+  }
+  /**
+   * Which of `ids` the fold leaves out: operations with a terminal-rejection marker
+   * from the server (or quarantined by a scope retraction, which the server never
+   * receives). Writes the user chose to discard from a held node are NOT left out:
+   * discarding stops the upload, it is not a rollback.
+   */
+  async loadTerminalRejections(tx, ids) {
+    const found = /* @__PURE__ */ new Set();
+    const CHUNK = 500;
+    for (let i = 0; i < ids.length; i += CHUNK) {
+      const chunk = ids.slice(i, i + CHUNK);
+      const rows = await tx.query(
+        `SELECT operation_id FROM ${TERMINAL_REJECTIONS_TABLE} WHERE code NOT IN (${KEPT_REJECTION_CODES.map(() => "?").join(", ")}) AND operation_id IN (${chunk.map(() => "?").join(", ")})`,
+        [...KEPT_REJECTION_CODES, ...chunk]
+      );
+      for (const row of rows) found.add(row.operation_id);
+    }
+    return found;
+  }
+  /**
+   * The record's stored state, or null (none, another format version, or a field
+   * whose fold kind the schema has changed since: the caller re-folds, RT-63).
+   */
+  async loadState(tx, collection, recordId) {
+    const state = await this.readStateRow(tx, FOLD_STATE_TABLE, collection, recordId);
+    if (state === null || mismatchedFoldFields(state, this.schema).length > 0) return null;
+    return state;
+  }
+  /** The stored state as it is, even when the plan changed (a snapshot seed). */
+  async loadStoredState(tx, collection, recordId) {
+    return this.readStateRow(tx, FOLD_STATE_TABLE, collection, recordId);
+  }
+  /** The record's compacted base, adapted to the current fold plan (RT-63). */
+  async loadBase(tx, collection, recordId) {
+    const base = await this.readStateRow(tx, FOLD_BASE_TABLE, collection, recordId);
+    return base === null ? null : adaptFoldState(base, this.schema, this.options()).state;
+  }
+  /** The record's row snapshot (RT-68), adapted to the current fold plan. */
+  async loadSnapshot(tx, collection, recordId) {
+    const snapshot = await this.readStateRow(tx, FOLD_SNAPSHOT_TABLE, collection, recordId);
+    return snapshot === null ? null : adaptFoldState(snapshot, this.schema, this.options()).state;
+  }
+  /** Store `snapshot` as the record's row snapshot (joined with an existing one). */
+  async saveSnapshot(tx, snapshot) {
+    const existing = await this.loadSnapshot(tx, snapshot.c, snapshot.r);
+    const state = existing === null ? snapshot : joinStates(existing, snapshot, this.schema);
+    await tx.execute(
+      `INSERT OR REPLACE INTO ${FOLD_SNAPSHOT_TABLE} (collection, record_id, state) VALUES (?, ?, ?)`,
+      [state.c, state.r, persistedForm(state)]
+    );
+  }
+  /**
+   * A scope entry carrying the server's fold state (RT-29) replaces the record's row
+   * snapshot (RT-68): the server's state is built from every operation of the record
+   * the device was missing, so with the device's own log it is the exact state.
+   * Only a carried state this schema can read and join counts (otherwise the entry
+   * merges by its data and the snapshot stays).
+   *
+   * @returns Whether a snapshot was dropped
+   */
+  async dropSnapshotForCarriedState(tx, op) {
+    if (op.type !== "insert" || op.foldState === void 0) return false;
+    const rows = await tx.query(
+      `SELECT COUNT(*) AS n FROM ${FOLD_SNAPSHOT_TABLE} WHERE collection = ? AND record_id = ?`,
+      [op.collection, op.recordId]
+    );
+    if ((rows[0]?.n ?? 0) === 0) return false;
+    let carried;
+    try {
+      carried = deserializeFoldState(op.foldState);
+    } catch (error) {
+      if (error instanceof FoldStateError) return false;
+      throw error;
+    }
+    if (carried.c !== op.collection || carried.r !== op.recordId) return false;
+    if (mismatchedFoldFields(carried, this.schema).length > 0) return false;
+    await tx.execute(`DELETE FROM ${FOLD_SNAPSHOT_TABLE} WHERE collection = ? AND record_id = ?`, [
+      op.collection,
+      op.recordId
+    ]);
+    return true;
+  }
+  /** Records that still fold against a row snapshot (approximate, RT-68). */
+  async listSnapshotRecords(tx) {
+    const rows = await tx.query(
+      `SELECT collection, record_id FROM ${FOLD_SNAPSHOT_TABLE} ORDER BY collection, record_id`
+    );
+    return rows.map((row) => ({ collection: row.collection, recordId: row.record_id }));
+  }
+  /**
+   * After a full resync, a record whose log holds its insert again no longer needs
+   * its row snapshot: drop it and re-fold the record from base and log (RT-68).
+   *
+   * @returns Whether the snapshot was dropped
+   */
+  async settleSnapshotInTx(tx, collection, recordId) {
+    const ops = await this.loadRecordOperations(tx, collection, recordId);
+    const rejected = await this.loadTerminalRejections(
+      tx,
+      ops.map((op) => op.id)
+    );
+    const hasInsert = ops.some((op) => op.type === "insert" && !rejected.has(op.id));
+    const base = await this.loadBase(tx, collection, recordId);
+    if (!hasInsert && (base?.cr ?? null) === null) return false;
+    await tx.execute(`DELETE FROM ${FOLD_SNAPSHOT_TABLE} WHERE collection = ? AND record_id = ?`, [
+      collection,
+      recordId
+    ]);
+    await this.refoldInTx(tx, collection, recordId);
+    return true;
+  }
+  /**
+   * Fold a local-only provisional side effect (RT-69) into its record: stored apart
+   * from the log (never sequenced, never uploaded) and kept until the real copy of
+   * the effect arrives or the delivery stream catches up.
+   *
+   * @param parentId - The remote operation that caused it (the parent delete)
+   */
+  async applyProvisionalInTx(tx, op, parentId) {
+    const existing = await tx.query(
+      `SELECT id FROM ${PROVISIONAL_OPS_TABLE} WHERE id = ?`,
+      [op.id]
+    );
+    if (existing.length > 0) return;
+    await tx.execute(
+      `INSERT INTO ${PROVISIONAL_OPS_TABLE} (id, collection, record_id, parent_id, operation) VALUES (?, ?, ?, ?, ?)`,
+      [op.id, op.collection, op.recordId, parentId, JSON.stringify(op)]
+    );
+    const prior = await this.loadOrRebuild(tx, op.collection, op.recordId, op.id);
+    const result = mergeOp(prior.state, op, this.schema, this.options());
+    if (!result.changed && !prior.rebuilt) return;
+    await this.saveState(tx, result.state);
+    await this.materializeRow(tx, result.state, prior.rebuilt ? "all" : this.touchedFields(op), {
+      clearRetraction: false
+    });
+  }
+  /**
+   * Remove provisional effects of a record (those caused by one of `parentIds`, or
+   * all of them when null). The caller re-folds the record.
+   *
+   * @returns How many were removed
+   */
+  async deleteProvisional(tx, collection, recordId, parentIds) {
+    if (parentIds !== null && parentIds.length === 0) return 0;
+    const filter = parentIds === null ? "" : ` AND parent_id IN (${parentIds.map(() => "?").join(", ")})`;
+    const rows = await tx.query(
+      `SELECT id FROM ${PROVISIONAL_OPS_TABLE} WHERE collection = ? AND record_id = ?${filter}`,
+      [collection, recordId, ...parentIds ?? []]
+    );
+    if (rows.length === 0) return 0;
+    await tx.execute(
+      `DELETE FROM ${PROVISIONAL_OPS_TABLE} WHERE id IN (${rows.map(() => "?").join(", ")})`,
+      rows.map((row) => row.id)
+    );
+    return rows.length;
+  }
+  /** Records with provisional effects. */
+  async listProvisionalRecords(tx) {
+    const rows = await tx.query(
+      `SELECT DISTINCT collection, record_id FROM ${PROVISIONAL_OPS_TABLE} ORDER BY collection, record_id`
+    );
+    return rows.map((row) => ({ collection: row.collection, recordId: row.record_id }));
+  }
+  async loadProvisional(tx, collection, recordId) {
+    const rows = await tx.query(
+      `SELECT operation FROM ${PROVISIONAL_OPS_TABLE} WHERE collection = ? AND record_id = ?`,
+      [collection, recordId]
+    );
+    return rows.map((row) => JSON.parse(row.operation));
+  }
+  async saveState(tx, state) {
+    await tx.execute(
+      `INSERT OR REPLACE INTO ${FOLD_STATE_TABLE} (collection, record_id, state) VALUES (?, ?, ?)`,
+      [state.c, state.r, persistedForm(state)]
+    );
+  }
+  async saveBase(tx, state) {
+    await tx.execute(
+      `INSERT OR REPLACE INTO ${FOLD_BASE_TABLE} (collection, record_id, state) VALUES (?, ?, ?)`,
+      [state.c, state.r, persistedForm(state)]
+    );
+  }
+  /** Join `addition` into the record's base state. */
+  async joinIntoBase(tx, addition) {
+    const base = await this.loadBase(tx, addition.c, addition.r);
+    await this.saveBase(tx, base === null ? addition : joinStates(base, addition, this.schema));
+  }
+  /**
+   * Write the row of a record from its fold state.
+   *
+   * - No insert merged: no row (an existing one is hidden).
+   * - Otherwise the row holds the fold's values (also while deleted: a tombstone
+   *   keeps its last values), `_deleted` from the record's liveness, and versions
+   *   from the state: `_version` / `_updated_at` = newest operation, `_created_at` =
+   *   creation, `_field_versions` = each field's newest write.
+   * - Only `fields` are written to an existing row; columns the fold never wrote
+   *   (a column a schema migration added with a default, a local-only backfill)
+   *   keep their stored value.
+   * - A row hidden by a scope retraction stays hidden unless `clearRetraction`
+   *   (a scope-entry insert) is set.
+   */
+  async materializeRow(tx, state, fields, options) {
+    const collection = state.c;
+    const definition = this.schema.collections[collection];
+    if (!definition) return;
+    const table = quoteIdent3(collection);
+    const rows = options.absent ? [] : await tx.query(`SELECT id, _deleted FROM ${table} WHERE id = ?`, [
+      state.r
+    ]);
+    const existing = rows[0];
+    if (state.cr === null || state.u === null) {
+      if (existing && existing._deleted !== 1) {
+        await tx.execute(`UPDATE ${table} SET _deleted = 1 WHERE id = ?`, [state.r]);
+      }
+      return;
+    }
+    const asLive = { ...state, d: null };
+    const values = materialize(asLive, { richtext: mergeYjsUpdates }) ?? {};
+    const latest = HybridLogicalClock.deserialize(state.u.t);
+    const created = HybridLogicalClock.deserialize(state.cr.t);
+    const fieldVersions = getFoldFieldVersionStrings(state);
+    let deleted = isDeadState(state) ? 1 : 0;
+    if (existing && deleted === 0) {
+      const retracted = await tx.query(
+        "SELECT record_id FROM _kora_scope_retractions WHERE collection = ? AND record_id = ?",
+        [collection, state.r]
+      );
+      if (retracted.length > 0) {
+        if (options.clearRetraction) {
+          await tx.execute(
+            "DELETE FROM _kora_scope_retractions WHERE collection = ? AND record_id = ?",
+            [collection, state.r]
+          );
+        } else {
+          deleted = 1;
+        }
+      }
+    }
+    const known = Object.keys(definition.fields);
+    const writable = existing && deleted === 1 ? [] : known.filter((field) => field in state.f && (fields === "all" || fields.has(field)));
+    const fieldValues = {};
+    for (const field of writable) {
+      const value = values[field] ?? null;
+      fieldValues[field] = definition.fields[field]?.kind === "richtext" && value !== null && typeof value === "object" && "$koraBytes" in value ? mergeYjsUpdates([base64ToBytes(String(value.$koraBytes))]) : value;
+    }
+    const serialized = serializeRecord(fieldValues, definition.fields);
+    const meta = {
+      _updated_at: latest.wallTime,
+      _version: state.u.t,
+      _field_versions: JSON.stringify(fieldVersions),
+      _deleted: deleted
+    };
+    if (!existing) {
+      const insert = buildInsertQuery(collection, {
+        id: state.r,
+        ...serialized,
+        ...meta,
+        _created_at: created.wallTime
+      });
+      await tx.execute(insert.sql, insert.params);
+      return;
+    }
+    const changes = {
+      ...serialized,
+      ...meta,
+      _created_at: created.wallTime
+    };
+    const columns = Object.keys(changes);
+    await tx.execute(
+      `UPDATE ${table} SET ${columns.map((c) => `${quoteIdent3(c)} = ?`).join(", ")} WHERE id = ?`,
+      [...columns.map((c) => changes[c]), state.r]
+    );
+  }
+  /**
+   * Load the record's state; rebuild it from base + log when it is missing or in
+   * another format version. `rebuilt` tells the caller to rewrite the whole row.
+   */
+  async loadOrRebuild(tx, collection, recordId, appendedId) {
+    const stored = await this.loadState(tx, collection, recordId);
+    if (stored !== null) return { state: stored, rebuilt: false };
+    const hasRow = await this.hasStateRow(tx, collection, recordId);
+    const others = await tx.query(
+      `SELECT COUNT(*) AS n FROM ${quoteIdent3(`_kora_ops_${collection}`)} WHERE record_id = ? AND id != ?`,
+      [recordId, appendedId]
+    );
+    const retained = await loadRetainedConflictRows(
+      (sql, params) => tx.query(sql, params),
+      collection,
+      recordId
+    );
+    const hasBase = await this.loadBase(tx, collection, recordId) !== null || await this.loadSnapshot(tx, collection, recordId) !== null || (await this.loadProvisional(tx, collection, recordId)).some((p) => p.id !== appendedId);
+    if (!hasRow && !hasBase && (others[0]?.n ?? 0) === 0 && retained.every((row) => row.id === appendedId)) {
+      return { state: createFoldState(collection, recordId), rebuilt: false };
+    }
+    const rebuilt = await this.foldFromLog(tx, collection, recordId);
+    return { state: rebuilt ?? createFoldState(collection, recordId), rebuilt: true };
+  }
+  async hasStateRow(tx, collection, recordId) {
+    const rows = await tx.query(
+      `SELECT COUNT(*) AS n FROM ${FOLD_STATE_TABLE} WHERE collection = ? AND record_id = ?`,
+      [collection, recordId]
+    );
+    return (rows[0]?.n ?? 0) > 0;
+  }
+  async readStateRow(tx, table, collection, recordId) {
+    const rows = await tx.query(
+      `SELECT state FROM ${table} WHERE collection = ? AND record_id = ?`,
+      [collection, recordId]
+    );
+    const raw = rows[0]?.state;
+    if (raw === void 0) return null;
+    try {
+      return deserializeFoldState(raw);
+    } catch (error) {
+      if (error instanceof FoldStateError) return null;
+      throw error;
+    }
+  }
+  async toMergeTraces(tx, traces) {
+    const out = [];
+    for (const trace of traces) {
+      let prior = null;
+      if (trace.priorOperationId !== null) {
+        const rows = await tx.query(
+          `SELECT * FROM ${quoteIdent3(`_kora_ops_${trace.operation.collection}`)} WHERE id = ?`,
+          [trace.priorOperationId]
+        );
+        const row = rows[0];
+        if (row) prior = deserializeOperationWithCollection(row, trace.operation.collection);
+      }
+      out.push(toMergeTrace(trace, prior));
+    }
+    return out;
+  }
+};
+function persistedForm(state) {
+  return JSON.stringify(state);
+}
+function isDeadState(state) {
+  return !isFoldStateLive(state);
+}
+
+export {
+  rehashOperation,
+  renumberOperationRow,
+  rewriteDependentsInTx,
+  allocateNextSequenceInTransaction,
+  SEQ_CONFLICTS_TABLE,
+  repairSequenceUniqueness,
+  insertConflictRow,
+  loadRetainedConflictRows,
+  isOperationLogged,
+  FOLD_STATE_TABLE,
+  FOLD_BASE_TABLE,
+  COMPACTED_THROUGH_TABLE,
+  FOLD_SNAPSHOT_TABLE,
+  PROVISIONAL_OPS_TABLE,
+  FOLD_MATERIALIZATION_META_KEY,
+  FOLD_MATERIALIZATION_CURRENT,
+  FOLD_MATERIALIZATION_LEGACY,
+  FOLD_TABLES_DDL,
+  mergeYjsUpdates,
+  isCompacted,
+  RecordFolder
+};
+//# sourceMappingURL=chunk-32EDKWMI.js.map