rapier-html 1.1.101 → 1.1.104

package/dist/ledger/history.mjs

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: MIT
 // Transient projections and selective inverses of the existing canonical journal.
-import {_rapierTransformSplices, _rapierRecordSplices, _rapierRecordMetadata, _rapierValidMetadata, _rapierTransformMetadata, _rapierMetadataDelta, _rapierHistoryEffects, _rapierMetadataState, _rapierReplayMetadata} from './journal-records.mjs';
-import {projectInverseSource} from './inverse-source.mjs';
-import {textRoot, rootAfter} from './hash.mjs';
+import {_rapierTransformSplices, _rapierRecordSplices, _rapierRecordMetadata, _rapierValidMetadata, _rapierTransformMetadata, _rapierMetadataDelta, _rapierHistoryEffects, _rapierMetadataState, _rapierReplayMetadata, _rapierPrepareHistoryRecords} from './journal-records.mjs';
+import {projectInverseSource, HistorySource} from './inverse-source.mjs';
+import {textRootParts, rootAfter} from './hash.mjs';
 import {authoredHistory} from './transport.mjs';
 import {plainData} from './data.mjs';
 
@@ -12,16 +12,16 @@ const historyBoundary = (source, at) => historyInteger(at) && at <= source.lengt
 	(source.charCodeAt(at - 1) & 0xFC00) === 0xD800 && (source.charCodeAt(at) & 0xFC00) === 0xDC00);
 
 function historyAct(record, effects = null) {
-	const tx = record.transaction;
-	return {id: tx.id, actor: {...tx.actor}, createdAt: tx.createdAt, baseRevision: tx.baseRevision, revision: tx.revision,
-		operation: tx.operation || 'document.change',
+	const tx = record.transaction, copy = value => value && typeof value === 'object' ? plainData(value) : value;
+	return {id: tx.id, actor: Object.fromEntries(Object.entries(tx.actor).map(([key, value]) => [key, copy(value)])), createdAt: tx.createdAt, baseRevision: tx.baseRevision, revision: tx.revision,
+		operation: copy(tx.operation) || 'document.change',
 		...(tx.turnId ? {turnId: tx.turnId} : {}),
-		...(tx.contribution ? {contribution: tx.contribution} : {}),
+		...(tx.contribution ? {contribution: copy(tx.contribution)} : {}),
 		...(tx.sourceTransactionId ? {sourceTransactionId: tx.sourceTransactionId} : {}),
 		...(tx.sourceTransactionIds?.length ? {sourceTransactionIds: tx.sourceTransactionIds.slice()} : {}),
 		...(tx.reverts ? {reverts: tx.reverts} : {}), ...(tx.reapplies ? {reapplies: tx.reapplies} : {}),
-		...(record.changeSet && Object.hasOwn(record.changeSet, 'label') ? {label: record.changeSet.label} : {}),
-		...(Array.isArray(tx.affectedBlockIds) ? {affectedBlockIds: tx.affectedBlockIds.slice()} : {}),
+		...(record.changeSet && Object.hasOwn(record.changeSet, 'label') ? {label: copy(record.changeSet.label)} : {}),
+		...(Array.isArray(tx.affectedBlockIds) ? {affectedBlockIds: tx.affectedBlockIds.map(copy)} : {}),
 		...(record.metadata ? {metadata: plainData(record.metadata)} : {}),
 		...(effects ? {active: effects.active.has(tx.id)} : {})};
 }
@@ -74,76 +74,75 @@ export function pictureHistorySplices({source, records}, target, redo) {
 	try { return plan(true); } catch (_) { return null; }
 }
 
-// Reading an admitted repair can recover pre-existing lone UTF-16 units. This is
-// not a document mutation; the forward replay and roots still validate every row.
-function historyPreviousSource(source, splices) {
-	let value = source;
-	for (let index = splices.length - 1; index >= 0; index--) {
-		const row = splices[index];
-		if (!row || !historyInteger(row.pos) || typeof row.removed !== 'string' || typeof row.inserted !== 'string' ||
-			row.pos > value.length || row.inserted.length > value.length - row.pos ||
-			value.slice(row.pos, row.pos + row.inserted.length) !== row.inserted) return null;
-		value = value.slice(0, row.pos) + row.removed + value.slice(row.pos + row.inserted.length);
-	}
-	return value;
-}
-
-// This is a projection of the existing records. No source snapshots or provenance survive the call.
+// Keep only the latest source observation. Inactive live documents must not retain
+// every revision's source tree. The weak key also lets the latest input be collected.
+// Mutable caller data is compared/captured before this cache can be consulted.
+let preparedHistories = new WeakMap();
 function prepareHistory(input) {
 	try {
 		if (!input || typeof input.source !== 'string' || !Array.isArray(input.records) || !_rapierValidMetadata(input.metadata)) return historyFailure('history_invalid');
-		const source = input.source, records = plainData(input.records), ids = new Set(), rows = [];
-		const effects = _rapierHistoryEffects(records);
-		if (!effects.ok) return historyFailure('history_invalid');
+		const source = input.source, metadata = {...input.metadata}, index = _rapierPrepareHistoryRecords(input.records);
+		if (!index.ok) return historyFailure('history_invalid');
+		const {records, effects} = index;
 		const revision = input.revision ?? records.at(-1)?.transaction?.revision ?? 0;
-		if (!historyInteger(revision)) return historyFailure('history_invalid');
-		let prior = input.earliestRevision ?? records[0]?.transaction?.baseRevision ?? revision, complete = prior === 0;
-		if (!historyInteger(prior)) return historyFailure('history_invalid');
-		for (const record of records) {
-			const tx = record?.transaction, actor = tx?.actor;
-			if (!tx || typeof tx.id !== 'string' || !tx.id || ids.has(tx.id) || !historyInteger(tx.baseRevision) ||
+		let prior = input.earliestRevision ?? records[0]?.transaction?.baseRevision ?? revision;
+		if (!historyInteger(revision) || !historyInteger(prior)) return historyFailure('history_invalid');
+		const earliest = prior, suppliedComplete = input.complete !== false, cached = preparedHistories.get(records);
+		if (cached && cached.source === source && cached.revision === revision && cached.earliest === earliest &&
+			cached.suppliedComplete === suppliedComplete && cached.metadata.filename === metadata.filename && cached.metadata.docKind === metadata.docKind) return cached;
+		let complete = prior === 0;
+		const rows = [], byId = new Map();
+		for (const owned of index.rows) {
+			const {record, splices, metadata: effect} = owned, tx = record?.transaction, actor = tx?.actor;
+			if (!tx || typeof tx.id !== 'string' || !tx.id || byId.has(tx.id) || !historyInteger(tx.baseRevision) ||
 				!historyInteger(tx.revision) || tx.revision !== tx.baseRevision + 1 || tx.baseRevision < prior ||
 				!actor || !['human', 'agent', 'system'].includes(actor.kind) || typeof actor.id !== 'string' || !actor.id ||
 				!(tx.createdAt === null || historyInteger(tx.createdAt)) ||
 				(tx.turnId != null && (typeof tx.turnId !== 'string' || !tx.turnId || tx.turnId.length > 160))) return historyFailure('history_invalid');
 			if (tx.baseRevision !== prior) complete = false;
-			const splices = _rapierRecordSplices(record, records), metadata = _rapierRecordMetadata(record, records);
-			if (!splices || metadata === undefined || (!splices.length &&
-				!Object.values(metadata || {}).some(pair => pair.before !== pair.after) && !effects.references.get(tx.id)?.length)) return historyFailure('history_unavailable');
-			rows.push({record, splices, metadata}); ids.add(tx.id); prior = tx.revision;
+			if (!splices || effect === undefined || (!splices.length &&
+				!Object.values(effect || {}).some(pair => pair.before !== pair.after) && !effects.references.get(tx.id)?.length)) return historyFailure('history_unavailable');
+			const row = {record, splices, metadata: effect};
+			rows.push(row); byId.set(tx.id, row); prior = tx.revision;
 		}
 		if (prior !== revision) return historyFailure('history_unavailable');
-		let initialSource = source, initialMetadata = {...input.metadata};
-		for (let index = rows.length - 1; index >= 0; index--) {
-			initialSource = historyPreviousSource(initialSource, rows[index].splices);
-			initialMetadata = _rapierTransformMetadata(initialMetadata, rows[index].metadata, true);
-			if (initialSource === null || !initialMetadata) return historyFailure('history_invalid');
+		let initial = new HistorySource(source), initialMetadata = {...metadata};
+		for (let at = rows.length - 1; at >= 0; at--) {
+			const row = rows[at];
+			row.afterSource = initial; row.afterMetadata = initialMetadata;
+			initial = initial.before(row.splices);
+			initialMetadata = _rapierTransformMetadata(initialMetadata, row.metadata, true);
+			if (!initial || !initialMetadata) return historyFailure('history_invalid');
+			row.beforeSource = initial; row.beforeMetadata = initialMetadata;
 		}
-		const earliestRevision = rows[0]?.record.transaction.baseRevision ?? revision;
-		let replay = initialSource, root = earliestRevision === 0 ? textRoot(initialSource) : null, rootRevision = earliestRevision;
+		const earliestRevision = records[0]?.transaction.baseRevision ?? revision;
+		let root = earliestRevision === 0 ? textRootParts(initial.parts()) : null, rootRevision = earliestRevision;
 		for (const {record, splices} of rows) {
 			const hashed = Object.hasOwn(record, 'beforeHash') || Object.hasOwn(record, 'afterHash');
 			if (hashed && (![record.beforeHash, record.afterHash].every(value =>
 				typeof value === 'string' && /^\d+:[a-z0-9]+:[a-z0-9]+$/.test(value)) ||
-				(splices.length ? record.beforeHash === record.afterHash : record.beforeHash !== record.afterHash)))
-				return historyFailure('history_invalid');
-			// Roots bind revision zero to the full source. A retained suffix has only a path root;
-			// omitted neutral pairs change that root, so a stated revision gap begins a new chain.
+				(splices.length ? record.beforeHash === record.afterHash : record.beforeHash !== record.afterHash))) return historyFailure('history_invalid');
+			// Revision gaps begin a new path root; a continuous revision-zero prefix
+			// still binds every untouched source byte through the initial text root.
 			if (record.transaction.baseRevision !== rootRevision) root = null;
 			if (hashed) {
 				if (root !== null && record.beforeHash !== root) return historyFailure('history_invalid');
 				root = record.beforeHash;
 			}
-			replay = _rapierTransformSplices(replay, splices);
-			if (replay === null) return historyFailure('history_invalid');
-			if (root !== null) for (const row of splices) root = rootAfter(root, row);
+			if (root !== null) for (const splice of splices) root = rootAfter(root, splice);
 			if (hashed && root !== record.afterHash) return historyFailure('history_invalid');
 			rootRevision = record.transaction.revision;
 		}
-		if (records.some(row => Object.hasOwn(row, 'authored'))) authoredHistory(initialSource, rows.map(({record, splices}) => ({...record, splices})));
-		const metadata = _rapierReplayMetadata(initialMetadata, records);
-		if (replay !== source || !metadata || ['filename', 'docKind'].some(key => metadata[key] !== input.metadata[key])) return historyFailure('history_invalid');
-		return {ok: true, source, initialSource, metadata, initialMetadata, effects, rows, revision, earliestRevision, complete: input.complete !== false && complete && earliestRevision === 0};
+		let initialText;
+		const initialSource = () => initialText ??= initial.slice();
+		if (records.some(row => Object.hasOwn(row, 'authored'))) authoredHistory(initialSource(), rows.map(({record, splices}) => ({...record, splices})));
+		const replayedMetadata = index.replayMetadata(initialMetadata);
+		if (!replayedMetadata || ['filename', 'docKind'].some(key => replayedMetadata[key] !== metadata[key])) return historyFailure('history_invalid');
+		const resolvedRecords = Object.freeze(rows.map(({record, splices}) => record.splices === splices ? record : Object.freeze({...record, splices}))); 
+		const prepared = {ok: true, source, records: resolvedRecords, get initialSource() { return initialSource(); }, initial, metadata, initialMetadata, effects, rows, byId,
+			revision, earliest, suppliedComplete, earliestRevision, complete: suppliedComplete && complete && earliestRevision === 0};
+		preparedHistories = new WeakMap([[records, prepared]]);
+		return prepared;
 	} catch (_) { return historyFailure('history_invalid'); }
 }
 
@@ -152,23 +151,17 @@ export function replayHistory(input) {
 	if (!prepared.ok) return prepared;
 	const {source, initialSource, metadata, initialMetadata, revision, earliestRevision, complete, rows, effects} = prepared;
 	const acts = rows.filter(({record}) => !effects.pictures.has(record.transaction.id)).map(({record}) => historyAct(record, effects));
-	return {ok: true, source, initialSource, metadata, initialMetadata, revision, earliestRevision, complete, acts,
+	return {ok: true, source, initialSource, metadata: {...metadata}, initialMetadata: {...initialMetadata}, revision, earliestRevision, complete, acts,
 		effectiveActIds: effects.effectiveActIds.slice(), groups: groupHistoryActs(acts)};
 }
 
 export function sourceBefore(input, actId) {
 	const prepared = prepareHistory(input);
 	if (!prepared.ok) return prepared;
-	let source = prepared.source, metadata = {...prepared.metadata};
-	for (let index = prepared.rows.length - 1; index >= 0; index--) {
-		const {record, splices} = prepared.rows[index];
-		source = historyPreviousSource(source, splices);
-		if (source === null) return historyFailure('history_invalid');
-		metadata = _rapierTransformMetadata(metadata, prepared.rows[index].metadata, true);
-		if (record.transaction.id === actId) return {ok: true, source, metadata, revision: record.transaction.baseRevision,
-			act: historyAct(record, prepared.effects), complete: prepared.complete, earliestRevision: prepared.earliestRevision};
-	}
-	return historyFailure('act_unavailable');
+	const row = prepared.byId.get(actId);
+	if (!row) return historyFailure('act_unavailable');
+	return {ok: true, source: row.beforeSource.slice(), metadata: {...row.beforeMetadata}, revision: row.record.transaction.baseRevision,
+		act: historyAct(row.record, prepared.effects), complete: prepared.complete, earliestRevision: prepared.earliestRevision};
 }
 
 function historyRangeBefore(range, splice) {
@@ -186,21 +179,23 @@ function historyRangeBefore(range, splice) {
 
 function projectHistoryRange(prepared, from, to, actId) {
 	if (!historyBoundary(prepared.source, from) || !historyBoundary(prepared.source, to) || to < from) return historyFailure('range_invalid');
-	let text = prepared.source, range = {from, to}, before = null;
+	let range = {from, to}, before = null;
 	const acts = [];
 	for (let index = prepared.rows.length - 1; index >= 0; index--) {
-		const {record, splices} = prepared.rows[index], after = {...range, source: text.slice(range.from, range.to)};
+		const {record, splices, beforeSource, afterSource} = prepared.rows[index], afterRange = range;
 		let touched = false;
 		for (let at = splices.length - 1; at >= 0; at--) {
 			const mapped = historyRangeBefore(range, splices[at]); touched ||= mapped.touched;
 			range = {from: mapped.from, to: mapped.to};
 		}
-		text = historyPreviousSource(text, splices);
-		if (text === null) return historyFailure('history_invalid');
-		const previous = {...range, source: text.slice(range.from, range.to)};
-		if (record.transaction.id === actId) before = previous;
-		if (!prepared.effects.pictures.has(record.transaction.id) && (touched || record.metadata || prepared.effects.references.get(record.transaction.id)?.length))
-			acts.push({...historyAct(record, prepared.effects), before: previous, after});
+		const include = !prepared.effects.pictures.has(record.transaction.id) &&
+			(touched || record.metadata || prepared.effects.references.get(record.transaction.id)?.length);
+		if (include || record.transaction.id === actId) {
+			const previous = {...range, source: beforeSource.slice(range.from, range.to)};
+			if (record.transaction.id === actId) before = previous;
+			if (include) acts.push({...historyAct(record, prepared.effects), before: previous,
+				after: {...afterRange, source: afterSource.slice(afterRange.from, afterRange.to)}});
+		}
 	}
 	if (actId != null && !before) return historyFailure('act_unavailable');
 	acts.reverse();
@@ -220,10 +215,47 @@ export function historyProjections(input, ranges) {
 	if (!prepared.ok) return prepared;
 	if (!Array.isArray(ranges)) return historyFailure('range_invalid');
 	return {ok: true, projections: ranges.map(({from = 0, to = prepared.source.length, actId} = {}) =>
-		structuredClone(projectHistoryRange(prepared, from, to, actId)))};
+		projectHistoryRange(prepared, from, to, actId))};
+}
+
+// Block intervals stay ordered under reverse splices. A fixed balanced tree can
+// shift an untouched suffix lazily and visit only intervals crossing the edit.
+function historyBlockIndex(projected) {
+	const items = projected.map(block => ({block, range: {from: block.from, to: block.to}, shift: 0}))
+		.sort((a, b) => a.range.from - b.range.from);
+	const refresh = node => {
+		node.minFrom = node.left?.minFrom ?? node.range.from;
+		node.maxTo = Math.max(node.range.to, node.left?.maxTo ?? -1, node.right?.maxTo ?? -1);
+	};
+	const build = (from, to, parent = null) => {
+		if (from === to) return null;
+		const mid = Math.floor((from + to) / 2), node = items[mid];
+		node.parent = parent; node.left = build(from, mid, node); node.right = build(mid + 1, to, node);
+		refresh(node); return node;
+	};
+	const root = build(0, items.length);
+	const shift = (node, delta) => {
+		if (!node || !delta) return;
+		node.range = {from: node.range.from + delta, to: node.range.to + delta};
+		node.minFrom += delta; node.maxTo += delta; node.shift += delta;
+	};
+	const move = (node, splice, touch) => {
+		if (!node || node.maxTo < splice.pos) return;
+		const end = splice.pos + splice.inserted.length;
+		if (node.minFrom > end) { shift(node, splice.removed.length - splice.inserted.length); return; }
+		if (node.shift) { shift(node.left, node.shift); shift(node.right, node.shift); node.shift = 0; }
+		const mapped = historyRangeBefore(node.range, splice);
+		if (mapped.touched) touch(node);
+		node.range = {from: mapped.from, to: mapped.to};
+		move(node.left, splice, touch); move(node.right, splice, touch); refresh(node);
+	};
+	return {move: (splice, touch) => move(root, splice, touch), range(node) {
+		let delta = 0;
+		for (let parent = node.parent; parent; parent = parent.parent) delta += parent.shift;
+		return {from: node.range.from + delta, to: node.range.to + delta};
+	}};
 }
 
-// Project all reading places in one replay. Typing only invalidates this transient view.
 export function historyPlaces(input, blocks) {
 	const prepared = prepareHistory(input);
 	if (!prepared.ok) return prepared;
@@ -231,47 +263,43 @@ export function historyPlaces(input, blocks) {
 		!historyBoundary(prepared.source, block.from) || !historyBoundary(prepared.source, block.to) || block.to < block.from))
 		return historyFailure('range_invalid');
 	const projected = blocks.map(block => ({id: block.id, from: block.from, to: block.to,
-		source: prepared.source.slice(block.from, block.to), range: {from: block.from, to: block.to}, acts: []}));
-	let text = prepared.source;
+		source: prepared.source.slice(block.from, block.to), acts: []}));
+	const ranges = historyBlockIndex(projected);
 	for (let index = prepared.rows.length - 1; index >= 0; index--) {
-		const {record, splices} = prepared.rows[index], before = historyPreviousSource(text, splices);
-		if (before === null) return historyFailure('history_invalid');
-		for (const block of projected) {
-			const after = {...block.range, source: text.slice(block.range.from, block.range.to)};
-			let touched = false;
-			for (let at = splices.length - 1; at >= 0; at--) {
-				const mapped = historyRangeBefore(block.range, splices[at]);
-				block.range = {from: mapped.from, to: mapped.to}; touched ||= mapped.touched;
-			}
-			const previous = {...block.range, source: before.slice(block.range.from, block.range.to)};
-			if (touched && previous.source !== after.source && !prepared.effects.pictures.has(record.transaction.id)) block.acts.push({...historyAct(record), before: previous, after});
-		}
-		text = before;
-	}
-	const acts = prepared.rows.filter(({record}) => !prepared.effects.pictures.has(record.transaction.id)).map(({record}) => historyAct(record));
-	const present = new Map(), effects = new Map();
-	for (const act of acts) {
-		const changes = [];
-		const set = (id, value) => {
-			const prior = present.get(id) === true;
-			present.set(id, value); changes.push({id, before: prior, after: value});
-		};
-		if (act.reapplies) {
-			for (const change of effects.get(act.reapplies) || [{id: act.reapplies, after: true}]) set(change.id, change.after);
-		} else {
-			const ids = act.sourceTransactionIds || (act.sourceTransactionId ? [act.sourceTransactionId] : act.reverts ? [act.reverts] : []);
-			for (const id of ids) {
-				for (const change of (effects.get(id) || [{id, before: false, after: true}]).slice().reverse()) {
-					if (present.get(change.id) === change.after) set(change.id, change.before);
+		const {record, splices, beforeSource, afterSource} = prepared.rows[index], touched = new Map();
+		for (let at = splices.length - 1; at >= 0; at--) ranges.move(splices[at], node => {
+			if (touched.has(node) || prepared.effects.pictures.has(record.transaction.id)) return;
+			// Earlier splices in this reverse walk only shifted this interval. Recover
+			// its coordinates at the record's after-state before recording the first touch.
+			let after = {...node.range};
+			for (let prior = at + 1; prior < splices.length; prior++) {
+				const row = splices[prior];
+				if (after.from >= row.pos + row.removed.length) {
+					const delta = row.inserted.length - row.removed.length;
+					after = {from: after.from + delta, to: after.to + delta};
 				}
 			}
+			touched.set(node, after);
+		});
+		for (const [node, afterRange] of touched) {
+			const beforeRange = ranges.range(node), previous = {...beforeRange, source: beforeSource.slice(beforeRange.from, beforeRange.to)},
+				after = {...afterRange, source: afterSource.slice(afterRange.from, afterRange.to)};
+			if (previous.source !== after.source) node.block.acts.push({...historyAct(record), before: previous, after});
 		}
-		set(act.id, true); effects.set(act.id, changes);
 	}
-	for (const block of projected) { block.acts.reverse(); delete block.range; }
+
+	const acts = prepared.rows.filter(({record}) => !prepared.effects.pictures.has(record.transaction.id)).map(({record}) => historyAct(record));
+	// Native Redo consumes its Undo as navigation while keeping that receipt in
+	// the reading history. All material withdrawals use the canonical blockers,
+	// including independent inverses holding the same original act suppressed.
+	const reversed = new Set();
+	for (const {record} of prepared.rows) if (prepared.effects.active.has(record.transaction.id) && !record.transaction.reapplies)
+		for (const id of prepared.effects.references.get(record.transaction.id) || []) reversed.add(id);
+
+	for (const block of projected) block.acts.reverse();
 	return {ok: true, source: prepared.source, initialSource: prepared.initialSource, revision: prepared.revision,
 		earliestRevision: prepared.earliestRevision, complete: prepared.complete, acts, blocks: projected,
-		reversed: acts.filter(act => present.get(act.id) !== true).map(act => act.id)};
+		reversed: acts.filter(act => reversed.has(act.id)).map(act => act.id)};
 }
 
 // Runs retain only exact replacement ancestry. A later replacement owns an ambiguous hunk whole.
@@ -282,26 +310,26 @@ export function selectiveUndo(input, actIds, options = {}) {
 	if (!options || typeof options !== 'object' || Array.isArray(options) ||
 		(options.keepHunk !== undefined && typeof options.keepHunk !== 'function') ||
 		(options.splitSplice !== undefined && typeof options.splitSplice !== 'function')) return historyFailure('act_invalid');
-	const requested = new Set(actIds), available = new Set(prepared.rows.map(({record}) => record.transaction.id));
+	const requested = new Set(actIds), available = prepared.byId;
 	if ([...requested].some(id => !available.has(id))) return historyFailure('act_unavailable');
 	const selected = new Set([...requested].filter(id => prepared.effects.active.has(id)));
-	const records = prepared.rows.map(({record, splices}) => ({...record, splices}));
+	const records = prepared.records;
 	let inverseId = 'planned-inverse'; while (available.has(inverseId)) inverseId += ':';
 	const inverse = {splices: [], transaction: {id: inverseId, sourceTransactionIds: [...selected]}};
 	const projectedEffects = selected.size ? _rapierHistoryEffects([...records, inverse]) : prepared.effects;
 	const afterMetadata = _rapierMetadataState(prepared.initialMetadata, records, projectedEffects);
 	if (!afterMetadata) return historyFailure('history_invalid');
 	const metadata = _rapierMetadataDelta(prepared.metadata, afterMetadata), effectChanged = selected.size > 0;
-	const authoredEffectChanged = records.some(record => !prepared.effects.references.get(record.transaction.id)?.length &&
+	const sourceEffectChanged = records.some(record => record.splices.length && !prepared.effects.references.get(record.transaction.id)?.length &&
 		prepared.effects.active.has(record.transaction.id) !== projectedEffects.active.has(record.transaction.id));
-	if (!authoredEffectChanged) return {ok: true, splices: [], after: prepared.source, actIds: [...requested],
+	if (!sourceEffectChanged) return {ok: true, splices: [], after: prepared.source, actIds: [...requested],
 		sourceTransactionIds: [...selected], metadata, afterMetadata, effectChanged, unchanged: !metadata && !effectChanged,
 		superseded: [], overlaps: []};
 	try {
 		const transported = records.some(row => row.authored) ? authoredHistory(prepared.initialSource, records, selected) : null;
 		const rows = transported ? transported.records.map(record => ({record, splices: record.splices,
 			sourceIndices: transported.sourceIndices.get(record.transaction.id)})) : prepared.rows;
-		const result = projectInverseSource({...prepared, rows}, selected, projectedEffects, options);
+		const result = projectInverseSource(transported ? {...prepared, rows, records: transported.records} : prepared, selected, projectedEffects, options);
 		if (!result.ok) return result;
 		return {...result, actIds: [...requested], sourceTransactionIds: [...selected], metadata, afterMetadata,
 			effectChanged, unchanged: result.after === prepared.source && !metadata && !effectChanged};

package/dist/ledger/inverse-source.mjs

@@ -9,6 +9,137 @@ const historyBoundary = (source, at) => Number.isSafeInteger(at) && at >= 0 && !
 	!(at > 0 && at < source.length && (source.charCodeAt(at - 1) & 0xFC00) === 0xD800 &&
 	(source.charCodeAt(at) & 0xFC00) === 0xDC00);
 
+// Persistent AVL pieces retain original strings and coordinates. A revision costs
+// only the edited paths; reading a range visits its leaves, never earlier bodies.
+const sourceLeaf = (text, from = 0, to = text.length) => to > from
+	? {text, from, length: to - from, height: 1} : null;
+const sourceHeight = node => node?.height || 0;
+const sourceNode = (left, right) => !left ? right : !right ? left
+	: {left, right, length: left.length + right.length, height: 1 + Math.max(left.height, right.height)};
+function sourceBalance(left, right) {
+	if (sourceHeight(left) > sourceHeight(right) + 1) {
+		if (sourceHeight(left.left) >= sourceHeight(left.right)) return sourceNode(left.left, sourceNode(left.right, right));
+		return sourceNode(sourceNode(left.left, left.right.left), sourceNode(left.right.right, right));
+	}
+	if (sourceHeight(right) > sourceHeight(left) + 1) {
+		if (sourceHeight(right.right) >= sourceHeight(right.left)) return sourceNode(sourceNode(left, right.left), right.right);
+		return sourceNode(sourceNode(left, right.left.left), sourceNode(right.left.right, right.right));
+	}
+	return sourceNode(left, right);
+}
+function sourceJoin(left, right) {
+	if (!left || !right) return left || right;
+	if (left.height > right.height + 1) return sourceBalance(left.left, sourceJoin(left.right, right));
+	if (right.height > left.height + 1) return sourceBalance(sourceJoin(left, right.left), right.right);
+	return sourceNode(left, right);
+}
+function sourceSplit(node, at) {
+	if (!node || at === 0) return [null, node];
+	if (at === node.length) return [node, null];
+	if (node.text !== undefined) return [sourceLeaf(node.text, node.from, node.from + at), sourceLeaf(node.text, node.from + at, node.from + node.length)];
+	if (at < node.left.length) {
+		const [left, right] = sourceSplit(node.left, at);
+		return [left, sourceJoin(right, node.right)];
+	}
+	const [left, right] = sourceSplit(node.right, at - node.left.length);
+	return [sourceJoin(node.left, left), right];
+}
+function* sourceParts(node, from, to) {
+	if (!node || from >= to) return;
+	if (node.text !== undefined) {
+		yield node.from + from === 0 && node.from + to === node.text.length ? node.text : node.text.slice(node.from + from, node.from + to); return;
+	}
+	if (from < node.left.length) yield* sourceParts(node.left, from, Math.min(to, node.left.length));
+	if (to > node.left.length) yield* sourceParts(node.right, Math.max(0, from - node.left.length), to - node.left.length);
+}
+function* sourceLeaves(node) {
+	if (!node) return;
+	if (node.text !== undefined) { yield node; return; }
+	yield* sourceLeaves(node.left); yield* sourceLeaves(node.right);
+}
+export class HistorySource {
+	#root;
+	constructor(text, root = sourceLeaf(text)) { this.#root = root; }
+	static fromParts(parts) {
+		const leaves = Array.from(parts, text => sourceLeaf(text)).filter(Boolean);
+		const build = (from, to) => from === to ? null : to - from === 1 ? leaves[from]
+			: sourceNode(build(from, Math.floor((from + to) / 2)), build(Math.floor((from + to) / 2), to));
+		return new HistorySource('', build(0, leaves.length));
+	}
+	get length() { return this.#root?.length || 0; }
+	charCodeAt(at) {
+		if (at < 0 || at >= this.length) return NaN;
+		let node = this.#root;
+		while (node.text === undefined) {
+			if (at < node.left.length) node = node.left;
+			else { at -= node.left.length; node = node.right; }
+		}
+		return node.text.charCodeAt(node.from + at);
+	}
+	parts(from = 0, to = this.length) { return sourceParts(this.#root, from, to); }
+	slice(from = 0, to = this.length) {
+		const root = this.#root;
+		if (!root || from >= to) return '';
+		if (root.text !== undefined) return root.from + from === 0 && root.from + to === root.text.length
+			? root.text : root.text.slice(root.from + from, root.from + to);
+		return Array.from(this.parts(from, to)).join('');
+	}
+	matches(from, text) {
+		if (from < 0 || from + text.length > this.length) return false;
+		let at = 0;
+		for (const part of this.parts(from, from + text.length)) {
+			if (!text.startsWith(part, at)) return false;
+			at += part.length;
+		}
+		return at === text.length;
+	}
+	sameParts(parts) {
+		const leaves = sourceLeaves(this.#root);
+		let leaf = leaves.next().value, offset = 0;
+		for (const text of parts) for (let at = 0; at < text.length;) {
+			if (!leaf) return false;
+			const length = Math.min(leaf.length - offset, text.length - at), from = leaf.from + offset;
+			// Untouched runs share their string and coordinates. Only changed fragments
+			// require a text comparison; no full-body join is needed to prove the plan.
+			if ((leaf.text !== text || from !== at) && leaf.text.slice(from, from + length) !== text.slice(at, at + length)) return false;
+			offset += length; at += length;
+			if (offset === leaf.length) { leaf = leaves.next().value; offset = 0; }
+		}
+		return !leaf;
+	}
+	replace(pos, length, text) {
+		const [left, rest] = sourceSplit(this.#root, pos), [, right] = sourceSplit(rest, length);
+		return new HistorySource('', sourceJoin(sourceJoin(left, sourceLeaf(text)), right));
+	}
+	// Undoing an admitted repair is observation: its after-state can join a scalar
+	// across the deleted run. Prove the forward boundaries on the reconstructed view.
+	before(splices) {
+		let source = this;
+		for (let index = splices.length - 1; index >= 0; index--) {
+			const row = splices[index];
+			if (!row || !Number.isSafeInteger(row.pos) || row.pos < 0 || Object.is(row.pos, -0) ||
+				typeof row.removed !== 'string' || typeof row.inserted !== 'string' ||
+				/[\uD800-\uDFFF]/u.test(row.removed) || /[\uD800-\uDFFF]/u.test(row.inserted) || !source.matches(row.pos, row.inserted)) return null;
+			source = source.replace(row.pos, row.inserted.length, row.removed);
+			if (!historyBoundary(source, row.pos) || !historyBoundary(source, row.pos + row.removed.length)) return null;
+		}
+		return source;
+	}
+	apply(splices, inverse = false) {
+		if (!Array.isArray(splices)) return null;
+		let source = this;
+		for (let index = 0; index < splices.length; index++) {
+			const row = splices[inverse ? splices.length - 1 - index : index];
+			const removed = inverse ? row?.inserted : row?.removed, inserted = inverse ? row?.removed : row?.inserted;
+			if (typeof removed !== 'string' || typeof inserted !== 'string' ||
+				/[\uD800-\uDFFF]/u.test(removed) || /[\uD800-\uDFFF]/u.test(inserted) ||
+				!historyBoundary(source, row.pos) || !historyBoundary(source, row.pos + removed.length) || !source.matches(row.pos, removed)) return null;
+			source = source.replace(row.pos, removed.length, inserted);
+		}
+		return source;
+	}
+}
+
 function minimalHistorySplice(before, after, pos = 0) {
 	let first = 0, a = before.length, b = after.length;
 	while (first < a && first < b && before[first] === after[first]) first++;
@@ -36,14 +167,18 @@ function historyHunks(row) {
 // Rows are already proved source placements, optionally carrying sourceIndices from
 // causal projection. Multiple inverse blockers can change history with no source edit.
 export function projectInverseSource(prepared, selected, projectedEffects, options = {}) {
-	const records = prepared.rows.map(({record, splices}) => ({...record, splices}));
+	const records = prepared.records || prepared.rows.map(({record, splices}) => record.splices === splices ? record : {...record, splices});
 	if (!records.some(record => !prepared.effects.references.get(record.transaction.id)?.length &&
 		prepared.effects.active.has(record.transaction.id) !== projectedEffects.active.has(record.transaction.id)))
 		return {ok: true, splices: [], after: prepared.source, superseded: [], overlaps: []};
 	try {
 		let pieces = prepared.initialSource ? [{text: prepared.initialSource, owner: null, lineage: []}] : [];
 		const all = [], byId = new Map(), byAct = new Map(), processed = [], keptInverseAncestors = new Set();
-		const textOf = rows => rows.map(row => row.text || '').join('');
+		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; };
+		const sourceOf = rows => HistorySource.fromParts(texts(rows));
+		const replays = (before, after, splices) => sourceOf(before).apply(splices)?.sameParts(texts(after)) === true;
 		const boundary = pos => {
 			let offset = 0;
 			for (let index = 0; index < pieces.length; index++) {
@@ -68,20 +203,24 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 		};
 		const owns = (piece, hunk) => piece === hunk.marker || piece.owner === hunk.id ||
 			piece.restoredBy?.includes(hunk.id) || hunk.restoredMarkers?.has(piece);
-		const effectiveBefore = (hunk, effects, visiting = new Set()) => {
-			if (visiting.has(hunk.id)) return null;
-			visiting.add(hunk.id); let text = '';
-			for (const piece of hunk.before) {
+		const effectiveBefore = (hunk, effects) => {
+			const active = new Set([hunk.id]), pending = [{hunk, at: 0, parts: []}];
+			while (pending.length) {
+				const frame = pending[pending.length - 1];
+				if (frame.at === frame.hunk.before.length) {
+					const text = frame.parts.join(''); pending.pop(); active.delete(frame.hunk.id);
+					if (!pending.length) return text;
+					pending[pending.length - 1].parts.push(text); continue;
+				}
+				const piece = frame.hunk.before[frame.at++];
 				if (!piece.text) continue;
 				const owner = byId.get(piece.owner);
 				if (owner && !effects.active.has(owner.actId) && !owner.kept) {
-					if (piece.text !== owner.inserted) return null;
-					const prior = effectiveBefore(owner, effects, new Set(visiting));
-					if (prior === null) return null;
-					text += prior;
-				} else text += piece.text;
+					if (piece.text !== owner.inserted || active.has(owner.id)) return null;
+					active.add(owner.id); pending.push({hunk: owner, at: 0, parts: []});
+				} else frame.parts.push(piece.text);
 			}
-			return text;
+			return null;
 		};
 		const restoreHunk = hunk => {
 			if (!pieces.includes(hunk.marker)) throw Error('reactivation');
@@ -111,9 +250,9 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 					hunk.active = true; delete hunk.undoneBy;
 					continue;
 				}
-				const pos = textOf(pieces.slice(0, marker)).length, current = textOf(pieces);
+				const pos = lengthOf(pieces, marker);
 				const removed = effectiveBefore(hunk, effects);
-				if (removed === null || current.slice(pos, pos + removed.length) !== removed) throw Error('reactivation');
+				if (removed === null || !sourceOf(pieces).matches(pos, removed)) throw Error('reactivation');
 				boundary(pos + removed.length);
 				const start = boundary(pos), end = boundary(pos + removed.length);
 				const at = start.last, count = Math.max(0, end.first - at);
@@ -160,7 +299,7 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 					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 = textOf(restored.slice(0, first)).length;
+					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);
@@ -189,7 +328,7 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 					restored.splice(first, last + 1 - first, hunk.marker, ...insertion);
 					inverses.push(hunk); priorSplices?.push({pos, removed: hunk.removed, inserted: hunk.inserted});
 				}
-				if (restored && textOf(restored) === _rapierTransformSplices(textOf(pieces), splices)) {
+				if (restored && replays(pieces, restored, splices)) {
 					pieces = restored;
 					for (const target of targets) { target.active = false; target.undoneBy = tx.id; }
 					for (const piece of pieces) if (piece.mark) {
@@ -209,7 +348,7 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 					const before = pieces, priorStates = all.map(hunk => [hunk, hunk.active, hunk.undoneBy]); pieces = pieces.slice();
 					try {
 						reactivate(activated, current);
-						if (textOf(pieces) === _rapierTransformSplices(textOf(before), splices)) continue;
+						if (replays(before, pieces, splices)) continue;
 					} catch (_) {}
 					pieces = before;
 					for (const [hunk, active, undoneBy] of priorStates) { hunk.active = active; hunk.undoneBy = undoneBy; }
@@ -270,7 +409,7 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 				}
 			}
 		}
-		if (textOf(pieces) !== prepared.source) throw Error('head');
+		if (!new HistorySource(prepared.source).sameParts(texts(pieces))) throw Error('head');
 		const origins = new Map();
 		let offset = 0;
 		for (const piece of pieces) if (piece.text) { origins.set(piece, offset); offset += piece.text.length; }
@@ -310,7 +449,7 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 		const removed = prepared.source.slice(cursor);
 		if (removed !== inserted) changes.push(minimalHistorySplice(removed, inserted, cursor));
 		const splices = changes.length <= 64 ? changes.reverse() : [minimalHistorySplice(prepared.source, after)];
-		if (_rapierTransformSplices(prepared.source, splices) !== after) throw Error('plan');
+		if (!new HistorySource(prepared.source).apply(splices)?.sameParts([after])) throw Error('plan');
 		return {ok: true, splices, after, superseded, overlaps: superseded.filter(row => row.reason === 'later_edit')};
 	} catch (_) { return historyFailure('history_invalid'); }
 }