rapier-markdown-kit 1.1.102 → 1.1.104

package/dist/kit/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'); }
 }