@cleocode/core 2026.10.7 → 2026.10.8

package/dist/store/sync/apply/applier.js

@@ -39,6 +39,9 @@
  *    so the sealer echoes nothing; row meta is set to the engine's state,
  *    conflicts are recorded, and the transaction is marked `applied`,
  *    `conflict` (something recorded) or `void` (every op refused).
+ *    A late transaction of a replica retired earlier in the stream is
+ *    inherited history (§3.5 D5, T13278): applied the same way, but its merge
+ *    conflicts are not recorded against the successor's reconcile.
  *
  * Passes repeat while a pass applies something, so a transaction pending on
  * a row a later transaction inserts applies in the same call.
@@ -58,7 +61,8 @@
  */
 import { BIRTH_FP_COLUMN, UID_COLUMN } from '../../row-identity-registry.js';
 import { captureTableDef } from '../capture.js';
-import { recordConflictOnce, recordConflicts } from '../conflicts.js';
+import { announcePlacedRekeys, settleLostUidCollisions } from '../collision-settle.js';
+import { recordConflictOnce, recordConflicts, resolveHeldConflicts } from '../conflicts.js';
 import { clearFieldLeaves, readFieldFrontiers, readFieldLeaves, recordFieldLeaves, restoreFieldState, setFieldFrontiers, } from '../field-leave.js';
 import { accountRebaseRows, heldOp, holdOp, txnHasHold, unholdOp } from '../held.js';
 import { encodeHlc, genesisHlc, isWithinSkew, parseHlc } from '../hlc.js';
@@ -67,16 +71,19 @@ import { applyOp, checkSchemaVersion } from '../merge/engine.js';
 import { mergeSpecFor } from '../merge/rules.js';
 import { UNSEEN_ROW, } from '../merge/types.js';
 import { remapPending } from '../remap.js';
+import { isInheritedHistory } from '../retire.js';
 import { fieldHlcsOf, readRowMetaFull, restoreRowMeta } from '../row-meta.js';
 import { hasTable } from '../schema.js';
 import { canonicalJson } from '../sealer-values.js';
 import { capturePosition, markSequenced, ownEchoFastPath, readRowUndo, recordForeignTouches, recordUndoBudget, resnapshotRowUndo, unsequencedLocalTxn, unsequencedLocalTxns, } from '../sequencing.js';
 import { withTriggersSuspended } from '../trigger-classes.js';
+import { followUidAliases, markAliasPlaced, recordUidAlias } from '../uid-alias.js';
 import { widenFootprint } from './footprints.js';
 import { withApplyFrame } from './frame.js';
 import { parentDeletePolicy } from './parent-delete.js';
 import { checkApplyPreconditions, checkTaskTreeShape } from './post-apply.js';
 import { resolveRef, uidOfKey } from './refs.js';
+import { wireToSql } from './write-api.js';
 const rowKey = (t, u) => `${t}\u0000${u}`;
 const keyText = (k) => `${k.stream}:${k.seq}:${k.txnIdx}`;
 /**
@@ -161,6 +168,63 @@ function uidCollision(db, def, op, resolution) {
         opHlc: op.h,
     };
 }
+/**
+ * The local-key collision an insert would hit, or null (T12341 §6.4 step 7,
+ * T13397): a minted row whose local key (a display id, never the uid or a
+ * device-local rowid) a live row of another uid holds here. The insert is
+ * held, never voided by the UNIQUE constraint: a re-mint of the key settles
+ * it (§9.2).
+ */
+function keyCollision(db, def, op, goneInTxn) {
+    if (op.o !== 'I' || !op.a || !def.identity.includes(BIRTH_FP_COLUMN))
+        return null;
+    const cols = def.key.filter((k) => k !== UID_COLUMN && k !== def.localRowid);
+    if (cols.length === 0 || cols.some((k) => op.a?.[k] === undefined || op.a?.[k] === null)) {
+        return null;
+    }
+    const row = db
+        .prepare(`SELECT "${UID_COLUMN}" AS uid FROM main."${def.table.replaceAll('"', '""')}" WHERE ${cols
+        .map((k) => `"${k.replaceAll('"', '""')}" = ?`)
+        .join(' AND ')}`)
+        .get(...cols.map((k) => wireToSql(op.a?.[k])));
+    // The holder is this row, or a row the transaction deletes first (a key re-used).
+    if (!row || row.uid === op.u || (row.uid !== null && goneInTxn(row.uid)))
+        return null;
+    return {
+        kind: 'key-collision',
+        table: op.t,
+        uid: op.u,
+        columns: cols,
+        resolution: 'op-held',
+        opHlc: op.h,
+    };
+}
+/**
+ * A reference of `op` to a uid in an open uid collision here, or null
+ * (T13397). Until the collision settles the uid names two rows, so the
+ * reference waits rather than bind to the wrong one; after the loser's K its
+ * origin's earlier references are read through the alias.
+ */
+function collidingRef(db, op, def, inTxn) {
+    if (!op.a || !hasTable(db, '_sync_conflict'))
+        return null;
+    const open = db.prepare(`SELECT 1 FROM _sync_conflict WHERE kind = 'uid-collision' AND tbl = ? AND uid = ? AND resolved_at IS NULL LIMIT 1`);
+    for (const [col, v] of Object.entries(op.a)) {
+        const target = def.refs.get(col);
+        if (!target || typeof v !== 'string' || inTxn.has(rowKey(target.table, v)))
+            continue;
+        if (open.get(target.table, v) !== undefined)
+            return { col, uid: v };
+    }
+    return null;
+}
+/** Whether a uid collision on (table, uid) was ever recorded here (T13399). */
+function hadUidCollision(db, table, uid) {
+    return (hasTable(db, '_sync_conflict') &&
+        db
+            .prepare(`SELECT 1 FROM _sync_conflict WHERE kind = 'uid-collision' AND tbl = ? AND uid = ? LIMIT 1`)
+            .get(table, uid) !== undefined);
+}
 /**
  * A missing reference of `op` (a target never seen), or null. A target the
  * transaction itself inserts or re-keys to counts as present wherever its op
@@ -236,6 +300,25 @@ function planTxn(db, api, st, defs, localReplica) {
                 holds: holds(),
             };
         }
+        const ambiguous = collidingRef(db, op, def, txnRows);
+        if (ambiguous !== null) {
+            return {
+                kind: 'pending',
+                reason: `${op.t}/${op.u}: reference ${ambiguous.col} to ${ambiguous.uid}, a uid in an open collision`,
+                holds: holds(),
+            };
+        }
+        const keyClash = states.has(k)
+            ? null
+            : keyCollision(db, def, op, (uid) => states.get(rowKey(op.t, uid))?.live === false);
+        if (keyClash !== null) {
+            return {
+                kind: 'pending',
+                reason: `${op.t}/${op.u}: local key ${keyClash.columns.join(', ')} is held by another row`,
+                holds: holds(),
+                collision: { opIdx, conflict: keyClash },
+            };
+        }
         const before = states.get(k) ?? loadRowState(db, api, def, op.u, localReplica);
         let spec = specs.get(op.t);
         if (!spec) {
@@ -460,8 +543,15 @@ function applyRekey(c, opIdx, op) {
     const nu = op.nu ?? op.u;
     const oldLive = rowExists(c.api, op.t, op.u);
     const newLive = nu !== op.u && rowExists(c.api, op.t, nu);
+    // The re-keyed row's later ops, and its origin's earlier references, follow
+    // it (T12341 §6.4 step 1, T13397).
+    const oldFp = op.obfp ?? op.bfp;
+    if (oldFp && nu !== op.u) {
+        recordUidAlias(c.db, { table: op.t, oldUid: op.u, oldBfp: oldFp, newUid: nu, origin: c.st.replicaId, hlc: op.h }, c.nowIso);
+    }
+    // Already re-keyed, deleted, or never placed here (a held loser): the alias is all.
     if (!oldLive)
-        return { result: 'skipped', conflicts: 0 }; // already re-keyed, or deleted
+        return { result: 'skipped', conflicts: 0 };
     // A K names the row it moves by (uid, old fingerprint): a live row holding
     // that uid with another fingerprint is the collision's winner, and a re-key
     // of the other row never touches it (T12341 §6.4, T13394).
@@ -484,6 +574,12 @@ function applyRekey(c, opIdx, op) {
     // and it would no longer match its `*K` intent.
     remapPending(c.db, { table: op.t, oldUid: op.u, newUid: nu, newBfp: op.bfp ?? null });
     c.api.rekeyRow(op.t, op.u, nu, op.bfp ?? null);
+    // Another replica settled a uid collision by re-keying a loser this replica
+    // had placed: its own earlier references to the old uid meant this row, so
+    // it owes the re-key's announcement (T13399).
+    if (op.obfp && nu !== op.u && c.st.replicaId !== c.replica && hadUidCollision(c.db, op.t, op.u)) {
+        markAliasPlaced(c.db, op.t, op.u, op.obfp);
+    }
     return { result: 'applied', conflicts: 0 };
 }
 /**
@@ -599,7 +695,9 @@ function applyOne(c, opIdx, op) {
         const st = c.replay
             ? { ...c.st, replicaId: c.replica, txn: { ...c.st.txn, actor: c.replay.actor } }
             : c.st;
-        const n = effect(c.db, c.api, st, opIdx, { op, def, before, out, refKeys }, c.nowIso, c.replay !== undefined);
+        const history = c.history === true && out.status !== 'void';
+        const recorded = effect(c.db, c.api, st, opIdx, { op, def, before, out, refKeys }, c.nowIso, c.replay !== undefined || history);
+        const n = history ? 0 : recorded;
         c.db.exec(`RELEASE ${sp}`);
         const result = out.status === 'applied' || out.status === 'partial'
             ? 'applied'
@@ -1085,7 +1183,15 @@ function applyInPage(x, st) {
     const local = x.sequencingOn && st.replicaId === opts.replica ? unsequencedLocalTxn(db, st.txn.txn) : null;
     // An own echo whose transaction the page rewound applies it at its stream position.
     const rewoundEcho = local !== null && x.rewound.has(local.txn);
-    const c = { db, api, st, defs, replica: opts.replica, nowIso };
+    const c = {
+        db,
+        api,
+        st,
+        defs,
+        replica: opts.replica,
+        nowIso,
+        history: isInheritedHistory(db, opts.stream, st.replicaId, st.key.seq),
+    };
     let n = 0;
     // Gate C (§3.6): the whole transaction is one savepoint, so a broken
     // multi-row invariant rolls all of it back (the page's rewind stays).
@@ -1165,6 +1271,8 @@ function applyInPage(x, st) {
         reason: n > 0 ? `${n} conflict(s) recorded` : null,
         nowIso,
     });
+    // A collision it was held on has settled: it went through (T13397).
+    resolveHeldConflicts(db, st.key, nowIso);
     return { status, holds: [], n, applied: true, decided: rewoundEcho && local ? local.txn : null };
 }
 /**
@@ -1216,94 +1324,109 @@ export function applyStagedTxns(db, opts) {
     let passes = 0;
     let rebased = 0;
     const heldTxns = new Set();
-    for (let progress = true; progress && passes < maxPasses;) {
-        progress = false;
-        passes += 1;
-        const heldReplicas = new Set();
-        const held = new Set(); // rows written by a pending transaction
-        const staged = stagedTxns(db, opts.stream).map((st) => withoutLocalRowids(st, defs));
-        // Each page is one frame and one scoped rebase (§3.5 Rule 3): rewind the
-        // page's scope once, apply its transactions in stream order, replay once.
-        for (let at = 0; at < staged.length;) {
-            const page = takePage(staged, at, opts.pageOps ?? REBASE_PAGE_OPS);
-            const pageStart = now();
-            const done = withApplyFrame(db, opts.scope, page[0]?.actor ?? null, (api) => {
-                const pageIso = new Date(pageStart).toISOString();
-                for (const p of page)
-                    adoptNaturalRows(db, api, defs, p.st.txn.ops);
-                const planned = sequencingOn
-                    ? planPageRebase(db, page.map((p) => p.st), defs, opts.replica)
-                    : { plan: null, inPlace: new Set() };
-                const rebase = planned.plan;
-                const c0 = {
-                    db,
-                    api,
-                    st: page[0].st,
-                    defs,
-                    replica: opts.replica,
-                    nowIso: pageIso,
-                };
-                const rw = rebase ? rewindTxns(c0, rebase) : { kept: new Map(), after: new Map() };
-                const rewound = new Set(rebase?.rewind.map((l) => l.txn) ?? []);
-                const decided = new Set(); // rewound locals whose echo this page applied
-                // The time bound covers applying, not the rewind: a large scope must
-                // not shrink every page to one transaction that rewinds it again.
-                const applyStart = now();
-                let taken = 0;
-                for (const { st } of page) {
-                    // The time bound cuts a page between transactions (never inside one).
-                    if (taken > 0 && now() - applyStart > (opts.pageMs ?? REBASE_PAGE_MS))
-                        break;
-                    taken += 1;
-                    const nowMs = now();
-                    const nowIso = new Date(nowMs).toISOString();
-                    const id = keyText(st.key);
-                    const result = applyInPage({
+    const runPasses = () => {
+        for (let progress = true; progress && passes < maxPasses;) {
+            progress = false;
+            passes += 1;
+            const heldReplicas = new Set();
+            const held = new Set(); // rows written by a pending transaction
+            const staged = stagedTxns(db, opts.stream).map((st) => followUidAliases(db, withoutLocalRowids(st, defs), defs));
+            // Each page is one frame and one scoped rebase (§3.5 Rule 3): rewind the
+            // page's scope once, apply its transactions in stream order, replay once.
+            for (let at = 0; at < staged.length;) {
+                const page = takePage(staged, at, opts.pageOps ?? REBASE_PAGE_OPS);
+                const pageStart = now();
+                const done = withApplyFrame(db, opts.scope, page[0]?.actor ?? null, (api) => {
+                    const pageIso = new Date(pageStart).toISOString();
+                    for (const p of page)
+                        adoptNaturalRows(db, api, defs, p.st.txn.ops);
+                    const planned = sequencingOn
+                        ? planPageRebase(db, page.map((p) => p.st), defs, opts.replica)
+                        : { plan: null, inPlace: new Set() };
+                    const rebase = planned.plan;
+                    const c0 = {
                         db,
                         api,
+                        st: page[0].st,
                         defs,
-                        opts,
-                        sequencingOn,
-                        rewound,
-                        inPlace: planned.inPlace,
-                        rw,
-                        nowMs,
-                        nowIso,
-                        held,
-                        heldReplicas,
-                    }, st);
-                    if (result.decided)
-                        decided.add(result.decided);
-                    for (const t of result.heldTxns ?? [])
-                        heldTxns.add(t);
-                    if (result.status !== null)
-                        last.set(id, result.status);
-                    conflicts += result.n;
-                    if (rebase && result.applied)
-                        rebased += 1;
-                    if (result.status === 'held-skew')
-                        heldReplicas.add(st.replicaId);
-                    if (result.status === 'pending')
-                        for (const k of result.holds)
-                            held.add(k);
-                    if (result.status === 'applied' ||
-                        result.status === 'conflict' ||
-                        result.status === 'void') {
-                        progress = true;
+                        replica: opts.replica,
+                        nowIso: pageIso,
+                    };
+                    const rw = rebase
+                        ? rewindTxns(c0, rebase)
+                        : { kept: new Map(), after: new Map() };
+                    const rewound = new Set(rebase?.rewind.map((l) => l.txn) ?? []);
+                    const decided = new Set(); // rewound locals whose echo this page applied
+                    // The time bound covers applying, not the rewind: a large scope must
+                    // not shrink every page to one transaction that rewinds it again.
+                    const applyStart = now();
+                    let taken = 0;
+                    for (const { st } of page) {
+                        // The time bound cuts a page between transactions (never inside one).
+                        if (taken > 0 && now() - applyStart > (opts.pageMs ?? REBASE_PAGE_MS))
+                            break;
+                        taken += 1;
+                        const nowMs = now();
+                        const nowIso = new Date(nowMs).toISOString();
+                        const id = keyText(st.key);
+                        const result = applyInPage({
+                            db,
+                            api,
+                            defs,
+                            opts,
+                            sequencingOn,
+                            rewound,
+                            inPlace: planned.inPlace,
+                            rw,
+                            nowMs,
+                            nowIso,
+                            held,
+                            heldReplicas,
+                        }, st);
+                        if (result.decided)
+                            decided.add(result.decided);
+                        for (const t of result.heldTxns ?? [])
+                            heldTxns.add(t);
+                        if (result.status !== null)
+                            last.set(id, result.status);
+                        conflicts += result.n;
+                        if (rebase && result.applied)
+                            rebased += 1;
+                        if (result.status === 'held-skew')
+                            heldReplicas.add(st.replicaId);
+                        if (result.status === 'pending')
+                            for (const k of result.holds)
+                                held.add(k);
+                        if (result.status === 'applied' ||
+                            result.status === 'conflict' ||
+                            result.status === 'void') {
+                            progress = true;
+                        }
                     }
-                }
-                // Replay what the page rewound and did not decide by its echo.
-                if (rebase) {
-                    const replay = rebase.rewind.filter((l) => !decided.has(l.txn));
-                    for (const t of replayTxns(c0, { rewind: rebase.rewind, replay, own: null }, rw)) {
-                        heldTxns.add(t);
+                    // Replay what the page rewound and did not decide by its echo.
+                    if (rebase) {
+                        const replay = rebase.rewind.filter((l) => !decided.has(l.txn));
+                        for (const t of replayTxns(c0, { rewind: rebase.rewind, replay, own: null }, rw)) {
+                            heldTxns.add(t);
+                        }
                     }
-                }
-                return taken;
-            });
-            at += done;
+                    return taken;
+                });
+                at += done;
+            }
         }
+    };
+    runPasses();
+    // The origin of a lost uid collision re-keys its row, then the held winner
+    // places under the freed uid (T12341 §6.4, T13397).
+    if (settleLostUidCollisions(db, opts).length > 0) {
+        opts.seal?.();
+        runPasses();
     }
+    // Every other replica that had placed a re-keyed loser announces the
+    // re-key, so its earlier references follow the loser too (T13399).
+    if (announcePlacedRekeys(db, opts, new Date(now()).toISOString()) > 0)
+        opts.seal?.();
     const count = (s) => [...last.values()].filter((v) => v === s).length;
     return {
         applied: count('applied'),