rapier-markdown-kit 1.1.102 → 1.2.3

package/dist/kit/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, _rapierValidMetadata, _rapierTransformMetadata, _rapierMetadataDelta, _rapierHistoryEffects, _rapierMetadataState, _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)} : {})};
 }
@@ -43,11 +43,15 @@ export function groupHistoryActs(acts) {
 
 // A picture's codec replacement travels with its original navigation step.
 // Match every complete replacement exactly before moving any source bytes.
-export function pictureHistorySplices({source, records}, target, redo) {
+export function pictureHistorySplices(input, target, redo) {
+	const {records} = input;
 	const id = target?.transaction?.id, at = records.indexOf(target);
 	if (!id || at < 0 || target.transaction.operation === 'document.finish-picture' || !Array.isArray(target.splices)) return null;
 	const later = records.slice(at + 1).filter(row => row?.transaction?.operation === 'document.finish-picture' && Array.isArray(row.splices) && row.splices.length);
 	if (!later.length) return null;
+	// A caller may hold a persistent source tree: request its text only when
+	// a later picture replacement can actually affect this navigation step.
+	const source = input.source;
 	const own = new Set(later.filter(row => row.transaction.sourceTransactionId === id));
 	const step = redo ? target.splices : target.splices.slice().reverse().map(row => ({pos: row.pos, removed: row.inserted, inserted: row.removed}));
 	const plan = moveOthers => {
@@ -74,76 +78,77 @@ 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;
+		// The window's owner may name its root (the source store mints it once per text); otherwise hash the initial text.
+		let root = earliestRevision === 0 ? (typeof input.earliestRoot === 'string' && input.earliestRoot || 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 +157,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 +185,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 +221,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 +269,49 @@ 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);
+		});
+		// Blocks one splice covers share its range (a whole-document delete maps every block to all it removed): slice each range once.
+		const slices = new Map(), cut = (source, side, from, to) => {
+			const key = side + from + ':' + to;
+			if (!slices.has(key)) slices.set(key, source.slice(from, to));
+			return slices.get(key);
+		};
+		for (const [node, afterRange] of touched) {
+			const beforeRange = ranges.range(node), previous = {...beforeRange, source: cut(beforeSource, 'b', beforeRange.from, beforeRange.to)},
+				after = {...afterRange, source: cut(afterSource, 'a', 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 +322,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};