rapier-markdown-kit 1.1.98 → 1.1.101

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

@@ -0,0 +1,316 @@
+// SPDX-License-Identifier: MIT
+// 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 {diff} from '../../packages/rapier-diff/index.mjs';
+
+const historyFailure = reason => ({ok: false, reason});
+const historyBoundary = (source, at) => Number.isSafeInteger(at) && at >= 0 && !Object.is(at, -0) && at <= source.length &&
+	!(at > 0 && at < source.length && (source.charCodeAt(at - 1) & 0xFC00) === 0xD800 &&
+	(source.charCodeAt(at) & 0xFC00) === 0xDC00);
+
+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++;
+	if (!historyBoundary(before, first) || !historyBoundary(after, first)) first--;
+	while (a > first && b > first && before[a - 1] === after[b - 1]) { a--; b--; }
+	if (!historyBoundary(before, a) || !historyBoundary(after, b)) { a++; b++; }
+	return {pos: pos + first, removed: before.slice(first, a), inserted: after.slice(first, b)};
+}
+
+// Split recorded replacements only at exact unchanged word or line tokens.
+// Shared letters inside changed words do not establish surviving ownership.
+function historyHunks(row) {
+	if (row.removed === row.inserted) return [];
+	if (!row.removed || !row.inserted) return [{...row}];
+	const size = row.removed.length + row.inserted.length;
+	const edits = size <= 1024 * 1024 ? diff(row.removed, row.inserted,
+		{_unit: size <= 16384 ? 'word' : 'line', limit: 1000000}).edits : null;
+	if (!edits || edits.length > 64 || edits.some(edit => edit.coarse))
+		return [minimalHistorySplice(row.removed, row.inserted, row.pos)];
+	return edits.map(edit => ({pos: row.pos + edit.before[0], removed: row.removed.slice(...edit.before),
+		inserted: row.inserted.slice(...edit.after)})).reverse();
+}
+
+
+// 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}));
+	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 boundary = pos => {
+			let offset = 0;
+			for (let index = 0; index < pieces.length; index++) {
+				const row = pieces[index];
+				if (!row.text) continue;
+				const end = offset + row.text.length;
+				if (pos > offset && pos < end) {
+					const at = pos - offset;
+					pieces.splice(index, 1, {...row, text: row.text.slice(0, at)}, {...row, text: row.text.slice(at)});
+				break;
+				}
+				offset = end;
+			}
+			offset = 0;
+			let first = pieces.length, last = pieces.length;
+			for (let index = 0; index < pieces.length; index++) {
+				if (offset === pos) { first = index; last = index; while (last < pieces.length && !pieces[last].text) last++; return {first, last}; }
+				offset += pieces[index].text?.length || 0;
+			}
+			if (offset !== pos) throw Error('range');
+			return {first, last};
+		};
+		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) {
+				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;
+			}
+			return text;
+		};
+		const restoreHunk = hunk => {
+			if (!pieces.includes(hunk.marker)) throw Error('reactivation');
+			for (let at = pieces.length - 1; at >= 0; at--)
+				if (pieces[at] !== hunk.marker && owns(pieces[at], hunk)) pieces.splice(at, 1);
+			pieces.splice(pieces.indexOf(hunk.marker), 1, ...hunk.before);
+			for (const piece of hunk.before) if (piece.mark) { piece.mark.active = true; delete piece.mark.undoneBy; }
+		};
+		const laterSource = (hunk, effects) => [...hunk.supersededBy].some(id => {
+			const next = byId.get(id);
+			return next && effects.active.has(next.actId) && !prepared.effects.references.get(next.actId)?.length;
+		});
+		const reactivate = (actIds, effects) => {
+			for (const hunk of all) {
+				if (!actIds.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;
+				const marker = pieces.indexOf(hunk.marker);
+				if (marker < 0) {
+					// A zero-row withdrawal can release source still carried by another
+					// 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;
+					hunk.active = true; delete hunk.undoneBy;
+					continue;
+				}
+				const pos = textOf(pieces.slice(0, marker)).length, current = textOf(pieces);
+				const removed = effectiveBefore(hunk, effects);
+				if (removed === null || current.slice(pos, pos + removed.length) !== 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);
+				if (textOf(pieces.slice(at, at + count)) !== removed) throw Error('reactivation');
+				const replacedOwners = new Set(pieces.slice(at, at + count).map(piece => piece.owner).filter(Boolean));
+				pieces.splice(at, count, ...(hunk.inserted ? [{text: hunk.inserted, owner: hunk.id, lineage: hunk.lineage.slice()}] : []));
+				for (const owner of replacedOwners) if (owner !== hunk.id && !pieces.some(piece => piece.text && piece.owner === owner)) {
+					const prior = byId.get(owner); if (prior) prior.active = false;
+				}
+				hunk.active = true; delete hunk.undoneBy;
+			}
+		};
+		const pictureInsertions = new Map(records.filter(record => prepared.effects.pictures.has(record.transaction.id))
+			.map(record => [prepared.effects.pictures.get(record.transaction.id), record.splices.map(row => row.removed)]));
+		for (const {record, splices, sourceIndices} of prepared.rows) {
+			const tx = record.transaction, references = new Set(prepared.effects.references.get(tx.id) || []);
+			const actSource = options.keepHunk && selected.has(tx.id) ? textOf(pieces) : null;
+			processed.push(record);
+			const picture = prepared.effects.pictures.get(tx.id);
+			if (picture) {
+				// The new codec bytes keep the exact inserted run's ownership. Do not
+				// cross a later edit, combine authors, or create another reversible act.
+				for (const row of splices) {
+					boundary(row.pos + row.removed.length);
+					const start = boundary(row.pos), end = boundary(row.pos + row.removed.length);
+					const removed = pieces.slice(start.last, end.first), owner = removed[0]?.owner, hunk = byId.get(owner);
+					if (!hunk || hunk.actId !== picture || removed.some(piece => !piece.text || piece.owner !== owner) || textOf(removed) !== row.removed)
+						throw Error('picture_ownership');
+					const at = hunk.inserted.indexOf(row.removed);
+					if (at < 0 || hunk.inserted.indexOf(row.removed, at + 1) >= 0) throw Error('picture_ownership');
+					hunk.inserted = hunk.inserted.slice(0, at) + row.inserted + hunk.inserted.slice(at + row.removed.length);
+					pieces.splice(start.last, end.first - start.last, {text: row.inserted, owner, lineage: hunk.lineage.slice()});
+				}
+				continue;
+			}
+			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 = textOf(restored.slice(0, first)).length;
+					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;
+					}
+					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 && textOf(restored) === _rapierTransformSplices(textOf(pieces), splices)) {
+					pieces = restored;
+					for (const target of targets) { 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);
+					continue;
+				}
+			}
+
+			if (references.size) {
+				const previous = _rapierHistoryEffects(processed.slice(0, -1)), current = _rapierHistoryEffects(processed);
+				const activated = new Set(current.effectiveActIds.filter(id => !previous.active.has(id) &&
+					id !== tx.id && !current.references.get(id)?.length));
+				if (activated.size) {
+					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;
+					} catch (_) {}
+					pieces = before;
+					for (const [hunk, active, undoneBy] of priorStates) { hunk.active = active; hunk.undoneBy = undoneBy; }
+				}
+			}
+			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;
+			// the previous picture stays in `before` for Undo, not as mixed live ownership.
+			const hunks = row => pictureInsertions.get(tx.id)?.some(text => row.inserted.includes(text)) ? [{...row}] : historyHunks(row);
+			for (let rowIndex = 0; rowIndex < splices.length; rowIndex++) {
+				const original = splices[rowIndex];
+				let rows;
+				if (options.splitSplice) {
+					const beforeSource = textOf(pieces), parts = options.splitSplice({actId: tx.id, beforeSource, splice: original});
+					// Semantic boundaries only refine this act's exact bytes, never its history.
+					if (!Array.isArray(parts) || _rapierTransformSplices(beforeSource, parts) !== _rapierTransformSplices(beforeSource, [original]))
+						throw Error('hunk_projection');
+					rows = parts.flatMap(hunks);
+				} else rows = hunks(original);
+				for (let index = 0; index < rows.length; index++) {
+					const row = rows[index];
+					const derived = (sourceIndices?.[rowIndex] ?? rowIndex) === record.derivedCommentIndex;
+					let chosen = selected.has(tx.id) && !derived;
+					boundary(row.pos + row.removed.length);
+					const start = boundary(row.pos), end = boundary(row.pos + row.removed.length);
+					let at = start.last, count = Math.max(0, end.first - at);
+					if (!row.removed.length) {
+						// A new insertion at a replacement's left boundary stays before that replacement.
+						const marker = pieces.slice(start.first, start.last).findIndex(item => item.mark?.inserted.length);
+						at = marker < 0 ? start.last : start.first + marker; count = 0;
+					}
+					const removed = pieces.slice(at, at + count);
+					if (textOf(removed) !== row.removed) throw Error('replay');
+					// A semantic owner may retain a drawing hunk while prose in that same act undoes.
+					// The predicate only selects transient hunks; every original row still replays.
+					if (chosen && options.keepHunk) {
+						const keep = options.keepHunk({actId: tx.id, spliceIndex: rowIndex, hunkIndex: index,
+							splice: {pos: row.pos, removed: row.removed, inserted: row.inserted}, beforeSource: textOf(pieces), actSource, priorSplices});
+						if (typeof keep !== 'boolean') throw Error('hunk_selection');
+						chosen = !keep;
+					}
+					const id = tx.id + '#' + rowIndex + ':' + index;
+					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};
+					hunk.marker = {mark: hunk};
+					all.push(hunk); byId.set(id, hunk);
+					if (!byAct.has(tx.id)) byAct.set(tx.id, []);
+					byAct.get(tx.id).push(hunk);
+					for (const parent of lineage) {
+						const earlier = byId.get(parent);
+						if (earlier && earlier !== hunk) earlier.supersededBy.add(id);
+					}
+					pieces.splice(at, count, hunk.marker, ...(row.inserted ? [{text: row.inserted, owner: id, lineage: [...lineage]}] : []));
+					priorSplices?.push({pos: row.pos, removed: row.removed, inserted: row.inserted});
+				}
+			}
+		}
+		if (textOf(pieces) !== prepared.source) 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; }
+		const superseded = [];
+		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) &&
+				!prepared.effects.references.get(hunk.actId)?.length;
+			if (!hunk.chosen && !inheritedInactive) continue;
+			hunk.active = prepared.effects.active.has(hunk.actId);
+			const laterActIds = [...new Set([...hunk.supersededBy].filter(id =>
+				(byId.get(id)?.kept || byId.get(id)?.active && projectedEffects.active.has(byId.get(id)?.actId))).map(id => byId.get(id).actId))];
+			const marker = pieces.indexOf(hunk.marker);
+			if ((!hunk.active && !inheritedInactive) || laterActIds.length || marker < 0) {
+				if (hunk.chosen) superseded.push({actId: hunk.actId, hunk: hunk.id, laterActIds: hunk.undoneBy ? [hunk.undoneBy] : laterActIds,
+					reason: hunk.active ? 'later_edit' : 'already_undone'});
+				continue;
+			}
+			// Restoring an inverse can restore a deletion marker without any owned text.
+			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);
+		const after = textOf(pieces), changes = [];
+		let cursor = 0, inserted = '';
+		for (const piece of pieces) {
+			if (!piece.text) continue;
+			const origin = origins.get(piece);
+			if (origin == null) { inserted += piece.text; continue; }
+			if (origin < cursor) throw Error('source_order');
+			const removed = prepared.source.slice(cursor, origin);
+			if (removed !== inserted) changes.push(minimalHistorySplice(removed, inserted, cursor));
+			inserted = ''; cursor = origin + piece.text.length;
+		}
+		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');
+		return {ok: true, splices, after, superseded, overlaps: superseded.filter(row => row.reason === 'later_edit')};
+	} catch (_) { return historyFailure('history_invalid'); }
+}

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

@@ -124,6 +124,22 @@ function _rapierRecordSplices(entry, ledger) {
 	} catch (_) { return null; }
 }
 
+// Source identifies a retained checkpoint even when host revision numbers differ.
+function journalOperations(before, after, journal) {
+	if (typeof before !== 'string' || typeof after !== 'string' || !Array.isArray(journal)) return;
+	if (before === after) return [];
+	let text = after;
+	const groups = [];
+	for (let index = journal.length - 1; index >= 0; index--) {
+		const rows = _rapierRecordSplices(journal[index], journal);
+		const prior = _rapierTransformSplices(text, rows, true);
+		if (prior === null) return;
+		groups.push(rows);
+		if (prior === before) return groups.reverse().flat().map(({pos, removed, inserted}) => ({pos, removed, inserted}));
+		text = prior;
+	}
+}
+
 function _rapierRecordMetadata(entry, ledger) {
 	try {
 		if (Object.hasOwn(entry, 'metadata')) return _rapierValidMetadataEffect(entry.metadata) ? entry.metadata : undefined;
@@ -140,12 +156,61 @@ function _rapierRecordMetadata(entry, ledger) {
 	} catch (_) { return undefined; }
 }
 
-// Active inverses suppress their targets. Reversing an inverse restores its targets,
-// including assignments hidden by later choices. Nothing outside these records is retained.
+// A codec replacement owns only one inserted definition and its reference. Its
+// source act remains the picture's author; an arbitrary edit cannot claim upkeep.
+function _rapierPictureFinish(record, original, earlier) {
+	const tx = record?.transaction, rows = record?.splices;
+	if (tx?.operation !== 'document.finish-picture' || !tx.sourceTransactionId || tx.sourceTransactionIds ||
+		tx.reverts || tx.reapplies || record.metadata || !Array.isArray(rows) || rows.length !== 2 ||
+		original?.transaction?.operation !== 'document.embed-image' || !Array.isArray(original.splices)) return false;
+	const reference = rows.find(row => /^\]\[[a-z0-9-]+\]$/i.test(row.removed));
+	if (!reference || !/^\]\[[a-z0-9-]+\]$/i.test(reference.inserted) || reference.removed === reference.inserted) return false;
+	const definition = rows.find(row => row !== reference), oldLabel = reference.removed.slice(2, -1), newLabel = reference.inserted.slice(2, -1);
+	const body = (text, label) => {
+		const prefix = '[' + label + ']: data:image/svg+xml;base64,';
+		if (typeof text !== 'string' || !text.startsWith(prefix)) return null;
+		const value = text.slice(prefix.length), end = value.indexOf(' '), bytes = end < 0 ? value : value.slice(0, end), title = end < 0 ? '' : value.slice(end);
+		return /^[A-Za-z0-9+/]+={0,2}$/.test(bytes) && !/[\r\n]/.test(title) ? title : null;
+	};
+	const title = body(definition.removed, oldLabel);
+	if (title === null || body(definition.inserted, newLabel) !== title) return false;
+	if (![definition.removed, reference.removed].every(text => {
+		let count = 0;
+		for (const row of original.splices) for (let at = row.inserted.indexOf(text); at >= 0; at = row.inserted.indexOf(text, at + 1)) count++;
+		return count === 1;
+	})) return false;
+	return rows.every((row, index) => {
+		let start = row.pos, end = start + row.removed.length;
+		const cross = (splice, owner) => {
+			const stop = splice.pos + splice.inserted.length;
+			if (splice.pos < end && stop > start || !splice.inserted.length && splice.pos > start && splice.pos < end) {
+				if (owner && start >= splice.pos && end <= stop && splice.inserted.slice(start - splice.pos, end - splice.pos) === row.removed) return 'owned';
+				return 'changed';
+			}
+			if (stop <= start) { const shift = splice.removed.length - splice.inserted.length; start += shift; end += shift; }
+			return null;
+		};
+		for (const prior of rows.slice(0, index).reverse()) if (cross(prior, false)) return false;
+		for (let at = earlier.length - 1; at >= 0; at--) {
+			const prior = earlier[at], source = _rapierRecordSplices(prior, earlier);
+			if (!source) return false;
+			const owner = prior === original || prior.transaction?.reapplies === original.transaction.id;
+			for (const splice of source.slice().reverse()) {
+				const result = cross(splice, owner);
+				if (result) return result === 'owned';
+			}
+		}
+		return false;
+	});
+}
+
+// Every active inverse keeps its original targets suppressed. Independent inverses
+// can share a target; withdrawing one restores it only after the last blocker leaves.
+// This includes assignments hidden by later choices. No second history is retained.
 function _rapierHistoryEffects(records, visit = null) {
 	try {
 		if (!Array.isArray(records)) return {ok: false};
-		const nodes = new Map(), references = new Map();
+		const nodes = new Map(), references = new Map(), pictures = new Map(), byId = new Map(), finished = new Set(), earlier = [];
 		const update = (target, delta) => {
 			const pending = [[target, delta]];
 			while (pending.length) {
@@ -156,7 +221,32 @@ function _rapierHistoryEffects(records, visit = null) {
 				if (was !== node.active) for (const ref of node.references) pending.push([ref, node.active ? 1 : -1]);
 			}
 		};
-		const lastUndo = new Map();
+		const lastUndo = new Map(), contexts = new Map(), order = [];
+		// Native Redo names an original act. Its inverse target is the last Undo
+		// in the author's proved causal view, not an unrelated later arrival.
+		const contextOf = origin => {
+			if (!origin) return null;
+			if (!_rapierValidAuthored(origin)) throw Error('origin');
+			const known = new Set(), pending = origin.basis.slice();
+			while (pending.length) {
+				const id = pending.pop(), context = contexts.get(id);
+				if (!context) throw Error('origin');
+				if (known.has(id)) continue;
+				known.add(id);
+				if (context.basis) pending.push(...context.basis);
+				else for (let index = 0; index < context.index; index++) known.add(order[index]);
+			}
+			const inactive = new Set();
+			for (let index = order.length - 1; index >= 0; index--) {
+				const id = order[index];
+				if (!known.has(id) || inactive.has(id)) continue;
+				for (const ref of references.get(id)) {
+					if (!known.has(ref)) throw Error('origin');
+					inactive.add(ref);
+				}
+			}
+			return {known, inactive};
+		};
 		for (const record of records) {
 			const tx = record?.transaction;
 			if (!tx || typeof tx.id !== 'string' || !tx.id || nodes.has(tx.id) || (tx.reverts && tx.reapplies)) return {ok: false};
@@ -164,24 +254,38 @@ function _rapierHistoryEffects(records, visit = null) {
 			if (!Array.isArray(supplied) || new Set(supplied).size !== supplied.length ||
 				(tx.sourceTransactionIds && tx.sourceTransactionId && (supplied.length !== 1 || supplied[0] !== tx.sourceTransactionId))) return {ok: false};
 			let refs = supplied;
+			if (tx.operation === 'document.finish-picture' && tx.sourceTransactionId) {
+				const owner = tx.sourceTransactionId;
+				if (!nodes.get(owner)?.active || finished.has(owner) || !_rapierPictureFinish(record, byId.get(owner), earlier)) return {ok: false};
+				pictures.set(tx.id, owner); finished.add(owner); refs = [];
+			}
 			if (tx.reverts || tx.reapplies) {
 				const target = tx.reverts || tx.reapplies;
 				if (!nodes.has(target) || (supplied.length && (supplied.length !== 1 || supplied[0] !== target))) return {ok: false};
 				if (tx.reverts) refs = [target];
 				else {
-					const undo = lastUndo.get(target);
-					if (!undo || !nodes.get(undo).active) return {ok: false};
+					const context = contextOf(record.authored || tx.authored);
+					const undo = (lastUndo.get(target) || []).findLast(id => context
+						? context.known.has(id) && !context.inactive.has(id) : nodes.get(id).active);
+					if (!undo) return {ok: false};
 					refs = [undo];
 				}
 			}
-			if (refs.some(id => typeof id !== 'string' || !nodes.get(id)?.active)) return {ok: false};
+			if (refs.some(id => typeof id !== 'string' || !nodes.has(id) || pictures.has(id))) return {ok: false};
 			nodes.set(tx.id, {active: true, blockers: 0, references: refs}); references.set(tx.id, refs.slice());
+			byId.set(tx.id, record);
+			earlier.push(record);
 			for (const ref of refs) update(ref, 1);
-			if (tx.reverts) lastUndo.set(tx.reverts, tx.id);
+			const origin = record.authored || tx.authored;
+			contexts.set(tx.id, {index: order.length, basis: origin?.basis || null}); order.push(tx.id);
+			if (tx.reverts) {
+				if (!lastUndo.has(tx.reverts)) lastUndo.set(tx.reverts, []);
+				lastUndo.get(tx.reverts).push(tx.id);
+			}
 			if (visit) visit(record, nodes, refs);
 		}
-		const effectiveActIds = [...nodes].filter(([, node]) => node.active).map(([id]) => id);
-		return {ok: true, effectiveActIds, active: new Set(effectiveActIds), references};
+		const effectiveActIds = [...nodes].filter(([id, node]) => node.active && !pictures.has(id)).map(([id]) => id);
+		return {ok: true, effectiveActIds, active: new Set(effectiveActIds), references, pictures};
 	} catch (_) { return {ok: false}; }
 }
 
@@ -311,8 +415,8 @@ function _rapierValidLedgerRecord(record, prior, earlier, documentAuthority, max
 			/^(?:human|agent|system)$/.test(transaction.actor.kind) &&
 			typeof transaction.actor.id === 'string' && transaction.actor.id.length > 0 &&
 			transaction.actor.id.length <= _RAPIER_TRANSACTION_ACTOR_LIMIT &&
-			optional(transaction.actor.name, value => nullableText(value, 120, false));
+			optional(transaction.actor.name, value => identity(value, 120));
 	} catch (_) { return false; }
 }
 
-export { _rapierValidAuthored, _RAPIER_TRANSACTION_ACTOR_LIMIT, _RAPIER_TRANSACTION_OPERATION_LIMIT, _RAPIER_TRANSACTION_REQUEST_LIMIT, _rapierTransformSplices, _rapierRecordSplices, _rapierValidLedgerRecord, _rapierJournalRecord, _rapierValidMetadata, _rapierValidMetadataEffect, _rapierMetadataDelta, _rapierTransformMetadata, _rapierRecordMetadata, _rapierHistoryEffects, _rapierMetadataState, _rapierReplayMetadata, _rapierHasHistoryEffect};
+export { _rapierValidAuthored, _RAPIER_TRANSACTION_ACTOR_LIMIT, _RAPIER_TRANSACTION_OPERATION_LIMIT, _RAPIER_TRANSACTION_REQUEST_LIMIT, _rapierTransformSplices, _rapierRecordSplices, _rapierValidLedgerRecord, _rapierJournalRecord, _rapierValidMetadata, _rapierValidMetadataEffect, _rapierMetadataDelta, _rapierTransformMetadata, _rapierRecordMetadata, _rapierHistoryEffects, _rapierMetadataState, _rapierReplayMetadata, _rapierHasHistoryEffect, journalOperations};

package/dist/kit/ledger/merge.mjs

@@ -39,7 +39,7 @@ function actFingerprint(record, effects) {
   const tx = record.transaction, references = effects.references.get(tx.id) || [];
   const {id, documentAuthority, baseRevision, revision, parent, reverts, reapplies,
     sourceTransactionId, sourceTransactionIds, remoteTransactionId, ...authored} = tx;
-  return sha256(canonicalJSON({transaction: authored, references,
+  return sha256(canonicalJSON({transaction: authored, references, picture: effects.pictures.get(tx.id) || null,
     changeSet: record.changeSet ?? null, derivedCommentIndex: record.derivedCommentIndex ?? null,
     // Applied source placement is proved below, never inferred from this fingerprint.
     // An inverse's physical metadata is projected from its targets at the destination.
@@ -143,7 +143,7 @@ export function merge(first, second) {
   }
   const records = ours.ledger.records.slice(), imported = new Set(localIds.keys());
   let text = ours.text, metadata = {...ours.metadata}, root = ours.root;
-  const append = (splices, original, effect = null, inverseIds = [], origin = original.authored) => {
+  const append = (splices, original, effect = null, inverseIds = [], origin = original.authored, picture = null) => {
     const next = _rapierTransformSplices(text, splices);
     if (next === null) return null;
     const beforeHash = root, revision = (records.at(-1)?.transaction.revision ?? ours.ledger.start.revision) + 1;
@@ -153,7 +153,7 @@ export function merge(first, second) {
     const record = {beforeHash, afterHash: nextRoot, splices, ...(origin ? {authored: origin} : {}), transaction: {
       ...tx, id: tx.id, documentAuthority: ours.ledger.documentAuthority,
       baseRevision: revision - 1, revision, actor: tx.actor, transport: tx.transport, operation: tx.operation, requestId: tx.requestId,
-      sourceTransactionId: inverseIds.length === 1 ? inverseIds[0] : null,
+      sourceTransactionId: picture || (inverseIds.length === 1 ? inverseIds[0] : null),
       ...(inverseIds.length > 1 ? {sourceTransactionIds: inverseIds} : {}),
       ...(tx.turnId ? {turnId: tx.turnId} : {}), affectedBlockIds: tx.affectedBlockIds.slice(),
       parent: records.at(-1)?.transaction.id ?? null, reverts: null, reapplies: null, createdAt: tx.createdAt,
@@ -167,6 +167,7 @@ export function merge(first, second) {
     const nextMetadata = _rapierTransformMetadata(metadata, effect);
     if (!nextMetadata) return null;
     if (effect) record.metadata = effect;
+    if (picture && !_rapierHistoryEffects([...records, record]).ok) return null;
     records.push(record); text = next; metadata = nextMetadata; root = nextRoot;
     return record.transaction.id;
   };
@@ -209,6 +210,8 @@ export function merge(first, second) {
     const references = incomingEffects.references.get(record.transaction.id) || [];
     const inverseIds = references.map(id => mappedIds.get(id));
     if (inverseIds.some(id => !id || !_rapierHistoryEffects(records).active.has(id))) return metadataConflict('inverse_target_unavailable');
+    const pictureOwner = incomingEffects.pictures.get(record.transaction.id), picture = pictureOwner && mappedIds.get(pictureOwner);
+    if (pictureOwner && (!picture || !_rapierHistoryEffects(records).active.has(picture))) return refused('history', 'record_transport_conflict');
     let moved;
     try { moved = transposeAuthored(ours.ledger.start.text, records, {...record, authored: incomingOrigins.get(record.transaction.id)},
       theirs.ledger.records.slice(0, theirs.ledger.records.indexOf(record)).map(row => row.transaction.id)); } catch (_) {}
@@ -217,7 +220,7 @@ export function merge(first, second) {
     const effect = record.metadata ? Object.fromEntries(Object.entries(record.metadata).map(([key, pair]) =>
       [key, {before: metadata[key], after: pair.after}])) : null;
     const origin = record.authored ?? (against.length ? incomingOrigins.get(record.transaction.id) : null);
-    const mapped = append(moved.splices, record, effect, inverseIds, origin);
+    const mapped = append(moved.splices, record, effect, inverseIds, origin, picture);
     if (!mapped) return metadataConflict(inverseIds.length ? 'inverse_target_unavailable' : 'record_transport_conflict');
     against = against.filter(row => row.transaction.id !== record.transaction.id);
     mappedIds.set(record.transaction.id, mapped);