rapier-markdown-kit 1.1.104 → 1.2.5

package/dist/kit/ledger/inverse-source.mjs

@@ -2,6 +2,8 @@
 // Exact source projection shared by canonical history and causal transport.
 // Callers admit and order the records first; this projection retains no state.
 import {_rapierTransformSplices, _rapierHistoryEffects} from './journal-records.mjs';
+import {authoredPlacements} from './authored-origin.mjs';
+import {canonicalJSON} from './data.mjs';
 import {diff} from '../../packages/rapier-diff/index.mjs';
 
 const historyFailure = reason => ({ok: false, reason});
@@ -174,6 +176,24 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 	try {
 		let pieces = prepared.initialSource ? [{text: prepared.initialSource, owner: null, lineage: []}] : [];
 		const all = [], byId = new Map(), byAct = new Map(), processed = [], keptInverseAncestors = new Set();
+		const recordsForCover = prepared.records || prepared.rows.map(({record, splices}) => record.splices === splices ? record : {...record, splices});
+		const coverGroups = new Map();
+		let coverOrigins = null;
+		// An empty document is a real causal source. Fresh notes start there, and a
+		// shared replacement authored against that source still has to stay covered.
+		if (typeof prepared.initialSource === 'string' && recordsForCover.some(record => record.authored?.splices?.some(row => row.removed.length))) {
+			try { coverOrigins = authoredPlacements(prepared.initialSource, recordsForCover); } catch { coverOrigins = null; }
+		}
+		const coverIdsFor = id => {
+			const origin = coverOrigins?.get(id);
+			if (!origin?.splices.some(row => row.removed.length)) return null;
+			const key = canonicalJSON({basis: origin.basis, splices: origin.splices});
+			if (!coverGroups.has(key)) coverGroups.set(key, []);
+			const ids = coverGroups.get(key);
+			if (!ids.includes(id)) ids.push(id);
+			return ids;
+		};
+		const coverHeld = hunk => hunk.coverIds?.length > 1 && hunk.coverIds.some(id => projectedEffects.active.has(id));
 		const texts = rows => rows.map(row => row.text || '');
 		const textOf = rows => texts(rows).join('');
 		const lengthOf = (rows, to = rows.length) => { let size = 0; for (let i = 0; i < to; i++) size += rows[i].text?.length || 0; return size; };
@@ -234,8 +254,16 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 			return next && effects.active.has(next.actId) && !prepared.effects.references.get(next.actId)?.length;
 		});
 		const reactivate = (actIds, effects) => {
+			// Any author of one shared removal or replacement restores that one physical
+			// hunk, including an author who stored no splice. A later independent act
+			// keeps the bytes it wrote until that act itself is withdrawn.
+			const wanted = new Set(actIds);
+			for (const id of actIds) for (const hunk of all) {
+				if (hunk.reversedHunk || hunk.derived || !hunk.coverIds?.includes(id) || wanted.has(hunk.actId)) continue;
+				if (hunk.coverIds.some(cover => effects.active.has(cover))) wanted.add(hunk.actId);
+			}
 			for (const hunk of all) {
-				if (!actIds.has(hunk.actId) || hunk.derived || prepared.effects.references.get(hunk.actId)?.length) continue;
+				if (!wanted.has(hunk.actId) || hunk.derived || prepared.effects.references.get(hunk.actId)?.length) continue;
 				if (keptInverseAncestors.has(hunk.id)) continue;
 				if (laterSource(hunk, effects) || pieces.some(piece => piece.text && piece.owner === hunk.id) ||
 					(!hunk.inserted && hunk.active)) continue;
@@ -245,8 +273,9 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 					// inverse's marker. Its exact ancestry also preserves later inserted runs.
 					const inverse = all.findLast(prior => prior.reversedHunk === hunk.id && pieces.includes(prior.marker));
 					if (!inverse) throw Error('reactivation');
-					if (laterSource(inverse, effects)) continue;
-					restoreHunk(inverse); inverse.active = false;
+					const runs = all.filter(prior => prior.actId === inverse.actId && prior.reversedHunk === hunk.id && pieces.includes(prior.marker));
+					if (runs.some(prior => laterSource(prior, effects))) continue;
+					for (const prior of runs) { restoreHunk(prior); prior.active = false; }
 					hunk.active = true; delete hunk.undoneBy;
 					continue;
 				}
@@ -291,51 +320,65 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 			if (references.size) {
 				// Exact inverse rows restore the previous run identities. Retain the inverse's
 				// own transient marker too, so reversing it restores that same ancestry again.
-				const targets = all.filter(hunk => hunk.active && references.has(hunk.actId));
-				let restored = targets.length ? pieces.slice() : null;
-				const inverses = [], priorSplices = options.keepHunk ? [] : null;
-				for (let index = targets.length - 1; restored && index >= 0; index--) {
-					const target = targets[index], first = restored.indexOf(target.marker);
-					if (first < 0) { restored = null; break; }
-					let last = first;
-					for (let at = first; at < restored.length; at++) if (owns(restored[at], target)) last = at;
-					const pos = lengthOf(restored, first);
-					const before = restored.slice(first, last + 1), replacement = [];
-					for (const piece of before) {
-						if (piece === target.marker) replacement.push(...target.before);
-						else if (!owns(piece, target)) replacement.push(piece);
-					}
-					const id = tx.id + '#inverse:' + index, lineage = new Set([id]);
-					for (const piece of before) for (const parent of piece.lineage || piece.mark?.lineage || []) lineage.add(parent);
-					const hunk = {id, actId: tx.id, removed: textOf(before), inserted: textOf(replacement), before, reversedHunk: target.id,
-						chosen: selected.has(tx.id), lineage: [...lineage], supersededBy: new Set(), active: true,
-						restoredMarkers: new Set(replacement.filter(piece => !piece.text))};
-					if (hunk.chosen && options.keepHunk) {
-						const spliceIndex = splices.findIndex(row => row.pos <= pos && row.pos + row.removed.length >= pos);
-						const keep = options.keepHunk({actId: tx.id, spliceIndex: Math.max(0, spliceIndex), hunkIndex: index,
-							splice: {pos, removed: hunk.removed, inserted: hunk.inserted}, beforeSource: textOf(restored), actSource, priorSplices});
-						if (typeof keep !== 'boolean') throw Error('hunk_selection');
-						hunk.chosen = !keep;
+				const invert = targets => {
+					const restored = pieces.slice(), inverses = [], priorSplices = options.keepHunk ? [] : null;
+					for (let index = targets.length - 1; index >= 0; index--) {
+						const target = targets[index], first = restored.indexOf(target.marker);
+						if (first < 0) return null;
+						// Each run of the target's own pieces inverts alone: a later author's pieces between
+						// its runs stay in place, outside every inverse, so reversing it cannot move them.
+						const runs = [];
+						for (let at = first; at < restored.length; at++) if (owns(restored[at], target))
+							if (runs.at(-1)?.[1] === at) runs.at(-1)[1]++; else runs.push([at, at + 1]);
+						for (let run = runs.length - 1; run >= 0; run--) {
+							const [from, to] = runs[run], before = restored.slice(from, to), pos = lengthOf(restored, from);
+							const replacement = run ? [] : target.before;
+							const id = tx.id + '#inverse:' + index + (run ? '.' + run : ''), lineage = new Set([id]);
+							for (const piece of before) for (const parent of piece.lineage || piece.mark?.lineage || []) lineage.add(parent);
+							const hunk = {id, actId: tx.id, removed: textOf(before), inserted: textOf(replacement), before, reversedHunk: target.id,
+								chosen: selected.has(tx.id), lineage: [...lineage], supersededBy: new Set(), active: true,
+								restoredMarkers: new Set(replacement.filter(piece => !piece.text))};
+							if (hunk.chosen && options.keepHunk) {
+								const spliceIndex = splices.findIndex(row => row.pos <= pos && row.pos + row.removed.length >= pos);
+								const keep = options.keepHunk({actId: tx.id, spliceIndex: Math.max(0, spliceIndex), hunkIndex: index,
+									splice: {pos, removed: hunk.removed, inserted: hunk.inserted}, beforeSource: textOf(restored), actSource, priorSplices});
+								if (typeof keep !== 'boolean') throw Error('hunk_selection');
+								hunk.chosen = !keep;
+							}
+							hunk.kept = selected.has(tx.id) && !hunk.chosen;
+							// A semantic owner retaining this inverse also retains the exact ancestors
+							// it restored; effect reactivation must not change them behind that owner.
+							if (hunk.kept) for (let prior = target; prior; prior = byId.get(prior.reversedHunk)) keptInverseAncestors.add(prior.id);
+							hunk.marker = {mark: hunk};
+							const insertion = replacement.map(piece => piece.text ? {...piece,
+								lineage: [...new Set([...(piece.lineage || []), id])],
+								restoredBy: [...(piece.restoredBy || []), id]} : piece);
+							restored.splice(from, to - from, hunk.marker, ...insertion);
+							inverses.push(hunk); priorSplices?.push({pos, removed: hunk.removed, inserted: hunk.inserted});
+						}
 					}
-					hunk.kept = selected.has(tx.id) && !hunk.chosen;
-					// A semantic owner retaining this inverse also retains the exact ancestors
-					// it restored; effect reactivation must not change them behind that owner.
-					if (hunk.kept) for (let prior = target; prior; prior = byId.get(prior.reversedHunk)) keptInverseAncestors.add(prior.id);
-					hunk.marker = {mark: hunk};
-					const insertion = replacement.map(piece => piece.text ? {...piece,
-						lineage: [...new Set([...(piece.lineage || []), id])],
-						restoredBy: [...(piece.restoredBy || []), id]} : piece);
-					restored.splice(first, last + 1 - first, hunk.marker, ...insertion);
-					inverses.push(hunk); priorSplices?.push({pos, removed: hunk.removed, inserted: hunk.inserted});
-				}
-				if (restored && replays(pieces, restored, splices)) {
-					pieces = restored;
-					for (const target of targets) { target.active = false; target.undoneBy = tx.id; }
+					return replays(pieces, restored, splices) ? {restored, inverses} : null;
+				};
+				// An inverse taken while a later edit had replaced some of the act's hunks restored only
+				// the rest. Those replaced hunks survive it: no later projection treats them as undone.
+				// Recorded splices decide. An author who stored no splice still inverts the one
+				// shared hunk; an empty inverse does not match that text change and leaves it.
+				const direct = all.filter(hunk => hunk.active && references.has(hunk.actId));
+				const targets = direct.length ? direct : all.filter(hunk => hunk.active && !hunk.reversedHunk && !hunk.derived &&
+					hunk.coverIds?.some(id => references.has(id)));
+				const free = targets.filter(hunk => ![...hunk.supersededBy].some(id => byId.get(id)?.active));
+				let found = targets.length ? invert(targets) : null, survivors = [];
+				if (!found && free.length && free.length < targets.length && (found = invert(free)))
+					survivors = targets.filter(hunk => !free.includes(hunk));
+				if (found) {
+					pieces = found.restored;
+					for (const target of targets) if (survivors.includes(target)) target.survived = true;
+					else { target.active = false; target.undoneBy = tx.id; }
 					for (const piece of pieces) if (piece.mark) {
 						piece.mark.active = true; delete piece.mark.undoneBy;
 					}
-					for (const hunk of inverses) { all.push(hunk); byId.set(hunk.id, hunk); }
-					byAct.set(tx.id, inverses);
+					for (const hunk of found.inverses) { all.push(hunk); byId.set(hunk.id, hunk); }
+					byAct.set(tx.id, found.inverses);
 					continue;
 				}
 			}
@@ -354,6 +397,7 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 					for (const [hunk, active, undoneBy] of priorStates) { hunk.active = active; hunk.undoneBy = undoneBy; }
 				}
 			}
+			if (!references.size) coverIdsFor(tx.id);
 			const priorSplices = options.keepHunk ? [] : null;
 			// An admitted codec finish replaces the complete embedded definition/reference.
 			// Keep its inserted run whole, including byte-identical prefixes of a re-edit;
@@ -395,7 +439,8 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 					const lineage = new Set([id]);
 					for (const piece of removed) for (const parent of piece.lineage || piece.mark?.lineage || []) lineage.add(parent);
 					const hunk = {id, actId: tx.id, removed: row.removed, inserted: row.inserted, before: removed, derived,
-						chosen, kept: selected.has(tx.id) && !chosen, lineage: [...lineage], supersededBy: new Set(), active: true};
+						chosen, kept: selected.has(tx.id) && !chosen, lineage: [...lineage], supersededBy: new Set(), active: true,
+						...(coverIdsFor(tx.id) ? {coverIds: coverIdsFor(tx.id)} : {})};
 					hunk.marker = {mark: hunk};
 					all.push(hunk); byId.set(id, hunk);
 					if (!byAct.has(tx.id)) byAct.set(tx.id, []);
@@ -414,9 +459,22 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 		let offset = 0;
 		for (const piece of pieces) if (piece.text) { origins.set(piece, offset); offset += piece.text.length; }
 		const superseded = [];
+		// Survival means an inverse left this hunk in place because a later independent
+		// edit still covered it. Once that edit is gone, deactivating its last owner through
+		// any inverse path withdraws every exposed hunk. Undoing only the later
+		// edit reveals the survived insertion and does not discard it.
+		for (const hunk of all) if (hunk.survived) {
+			const covered = [...hunk.supersededBy].some(id => {
+				const next = byId.get(id);
+				return next?.active && projectedEffects.active.has(next.actId) && !prepared.effects.references.get(next.actId)?.length;
+			});
+			const owners = hunk.coverIds?.length ? hunk.coverIds : [hunk.actId];
+			if (!covered && owners.some(id => prepared.effects.active.has(id)) && !owners.some(id => projectedEffects.active.has(id))) hunk.survived = false;
+		}
 		for (let index = all.length - 1; index >= 0; index--) {
 			const hunk = all[index];
-			const inheritedInactive = !hunk.derived && !hunk.kept && !keptInverseAncestors.has(hunk.id) && !projectedEffects.active.has(hunk.actId) &&
+			if (coverHeld(hunk)) continue;
+			const inheritedInactive = !hunk.derived && !hunk.kept && !hunk.survived && !keptInverseAncestors.has(hunk.id) && !projectedEffects.active.has(hunk.actId) &&
 				!prepared.effects.references.get(hunk.actId)?.length;
 			if (!hunk.chosen && !inheritedInactive) continue;
 			hunk.active = prepared.effects.active.has(hunk.actId);
@@ -432,9 +490,13 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 			restoreHunk(hunk);
 		}
 		// A hidden withdrawal can have no splice of its own. Reversing that withdrawal
-		// reactivates the original hunk at its retained marker, never at a text search.
-		reactivate(new Set(records.filter(record => !prepared.effects.active.has(record.transaction.id) &&
-			projectedEffects.active.has(record.transaction.id)).map(record => record.transaction.id)), projectedEffects);
+		// reactivates the shared hunk through the inverse that still carries it.
+		// Withdrawing a later act reveals that same hunk while any original author remains.
+		const reactivated = new Set(records.filter(record => !prepared.effects.active.has(record.transaction.id) &&
+			projectedEffects.active.has(record.transaction.id)).map(record => record.transaction.id));
+		for (const hunk of all) if (!hunk.reversedHunk && !hunk.derived && hunk.coverIds?.length > 1 &&
+			hunk.coverIds.some(id => projectedEffects.active.has(id))) reactivated.add(hunk.actId);
+		reactivate(reactivated, projectedEffects);
 		const after = textOf(pieces), changes = [];
 		let cursor = 0, inserted = '';
 		for (const piece of pieces) {

package/dist/kit/ledger/journal-records.mjs

@@ -1,4 +1,5 @@
 // SPDX-License-Identifier: MIT
+import {fields, scalar, plainPrototype} from './data.mjs';
 
 const _RAPIER_TRANSACTION_ACTOR_LIMIT = 160;
 const _RAPIER_TRANSACTION_OPERATION_LIMIT = 96;
@@ -32,32 +33,15 @@ function _rapierTransformSplices(text, splices, inverse = false) {
 }
 
 function _rapierPlainLedgerData(record) {
-	try {
-		const active = new Set(), pending = [[record, false]];
-		while (pending.length) {
-			const [value, leaving] = pending.pop();
-			if (leaving) { active.delete(value); continue; }
-			if (value === null || typeof value === 'boolean') continue;
-			if (typeof value === 'string') { if (/[\uD800-\uDFFF]/u.test(value)) return false; continue; }
-			if (typeof value === 'number') { if (!Number.isFinite(value) || Object.is(value, -0)) return false; continue; }
-			if (!value || typeof value !== 'object' || active.has(value)) return false;
-			const array = Array.isArray(value), proto = Object.getPrototypeOf(value);
-			if (!array && proto !== null && (Object.getPrototypeOf(proto) !== null ||
-				Object.getOwnPropertyDescriptor(proto, 'constructor')?.value?.name !== 'Object')) return false;
-			const keys = Reflect.ownKeys(value);
-			if (array && keys.length !== value.length + 1) return false;
-			active.add(value); pending.push([value, true]);
-			for (const key of keys) {
-				if (array && key === 'length') continue;
-				if (typeof key !== 'string' || ['__proto__', 'constructor', 'prototype'].includes(key) ||
-					(array && (!Number.isSafeInteger(Number(key)) || Number(key) < 0 || Number(key) >= value.length || String(Number(key)) !== key))) return false;
-				const field = Object.getOwnPropertyDescriptor(value, key);
-				if (!field || !Object.hasOwn(field, 'value') || !field.enumerable) return false;
-				pending.push([field.value, false]);
-			}
-		}
-		return true;
-	} catch (_) { return false; }
+	const active = new Set();
+	const walk = (value, depth) => {
+		if (scalar(value)) return;
+		const {descriptors, keys} = fields(value, depth, active, false);
+		active.add(value);
+		for (const key of keys) walk(descriptors[key].value, depth + 1);
+		active.delete(value);
+	};
+	try { walk(record, 0); return true; } catch (_) { return false; }
 }
 
 const _rapierMetadataValue = (key, value) => key === 'filename'
@@ -156,9 +140,16 @@ function _rapierRecordSplices(entry, ledger) {
 }
 
 // Source identifies a retained checkpoint even when host revision numbers differ.
+// The History Slider compares now → earlier: that answer is the earlier → now walk, inverted.
 function journalOperations(before, after, journal) {
 	if (typeof before !== 'string' || typeof after !== 'string' || !Array.isArray(journal)) return;
 	if (before === after) return [];
+	const forward = journalWalk(before, after, journal);
+	if (forward) return forward;
+	return journalWalk(after, before, journal)?.reverse().map(({pos, removed, inserted}) => ({pos, removed: inserted, inserted: removed}));
+}
+
+function journalWalk(before, after, journal) {
 	try {
 		let text = after;
 		const lookup = _rapierRecordIndex(journal), groups = [];
@@ -480,8 +471,7 @@ const _rapierPrepareHistoryRecords = (() => {
 			// input later cannot retroactively certify an earlier view of its properties.
 			frame.frozen = frame.immutable = Object.isFrozen(value);
 			const array = Array.isArray(value), proto = Object.getPrototypeOf(value);
-			if (!array && proto !== null && (Object.getPrototypeOf(proto) !== null ||
-				Object.getOwnPropertyDescriptor(Object.getOwnPropertyDescriptor(proto, 'constructor')?.value || {}, 'name')?.value !== 'Object')) throw Error('history_data');
+			if (!array && !plainPrototype(proto)) throw Error('history_data');
 			const descriptors = Object.getOwnPropertyDescriptors(value), keys = Reflect.ownKeys(descriptors);
 			if (array && keys.length !== descriptors.length.value + 1) throw Error('history_data');
 			for (const key of keys) {
@@ -588,7 +578,12 @@ function _rapierCheckLedgerRecord(record, prior, documentAuthority, maxDocumentB
 		const own = Array.isArray(record.splices), navigation = !!(record.transaction?.reverts || record.transaction?.reapplies);
 		if ((!own && !navigation) || (own && record.splices.length > 64) ||
 			(record.transaction?.reverts && record.transaction?.reapplies)) return false;
-		if (metadata === undefined || (!splices?.length && !Object.values(metadata || {}).some(pair => pair.before !== pair.after) && !semantic) ||
+		const metadataChanged = Object.values(metadata || {}).some(pair => pair.before !== pair.after);
+		// An identical concurrent replacement keeps its authored rows and an empty
+		// physical splice. The origin proof, not this gate, shows the effect is already present.
+		const coincidentWitness = !splices?.length && record.beforeHash === record.afterHash &&
+			record.authored && _rapierValidAuthored(record.authored) && record.authored.splices.some(row => row.removed.length);
+		if (metadata === undefined || (!splices?.length && !metadataChanged && !semantic && !coincidentWitness) ||
 			(record.beforeHash === record.afterHash && splices?.length) ||
 			(record.beforeHash !== record.afterHash && !splices?.length) ||
 			((record.transaction?.sourceTransactionId || record.transaction?.sourceTransactionIds?.length || navigation) && !semantic)) return false;

package/dist/kit/ledger/merge.mjs

@@ -3,7 +3,7 @@ import {readLedger, exportLedger, rootAfter} from './format.mjs';
 import {_rapierTransformSplices, _rapierTransformMetadata, _rapierMetadataDelta, _rapierHistoryEffects, _rapierMetadataState} from './journal-records.mjs';
 import {mergeText} from './text-merge.mjs';
 import {transposeAuthored, authoredPlacements} from './transport.mjs';
-import {parseWill} from '../../agent/will.mjs';
+import {parseWill, stripOneTerminator} from '../../agent/will.mjs';
 import {sha256} from './hash.mjs';
 import {canonicalJSON, fault} from './data.mjs';
 // The same interval transport used by the agent kernel, now shared with the public ledger.
@@ -46,6 +46,16 @@ function actFingerprint(record, effects) {
     metadata: references.length ? null : Object.fromEntries(Object.entries(record.metadata || {}).map(([key, pair]) => [key, pair.after]))}));
 }
 const mergeIdentity = (localDigest, incomingDigest) => 'merge:' + sha256(canonicalJSON([localDigest, incomingDigest]));
+// One physical replacement can carry two authored acts when both removed the same
+// units and wrote the same text. An empty list is the act that does not repeat it.
+function coincidentEffect(origin, left, right) {
+  const authored = origin?.splices;
+  if (!authored?.some(row => row.removed.length)) return false;
+  const same = (rows, expected) => rows.length === expected.length && rows.every((row, index) =>
+    row.pos === expected[index].pos && row.removed === expected[index].removed && row.inserted === expected[index].inserted);
+  const lists = [left, right];
+  return lists.every(rows => !rows.length || same(rows, authored)) && lists.some(rows => same(rows, authored));
+}
 function checkpointList(read) {
   const list = [{root: read.ledger.start.root, text: read.ledger.start.text, metadata: read.ledger.start.metadata,
     revision: read.ledger.start.revision, identity: null, index: 0}], records = read.ledger.records;
@@ -58,10 +68,18 @@ function checkpointList(read) {
   }
   return list;
 }
+// Keep and append regions with their intents, and the kept text: what the other copy may not change unseen.
 function kept(text) {
   const will = parseWill(text);
   if (will.fault) return {fault: will.fault, text};
-  return will.regions.filter(region => region.law === 'keep').map(region => text.slice(region.start, region.end));
+  return will.regions.filter(region => region.law !== 'edit').map(({law, intent, start, end}) =>
+    law === 'keep' ? {law, intent, text: text.slice(start, end)} : {law, intent});
+}
+// Every append region of `from` still begins its counterpart in `to`.
+function appended(from, to) {
+  const regions = text => parseWill(text).regions.filter(region => region.law === 'append');
+  const was = regions(from), now = regions(to), core = (text, region) => stripOneTerminator(text.slice(region.start, region.end));
+  return was.length === now.length && was.every((region, index) => core(to, now[index]).startsWith(core(from, region)));
 }
 // A retained suffix can reuse a prefix only when an existing ledger proves its
 // exact source, metadata, revision and path root. Export then rechecks the whole
@@ -104,7 +122,11 @@ export function merge(first, second) {
         conflicts: [{kind: 'identity', code: 'act_order_conflict', actId: record.transaction.id}],
         review: {required: true, base: ours.text, proposed: theirs.text}};
     if (local && (canonicalJSON(local.splices) !== canonicalJSON(record.splices) ||
-        canonicalJSON(local.metadata || {}) !== canonicalJSON(record.metadata || {}))) unproved.add(record.transaction.id);
+        canonicalJSON(local.metadata || {}) !== canonicalJSON(record.metadata || {}))) {
+      const metadataSame = canonicalJSON(local.metadata || {}) === canonicalJSON(record.metadata || {});
+      if (!(metadataSame && coincidentEffect(localOrigins.get(local.transaction.id), local.splices, record.splices)))
+        unproved.add(record.transaction.id);
+    }
   }
   const a = checkpointList(ours), b = checkpointList(theirs);
   // A synthetic conflict act has one identity derived from both original envelopes.
@@ -190,7 +212,10 @@ export function merge(first, second) {
     const local = localIds.get(record.transaction.id);
     if (local) mappedIds.set(record.transaction.id, local.transaction.id);
   }
-  const keepDiffers = canonicalJSON(kept(ours.text)) !== canonicalJSON(kept(theirs.text));
+  // Kept text arriving from the other copy waits for the person; this copy's own kept edits merge like any other.
+  const incomingKept = canonicalJSON(kept(theirs.text));
+  const keepDiffers = incomingKept !== canonicalJSON(kept(ours.text)) && incomingKept !== canonicalJSON(kept(common.text)) ||
+    !appended(common.text, theirs.text) && !appended(ours.text, theirs.text);
   let conflicted = keepDiffers && unseen.length > 0, incomingSource = common.text;
   if (!conflicted) for (const record of incoming) {
     const beforeSource = incomingSource;
@@ -237,20 +262,31 @@ export function merge(first, second) {
       return settled(theirs);
     }
   }
-  let conflicts = [];
   if (conflicted) {
     if (unseen.length !== incoming.length) return refused('history', 'record_transport_conflict');
-    if (incomingFields.size || unseen.some(record => incomingEffects.references.get(record.transaction.id)?.length))
-      return metadataConflict('record_transport_conflict', {fields: [...incomingFields]});
-    // Restart from the original local head: partially transported records never leak into a conflict result.
-    records.splice(ours.ledger.records.length); text = ours.text; metadata = {...ours.metadata}; root = ours.root;
+    if (incomingFields.size) return metadataConflict('record_transport_conflict', {fields: [...incomingFields]});
+    // A display of both alternatives is not an accepted history. The caller's envelope
+    // stays whole; neither original act is replaced by a synthetic copy.
     const merged = mergeText(keepDiffers ? null : common.text, ours.text, theirs.text, {oursId: 'copy-' + ours.ledger.sha256.slice(0, 16), theirsId: 'copy-' + theirs.ledger.sha256.slice(0, 16)});
-    conflicts = merged.conflicts;
-    // Text equality cannot replace the unproved original acts with a clean receipt.
-    if (!conflicts.length) return refused('history', 'record_transport_conflict');
-    if (merged.text !== text) append([{pos: 0, removed: text, inserted: merged.text}], {transaction: {
-      id: mergeIdentity(ours.ledger.sha256, theirs.ledger.sha256), actor: {kind: 'system', id: 'merge'}, transport: 'platform', operation: 'document.merge', requestId: null,
-      affectedBlockIds: [], createdAt: null}});
+    if (!merged.conflicts.length) return refused('history', 'record_transport_conflict');
+    return {text: ours.text, metadata: ours.metadata, ledger: ours.ledger, clean: false,
+      conflicts: merged.conflicts.map(row => ({...row, code: 'text_overlap_unpreserved'})),
+      review: {required: true, base: ours.text, proposed: theirs.text}};
+  }
+  let conflicts = [];
+  // The act that keeps the physical splice needs the same authored origin as its
+  // witness. Copy it onto this result only; the caller's record stays untouched.
+  if (records.some(row => !row.splices.length && row.authored?.splices?.some(splice => splice.removed.length))) {
+    const origins = authoredPlacements(ours.ledger.start.text, records);
+    for (let index = 0; index < records.length; index++) {
+      const record = records[index];
+      if (record.authored) continue;
+      const origin = origins.get(record.transaction.id);
+      if (!origin?.splices.some(splice => splice.removed.length)) continue;
+      const key = canonicalJSON(origin);
+      if (records.some(other => other.transaction.id !== record.transaction.id && canonicalJSON(origins.get(other.transaction.id)) === key))
+        records[index] = {...record, authored: origin};
+    }
   }
   const ledger = exportLedger({text, metadata, records, documentAuthority: ours.ledger.documentAuthority, root,
     revision: records.at(-1)?.transaction.revision ?? ours.revision, complete: ours.complete});

package/dist/kit/ledger/text-merge.mjs

@@ -151,39 +151,81 @@ function textUnits(text) {
 	return out;
 }
 
-function textEdits(base, side) {
-	const n = base.length, m = side.length;
-	if ((n + 1) * (m + 1) > 1000000) return null;
-	const width = m + 1, score = new Uint32Array((n + 1) * width);
+const TEXT_WINDOW_CELLS = 1000000, TEXT_CELLS = 4000000;
+// One window's authored matches, or false when two optimal alignments disagree on any of them.
+function textWindowMatches(base, side, b0, b1, s0, s1, out, budget) {
+	const n = b1 - b0, m = s1 - s0, cells = (n + 1) * (m + 1);
+	if (cells > TEXT_WINDOW_CELLS || (budget.cells -= cells) < 0) return false;
+	// Only authored units score; a blank line matches only beside a matched neighbour.
+	const width = m + 1, score = new Uint32Array(cells), content = i => !textSpace(base[b0 + i]), same = (i, j) => base[b0 + i] === side[s0 + j];
 	for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) {
 		const p = i * width + j;
-		score[p] = base[i] === side[j] ? score[p + width + 1] + 1 : Math.max(score[p + width], score[p + 1]);
+		score[p] = content(i) && same(i, j) ? score[p + width + 1] + 1 : Math.max(score[p + width], score[p + 1]);
+	}
+	const meaningful = [];
+	for (let i = 0, j = 0; i < n && j < m;) {
+		const p = i * width + j; if (!score[p]) break;
+		if (content(i) && same(i, j) && score[p] === score[p + width + 1] + 1) meaningful.push([i++, j++]);
+		else if (score[p + width] >= score[p + 1]) i++; else j++;
 	}
-	const walk = () => {
-		const pairs = []; let i = 0, j = 0;
-		while (i < n && j < m) {
-			const value = score[i * width + j]; if (!value) break;
-			if (base[i] === side[j]) { pairs.push([i++, j++]); continue; }
-			if (score[(i + 1) * width + j] >= score[i * width + j + 1]) i++; else j++;
-		}
-		return pairs;
-	};
-	const pairs = walk(), meaningful = pairs.filter(([i]) => !textSpace(base[i]));
 	// Every optimal path must agree on every authored anchor, not just two greedy walks.
-	const seen = new Uint32Array(score.length); seen.fill(0xffffffff); seen[0] = 0;
+	const seen = new Uint32Array(cells); seen.fill(0xffffffff); seen[0] = 0;
 	for (let i = 0; i <= n; i++) for (let j = 0; j <= m; j++) {
 		const p = i * width + j, at = seen[p]; if (at === 0xffffffff) continue;
 		const visit = (next, count) => { if (seen[next] !== 0xffffffff && seen[next] !== count) return false; seen[next] = count; return true; };
-		if (i < n && score[p + width] === score[p] && !visit(p + width, at)) return null;
-		if (j < m && score[p + 1] === score[p] && !visit(p + 1, at)) return null;
-		if (i < n && j < m && base[i] === side[j] && score[p] === score[p + width + 1] + 1) {
-			const content = !textSpace(base[i]);
-			if (content && (meaningful[at]?.[0] !== i || meaningful[at]?.[1] !== j)) return null;
-			if (!visit(p + width + 1, at + (content ? 1 : 0))) return null;
+		if (i < n && score[p + width] === score[p] && !visit(p + width, at)) return false;
+		if (j < m && score[p + 1] === score[p] && !visit(p + 1, at)) return false;
+		if (i < n && j < m && content(i) && same(i, j) && score[p] === score[p + width + 1] + 1) {
+			if (meaningful[at]?.[0] !== i || meaningful[at]?.[1] !== j) return false;
+			if (!visit(p + width + 1, at + 1)) return false;
 		}
 	}
-	if (seen[n * width + m] !== meaningful.length) return null;
-	const edits = []; let i = 0, j = 0;
+	if (seen[n * width + m] !== meaningful.length) return false;
+	for (const [i, j] of meaningful) out.push([b0 + i, s0 + j]);
+	return true;
+}
+
+// A window too large to prove whole splits only at authored units found once on each side of it:
+// such a unit names its own occurrence. The strict rule above still decides every window between them.
+function textMatches(base, side, b0, b1, s0, s1, out, budget) {
+	if ((b1 - b0 + 1) * (s1 - s0 + 1) <= TEXT_WINDOW_CELLS) return textWindowMatches(base, side, b0, b1, s0, s1, out, budget);
+	const once = (units, from, to) => {
+		const found = new Map();
+		for (let k = from; k < to; k++) if (!textSpace(units[k])) found.set(units[k], found.has(units[k]) ? -1 : k);
+		return found;
+	};
+	const inBase = once(base, b0, b1), pairs = [];
+	for (const [unit, j] of once(side, s0, s1)) { const i = inBase.get(unit); if (j >= 0 && i >= 0) pairs.push([i, j]); }
+	// The longest run of them in the same order on both sides.
+	const tails = [], prev = new Int32Array(pairs.length);
+	for (let k = 0; k < pairs.length; k++) {
+		let lo = 0, hi = tails.length;
+		while (lo < hi) { const mid = (lo + hi) >>> 1; if (pairs[tails[mid]][0] < pairs[k][0]) lo = mid + 1; else hi = mid; }
+		prev[k] = lo ? tails[lo - 1] : -1; tails[lo] = k;
+	}
+	if (!tails.length) return false;
+	const chain = [];
+	for (let k = tails[tails.length - 1]; k >= 0; k = prev[k]) chain.push(pairs[k]);
+	let i = b0, j = s0;
+	for (const [bi, sj] of chain.reverse()) {
+		if (!textMatches(base, side, i, bi, j, sj, out, budget)) return false;
+		out.push([bi, sj]); i = bi + 1; j = sj + 1;
+	}
+	return textMatches(base, side, i, b1, j, s1, out, budget);
+}
+
+function textEdits(base, side) {
+	const n = base.length, m = side.length, meaningful = [];
+	if (!textMatches(base, side, 0, n, 0, m, meaningful, {cells: TEXT_CELLS})) return null;
+	const pairs = [];
+	let i = 0, j = 0;
+	for (let k = 0; k < meaningful.length; k++) {
+		const [bi, sj] = meaningful[k], [ni, nj] = meaningful[k + 1] || [n, m];
+		if (bi > i && sj > j && textSpace(base[bi - 1]) && base[bi - 1] === side[sj - 1]) pairs.push([bi - 1, sj - 1]);
+		pairs.push([bi, sj]); i = bi + 1; j = sj + 1;
+		if (i < ni && j < nj && textSpace(base[i]) && base[i] === side[j]) pairs.push([i++, j++]);
+	}
+	const edits = []; i = 0; j = 0;
 	for (const [bi, sj] of [...pairs, [n, m]]) {
 		if (i !== bi || j !== sj) edits.push({start: i, end: bi, text: side.slice(j, sj).join('')});
 		i = bi + 1; j = sj + 1;
@@ -234,11 +276,13 @@ function textEnvelope(id, variants) {
 	return out + '<!-- /note-conflict:v1 -->\n';
 }
 
-function textDeclarations(text) {
-	text = textUnits(text).filter(unit => !textEnvelopeAt(unit)).join('');
+// Takes the text's units, scanned once by the caller; a text without conflict envelopes is not scanned again.
+function textDeclarations(units) {
+	const kept = units.filter(unit => !textEnvelopeAt(unit)).map(unit =>
+		textFence(unit.split(/\r\n|\r|\n/, 1)[0].replace(/^\ufeff/, '')) ? '\n' : unit), text = kept.join('');
 	// A definition can move a destination/title onto the next unindented line, or span its label.
 	const definitions = text.match(/^\ufeff? {0,3}\[(?:\\.|[^\]\\])+\]:[^\r\n]*(?:(?:\r\n|\r|\n)(?![ 	]*(?:\r\n|\r|\n|$))[^\r\n]*)*/gm) || [];
-	const continuations = textUnits(text).filter(unit => /^\ufeff? {0,3}\[\^/.test(unit));
+	const continuations = (kept.length === units.length ? kept : textUnits(text)).filter(unit => /^\ufeff? {0,3}\[\^/.test(unit));
 	return [...definitions, ...continuations, ...(text.match(/<!--[\s\S]*?(?:-->|$)/g) || [])].join('\0');
 }
 
@@ -284,10 +328,12 @@ export function mergeText(base, ours, theirs, options = {}) {
 		conflicts.push({kind, base: before, variants, start, end: start + block.length, block});
 		text += block;
 	};
+	const [units, oursUnits, theirsUnits] = base === null ? [] : [base, ours, theirs].map(textUnits);
+	const declared = base !== null && textDeclarations(units);
 	if (base === null) conflict(null, ours, theirs, 'no-ancestor');
-	else if (textDeclarations(ours) !== textDeclarations(base) || textDeclarations(theirs) !== textDeclarations(base)) conflict(base, ours, theirs, 'document-bindings');
+	else if (textDeclarations(oursUnits) !== declared || textDeclarations(theirsUnits) !== declared) conflict(base, ours, theirs, 'document-bindings');
 	else {
-		const units = textUnits(base), a = textEdits(units, textUnits(ours)), b = textEdits(units, textUnits(theirs));
+		const a = textEdits(units, oursUnits), b = textEdits(units, theirsUnits);
 		if (!a || !b) conflict(base, ours, theirs, 'ambiguous-alignment-or-budget');
 		else {
 			const changes = [...a.map(e => ({...e, side: 0})), ...b.map(e => ({...e, side: 1}))].sort((x, y) => x.start - y.start || x.end - y.end || x.side - y.side);