rapier-markdown-kit 1.2.3 → 1.2.5

package/dist/kit/render-sanitize.mjs

@@ -29,11 +29,6 @@ const RAPIER_SANITIZE_OPTIONS = Object.freeze({
 		FORBID_TAGS: RAPIER_SANITIZE_FORBID_TAGS,
 		FORBID_ATTR: RAPIER_SANITIZE_FORBID_ATTR,
 	}),
-	snippet: Object.freeze({
-		..._rapierSanitizeProfile('html'),
-		FORBID_TAGS: RAPIER_SANITIZE_FORBID_TAGS,
-		FORBID_ATTR: Object.freeze([...'style']),
-	}),
 	diagram: Object.freeze({
 		..._rapierSanitizeProfile('html', 'svg'),
 		FORBID_TAGS: Object.freeze(['form', 'dialog', 'template', 'iframe', 'script', 'foreignobject']),
@@ -59,6 +54,9 @@ const DIAGRAM_LABEL_SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
 const DIAGRAM_LABEL_HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
 const DIAGRAM_LABEL_MATH_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
 
+// The profile each DOMPurify instance holds (setConfig), shared by every renderer made over it.
+const purifyConfigured = new WeakMap();
+
 function _rapierImageDataAttributeAllowed(tag, attribute, value, verify) {
 	return (tag === 'img' && attribute === 'src' || tag === 'image' && /^(?:href|xlink:href)$/.test(attribute)
 		&& /^data:image\/(?:png|jpeg|webp|jxl);base64,/i.test(value)) && verify(value);
@@ -376,6 +374,8 @@ function _rapierInstallSanitizeHooks() {
 	});
 }
 
+const purifyOptions = new Map();
+
 function sanitizeRapierHtml(value, context = 'render') {
 	return sanitize(value, context, false);
 }
@@ -392,24 +392,31 @@ function sanitize(value, context, fragment) {
 	// (the hook) without an id the chrome owns. 'source' is Markdown source HTML, written and never shown: the render
 	// profile's admission, and the block on remote content stays the reader's (a remote picture's URL is the person's words).
 	const selected = context === 'raw' || context === 'export' || context === 'source' || RAPIER_SANITIZE_OPTIONS[context] ? context : 'render';
-	let options = selected === 'raw' ? { ...RAPIER_SANITIZE_OPTIONS.render, ALLOW_DATA_ATTR: false } : RAPIER_SANITIZE_OPTIONS[selected] || RAPIER_SANITIZE_OPTIONS.render;
-	if (selected === 'source') options = {...options, ADD_DATA_URI_TAGS: ['image']};
-	const labels = selected === 'diagram' || selected === 'export';
-	if (labels) {
+	const labels = selected === 'diagram' || selected === 'export', key = selected + (fragment ? ' fragment' : '');
+	let options = purifyOptions.get(key);
+	if (!options) {
+		options = selected === 'raw' ? { ...RAPIER_SANITIZE_OPTIONS.render, ALLOW_DATA_ATTR: false } : RAPIER_SANITIZE_OPTIONS[selected] || RAPIER_SANITIZE_OPTIONS.render;
+		if (selected === 'source') options = {...options, ADD_DATA_URI_TAGS: ['image']};
 		// DOMPurify's USE_PROFILES replaces explicit allowlists. Add MathML to the
 		// selected profile without discarding its admitted HTML and SVG vocabulary.
-		options = {...options, ALLOWED_TAGS: [...new Set([...options.ALLOWED_TAGS, ...RAPIER_SANITIZE_PROFILES.mathTags])],
+		if (labels) options = {...options, ALLOWED_TAGS: [...new Set([...options.ALLOWED_TAGS, ...RAPIER_SANITIZE_PROFILES.mathTags])],
 			ALLOWED_ATTR: [...new Set([...options.ALLOWED_ATTR, ...RAPIER_SANITIZE_PROFILES.mathAttributes])], ADD_TAGS: ['foreignobject'], ADD_DATA_URI_TAGS: ['image'],
 			HTML_INTEGRATION_POINTS: {foreignobject: true}, FORBID_TAGS: options.FORBID_TAGS.filter(tag => tag !== 'foreignobject')};
+		if (fragment) options = {...options, RETURN_DOM_FRAGMENT: true};
+		purifyOptions.set(key, options);
+	}
+	if (labels) {
 		DOMPurify.addHook('uponSanitizeElement', diagramLabelElement);
 		DOMPurify.addHook('uponSanitizeAttribute', diagramLabelAttribute);
 		DOMPurify.addHook('afterSanitizeAttributes', diagramLabelContained);
 	}
-	if (fragment) options = {...options, RETURN_DOM_FRAGMENT: true};
+	// DOMPurify reparses a per-call configuration on every call (its cache compares its own copy), about 0.45 ms
+	// each in Chrome 155. A profile is set once and kept until another profile is asked for; every caller comes here.
+	if (purifyConfigured.get(DOMPurify) !== options) { DOMPurify.setConfig(options); purifyConfigured.set(DOMPurify, options); }
 	const previous = _rapierSanitizeRuntime.context;
 	_rapierSanitizeRuntime.context = selected;
 	try {
-		return DOMPurify.sanitize(value == null ? '' : String(value), options);
+		return DOMPurify.sanitize(value == null ? '' : String(value));
 	} finally {
 		if (labels) {
 			DOMPurify.removeHook('uponSanitizeElement', diagramLabelElement);

package/dist/kit/render-styles.mjs

@@ -103,9 +103,9 @@ function _rapierArtifactStyles(theme, includeFonts, printMode, houseDefaults = f
 	const highlightCss = _rapierStyleText('rapier-highlight-style');
 	parts.push(highlightCss);
 	// A page written for the system theme has no body.light to switch: under a light system
-	// setting it takes the Standard palette's light values from the sheet's own body.light rule.
-	const light = theme === 'system' && /html\[data-highlights="standard"\] body\.light\s*\{([^}]*)\}/.exec(highlightCss);
-	if (light) parts.push('@media (prefers-color-scheme:light){html[data-rapier-theme="system"][data-highlights="standard"] body{' + light[1].trim() + '}}');
+	// setting each palette takes its light values from the sheet's own body.light rule.
+	if (theme === 'system') for (const [, palette, light] of highlightCss.matchAll(/html\[data-highlights="(standard|accent)"\] body\.light\s*\{([^}]*)\}/g))
+		parts.push('@media (prefers-color-scheme:light){html[data-rapier-theme="system"][data-highlights="' + palette + '"] body{' + light.trim() + '}}');
 	if (printMode) parts.push(_rapierArtifactPrintCss());
 	return parts.filter(Boolean).join('\n\n');
 }

package/dist/kit/render.mjs

@@ -8,43 +8,6 @@ import {documentLanguage, documentSettingsFonts} from '../spec/document-settings
 import {createLineMeasurer, linesHeight} from '../layout/model.mjs';
 import {markPrintCapitals, createPrintCapitals, followingPrintProse} from './print-capitals.mjs';
 import {freezePublishedInk} from './render-ink.mjs';
-// The document's renderer. DOM, codecs and host state are explicit inputs.
-// Rapier generates attribute selectors for dark paper. Project those owned rules onto their
-// SVG elements before export removes stylesheets; the inert host and the editor share this pass.
-export function presentNativeDiagram(drawing) {
-  const winners=new Map();
-  for(const style of drawing.querySelectorAll('style')){
-    const media=/^\s*@media\s*\(\s*prefers-color-scheme\s*:\s*dark\s*\)\s*\{([\s\S]*)\}\s*$/.exec(style.textContent);
-    if(media)for(const rule of media[1].matchAll(/([^{}]+)\{([^{}]*)\}/g)){
-      // The browser's CSS sanitizer serializes owned hex colours as rgb()/rgba().
-      const properties=[...rule[2].matchAll(/(?:^|;)\s*(fill|stroke|color|stop-color)\s*:\s*(#[\da-f]{3,8}|rgba?\([\d.,%/\s]+\)|none)\s*(?:!important)?(?=;|$)/gi)];
-      for(const selector of rule[1].split(',')){
-        // Draw's selectors contain only attributes, descendants and immediate children.
-        if(!/^\s*\[[^\[\]{};]+\](?:\s*(?:>\s*)?\[[^\[\]{};]+\])*\s*$/.test(selector))continue;
-        const rank=(selector.match(/\[/g)||[]).length;
-        for(const element of [...(drawing.matches(selector)?[drawing]:[]),...drawing.querySelectorAll(selector)]){
-          let paints=winners.get(element);if(!paints)winners.set(element,paints=new Map());
-          for(const [,property,dark] of properties){const light=element.getAttribute(property);
-            if(light&&(paints.get(property)?.rank??-1)<=rank)paints.set(property,{light,dark,rank});}
-        }
-      }
-    }
-    style.remove();
-  }
-  for(const [element,paints] of winners)for(const [property,{light,dark}] of paints)
-    element.style.setProperty(property,'light-dark('+light+', '+dark+')','important');
-  drawing.classList.add('rapier-native-flowchart');drawing.setAttribute('role','img');
-  drawing.setAttribute('aria-roledescription',drawing.getAttribute('data-rapier-diagram-kind')||'flowchart');
-  const width=Number(drawing.getAttribute('width')),
-    sizes=[...drawing.querySelectorAll('text[font-size]')].map(text=>Number(text.getAttribute('font-size'))).filter(size=>Number.isFinite(size)&&size>0),
-    minimum=sizes.reduce((smallest,size)=>Math.min(smallest,size),Infinity);
-  if(Number.isFinite(width)&&width>0){
-    const readable=Math.ceil(width*14/(Number.isFinite(minimum)?minimum:14)*1000)/1000;
-    drawing.style.width='clamp('+readable+'px, 100%, '+width+'px)';
-  }
-  drawing.style.maxWidth='none';
-}
-
 // Set the first view once. Subsequent rendering keeps the person's horizontal position.
 export function positionNativeDiagram(drawing) {
   const surface=drawing?.closest?.('.diagram-block,.diagram-live-preview');
@@ -67,6 +30,7 @@ export function positionNativeDiagram(drawing) {
   surface.scrollLeft=Math.max(0,Math.min(surface.scrollWidth-surface.clientWidth,left));
 }
 
+// The document's renderer. DOM, codecs and host state are explicit inputs.
 function createRenderer(runtime) {
   const {RapierLedgerCarried, RapierPageReturnAddress, RapierTextCodec, _rapierArtifactHighlight, _rapierArtifactPreference, _rapierArtifactStyles, _rapierBlobDataUrl, _rapierBuildInterchangeContext, _rapierDocumentNameIsAdmissible, _rapierLedgerParts, _rapierDrawReadSVGRecipe, _rapierDrawShapeProfileFor, _rapierExportFontCss, _rapierFillDiagram, _rapierFinalizeExportCode, _rapierLanguageClass, _rapierLineStartOffsets, _rapierMarkdownEnvironment, _rapierPortableHtml, _rapierPrepareInterchangeContext, _rapierProjectPortableRoot, _rapierProviders, _rapierSourceCharEscaped, _rapierSourceLineSpan, crypto, document, escapeRapierHtmlText, globalThis, sanitizeRapierHtml} = runtime;
   let md = runtime.md;
@@ -659,11 +623,12 @@ function _rapierSharedResolve(text, ids, images, definitions) {
 	// Authored # characters were encoded. A raw id after ]( can only be a structural
 	// substitution; matching its destination lets nested alt brackets survive unchanged.
 	const inline = new RegExp('(\\]\\([ \\t\\r\\n]*(?:&lt;)?)#' + id + '(?=>?[ \\t\\r\\n]*\\)|>?[ \\t\\r\\n]+["\'(])', 'g');
-	// A definition may sit in a quote or a list item: its line starts with that container's markers.
-	const definition = new RegExp('(^[ \\t>]*\\[((?:\\\\.|[^\\]\\\\])+)\\]:[ \\t]*(?:(?:\\r\\n|\\r|\\n)[ \\t>]*)?(?:&lt;)?)#' + id + '(?=>?[ \\t]*$|>?[ \\t]+["\'(])', 'gm');
+	// A definition may sit in a quote or a list item, as the writer found it: its line starts with their markers.
+	const definition = new RegExp('(^[ \\t>]*(?:(?:[-+*]|\\d{1,9}[.)])[ \\t]+[ \\t>]*)*\\[((?:\\\\.|[^\\]\\\\])+)\\]:[ \\t]*(?:(?:\\r\\n|\\r|\\n)[ \\t>]*)?(?:&lt;)?)#' + id + '(?=>?[ \\t]*$|>?[ \\t]+["\'(])', 'gm');
 	const swapInline = (match, lead, value) => { const found = src(value); return found == null ? match : lead + found; };
 	const swapDefinition = (match, lead, label, value) => {
-		if (!definitions.has(md.utils.normalizeReference(_rapierSharedDecode(label)))) return match;
+		const decoded = _rapierSharedDecode(label), quoted = decoded.replace(/\r?\n[ \t]*(?:>[ \t]*)+/g, ' ');
+		if (!definitions.has(md.utils.normalizeReference(decoded)) && !definitions.has(md.utils.normalizeReference(quoted))) return match;
 		const found = src(value);
 		return found == null ? match : lead + found;
 	};

package/dist/layout/paragraph-fit.mjs

@@ -172,20 +172,6 @@ export function createParagraphFitter() {
     return {lines, work, cost: totalCost, approximate: false};
   }
 
-  function solve(prepared, width, options, observe) {
-    const work = solveSteps(prepared, width, options);
-    try {
-      let step = work.next();
-      while (!step.done) {
-        if (step.value && !observe) return null;
-        step = work.next(step.value ? observe(step.value) : undefined);
-      }
-      return step.value;
-    } finally { work.return(); }
-  }
-  return {prepare, solve, solveSteps};
+  return {prepare, solveSteps};
 }
 
-const fitter = createParagraphFitter();
-export const prepareParagraph = fitter.prepare;
-export const fitParagraph = fitter.solve;

package/dist/layout/typography.mjs

@@ -3,7 +3,8 @@ import {createPreparationScope, supportsRichStyle, captureFontAuthority} from '.
 import {createParagraphFitter} from './paragraph-fit.mjs';
 
 // Layout projections keep the original text in place. The factory also runs in an exported page.
-export function createTypography(fitter = createParagraphFitter()) {
+export function createTypography() {
+  const fitter = createParagraphFitter();
   const mark = 'data-rapier-typography', boundary = mark + '-break', hang = mark + '-hang';
   const protectedInitial = mark + '-protected-initial';
   const gapMark = mark + '-gap', fitMark = mark + '-fit';

package/dist/packages/rapier-diff/concerns.mjs

@@ -0,0 +1,163 @@
+// SPDX-License-Identifier: MIT
+import {letter, within, prev, next} from './tokens.mjs';
+
+// Separator-only pieces join the edit beside them; adjacent blocks each carry their own line break.
+export function separate(c, endA = c.before.length, endB = c.after.length) {
+  const {before, after, safe, raw, spend} = c;
+  // A separator-only piece beside another edit joins it; equal separators at its ends stay unchanged.
+  if (!raw) for (let i = c.result.length - 1; i > 0; i--) {
+    const p = c.result[i - 1], q = c.result[i], side = p[0][0] === p[0][1] ? 1 : p[1][0] === p[1][1] ? 0 : -1, text = side ? after : before;
+    if (side >= 0 && !/\S/.test(text.slice(...p[side]))) {
+      let n = 0;
+      while (p[0][1] + n < q[0][0] && text[p[side][0] + n] === text[p[side][1] + n] && spend()) n++;
+      if (p[0][1] + n === q[0][0] && p.slice(0, 2).every((span, k) => safe(k ? after : before, span[0] + n) && safe(k ? after : before, span[1] + n)))
+        for (const span of p.slice(0, 2)) { span[0] += n; span[1] += n; }
+    }
+    if (p[2] || q[2] || p[0][1] !== q[0][0] || p[1][1] !== q[1][0] ||
+      ![p, q].some(r => !/\S/.test(before.slice(...r[0]) + after.slice(...r[1])))) continue;
+    const x = [p[0][0], q[0][1]], y = [p[1][0], q[1][1]], keep = /\S/.test(before.slice(...q[0]) + after.slice(...q[1])) ? q : p;
+    // CRLF steps as one separator.
+    for (let k; x[0] < x[1] && y[0] < y[1] && /\s/.test(before[x[1] - 1]) && before[x[1] - 1] === after[y[1] - 1] &&
+      (k = before.endsWith('\r\n', x[1]) && after.endsWith('\r\n', y[1]) ? 2 : 1) <= Math.min(x[1] - x[0], y[1] - y[0]) &&
+      safe(before, x[1] - k) && safe(after, y[1] - k);) { x[1] -= k; y[1] -= k; }
+    keep[3][0] = x[0] === x[1] ? 2 : y[0] === y[1] ? 0 : 1;
+    c.result.splice(i - 1, 2, [x, y, false, keep[3]]);
+  }
+  // Repeated closing lines can attach to the wrong block. Rotate an exact insertion/deletion to the
+  // next blank-line boundary, without crossing another edit or splitting a character.
+  if (!raw) for (let i = 0; i < c.result.length; i++) {
+    const p = c.result[i], q = c.result[i + 1], side = p[0][0] === p[0][1] ? 1 : p[1][0] === p[1][1] ? 0 : -1;
+    if (side < 0 || p[2]) continue;
+    const text = side ? after : before;
+    const room = Math.min((q?.[0][0] ?? endA) - p[0][1], (q?.[1][0] ?? endB) - p[1][1]);
+    let n = 0, shift = 0;
+    while (n < room && text[p[side][0] + n] === text[p[side][1] + n] && spend()) {
+      n++;
+      if (text[p[side][0] + n - 1] === '\n' && /^\r?\n/.test(text.slice(p[side][0] + n))) { shift = n; break; }
+    }
+    if (shift && p.slice(0, 2).every((span, k) => safe(k ? after : before, span[0] + shift) && safe(k ? after : before, span[1] + shift)))
+      for (const span of p.slice(0, 2)) { span[0] += shift; span[1] += shift; }
+  }
+  // Adjacent blocks deleted or inserted together: when the first carries the line break before it, each carries
+  // its own, so any one restores apart from its neighbours.
+  if (!raw) for (let i = 1; i < c.result.length; i++) {
+    const p = c.result[i - 1], q = c.result[i], kind = p[3][0], side = kind ? 1 : 0, text = side ? after : before;
+    if (kind % 2 || q[3][0] !== kind || p[2] || q[2] || p[side][1] !== q[side][0] || p[1 - side][0] !== q[1 - side][0]) continue;
+    const blank = /^\r?\n/.test(text.slice(...p[side])) && !/^\r?\n/.test(text.slice(...q[side])) && /(\r?\n)(?:[ \t]*\r?\n)+$/.exec(text.slice(...p[side]));
+    if (blank && blank.index > 0) p[side][1] = q[side][0] -= blank[0].length - blank[1].length;
+  }
+}
+
+// Refine the outer walk and each move's inner walk before assigning transport ownership.
+export function phrases(c) {
+  const {before, after, raw, code} = c;
+  // Whole-word replacements separated only by spaces read and restore as one phrase, and one number stays one number.
+  if (!raw) for (let i = c.result.length - 1; i > 0; i--) {
+    const p = c.result[i - 1], q = c.result[i], gap = before.slice(p[0][1], q[0][0]);
+    if (p[3][0] !== 1 || q[3][0] !== 1 || p[3][3] || q[3][3] || p[2] || q[2] || gap !== after.slice(p[1][1], q[1][0])) continue;
+    // A time, a date, a version or a decimal is one number.
+    const number = /^(?:[.,:/-]\d*)+$/.test(gap) && /\d/.test(before[p[0][1] - 1] + after[p[1][1] - 1]) && /\d/.test(before[q[0][0]] + after[q[1][0]]);
+    if (!number && (code || !/^[^\S\r\n]+$/.test(gap) || within(before, p[0][0]) || within(after, p[1][0]) ||
+      within(before, q[0][1]) || within(after, q[1][1]))) continue;
+    p[0][1] = q[0][1]; p[1][1] = q[1][1]; c.result.splice(i, 1);
+  }
+  // Paired inline markers added or removed around unchanged text on one line are one concern.
+  if (!raw && !code) for (let i = 1; i < c.result.length; i++) {
+    const p = c.result[i - 1], q = c.result[i], kind = p[3][0], side = kind ? 1 : 0, text = side ? after : before;
+    if (kind % 2 || kind !== q[3][0] || p[2] || q[2] || p[3][3] || q[3][3]) continue;
+    const open = text.slice(...p[side]), close = text.slice(...q[side]), inner = text.slice(p[side][1], q[side][0]);
+    if (!inner.trim() || inner.includes('\n') || !(open === close && /^(?:[*_]{1,3}|~~|==|`+)$/.test(open) ||
+      open === '[' && /^\]\([^\s()]*\)$/.test(close))) continue;
+    p[3] = q[3] = [kind, 'word', p[3][2], [[p[0][0], q[0][1]], [p[1][0], q[1][1]]]];
+  }
+}
+
+// Readable concerns: phrases, numbers and paired markers, then the public edits and changes with context.
+export function concerns(c) {
+  phrases(c);
+  const {before, after, spend, safe, budget, raw, code, evidence, structures, initial, options, pa, pb} = c, lb = c.lb;
+  const overlaps = (a, b) => a[0] < b[1] && a[1] > b[0];
+  // Siblings are ordered and disjoint: the parts holding a range are found by descent, outermost first.
+  const containing = (parts, from, to, out = []) => {
+    let lo = 0, hi = parts.length;
+    while (lo < hi) { const mid = lo + hi >>> 1; if (parts[mid].end < to) lo = mid + 1; else hi = mid; }
+    for (let k = lo; k < parts.length && parts[k].start <= from && spend(); k++)
+      if (parts[k].end >= to) { out.push(parts[k]); containing(parts[k].children, from, to, out); }
+    return out;
+  };
+  // Edits are ordered and disjoint on the after side.
+  const touched = (edits, range) => {
+    let lo = 0, hi = edits.length;
+    while (lo < hi) { const mid = lo + hi >>> 1; if (edits[mid].after[1] <= range[0]) lo = mid + 1; else hi = mid; }
+    return lo < edits.length && overlaps(range, edits[lo].after);
+  };
+  const changes = [], edits = [];
+  let normalized;
+  const meaning = structures?.[0]?.meaning;
+  const format = typeof meaning === 'string' && meaning === structures[1].meaning;
+  for (let i = 0; i < c.result.length; i++) {
+    const item = c.result[i];
+    if (raw === 'char' && !evidence) {
+      const a = item[0], b = item[1], next = c.result[i + 1];
+      if (item[3][0] !== 1) {
+        const room = Math.min((next?.[0][0] ?? before.length) - a[1], (next?.[1][0] ?? after.length) - b[1]);
+        let n = 0;
+        while (n < room && before[a[0] + n] === after[b[0] + n] && spend()) n++;
+        while (n && (!safe(before, a[0] + n) || !safe(before, a[1] + n) || !safe(after, b[0] + n) || !safe(after, b[1] + n))) n--;
+        a[0] += n; a[1] += n; b[0] += n; b[1] += n;
+      }
+      const p = normalized;
+      if (p && p[0][0] === p[0][1] && item[3][0] === 2 && p[0][0] === a[0] && p[1][1] === b[0]) {
+        p[1][1] = b[1]; if (item[2]) edits.at(-1).coarse = true; continue;
+      }
+      normalized = item;
+    }
+    const group = item[3];
+    if (!raw && !group[3]) group[3] = [[...item[0]], [...item[1]]];
+    if (!group[4]) {
+      const context = group[3];
+      // Context completes a word only where an edge falls inside it.
+      if (!raw) for (const [text, span] of [[before, context[0]], [after, context[1]]]) {
+        const start = within(text, span[0]), end = within(text, span[1]);
+        for (let c; start && letter(c = prev(text, span[0])) && spend() && safe(text, span[0] - c.length);) span[0] -= c.length;
+        for (let c; end && letter(c = next(text, span[1])) && spend() && safe(text, span[1] + c.length);) span[1] += c.length;
+      }
+      group[4] = []; changes.push(group);
+      if (format) group[0] = 5;
+    }
+    group[4].push(edits.length);
+    edits.push({before: item[0], after: item[1], ...(item[2] ? {coarse: true} : {})});
+  }
+  if (structures && !raw && budget.left >= 0) {
+    const oldNames = new Set(pa.filter(p => p.nameAt).map(p => p.name)), newNames = new Set(pb.filter(p => p.nameAt).map(p => p.name));
+    const linksTo = new Map();
+    if (spend(pa.length + pb.length + lb.length)) lb.forEach((link, k) => linksTo.set(link.to, [...linksTo.get(link.to) || [], k]));
+    for (const change of changes) {
+      if (change[0] === 5) continue;
+      if (budget.left < 0) break;
+      const range = change[3];
+      const older = containing(structures[0].parts, ...range[0]), newer = containing(structures[1].parts, ...range[1]);
+      const part = (change[0] === 0 ? older : newer).at(-1) || older.at(-1);
+      if (!change[2] && part?.name) { change[2] = part.name; change[1] = part.kind; }
+      const names = new Set([change[2], ...older.map(p => p.name), ...newer.map(p => p.name)]), breaks = [], affects = [];
+      for (const k of [...names].flatMap(name => linksTo.get(name) || []).sort((a, b) => a - b)) {
+        const {at, to} = lb[k];
+        if (!newNames.has(to)) { if (oldNames.has(to)) breaks.push({at, to}); continue; }
+        if (!spend() || touched(edits, at)) continue;
+        const p = containing(structures[1].parts, ...at).filter(p => /^(paragraph|call|item|task|cell|declaration)$/.test(p.kind)).at(-1);
+        affects.push(p && !touched(edits, [p.start, p.end]) ? [p.start, p.end] : at);
+      }
+      if (breaks.length) change[6] = breaks;
+      if (affects.length) change[5] = affects;
+    }
+  }
+  if (options._stats) Object.assign(options._stats, {work: Math.max(0, initial - Math.max(0, budget.left)), coarse: edits.some(c => c.coarse)});
+  // Concern tuples: kind, unit, name, context, edits, affects, breaks. Wording inside a move shares its context.
+  const moves = new Map(changes.map((change, i) => change[0] === 3 && [change[3], i + 1]).filter(Boolean));
+  return {edits, changes: changes.map(([kind, unit, name, context, owned, affects, breaks], i) => ({
+    id: i + 1, kind: ['delete', 'replace', 'insert', 'move', 'rename', 'format'][kind], unit, edits: owned,
+    ...(name ? {name} : {}), ...(context ? {context: {before: context[0], after: context[1]}} : {}),
+    ...(kind !== 3 && moves.has(context) ? {move: moves.get(context)} : {}),
+    ...(affects ? {affects} : {}), ...(breaks ? {breaks} : {})
+  }))};
+}

package/dist/packages/rapier-diff/diff.mjs

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: MIT
+// One comparison: observe structure, walk the source into exact records, find moves and renames, then read them as
+// concerns. Each stage lives in its own module and shares one comparison context.
+import {observe} from './structure.mjs';
+import {boundaries, tokenizer, wordSegmenter} from './tokens.mjs';
+import {matcher} from './matching.mjs';
+import {walker} from './walk.mjs';
+import {moves} from './moves.mjs';
+import {separate, concerns} from './concerns.mjs';
+
+export function diff(before, after, options = {}) {
+  if (before === after) return {edits: [], changes: []};
+  const budget = options._budget || {left: Number.isFinite(options.limit) ? Math.max(0, options.limit) : 1e7};
+  const spend = (n = 1) => (budget.left -= n) >= 0, safe = boundaries(), raw = options._unit;
+  // Internal records: [before range, after range, coarse, concern, transported fragments].
+  const c = {before, after, options, budget, spend, safe, raw, chars: options.unit === 'char', initial: budget.left,
+    segmenter: wordSegmenter(), result: [], code: options.as === 'code'};
+  // A Markdown fence holds code inside prose; only code outside fences makes the text code.
+  if (options.as !== 'prose' && options.as !== 'code') c.code = /(?:^|\n)\s*(?:[{}]|(?:function|class|const|let|var|import|export|def|fn|func|package)\s+\w[^]{0,80}[({=:;])/
+    .test((before.slice(0, 4096) + '\n' + after.slice(0, 4096)).replace(/^ {0,3}(`{3,}|~{3,})[^]*?(?:^ {0,3}\1[`~]*[ \t]*$|(?![^]))/gm, ''));
+  let fallback;
+  if (options.structure && (!raw || options._structure)) {
+    let structures;
+    try {
+      structures = options._observed || [observe(before, options.structure, spend, safe), observe(after, options.structure, spend, safe)];
+      if (structures.some(value => !value || value.invalid)) throw null;
+      const [pa, pb] = structures.map(value => value.flat), aliases = new Map();
+      const oldByKey = new Map(pa.filter(p => p.key != null).map(p => [p.key, p]));
+      const oldNames = new Set(pa.map(p => p.name)), newNames = new Set(pb.map(p => p.name));
+      for (const p of pb) {
+        const old = oldByKey.get(p.key);
+        if (old?.nameAt && p.nameAt && old.kind === p.kind && !oldNames.has(p.name) && !newNames.has(old.name)) aliases.set(p, old);
+      }
+      Object.assign(c, {structures, pa, pb, la: structures[0].links, lb: structures[1].links, aliases});
+    } catch {
+      // A failed reader preserves an explicit prose choice and reports why structure was not used.
+      const failed = structures?.find(value => !value || value.invalid);
+      fallback = {structure: failed?.threw ? 'threw' : budget.left < 0 ? 'limit' : 'invalid', ...(failed?.threw ? {error: failed.error} : {})};
+      c.code = options.as !== 'prose';
+    }
+  }
+  c.tokens = tokenizer(c); c.matches = matcher(spend, budget);
+  const {walk, operations} = Object.assign(c, walker(c)), {structures, pa, pb} = c;
+  const evidence = c.evidence = options.from && operations(options.from);
+  if (options.from && !evidence) (fallback ||= {}).from = budget.left < 0 ? 'limit' : 'invalid';
+  if (evidence) for (const span of evidence) walk(...span, structures ? 0 : raw === 'char' ? 3 : 1, pa, pb);
+  else walk(0, before.length, 0, after.length, structures ? 0 : raw === 'word' ? 2 : 1,
+    structures?.[0]?.parts, structures?.[1]?.parts);
+  separate(c);
+  moves(c);
+  // A heading edit can re-record its children. Compare both walks after transport is known: unchanged moved
+  // fragments cost nothing, so a smaller plain walk cannot discard a move just by aligning some of its lines.
+  if (structures && !evidence && !raw && c.result.some(r => r[0][0] === r[0][1]) && c.result.some(r => r[1][0] === r[1][1]) &&
+    budget.left >= c.initial - budget.left) {
+    const size = (rows, transport = false) => rows.reduce((n, r) => n + (!transport && r[3][0] === 3 ? 0 : r[0][1] - r[0][0] + r[1][1] - r[1][0]), 0);
+    const walked = c.result, links = c.lb, cost = size(walked);
+    if (cost) {
+      c.result = []; c.lb = structures[1].links;
+      walk(0, before.length, 0, after.length, 1);
+      separate(c); moves(c);
+      const plain = size(c.result);
+      if (budget.left < 0 || c.result.some(r => r[2]) || plain > cost ||
+        plain === cost && size(c.result, true) >= size(walked, true)) { c.result = walked; c.lb = links; }
+    }
+  }
+  const {edits, changes} = concerns(c);
+  return {edits, ...(fallback && !raw ? {fallback} : {}), changes};
+}