rapier-markdown-kit 1.2.7 → 1.2.9

package/dist/kit/ledger/merge.mjs

@@ -6,7 +6,6 @@ import {transposeAuthored, authoredPlacements} from './transport.mjs';
 import {parseWill, stripOneTerminator} from '../../agent/will.mjs';
 import {sha256} from './hash.mjs';
 import {canonicalJSON, fault} from './data.mjs';
-// The same interval transport used by the agent kernel, now shared with the public ledger.
 export function transportInterval(start, end, splices) {
   let a = start, b = end;
   for (const row of splices) {
@@ -17,14 +16,11 @@ export function transportInterval(start, end, splices) {
   }
   return {start: a, end: b};
 }
-// Follow the current extent of a touched range for disclosure or the person's focus.
-// Unlike transportInterval, this does not prove unchanged source and never grants edit authority.
 export function transportTouchedInterval(start, end, splices) {
   const unchanged = transportInterval(start, end, splices);
   if (unchanged) return unchanged;
   let range = {start, end};
   for (const row of splices) {
-    // A split replacement can insert at a boundary before another splice touches the range.
     const boundaryInsertion = !row.removed.length && (row.pos === range.start || row.pos === range.end);
     const exact = boundaryInsertion ? null : transportInterval(range.start, range.end, [row]);
     range = exact || {start: Math.min(range.start, row.pos),
@@ -33,21 +29,15 @@ export function transportTouchedInterval(start, end, splices) {
   return range;
 }
 const recordKey = record => sha256(canonicalJSON(record));
-// Identity survives rebasing. Position, roots, revision and parent are local placement,
-// while authorial choices and semantic inverse targets belong to the original act.
 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, 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.
     metadata: references.length ? null : Object.fromEntries(Object.entries(record.metadata || {}).map(([key, pair]) => [key, pair.after]))}));
 }
 const mergeIdentity = (localDigest, incomingDigest) => 'merge:' + sha256(canonicalJSON([localDigest, incomingDigest]));
-// One physical replacement can carry two authored acts when both removed the same
-// units and wrote the same text. An empty list is the act that does not repeat it.
 function coincidentEffect(origin, left, right) {
   const authored = origin?.splices;
   if (!authored?.some(row => row.removed.length)) return false;
@@ -68,22 +58,17 @@ function checkpointList(read) {
   }
   return list;
 }
-// Keep and append regions with their intents, and the kept text: what the other copy may not change unseen.
 function kept(text) {
   const will = parseWill(text);
   if (will.fault) return {fault: will.fault, text};
   return will.regions.filter(region => region.law !== 'edit').map(({law, intent, start, end}) =>
     law === 'keep' ? {law, intent, text: text.slice(start, end)} : {law, intent});
 }
-// Every append region of `from` still begins its counterpart in `to`.
 function appended(from, to) {
   const regions = text => parseWill(text).regions.filter(region => region.law === 'append');
   const was = regions(from), now = regions(to), core = (text, region) => stripOneTerminator(text.slice(region.start, region.end));
   return was.length === now.length && was.every((region, index) => core(to, now[index]).startsWith(core(from, region)));
 }
-// A retained suffix can reuse a prefix only when an existing ledger proves its
-// exact source, metadata, revision and path root. Export then rechecks the whole
-// chain, including the boundary parent. No missing act is invented.
 function expandRetainedStart(shorter, longer) {
   if (shorter.ledger.documentAuthority !== longer.ledger.documentAuthority ||
       shorter.ledger.start.revision <= longer.ledger.start.revision) return null;
@@ -104,7 +89,6 @@ export function merge(first, second) {
   const expandedOurs = expandRetainedStart(ours, theirs);
   if (expandedOurs) {
     const result = merge(expandedOurs, theirs.ledger);
-    // A refused join still returns the caller's exact retained envelope.
     return !result.clean && result.ledger.sha256 === expandedOurs.sha256
       ? {...result, ledger: ours.ledger} : result;
   }
@@ -129,8 +113,6 @@ export function merge(first, second) {
     }
   }
   const a = checkpointList(ours), b = checkpointList(theirs);
-  // A synthetic conflict act has one identity derived from both original envelopes.
-  // Reconstruct its exact local prefix to recognize a repeat without aliasing act IDs.
   for (const [index, record] of ours.ledger.records.entries()) {
     if (record.transaction.operation !== 'document.merge') continue;
     const point = a[index], prefix = exportLedger({text: point.text, metadata: point.metadata,
@@ -148,8 +130,6 @@ export function merge(first, second) {
     if (found) common = {ours: found.index, theirs: b[i].index, text: found.text, metadata: found.metadata};
   }
   if (!common) throw fault('copies have no proven common start');
-  // A prior join can contain our acts in a different transported order. After
-  // proving their placement below, keep the complete superset's representation.
   const incomingIds = new Set(theirs.ledger.records.map(row => row.transaction.id));
   const sameStart = ours.complete && theirs.complete && ours.ledger.documentAuthority === theirs.ledger.documentAuthority &&
     canonicalJSON(ours.ledger.start) === canonicalJSON(theirs.ledger.start);
@@ -195,7 +175,6 @@ export function merge(first, second) {
   };
   let against = ours.ledger.records.slice(common.ours);
   const incoming = theirs.ledger.records.slice(common.theirs);
-  // The same original ID is a repeat only after its immutable fingerprint agrees.
   const unseen = incoming.filter(record => !imported.has(record.transaction.id));
   const refused = (kind, code, details = {}) => ({text: ours.text, metadata: ours.metadata, ledger: ours.ledger,
     clean: false, conflicts: [{kind, code, ...details}],
@@ -212,7 +191,6 @@ export function merge(first, second) {
     const local = localIds.get(record.transaction.id);
     if (local) mappedIds.set(record.transaction.id, local.transaction.id);
   }
-  // Kept text arriving from the other copy waits for the person; this copy's own kept edits merge like any other.
   const incomingKept = canonicalJSON(kept(theirs.text));
   const keepDiffers = incomingKept !== canonicalJSON(kept(ours.text)) && incomingKept !== canonicalJSON(kept(common.text)) ||
     !appended(common.text, theirs.text) && !appended(ours.text, theirs.text);
@@ -253,7 +231,6 @@ export function merge(first, second) {
   if (!conflicted) {
     if (unproved.size) return refused('identity', 'act_order_conflict', {actId: unproved.values().next().value});
     if (theirsContained) {
-      // Only equivalent proved states choose a representation, never competing authored values.
       return settled(oursContained && theirs.ledger.sha256 < ours.ledger.sha256 ? theirs : ours);
     }
     if (oursContained) {
@@ -265,8 +242,6 @@ export function merge(first, second) {
   if (conflicted) {
     if (unseen.length !== incoming.length) return refused('history', 'record_transport_conflict');
     if (incomingFields.size) return metadataConflict('record_transport_conflict', {fields: [...incomingFields]});
-    // A display of both alternatives is not an accepted history. The caller's envelope
-    // stays whole; neither original act is replaced by a synthetic copy.
     const merged = mergeText(keepDiffers ? null : common.text, ours.text, theirs.text, {oursId: 'copy-' + ours.ledger.sha256.slice(0, 16), theirsId: 'copy-' + theirs.ledger.sha256.slice(0, 16)});
     if (!merged.conflicts.length) return refused('history', 'record_transport_conflict');
     return {text: ours.text, metadata: ours.metadata, ledger: ours.ledger, clean: false,
@@ -274,8 +249,6 @@ export function merge(first, second) {
       review: {required: true, base: ours.text, proposed: theirs.text}};
   }
   let conflicts = [];
-  // The act that keeps the physical splice needs the same authored origin as its
-  // witness. Copy it onto this result only; the caller's record stays untouched.
   if (records.some(row => !row.splices.length && row.authored?.splices?.some(splice => splice.removed.length))) {
     const origins = authoredPlacements(ours.ledger.start.text, records);
     for (let index = 0; index < records.length; index++) {

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

@@ -1,5 +1,4 @@
 // SPDX-License-Identifier: MIT
-// Shared conflict envelopes and exact three-way text merge; Notes and the ledger import this owner.
 function textFault(code, message) { return Object.assign(new Error(message), {code}); }
 export function canonicalNote(text) {
 	if (typeof text !== 'string') throw textFault('note_text', 'A note must be text');
@@ -24,7 +23,6 @@ const textHeading = line => /^ {0,3}#{1,6}(?:[ \t]|$)/.test(line);
 const textDefinition = line => /^ {0,3}\[(?:\\.|[^\]\\\r\n])+\]:/.test(line);
 const textStart = line => textHeading(line) || textRule(line) || textFence(line) || /^ {0,3}(?:[-+*]|1[.)])[ \t]+/.test(line) || /^ {0,3}(?:>|<!--|<(?:script|style|pre|textarea)(?:\s|>))/i.test(line);
 
-// Only the exact public envelope is structural; malformed comments and fenced examples stay text.
 function textEnvelopeAt(text, start = 0) {
 	if (!text.startsWith(TEXT_CONFLICT, start)) return null;
 	const headerEnd = text.indexOf(' -->\n\n', start), variants = [];
@@ -60,8 +58,6 @@ export function inspectTextConflicts(text, {nested = false} = {}) {
 		const found = textEnvelopeAt(unit);
 		if (found && found.end === unit.length) {
 			out.push({...found, start: at, end: at + unit.length});
-			// Nested offsets belong to their alternative's source; custody callers use
-			// the exact block bytes. Ordinary fenced examples remain opaque at every level.
 			if (nested) for (const variant of found.variants) out.push(...inspectTextConflicts(variant.text, {nested}));
 		}
 		at += unit.length;
@@ -80,7 +76,6 @@ export function mapTextConflictVariants(text, mapper) {
 	return out + text.slice(at);
 }
 
-// This is a conservative edit boundary scan, never the document's rendering grammar.
 function textUnits(text) {
 	const lines = text.match(/[^\r\n]*(?:\r\n|\r|\n)|[^\r\n]+$/g) || [], out = [], offsets = [0];
 	for (const line of lines) offsets.push(offsets[offsets.length - 1] + line.length);
@@ -152,11 +147,9 @@ function textUnits(text) {
 }
 
 const TEXT_WINDOW_CELLS = 1000000, TEXT_CELLS = 4000000;
-// One window's authored matches, or false when two optimal alignments disagree on any of them.
 function textWindowMatches(base, side, b0, b1, s0, s1, out, budget) {
 	const n = b1 - b0, m = s1 - s0, cells = (n + 1) * (m + 1);
 	if (cells > TEXT_WINDOW_CELLS || (budget.cells -= cells) < 0) return false;
-	// Only authored units score; a blank line matches only beside a matched neighbour.
 	const width = m + 1, score = new Uint32Array(cells), content = i => !textSpace(base[b0 + i]), same = (i, j) => base[b0 + i] === side[s0 + j];
 	for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) {
 		const p = i * width + j;
@@ -168,7 +161,6 @@ function textWindowMatches(base, side, b0, b1, s0, s1, out, budget) {
 		if (content(i) && same(i, j) && score[p] === score[p + width + 1] + 1) meaningful.push([i++, j++]);
 		else if (score[p + width] >= score[p + 1]) i++; else j++;
 	}
-	// Every optimal path must agree on every authored anchor, not just two greedy walks.
 	const seen = new Uint32Array(cells); seen.fill(0xffffffff); seen[0] = 0;
 	for (let i = 0; i <= n; i++) for (let j = 0; j <= m; j++) {
 		const p = i * width + j, at = seen[p]; if (at === 0xffffffff) continue;
@@ -185,8 +177,6 @@ function textWindowMatches(base, side, b0, b1, s0, s1, out, budget) {
 	return true;
 }
 
-// A window too large to prove whole splits only at authored units found once on each side of it:
-// such a unit names its own occurrence. The strict rule above still decides every window between them.
 function textMatches(base, side, b0, b1, s0, s1, out, budget) {
 	if ((b1 - b0 + 1) * (s1 - s0 + 1) <= TEXT_WINDOW_CELLS) return textWindowMatches(base, side, b0, b1, s0, s1, out, budget);
 	const once = (units, from, to) => {
@@ -196,7 +186,6 @@ function textMatches(base, side, b0, b1, s0, s1, out, budget) {
 	};
 	const inBase = once(base, b0, b1), pairs = [];
 	for (const [unit, j] of once(side, s0, s1)) { const i = inBase.get(unit); if (j >= 0 && i >= 0) pairs.push([i, j]); }
-	// The longest run of them in the same order on both sides.
 	const tails = [], prev = new Int32Array(pairs.length);
 	for (let k = 0; k < pairs.length; k++) {
 		let lo = 0, hi = tails.length;
@@ -239,7 +228,6 @@ function textTick(base, a, b) {
 		return m && {at: m[1].length, tick: m[2], body: value.slice(0, m[1].length) + ' ' + value.slice(m[1].length + 1)};
 	};
 	const c = box(base); if (!c) return null;
-	// One side ticked, the other added lines: the tick lands on the item found whole among the other side's units. Ambiguity is a conflict.
 	const au = textUnits(a), bu = textUnits(b);
 	if (au.length !== 1 || bu.length !== 1) {
 		const [one, many] = au.length === 1 ? [a, bu] : bu.length === 1 ? [b, au] : [null, null];
@@ -276,11 +264,9 @@ function textEnvelope(id, variants) {
 	return out + '<!-- /note-conflict:v1 -->\n';
 }
 
-// Takes the text's units, scanned once by the caller; a text without conflict envelopes is not scanned again.
 function textDeclarations(units) {
 	const kept = units.filter(unit => !textEnvelopeAt(unit)).map(unit =>
 		textFence(unit.split(/\r\n|\r|\n/, 1)[0].replace(/^\ufeff/, '')) ? '\n' : unit), text = kept.join('');
-	// A definition can move a destination/title onto the next unindented line, or span its label.
 	const definitions = text.match(/^\ufeff? {0,3}\[(?:\\.|[^\]\\])+\]:[^\r\n]*(?:(?:\r\n|\r|\n)(?![ 	]*(?:\r\n|\r|\n|$))[^\r\n]*)*/gm) || [];
 	const continuations = (kept.length === units.length ? kept : textUnits(text)).filter(unit => /^\ufeff? {0,3}\[\^/.test(unit));
 	return [...definitions, ...continuations, ...(text.match(/<!--[\s\S]*?(?:-->|$)/g) || [])].join('\0');
@@ -294,7 +280,6 @@ export function mergeText(base, ours, theirs, options = {}) {
 	if (base === theirs) return unchanged(ours);
 	const conflicts = []; let text = '';
 	const conflict = (before, a, b, kind) => {
-		// Shared framing remains ordinary text; only the changed region is a choice.
 		const ab = inspectTextConflicts(a), bb = inspectTextConflicts(b);
 		const au = textUnits(a), bu = textUnits(b); let first = 0, last = 0;
 		while (first < Math.min(au.length, bu.length) && au[first] === bu[first]) first++;
@@ -305,8 +290,6 @@ export function mergeText(base, ours, theirs, options = {}) {
 			conflict(null, au.slice(first, last ? -last : undefined).join(''), bu.slice(first, last ? -last : undefined).join(''), kind);
 			text += suffix; return;
 		}
-		// A shared unresolved region is an anchor even when its alternatives have grown. Splitting
-		// around it keeps surrounding edits in their own choices instead of quoting an old choice.
 		const overlaps = (x, y) => x.variants.some(v => y.variants.some(w => v.device === w.device && v.text === w.text));
 		const anchor = ab.map(x => ({x, matches: bb.filter(y => overlaps(x, y))})).find(({x, matches}) =>
 			matches.length === 1 && ab.filter(y => overlaps(y, matches[0])).length === 1 &&
@@ -340,10 +323,8 @@ export function mergeText(base, ours, theirs, options = {}) {
 			let pos = 0;
 			for (let i = 0; i < changes.length;) {
 				const group = [changes[i++]], start = group[0].start; let end = group[0].end;
-				// An insertion can anchor on either side of a blank run; that is still one gap.
 				while (i < changes.length && (changes[i].start < end || group.some(e => {
 					const next = changes[i];
-					// Appending after an unresolved block does not edit any of its alternatives.
 					const afterBlock = (edit, insert) => insert.start === insert.end && insert.start === edit.end && edit.start < edit.end && units.slice(edit.start, edit.end).every(unit => textEnvelopeAt(unit));
 					if (afterBlock(e, next) || afterBlock(next, e)) return false;
 					if (e.start === e.end && next.start <= e.start && e.start <= next.end) return true;
@@ -376,7 +357,6 @@ export function mergeText(base, ours, theirs, options = {}) {
 	return {text, clean: conflicts.length === 0 && !text.includes(TEXT_CONFLICT), conflicts};
 }
 
-// A marker is advisory data. The caller supplies its trusted descriptor and current revision.
 export function resolveTextConflict(text, conflict, device) {
 	canonicalNote(text);
 	if (!conflict || !Number.isInteger(conflict.start) || !Number.isInteger(conflict.end) || conflict.start < 0 || conflict.end < conflict.start || text.slice(conflict.start, conflict.end) !== conflict.block) {

package/dist/kit/ledger/transport.mjs

@@ -1,5 +1,4 @@
 // SPDX-License-Identifier: MIT
-// Paired source placement, shared by live editing and canonical-history proof.
 import {_rapierTransformSplices, _rapierValidAuthored, _rapierHistoryEffects} from './journal-records.mjs';
 import {projectInverseSource} from './inverse-source.mjs';
 import {authoredBasis, authoredPlacement, authoredPlacements} from './authored-origin.mjs';
@@ -25,8 +24,6 @@ function emit(rows, at, remove, insert = '') {
   } else rows.push({at, remove, insert});
 }
 
-// Sweep original-source boundaries. Each counter names a coordinate in one input's
-// resulting document; concurrent insertions never enter the other input's removals.
 export function transformPair(left, right, leftFirst) {
   admitted(left); admitted(right);
   const points = [...new Set([0, ...left.flatMap(row => [row.at, row.at + row.remove]),
@@ -62,9 +59,6 @@ function applyBatch(text, rows) {
   return {text: after, splices: exact};
 }
 
-// Transport one sequential canonical act and every crossed record together. The
-// reciprocal path is checked against exact source, rather than only equal end text.
-// Canonical transport refuses deleting any authored unit already removed elsewhere.
 export function transposeRecord(base, splices, id, records) {
   if (typeof base !== 'string' || !Array.isArray(splices) || typeof id !== 'string' || !Array.isArray(records))
     throw new RangeError('canonical_transport_invalid');
@@ -75,10 +69,6 @@ export function transposeRecord(base, splices, id, records) {
     if (next === null) throw new RangeError('canonical_transport_invalid');
     current = next;
   }
-  // A concurrent act that already removed these same authored units and wrote the
-  // same replacement is one physical edit. This act stays in history with no second
-  // deletion. Pure insertions are never collapsed: each one is its own unit. An
-  // inverse of that act means the replacement is not still in force.
   const sameRows = (left, right) => left.length === right.length && left.every((row, index) =>
     row.pos === right[index].pos && row.removed === right[index].removed && row.inserted === right[index].inserted);
   const matched = crossed.filter(record => sameRows(record.splices, splices));
@@ -122,8 +112,6 @@ export function transposeRecord(base, splices, id, records) {
   return {splices: moved, sourceIndices, against: crossed, text: current};
 }
 
-// Hosted and editor callers already own a reciprocal transport log. Convert only
-// its admitted exact source to records, then prove canonical-unit preservation.
 export function transposeSource(base, splices, client, log) {
   let source = base;
   const records = log.map(entry => {
@@ -135,8 +123,6 @@ export function transposeSource(base, splices, client, log) {
 
 export {authoredBasis, authoredPlacement, authoredPlacements};
 
-// Reconstruct an authored view from the same records, then prove its exact physical
-// placement. Equality of resulting text alone cannot prove a repeated-text anchor.
 function authoredReplay(base, records, append = null) {
   const origins = new Map(), byId = new Map(), originalOrder = [], cache = new Map(), frontier = new Set();
   const effects = _rapierHistoryEffects(append ? [...records, append] : records);
@@ -156,8 +142,6 @@ function authoredReplay(base, records, append = null) {
     if (!result.ok) throw new RangeError('canonical_origin_invalid');
     return result;
   };
-  // Only immutable text digests are reused, within this one replay. Every
-  // authored-source comparison and physical placement proof still runs.
   const textHashes = new Map();
   const hashText = text => {
     if (typeof text !== 'string') return sha256(text);
@@ -166,7 +150,6 @@ function authoredReplay(base, records, append = null) {
     return digest;
   };
   const same = (a, b) => canonicalJSON(a) === canonicalJSON(b);
-  // Only owner-created ordered views of already admitted string IDs use this.
   const sameIds = (a, b) => {
     if (a.length !== b.length) return false;
     for (let index = 0; index < a.length; index++) if (a[index] !== b[index]) return false;
@@ -192,8 +175,6 @@ function authoredReplay(base, records, append = null) {
     })()))) throw new RangeError('canonical_origin_invalid');
     const refs = effects.references.get(id) || [];
     if (refs.some(id => !seen.has(id))) throw new RangeError('canonical_origin_invalid');
-    // An explicit origin can prove the same linear placement as an implicit one.
-    // Preserve the origin, but do not reconstruct every growing prefix to prove it again.
     if (linearPrefix === originalOrder.length && same(origin.basis, [...frontier].sort()) &&
         same(origin.splices, record.splices) && (!Object.hasOwn(record, 'authored') || origin.source === sha256(source)))
       linearPrefix++;
@@ -212,7 +193,6 @@ function authoredReplay(base, records, append = null) {
     const key = coverKey(origin);
     if (key) coverCounts.set(key, (coverCounts.get(key) || 0) + 1);
   }
-  // Two inverses can name different acts and still withdraw one physical replacement.
   const sharesCover = id => (effects.references.get(id) || []).some(ref => {
     const key = coverKey(origins.get(ref));
     return !!key && coverCounts.get(key) > 1;
@@ -250,14 +230,9 @@ function authoredReplay(base, records, append = null) {
     return closure;
   };
   const canonicalOrder = ordered(originalOrder);
-  // Only the three immediate fresh-spread call sites use this entry. Nothing
-  // retains allocation trust after an array has crossed an observable method.
   const literalKey = order => {
-    // An input iterator can supply arbitrary values. Preserve the whole-array
-    // depth/refusal path before any per-string encoding in that case.
     for (let index = 0; index < order.length; index++)
       if (typeof order[index] !== 'string') return canonicalJSON(order);
-    // Keep each canonical primitive encoder call and its serializer behavior.
     return '[' + Array.from({length: order.length}, (_, index) => canonicalJSON(order[index])).join(',') + ']';
   };
   const materialize = (order, rawSubmitted = false) => materializeKey(order, canonicalJSON(order), rawSubmitted);
@@ -266,14 +241,10 @@ function authoredReplay(base, records, append = null) {
     if (cache.has(key)) return cache.get(key);
     let prefixEnds = null;
     const prefixKey = length => {
-      // The original submitted array keeps its existing slice/species/data gate.
-      // Only this module's own order allocations use the validated key string.
       if (rawSubmitted) return canonicalJSON(order.slice(0, length));
       if (!prefixEnds) {
         prefixEnds = [1];
         let quoted = false, depth = 0;
-        // Scan canonical JSON only: an escaped code unit cannot end a string,
-        // and commas inside strings or nested values cannot split this array.
         for (let at = 1; at < key.length - 1; at++) {
           const code = key.charCodeAt(at);
           if (quoted) {
@@ -290,11 +261,7 @@ function authoredReplay(base, records, append = null) {
     };
     let placed = [], ids = new Set(), sourceIndices = new Map(), text = base;
     if (!order.length) { const empty = {text, records: [], sourceIndices}; cache.set(key, empty); return empty; }
-    // A proved linear prefix already is its authored view. Replay it once;
-    // reconstructing every growing prefix adds no evidence.
     let prefix = 0;
-    // Resume only an exact ordered prefix already proved in this replay. Copy its
-    // mutable containers before extending it; transported rows retain their placement.
     for (let length = order.length - 1; length > 0; length--) {
       const prior = cache.get(prefixKey(length));
       if (!prior) continue;
@@ -314,8 +281,6 @@ function authoredReplay(base, records, append = null) {
         throw new RangeError('canonical_origin_invalid');
       const closure = closureOf(origin.basis);
       if (closure.size === ids.size && [...closure].every(prior => ids.has(prior))) {
-        // The current view already is the complete authored context. There are no
-        // independent rows to cross, even when earlier acts were concurrent.
         if (hashText(text) !== origin.source) throw new RangeError('canonical_origin_invalid');
         const next = _rapierTransformSplices(text, origin.splices);
         if (next === null) throw new RangeError('canonical_origin_invalid');
@@ -326,8 +291,6 @@ function authoredReplay(base, records, append = null) {
       }
       const basisOrder = canonicalOrder.filter(prior => closure.has(prior)), basis = materialize(basisOrder);
       if (hashText(basis.text) !== origin.source) throw new RangeError('canonical_origin_invalid');
-      // Reconstruct causal context before crossing it. Physical gaps may already
-      // have collapsed under a deletion; they cannot choose concurrent ordering.
       const contextOrder = canonicalOrder.filter(prior => ids.has(prior)), context = sameIds(contextOrder, [...ids]) ? {text, records: placed} : materialize(contextOrder);
       if (context.text !== text) throw new RangeError('canonical_origin_invalid');
       const alignedOrder = [...basisOrder, ...contextOrder.filter(prior => !closure.has(prior))];
@@ -336,10 +299,6 @@ function authoredReplay(base, records, append = null) {
       const crossed = aligned.records.slice(basisOrder.length);
       let moved;
       if (effects.references.get(id)?.length && (sharedInverses || sharesCover(id))) {
-        // Each inverse retains its own targets. First prove the exact intention
-        // in its causal source, then place that choice in the accepted effect
-        // graph. Another inverse may already suppress the same original bytes,
-        // including when the two inverses name different authors of one replacement.
         const authored = projectInverse(basis.text, basis.records, id);
         if (!same(origin.splices, authored.splices) ||
             _rapierTransformSplices(basis.text, origin.splices) !== authored.after)
@@ -357,7 +316,6 @@ function authoredReplay(base, records, append = null) {
   const physicalOrder = append ? originalOrder.slice(0, -1) : originalOrder, physical = materialize(physicalOrder);
   if (physical.text !== source || physical.records.some((row, index) => !same(row.splices, records[index].splices)))
     throw new RangeError('canonical_origin_invalid');
-  // Raw submission is selected here by a private call site, never an input flag.
   return {source, origins, originalOrder, materialize, materializeLiteral,
     materializeSubmitted: order => materialize(order, true), ordered};
 }
@@ -365,14 +323,11 @@ function authoredReplay(base, records, append = null) {
 export function authoredHistory(base, records, selected = null) {
   const replay = authoredReplay(base, records);
   if (!selected) return {text: replay.source, records, origins: replay.origins};
-  // Targets follow independent work only in this transient Undo projection.
   const projected = replay.materialize(replay.ordered(replay.originalOrder, selected));
   if (projected.text !== replay.source) throw new RangeError('canonical_origin_invalid');
   return {...projected, origins: replay.origins};
 }
 
-// Semantic annotations use the original splice coordinates, even when an accepted
-// physical placement split those rows. The same replay proves the causal basis first.
 export function authoredSourceReader(base, records) {
   const replay = authoredReplay(base, records);
   return actId => {
@@ -390,8 +345,6 @@ export function authoredSourceReader(base, records) {
   };
 }
 
-// The original view and the accepted view are both reconstructed from the same
-// immutable acts. The reciprocal rows are an exact ACK, not another history.
 export function transposeAuthored(base, records, incoming, submitted) {
   if (!incoming.authored || !Array.isArray(submitted)) throw new RangeError('canonical_origin_invalid');
   const replay = authoredReplay(base, records, incoming), id = incoming.transaction.id;

package/dist/kit/ledger.d.mts

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: MIT
+// rapier-markdown-kit/rapier-ledger: a document's edit history with authorship, Undo of any act and offline merge.
+// Offsets count UTF-16 code units; splices run in their recorded order.
+export type ActorKind = 'human' | 'agent' | 'system';
+export interface Actor { kind: ActorKind; id: string; }
+export type DocKind = 'markdown' | 'text' | 'code';
+export interface Metadata { filename: string; docKind: DocKind; }
+export interface Splice { pos: number; removed: string; inserted: string; }
+export interface Transaction {
+  id: string; documentAuthority: string; baseRevision: number; revision: number; actor: Actor;
+  transport: string; operation: string; requestId: string | null; sourceTransactionId: string | null;
+  affectedBlockIds: string[]; parent: string | null; reverts: string | null; reapplies: string | null;
+  createdAt: string | null; turnId?: string; sourceTransactionIds?: string[];
+}
+export interface LedgerRecord { transaction: Transaction; splices: Splice[]; beforeHash: string; afterHash: string; metadata?: Record<string, unknown>; authored?: unknown; }
+/** rapier-ledger/2: plain JSON. */
+export interface LedgerEnvelope {
+  format: 'rapier-ledger/2';
+  documentAuthority: string;
+  start: {text: string; revision: number; root: string; sha256: string; metadata: Metadata};
+  records: LedgerRecord[];
+  head: {revision: number; root: string; sha256: string; metadata: Metadata};
+  complete: boolean;
+  sha256: string;
+}
+/** Runs of [start, end, actor kind, actor id, createdAt] over the current text. */
+export interface AuthorshipEnvelope { format: 'rapier-authorship/1'; sha256: string; runs: [number, number, ActorKind, string, string | number | null][]; }
+export interface ReadLedger { ledger: LedgerEnvelope; text: string; metadata: Metadata; root: string; revision: number; complete: boolean; }
+export interface LedgerInput { text: string; metadata: Metadata; records: LedgerRecord[]; documentAuthority?: string; revision?: number; root?: string; complete?: boolean; }
+
+/** A new ledger with no history. Give every copy that may later merge the same documentAuthority. */
+export function openLedger(text: string, options?: {filename?: string; docKind?: DocKind; documentAuthority?: string}): LedgerEnvelope;
+export function exportLedger(input: LedgerInput): LedgerEnvelope;
+/** Verifies the envelope (and, when given, that it describes this text and metadata); throws when it does not. */
+export function readLedger(input: LedgerEnvelope, expectedText?: string, expectedMetadata?: Metadata): ReadLedger;
+/** Records one replacement of the whole text as an act by `actor`. */
+export function replaceLedgerText(input: LedgerEnvelope, text: string, options?: {actor?: Actor; operation?: string; at?: string}): LedgerEnvelope;
+export function ledgerWithStart(input: LedgerEnvelope, text: string): LedgerEnvelope;
+export function historyEnvelope(input: LedgerEnvelope, segmentIdentity?: unknown[], expectedText?: string, expectedMetadata?: Metadata): Record<string, unknown>;
+/** The actor id an agent writes under, for a door and an agent name. */
+export function agentActorId(door: string, agent: string): string;
+export function textRoot(text: string): string;
+export function rootAfter(root: string, splice: Splice): string;
+export function sha256State(): {update(text: string): unknown; digest(): string};
+
+export function authorship(input: LedgerEnvelope): AuthorshipEnvelope;
+export function readAuthorship(input: AuthorshipEnvelope, text: string): AuthorshipEnvelope;
+export function ledgerFromAuthorship(input: AuthorshipEnvelope, text: string, documentAuthority: string, metadata: Metadata): LedgerEnvelope;
+
+export interface MergeConflict { kind: string; code?: string; actId?: string; [key: string]: unknown; }
+export interface MergeResult {
+  text: string; metadata: Metadata; ledger: LedgerEnvelope;
+  /** False when a person must review: conflicts, or Will keep regions that differ. */
+  clean: boolean;
+  conflicts: MergeConflict[];
+  review: {required: boolean; base: string; proposed: string};
+}
+/** Merges two copies of one document (same documentAuthority) without a server. */
+export function merge(first: LedgerEnvelope, second: LedgerEnvelope): MergeResult;
+export function transportInterval(start: number, end: number, splices: Splice[]): {start: number; end: number} | null;
+export function transportTouchedInterval(start: number, end: number, splices: Splice[]): {start: number; end: number};
+
+export interface HistoryInput { source: string; metadata: Metadata; records: LedgerRecord[]; revision: number; earliestRevision: number; complete: boolean; }
+export interface HistoryFailure { ok?: false; code: string; [key: string]: unknown; }
+/** Reverses chosen acts while later work stays. */
+export function selectiveUndo(input: HistoryInput, actIds: string[], options?: {actor?: Actor; splitSplice?: (...args: unknown[]) => unknown}): Record<string, unknown> | HistoryFailure;
+export function replayHistory(input: HistoryInput): unknown;
+export function sourceBefore(input: HistoryInput, actId: string): unknown;
+export function historyProjection(input: HistoryInput, range?: {from?: number; to?: number; actId?: string}): unknown;
+export function historyProjections(input: HistoryInput, ranges: unknown[]): unknown;
+export function historyPlaces(input: HistoryInput, blocks: unknown[]): unknown;
+export function groupHistoryActs(acts: unknown[]): unknown;
+export function pictureHistorySplices(input: unknown, target: unknown, redo: boolean): Splice[] | null;
+export function transposeSource(base: string, splices: Splice[], client: unknown, log: unknown): unknown;
+export function authoredBasis(...args: unknown[]): unknown;
+export function authoredPlacement(...args: unknown[]): unknown;
+export function authoredHistory(base: string, records: LedgerRecord[], selected?: unknown): unknown;
+export function transposeAuthored(base: string, records: LedgerRecord[], incoming: unknown, submitted: unknown): unknown;
+
+export {writeDocument, readDocument, writeParts, readParts} from './ledger/carried.mjs';
+
+export interface TextConflict { kind: 'text'; id: string; start: number; end: number; block: string; variants: string[]; }
+export interface TextMerge { text: string; clean: boolean; conflicts: (TextConflict | {kind: string; advisory?: boolean})[]; }
+/** Exact three-way text merge; a region both sides changed becomes a marked choice in the text. */
+export function mergeText(base: string | null, ours: string, theirs: string, options?: Record<string, unknown>): TextMerge;
+export function inspectTextConflicts(text: string, options?: {nested?: boolean}): TextConflict[];
+export function resolveTextConflict(text: string, conflict: TextConflict | string, device: unknown): string;
+export function mapTextConflictVariants(text: string, mapper: (variant: string) => string): string;

package/dist/kit/ledger.mjs

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+import {exportLedger} from './ledger/format.mjs';
+export {exportLedger, replaceLedgerText, readLedger, ledgerWithStart, textRoot, rootAfter, historyEnvelope, agentActorId} from './ledger/format.mjs';
+export {authorship, readAuthorship, ledgerFromAuthorship} from './ledger/authorship.mjs';
+export {merge, transportInterval, transportTouchedInterval} from './ledger/merge.mjs';
+export {replayHistory, sourceBefore, historyProjection, historyProjections, historyPlaces, selectiveUndo, groupHistoryActs, pictureHistorySplices} from './ledger/history.mjs';
+export {sha256State} from './ledger/hash.mjs';
+export {transposeSource, authoredBasis, authoredPlacement, authoredHistory, transposeAuthored} from './ledger/transport.mjs';
+export {writeDocument, readDocument, writeParts, readParts} from './ledger/carried.mjs';
+export {mergeText, resolveTextConflict, inspectTextConflicts, mapTextConflictVariants} from './ledger/text-merge.mjs';
+
+export function openLedger(text, {filename = 'document.md', docKind = 'markdown', documentAuthority = globalThis.crypto.randomUUID()} = {}) {
+  return exportLedger({text, metadata: {filename, docKind}, records: [], documentAuthority, complete: true});
+}

package/dist/kit/markdown-it.d.mts

@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: MIT
+// md.use(rapierMarkdown): Self-contained Markdown in markdown-it, with the reference style's markup.
+interface MarkdownItLike { use(plugin: (md: any, ...params: any[]) => unknown, ...params: any[]): any; renderer: {rules: Record<string, unknown>}; core: {ruler: {after(after: string, name: string, rule: (state: any) => unknown): void}}; }
+export function rapierMarkdown<T extends MarkdownItLike>(md: T): T;

package/dist/kit/markdown-it.mjs

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+import {parseLayout, imageStyle} from './layout.mjs';
+import {typography, isPageBreakBlock} from './marks.mjs';
+import {installMarkdownImages} from './assets.mjs';
+
+const PAGE_BREAK = '<div class="rapier-page-break" data-md-break="page" role="separator" aria-label="Page break"></div>\n';
+
+export function rapierMarkdown(md) {
+  if (md.__rapierMarkdownInstalled) return md;
+  md.__rapierMarkdownInstalled = true;
+  typography.install(installMarkdownImages(md));
+  md.renderer.rules.table_open = (tokens, index, options, env, renderer) =>
+    '<div class="table-scroll-wrap">\n' + renderer.renderToken(tokens, index, options);
+  md.renderer.rules.table_close = (tokens, index, options, env, renderer) =>
+    renderer.renderToken(tokens, index, options) + '</div>\n';
+  md.core.ruler.after('inline', 'rapier-layout', state => {
+    for (let i = 1; i < state.tokens.length; i++) {
+      const inline = state.tokens[i], owner = state.tokens[i - 1];
+      if (inline.type !== 'inline' || !['paragraph_open', 'heading_open'].includes(owner.type)) continue;
+      const children = inline.children, marker = children.at(-1);
+      const layout = marker?.type === 'html_inline' ? parseLayout(marker.content) : null;
+      if (!layout) continue;
+      children.pop();
+      if (layout.align) owner.attrSet('data-md-align', layout.align);
+      const visible = children.filter(token => token.type !== 'text' || token.content.trim());
+      if (visible.length === 1 && visible[0].type === 'image' && layout.width) {
+        visible[0].attrSet('style', imageStyle(layout));
+        visible[0].attrSet('data-md-image-width', String(layout.width));
+      }
+    }
+  });
+  const htmlBlock = md.renderer.rules.html_block || ((tokens, index) => tokens[index].content);
+  md.renderer.rules.html_block = (tokens, index, options, env, renderer) =>
+    isPageBreakBlock(tokens[index].content) ? PAGE_BREAK : htmlBlock(tokens, index, options, env, renderer);
+  return md;
+}