rapier-markdown-kit 1.2.8 → 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.mjs

@@ -1,6 +1,4 @@
 // SPDX-License-Identifier: MIT
-// The public edit ledger (rapier-markdown-kit/rapier-ledger): the history, its carried parts and three-way text merge.
-// The editor binds kit/rapier-ledger.mjs, which also carries its private record helpers.
 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';
@@ -11,8 +9,6 @@ export {transposeSource, authoredBasis, authoredPlacement, authoredHistory, tran
 export {writeDocument, readDocument, writeParts, readParts} from './ledger/carried.mjs';
 export {mergeText, resolveTextConflict, inspectTextConflicts, mapTextConflictVariants} from './ledger/text-merge.mjs';
 
-// A new ledger for one text, with no history yet. documentAuthority names the document across its copies:
-// pass the same one to every copy that may later merge.
 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.mjs

@@ -1,6 +1,4 @@
 // SPDX-License-Identifier: MIT
-// rapier-markdown-kit/markdown-it: md.use(rapierMarkdown) renders Self-contained Markdown with the reference style's markup
-// (wrap the output in <main class="md-render"> with rapier-markdown-kit/style.css). Create markdown-it with {html: true}.
 import {parseLayout, imageStyle} from './layout.mjs';
 import {typography, isPageBreakBlock} from './marks.mjs';
 import {installMarkdownImages} from './assets.mjs';
@@ -15,7 +13,6 @@ export function rapierMarkdown(md) {
     '<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';
-  // A paragraph's or heading's closing layout comment: its alignment, and a lone picture's width.
   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];

package/dist/kit/pdf-glyphs.mjs

@@ -1,6 +1,5 @@
 // SPDX-License-Identifier: MIT
 // The licensed static faces retain the shipped variable font's exact glyphs and metrics.
-// Browser ranges own placement; unsupported shaping stays in the original page paint.
 
 const familyName = value => value.trim().replace(/^['"]|['"]$/g, '');
 
@@ -80,7 +79,6 @@ function shape(value, font, preserve, ligatures) {
     if (code === 0x00ad) {
       at += character.length;
       const own = font.glyph(code), hyphen = font.glyph(0x2d), glyph = own || hyphen;
-      // A discretionary hyphen with no glyph stays in the page paint. Do not skip the lookup.
       if (!glyph || glyph >= font.glyphCount) return null;
       result.push({start, end: at, text: own ? character : '-', glyph, soft: true});
       continue;
@@ -101,7 +99,7 @@ function shape(value, font, preserve, ligatures) {
 }
 
 export async function collectPdfGlyphs(main, {width, check, faces = []}) {
-  const fontCache = new Map(); // Parsed byte copies belong to this PDF operation.
+  const fontCache = new Map();
   const document = main.ownerDocument, window = document.defaultView, origin = main.getBoundingClientRect();
   const nodes = new Map(), hidden = [], canvas = document.createElement('canvas'); canvas.width = canvas.height = 1;
   const context = canvas.getContext('2d', {willReadFrequently: true});
@@ -130,9 +128,6 @@ export async function collectPdfGlyphs(main, {width, check, faces = []}) {
     let visited = 0;
     for (const element of main.querySelectorAll('*')) {
       if (++visited % 128 === 0) {await new Promise(resolve => setTimeout(resolve, 0)); check();}
-      // Leaving the existing element in place preserves selectors, counters, line breaking and inline marks.
-      // Keep preformatted blocks, their inline struts and syntax paint together.
-      // A paragraph's own words beside a mark, a link or code are drawn too: each text node is placed and hidden on its own.
       if (element.namespaceURI !== 'http://www.w3.org/1999/xhtml' || element.closest('svg,pre,.rapier-will-carrier')) continue;
       const textNodes = Array.from(element.childNodes).filter(node => node.nodeType === 3 && node.data.trim());
       if (!textNodes.length || !safe(element)) continue;
@@ -162,8 +157,6 @@ export async function collectPdfGlyphs(main, {width, check, faces = []}) {
         for (const item of shaped) {
           range.setStart(node, item.start); range.setEnd(node, item.end);
           const ink = Array.from(range.getClientRects()).filter(rect => rect.height > 0);
-          // A break after a soft hyphen can leave the next letter with a phantom box on the
-          // hyphen's line. Keep the line that actually holds the ink.
           const lines = [];
           for (const rect of ink) {
             const line = lines.find(row => Math.abs(row[0].top - rect.top) <= .25);
@@ -174,7 +167,6 @@ export async function collectPdfGlyphs(main, {width, check, faces = []}) {
           if (lines.length > 1 && !item.soft && !previous?.soft) {valid = false; break;}
           const rects = lines[0] || [];
           const first = (item.soft ? rects.find(rect => rect.width > 0) : null) || rects[0];
-          // An unbroken soft hyphen has no ink. Leave it out of the vector run.
           if (item.soft && !(first?.width > 0)) continue;
           if (!first) {valid = false; break;}
           const page = Math.max(0, Math.floor((first.left - origin.left + .01) / width));
@@ -184,7 +176,6 @@ export async function collectPdfGlyphs(main, {width, check, faces = []}) {
         if (!valid || !placed.length) continue;
         nodes.set(node, placed);
         if (element.localName === 'li' || element.children.length || textNodes.length > 1) {
-          // A list item's marker and a paragraph's marks are not this node's words: hide only the words.
           const wrap = document.createElement('span');
           node.replaceWith(wrap); wrap.append(node);
           wrap.style.setProperty('-webkit-text-fill-color', 'transparent', 'important');

package/dist/kit/pdf-source.mjs

@@ -1,5 +1,4 @@
 // SPDX-License-Identifier: MIT
-// Add an associated source file to Rapier's fresh PDF without rewriting its pages.
 function pdfStructure(input) {
   const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
   const fail = () => { throw Object.assign(new Error('The PDF source could not be attached.'), {code: 'pdf_source_invalid'}); };
@@ -93,14 +92,15 @@ export async function attachPdfSource(input, {source, filename, maxBytes = Infin
   const payload = encode.encode(source); check();
   const compressed = new Uint8Array(await new Response(new Blob([payload]).stream().pipeThrough(new CompressionStream('deflate'))).arrayBuffer()); check();
   const fileId = size, streamId = size + 1, infoId = size + 2, totalSize = size + 3;
-  let infoBody = '<< /Producer (Rapier) >>';
+  let infoBody = '<< /Producer (Rapier) /Creator (Rapier) >>';
   const existingInfo = trailer.fields.get('Info');
   if (existingInfo) {
     const ref = /^(\d+)\s+(\d+)\s+R$/.exec(existingInfo.value);
     const held = ref ? readDictionary(Number(ref[1]), Number(ref[2])) : dictionary(existingInfo.from);
-    const producer = held.fields.get('Producer');
-    const kept = producer ? text.slice(held.start, producer.start) + text.slice(producer.end, held.end - 2) : text.slice(held.start, held.end - 2);
-    infoBody = kept + ' /Producer (Rapier) >>';
+    const named = ['Producer', 'Creator'].map(key => held.fields.get(key)).filter(Boolean).sort((a, b) => a.start - b.start);
+    let kept = '', at = held.start;
+    for (const field of named) { kept += text.slice(at, field.start); at = field.end; }
+    infoBody = kept + text.slice(at, held.end - 2) + ' /Producer (Rapier) /Creator (Rapier) >>';
   }
   const escaped = '(' + filename.replace(/[^\x20-\x7e]/g, '_').replace(/[\\()]/g, '\\$&') + ')';
   const parts = [bytes, ascii('\n')], merged = new Map(offsets);

package/dist/kit/pdf-vectors.mjs

@@ -1,5 +1,4 @@
 // SPDX-License-Identifier: MIT
-// SVG keeps its geometry in PDF; only paint operations that need browser compositing are rasterized.
 const SVG = 'http://www.w3.org/2000/svg';
 const number = value => Number(Number(value).toFixed(6));
 const nums = values => values.map(number).join(' ');
@@ -132,7 +131,6 @@ export async function collectPdfVectors(main, {width, height, count, capture, si
         root = document.importNode(parsed.documentElement, true);
         root.style.setProperty('width', originalBox.width + 'px', 'important'); root.style.setProperty('height', originalBox.height + 'px', 'important');
         mount = document.createElement('div'); mount.style.cssText = `position:fixed;left:${originalBox.left}px;top:${originalBox.top}px;width:${originalBox.width}px;height:${originalBox.height}px;pointer-events:none`;
-        // A shadow root keeps the picture's own <style> on the picture, as an <img> does.
         mount.attachShadow({mode: 'open'}).append(root); document.body.append(mount); temporary.push(mount); await document.fonts.ready;
         textRoots.push(root);
       }
@@ -177,7 +175,6 @@ export async function collectPdfVectors(main, {width, height, count, capture, si
         let path, fill, stroke;
         try {
           path = geometry(node); fill = color(style.fill);
-          // SVG zero-width strokes are absent; PDF's zero width instead paints a hairline.
           stroke = Number.parseFloat(style.strokeWidth) === 0 ? null : color(style.stroke);
           if (style.vectorEffect !== 'none' || style.markerStart !== 'none' || style.markerMid !== 'none' || style.markerEnd !== 'none' || style.paintOrder !== 'normal') unsupported();
         } catch (_) { sequence.push({raster: node}); return; }

package/dist/kit/print-capitals.mjs

@@ -9,8 +9,6 @@ export function followingPrintProse(paragraph) {
   return next;
 }
 
-// The print compositor owns pagination. Only a normal-flow picture initial moves into
-// its adjacent prose, so a native float can remain with the lines it introduces.
 export function markPrintCapitals(root) {
   for (const image of root.querySelectorAll('img[data-rapier-image-layout]')) {
     const layout = parseLayoutAttribute(image.getAttribute('data-rapier-image-layout'));
@@ -23,7 +21,6 @@ export function markPrintCapitals(root) {
   }
 }
 
-// This factory is also embedded in the offline page, with the same line metrics owner.
 export function createPrintCapitals(lineMetrics, linesHeight, followingProse) {
   const selector = 'img[data-rapier-print-lines]', states = new WeakMap();
   const restoreStyle = (node, value) => value == null ? node.removeAttribute('style') : node.setAttribute('style', value);
@@ -55,7 +52,6 @@ export function createPrintCapitals(lineMetrics, linesHeight, followingProse) {
       const availableWidth = owner.getBoundingClientRect().width -
         ['paddingLeft', 'paddingRight', 'borderLeftWidth', 'borderRightWidth'].reduce((sum, name) => sum + (parseFloat(style[name]) || 0), 0);
       if (!(availableWidth > 0)) continue;
-      // As imageBox does, cap the width first and retain the picture's natural ratio.
       const width = Math.min(availableWidth, height * naturalWidth / naturalHeight);
       const occurrence = state?.occurrence || (image.parentElement.tagName === 'A' ? image.parentElement : image);
       if (!state) {

package/dist/kit/render-entry.mjs

@@ -1,5 +1,4 @@
 // SPDX-License-Identifier: MIT
-// The public renderer door; each factory binds explicit host ports once per document realm.
 export {createRenderer} from './render.mjs';
 export {createMarkdownRenderer} from './render-markdown.mjs';
 export {createRenderStyles} from './render-styles.mjs';