rapier-markdown-kit 1.1.101 → 1.1.104

package/dist/layout/hyphenation.mjs

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: MIT
+import {next, weight, exceptions, maximum} from '../agent/vendor/hyphen-en-us/patterns.js';
+
+// An original matcher over the permitted Kuiken/Plain TeX data. Its maximum pattern
+// length bounds the work per input character. Its static prefix data need no decoder,
+// runtime trie or font. Prepared paragraphs own the resulting positions for their lifetime.
+function englishCuts(word) {
+  if (!/^[A-Z]?[a-z]+$/.test(word)) return null;
+  if (word.length < 6) return [];
+  const lower = word.toLowerCase(), known = exceptions[lower];
+  if (Array.isArray(known)) return known.filter(at => at >= 3 && at <= word.length-3);
+  const source = '.'+lower+'.', weights = new Uint8Array(source.length+1);
+  for (let start = 0; start < source.length; start++) {
+    let node = 0;
+    for (let end = start+1; end <= source.length && end <= start+maximum; end++) {
+      node = next(node, source.charCodeAt(end-1));
+      if (node < 0) break;
+      let packed = weight(node);
+      if (typeof packed !== 'number') continue;
+      for (let at = start; packed; at++, packed = Math.floor(packed/16)) weights[at] = Math.max(weights[at],packed%16);
+    }
+  }
+  const cuts = [];
+  for (let at = 3; at <= word.length-3; at++) if (weights[at+1]&1) cuts.push(at);
+  return cuts;
+}
+
+// Ask the host's offline hyphenator for successive word cuts. A zero-width word exposes
+// its first available cut; increasing the minimum prefix then exposes the next one.
+// Merely reading every line at width zero misses useful cuts (e.g. justifi-ca-tion).
+// Each round writes every live word first, then reads every word: no per-word layout
+// loop. This supplies positions only, never reusable font metrics or a second shaper.
+// Three graphemes on either side and at most one automatic split per word are deliberate
+// typography policy. Hosts without a dictionary for the language naturally return no cuts.
+export function paragraphHyphens(words, text, items, offsets, language, document) {
+  const result = new Map();
+  if (!language) return result;
+  const exactEnglish = /^(?:en|en-US)(?:-u-.*)?$/i.test(language), unique = new Map(), english = new Map(), jobs = [];
+  let segmenter, itemIndex = -1;
+  for (const word of words) {
+    if (word.protected) continue;
+    const body = text.slice(word.start, word.end);
+    // The exact ASCII subset avoids Unicode-regexp setup for ordinary English.
+    const match = /^[-!"#%&'()*,.\/:;?@\[\]\\_{}]*([A-Za-z]+)[-!"#%&'()*,.\/:;?@\[\]\\_{}]*$/.exec(body) ||
+      /^\p{P}*([\p{L}\p{M}]+)\p{P}*$/u.exec(body);
+    if (!match || /[\u00a0\u00ad\u202f\u2060]/u.test(body)) continue;
+    const start = word.start + body.indexOf(match[1]), end = start + match[1].length;
+    // The prepared source words and runs are ordered. Visit only the overlapping
+    // runs, retaining the exact open-boundary policy even for empty authored runs.
+    // A hard-break chunk can begin far into the shared paragraph run array.
+    if (itemIndex < 0) {
+      let lo = 0, hi = items.length;
+      while (lo < hi) {
+        const middle = Math.floor((lo+hi)/2);
+        if (offsets[middle+1] <= start) lo = middle+1; else hi = middle;
+      }
+      itemIndex = lo;
+    } else while (itemIndex < items.length && offsets[itemIndex+1] <= start) itemIndex++;
+    let disabled = false;
+    for (let index = itemIndex; index < items.length && offsets[index] < end; index++) {
+      if (items[index].hyphenate === false) {disabled = true;break;}
+    }
+    if (disabled) continue;
+    if (exactEnglish) {
+      if (!english.has(match[1])) english.set(match[1],englishCuts(match[1]));
+      const local = english.get(match[1]);
+      if (local) {result.set(word,local.map(offset => start+offset));continue;}
+    }
+    let entry = unique.get(match[1]);
+    if (!entry) {
+      if (match[1].length < 6) continue;
+      // Exact English needs neither ICU grapheme setup nor native DOM probing.
+      // Language admission belongs to preparation; this is only its fallback owner.
+      segmenter ||= new Intl.Segmenter(language, {granularity:'grapheme'});
+      const units = [...segmenter.segment(match[1])].map(part => part.index);
+      if (units.length < 6) continue;
+      units.push(match[1].length);
+      entry = {text:match[1], units, cuts:[], minimum:3};
+      unique.set(entry.text, entry);
+    }
+    jobs.push({word,start,entry});
+  }
+  if (!jobs.length) return result;
+  // If this host cannot expose its language opportunities, preserve native automatic
+  // hyphenation for the paragraph instead of projecting a weaker whole-word substitute.
+  if (!document?.body || !document.defaultView?.CSS.supports('hyphenate-limit-chars', '6 3 3')) return null;
+  const host = document.createElement('span');
+  host.setAttribute('aria-hidden','true'); host.inert = true;
+  host.style.cssText = 'all:initial!important;position:fixed!important;left:0!important;top:0!important;width:0!important;height:0!important;overflow:hidden!important;contain:strict!important;visibility:hidden!important;pointer-events:none!important;';
+  const shadow = host.attachShadow({mode:'closed'});
+  let active = [...unique.values()];
+  for (const entry of active) {
+    const element = document.createElement('div'); element.lang = language;
+    // Do not reset `all` here: Blink's language declaration is a UA style, and an
+    // inline reset would erase it. The shadow root already isolates author selectors.
+    element.style.cssText = 'display:block;width:0;font:16px serif;line-height:20px;hyphens:auto;hyphenate-limit-chars:6 3 3;white-space:normal;word-break:normal;overflow-wrap:normal;text-wrap:wrap;';
+    element.textContent = entry.text; shadow.append(element); entry.element = element;
+  }
+  document.body.append(host);
+  const range = document.createRange();
+  try {
+    while (active.length) {
+      const next = [];
+      for (const entry of active) {
+        const node = entry.element.firstChild, {units} = entry;
+        const top = index => {
+          range.setStart(node,units[index]); range.setEnd(node,units[index+1]);
+          // At a native discretionary boundary a character Range can also report
+          // the preceding line's hyphen rectangle. Its final rect owns the character.
+          return [...range.getClientRects()].at(-1)?.top;
+        };
+        const first = top(0), last = top(units.length-2);
+        if (first == null || last == null || first === last) continue;
+        let lo = entry.minimum, hi = units.length-1;
+        while (lo < hi) { const middle = lo+hi>>>1; if (top(middle) === first) lo=middle+1; else hi=middle; }
+        if (lo < entry.minimum || lo > units.length-4) continue;
+        entry.cuts.push(units[lo]); entry.minimum = lo+1;
+        if (entry.minimum <= units.length-4) next.push(entry);
+      }
+      // All reads above finish before any mutation for the next shared layout.
+      for (const entry of next) entry.element.style.hyphenateLimitChars = '6 '+entry.minimum+' 3';
+      active = next;
+    }
+  } finally { host.remove(); }
+  for (const {word,start,entry} of jobs) result.set(word, entry.cuts.map(offset => start+offset));
+  return result;
+}

package/dist/layout/line-plan.mjs

@@ -1,119 +1,96 @@
 // SPDX-License-Identifier: MIT
-// A word or an address wider than its slot has to break inside itself; the browser would let it run out of the column, a
-// projection cannot. Pretext breaks it after the last hyphen that fits, else after the last letter that fits. A person reads an
-// address better broken where it has its own punctuation, so the break moves back to the last of these that fits.
-const naturalBreak = /[/._?&=]/, hyphen = /[-\u058a\u2010\u2012\u2013\u2014]/;
-let clusters;
-const lettersOf = new WeakMap();
 
-function breakAtPunctuation(flow, range, cursor, layoutNextRichInlineLineRange) {
-  const last = range.fragments.at(-1), end = last?.end;
-  if (!end || end.graphemeIndex === 0) return range;
-  const prepared = flow.items[last.itemIndex]?.prepared, segment = prepared?.segments?.[end.segmentIndex];
-  if (typeof segment !== 'string') return range;
-  // A long address is cut once per line; its letters are counted once.
-  let byIndex = lettersOf.get(prepared);
-  if (!byIndex) lettersOf.set(prepared, byIndex = new Map());
-  let letters = byIndex.get(end.segmentIndex);
-  if (!letters) {
-    clusters ||= new Intl.Segmenter(undefined, {granularity: 'grapheme'});
-    byIndex.set(end.segmentIndex, letters = [...clusters.segment(segment)].map(part => part.segment));
-  }
-  const from = last.start.segmentIndex === end.segmentIndex ? last.start.graphemeIndex : 0;
-  if (end.graphemeIndex > letters.length || hyphen.test(letters[end.graphemeIndex - 1]) || naturalBreak.test(letters[end.graphemeIndex - 1])) return range;
-  let target = end.graphemeIndex - 1;
-  while (target > from && !naturalBreak.test(letters[target - 1])) target--;
-  if (target <= from) return range;
-  // Each narrower limit yields the break one letter back (`balanced` walks the breaks of a line the same way).
-  for (let limit = range.width - .05, at = end.graphemeIndex; at > target;) {
-    const shorter = layoutNextRichInlineLineRange(flow, limit, cursor), tail = shorter?.fragments.at(-1);
-    if (!tail || tail.itemIndex !== last.itemIndex || tail.end.segmentIndex !== end.segmentIndex || tail.end.graphemeIndex >= at) return range;
-    if (tail.end.graphemeIndex === target) return shorter;
-    at = tail.end.graphemeIndex;
-    limit = shorter.width - .05;
-  }
-  return range;
-}
-
-// Pretext lets a line end wherever one element ends and the next begins. The browser allows no break there unless white space
-// stands between them, so a comma, a colon or a closing bracket straight after `agents.md` (a chip, a link, bold words) would
-// start the next line alone. The line ends one break earlier instead, and the punctuation keeps its word.
-const closing = /^[,.:;!?)\]}%\u2019\u201d\u00bb\u203a\u2026\u060c\u061b\u061f\u3001\u3002\uff0c\uff0e\uff1a\uff1b\uff01\uff1f\uff09\u300d\u300f]/;
+const lastSource = line => line.fragments.at(-1);
+const afterSource = (point, previous) => !!point && (!previous || point.itemIndex > previous.itemIndex ||
+  point.itemIndex === previous.itemIndex && point.sourceEnd > previous.sourceEnd);
 
-function stranding(flow, range) {
-  const {itemIndex, segmentIndex, graphemeIndex} = range.end;
-  if (segmentIndex !== 0 || graphemeIndex !== 0) return false;
-  for (let index = itemIndex; index < flow.items.length; index++) {
-    const item = flow.items[index];
-    if (!item?.establishesLine) continue;
-    return !item.breakBefore && closing.test(item.prepared?.segments?.[0] ?? '');
-  }
-  return false;
+// A chip may continue on later rows but does not cross a picture within the same row.
+// Containment uses the original item and materialized source interval, never engine cursors.
+function insideChip(items, line) {
+  const last = lastSource(line), item = items?.[last?.itemIndex];
+  return item?.extraWidth > 0 && typeof item.text === 'string' &&
+    /[^ \t\r\n\f]/.test(item.text.slice(last.sourceEnd));
 }
 
-function keepWithWord(flow, range, cursor, layoutNextRichInlineLineRange) {
-  if (!stranding(flow, range)) return range;
-  for (let limit = range.width - .05, tries = 64; tries > 0; tries--) {
-    const shorter = layoutNextRichInlineLineRange(flow, limit, cursor);
-    if (!shorter || shorter.width > limit + .05) return range;
-    if (!stranding(flow, shorter)) return shorter;
+function beforeChip(flow, range, line, cursor, items, next, materialize) {
+  let first = lastSource(line).itemIndex;
+  while (first > 0 && items[first - 1]?.extraWidth > 0) first--;
+  if (first <= line.fragments[0].itemIndex) return null;
+  for (let limit = range.width - .05, tries = 64; tries > 0 && limit > 0; tries--) {
+    const shorter = next(flow, limit, cursor);
+    if (!shorter || shorter.width > limit + .05) return null;
+    const materialized = materialize(flow, shorter), last = lastSource(materialized);
+    if (!last) return null;
+    if (last.itemIndex < first) return {range: shorter, line: materialized};
     limit = shorter.width - .05;
   }
-  return range;
+  return null;
 }
 
-// A chip (inline code, a box each piece of it repeats) breaks at its own spaces and hyphens like any words, but never across a
-// picture: "npx rapier-" left of the picture and "html" right of it read as two things. When a line would end inside a chip
-// with another slot of the row still to come, the line ends before the chip instead and the chip goes whole to the next slot;
-// when nothing but the chip stands in the slot, the row's remaining slots are given up and the chip's pieces stack in this one.
-function insideChip(flow, range) {
-  const {itemIndex, segmentIndex, graphemeIndex} = range.end;
-  return (segmentIndex > 0 || graphemeIndex > 0) && flow.items[itemIndex]?.extraWidth > 0;
-}
-function beforeChip(flow, range, cursor, layoutNextRichInlineLineRange) {
-  let first = range.end.itemIndex;
-  while (first > 0 && flow.items[first - 1]?.extraWidth > 0) first--;
-  if (first === 0 || first <= cursor.itemIndex && (cursor.segmentIndex > 0 || cursor.graphemeIndex > 0 || first < cursor.itemIndex)) return null;
-  const before = shorter => shorter.end.itemIndex < first || shorter.end.itemIndex === first && shorter.end.segmentIndex === 0 && shorter.end.graphemeIndex === 0;
-  for (let limit = range.width - .05, tries = 64; tries > 0; tries--) {
-    const shorter = layoutNextRichInlineLineRange(flow, limit, cursor);
-    if (!shorter || shorter.width > limit + .05) return null;
-    if (before(shorter)) return shorter.end.itemIndex === cursor.itemIndex && shorter.end.segmentIndex === cursor.segmentIndex && shorter.end.graphemeIndex === cursor.graphemeIndex ? null : shorter;
-    limit = shorter.width - .05;
+// A lone alphabetic prefix in a narrow picture-side slot need not be split when the
+// same engine continuation fits its whole word in a later slot on this row. This is
+// a small placement policy, not a reconstruction of upstream legal break candidates.
+// Authored no-break spaces stay with this alphabetic group. Punctuation, discretionary
+// hyphens, mixed items and non-alphabetic scripts retain
+// the engine's choice. All ranges and cursors remain untouched public API values.
+function laterWholeWord(flow, cursor, line, items, bands, slot, next, materialize) {
+  if (line.fragments.length !== 1) return false;
+  const first = line.fragments[0], item = items?.[first.itemIndex], text = item?.text;
+  if (typeof text !== 'string' || item.break === 'never' || item.extraWidth > 0) return false;
+  const start = first.sourceStart, end = first.sourceEnd;
+  const letter = char => /\p{L}/u.test(char) && /[\p{Script=Latin}\p{Script=Greek}\p{Script=Cyrillic}]/u.test(char);
+  const join = char => char === '\u00a0' || char === '\u202f';
+  const member = char => letter(char) || /\p{M}/u.test(char) || join(char);
+  const point = at => at < text.length ? String.fromCodePoint(text.codePointAt(at)) : '';
+  const before = [...text.slice(Math.max(0, start - 2), start)].at(-1) || '';
+  if (!(end > start) || start === 0 && first.itemIndex > 0 || !letter(point(start)) ||
+      ![...text.slice(start, end)].every(member) || member(before) || /[\p{L}\p{M}\p{N}]/u.test(before) || !member(point(end))) return false;
+  let wordEnd = end, lastPoint = '';
+  while (wordEnd < text.length && member(point(wordEnd))) {
+    lastPoint = point(wordEnd); wordEnd += lastPoint.length;
   }
-  return null;
+  if (join(lastPoint) || /[\p{L}\p{M}\p{N}]/u.test(point(wordEnd)) ||
+      wordEnd === text.length && first.itemIndex + 1 < items.length) return false;
+  for (let at = slot + 1; at < bands.length; at++) {
+    if (bands[at].width <= bands[slot].width) continue;
+    const range = next(flow, bands[at].width, cursor);
+    if (!range || !Number.isFinite(range.width) || range.width > bands[at].width + .5) continue;
+    const candidate = materialize(flow, range), begin = candidate.fragments[0], last = lastSource(candidate);
+    if (begin?.itemIndex !== first.itemIndex || begin.sourceStart !== start) continue;
+    if (last && (last.itemIndex > first.itemIndex ||
+        last.itemIndex === first.itemIndex && last.sourceEnd >= wordEnd)) return true;
+  }
+  return false;
 }
 
-export function linePlan(flow, width, top, obstacles, lineHeight, minWidth, direction, balance, slotsForBand, layoutNextRichInlineLineRange, materializeRichInlineLineRange) {
-  const lines = [], ranges = [];
-  let cursor = {itemIndex: 0, segmentIndex: 0, graphemeIndex: 0}, y = 0, bottom = 0, rows = 0;
+// Upstream owns every emitted break and emergency advance. Ordinary CSS balance
+// stays native; Draw's existing token-only balance is kept independently below.
+export function linePlan(flow, width, top, obstacles, lineHeight, minWidth, direction, balance,
+  slotsForBand, layoutNextRichInlineLineRange, materializeRichInlineLineRange, items = null) {
+  if (!flow || balance) return null;
+  const lines = [];
+  let cursor, previous = null, y = 0, bottom = 0, rows = 0;
   for (let step = 0; step < 4096 && rows < 768; step++) {
     const bands = slotsForBand(width, obstacles, top + y, lineHeight, Math.min(minWidth, width));
     if (!bands) return null;
     if (direction === 'rtl') bands.reverse();
-    const widest = Math.max(0, ...bands.map(band => band.width));
     let advanced = false;
     for (let slot = 0; slot < bands.length; slot++) {
       const band = bands[slot];
       let range = layoutNextRichInlineLineRange(flow, band.width, cursor);
-      if (!range) return lines.length ? {lines: balance ? balanced(flow, width, balance, lines, ranges, lineHeight, layoutNextRichInlineLineRange, materializeRichInlineLineRange) : lines, height: Math.max(lineHeight, bottom)} : null;
-      if (range.width > width + .5 || range.end.itemIndex === cursor.itemIndex &&
-          range.end.segmentIndex === cursor.segmentIndex && range.end.graphemeIndex === cursor.graphemeIndex) return null;
+      if (!range) return lines.length ? {lines, height: Math.max(lineHeight, bottom)} : null;
+      if (!Number.isFinite(range.width) || range.width > width + .5) return null;
       if (range.width > band.width + .5) continue;
-      range = breakAtPunctuation(flow, range, cursor, layoutNextRichInlineLineRange);
-      // Ending a line earlier for a comma can cut a word too, so that cut is settled as well.
-      if (!balance && stranding(flow, range)) range = breakAtPunctuation(flow, keepWithWord(flow, range, cursor, layoutNextRichInlineLineRange), cursor, layoutNextRichInlineLineRange);
-      // A word or address that must break inside itself does it in the widest slot of the row. A narrower one, a sliver beside the
-      // picture, waits and the widest takes it, so the head of an address, or "passage" and "s,", is never left alone in a corner.
-      if (range.end.graphemeIndex > 0 && band.width < widest - .5) continue;
-      let column = false;
-      if (!balance && slot + 1 < bands.length && insideChip(flow, range)) {
-        const whole = beforeChip(flow, range, cursor, layoutNextRichInlineLineRange);
-        if (whole) range = whole; else column = true;
+      let line = materializeRichInlineLineRange(flow, range), column = false;
+      if (!afterSource(lastSource(line), previous)) return null;
+      if (laterWholeWord(flow, cursor, line, items, bands, slot, layoutNextRichInlineLineRange, materializeRichInlineLineRange)) continue;
+      if (slot + 1 < bands.length && insideChip(items, line)) {
+        const whole = beforeChip(flow, range, line, cursor, items, layoutNextRichInlineLineRange, materializeRichInlineLineRange);
+        if (whole) { range = whole.range; line = whole.line; } else column = true;
       }
-      if (lines.length === 4096) return null;
-      lines.push({...materializeRichInlineLineRange(flow, range), ...band, y}); ranges.push(range);
-      cursor = range.end; advanced = true; bottom = y + lineHeight;
+      if (!afterSource(lastSource(line), previous) || lines.length === 4096) return null;
+      lines.push({...line, ...band, y});
+      previous = lastSource(line); cursor = range.end; advanced = true; bottom = y + lineHeight;
       if (column) break;
     }
     if (advanced) { y += lineHeight; rows++; continue; }
@@ -127,7 +104,22 @@ export function linePlan(flow, width, top, obstacles, lineHeight, minWidth, dire
   return null;
 }
 
-// `text-wrap: balance` as Chromium 154 lays it (score_line_breaker.cc, then paragraph_line_breaker.cc), over Pretext's own breaks:
+// Draw's numeric tokens predate the rich engine contract and are not vendor handles. This is
+// its existing whole-column greedy walk, with its existing balancing decisions below.
+function measuredPlan(flow, width, lineHeight, fontSize, next, materialize) {
+  const lines = [], ranges = [];
+  let cursor = {itemIndex: 0, segmentIndex: 0, graphemeIndex: 0};
+  for (let row = 0; row < 768; row++) {
+    const range = next(flow, width, cursor);
+    if (!range) return lines.length ? {lines: fontSize ? balanced(flow, width, fontSize, lines, ranges, lineHeight, next, materialize) : lines} : null;
+    if (range.width > width + .5 || range.end.segmentIndex === cursor.segmentIndex) return null;
+    lines.push({...materialize(flow, range), x: 0, width, y: row * lineHeight}); ranges.push(range);
+    cursor = range.end;
+  }
+  return null;
+}
+
+// Draw's existing `text-wrap: balance` approximation, over its own measured token breaks:
 // `balance` is the block's font size. Only a run of two to six greedy lines, each on the whole column, no word broken, balances.
 // The score breaker minimises (width - line)² per line with Minikin's penalties (4·width·font a line, 2·width·font a soft hyphen)
 // and 10000 on the break before the last word; it stands when there are three breaks to choose from and it keeps greedy's count.
@@ -226,7 +218,7 @@ export function measuredLines(tokens, width, lineHeight, fontSize) {
     while (end > first && tokens[end - 1].space) end--;
     return {width: range.width, end: range.end, fragments: [{...source, text: tokens.slice(first, end).map(token => token.text).join(''), sourceStart: tokens[first].start, sourceEnd: tokens[end - 1].end}]};
   };
-  const plan = linePlan(flow, width, 0, [], lineHeight, 1, 'ltr', fontSize, () => [{x: 0, width}], next, materialize);
+  const plan = measuredPlan(flow, width, lineHeight, fontSize, next, materialize);
   return plan?.lines.map(line => {
     const fragment = line.fragments[0];
     return {text: fragment.text, start: fragment.sourceStart, end: fragment.sourceEnd, width: fragment.occupiedWidth};

package/dist/layout/model.mjs

@@ -1,116 +1,96 @@
 // SPDX-License-Identifier: MIT
-import {prepareWithSegments} from '../agent/vendor/pretext/layout.js';
 import {layoutNextRichInlineLineRange, materializeRichInlineLineRange} from '../agent/vendor/pretext/rich-inline.js';
 import {validLayout} from '../spec/md-layout.mjs';
 import {linePlan} from './line-plan.mjs';
+import {captureFontAuthority, createPreparationScope, fontReady, invalidateRichMetrics, paragraphItems,
+  prepareRichParagraph, supportsRichStyle} from './preparation.mjs';
+export {captureFontAuthority, createPreparationScope, invalidateRichMetrics, prepareRichParagraph, supportsRichStyle};
 
 const finite = value => typeof value === 'number' && Number.isFinite(value);
 const space = code => code === 32 || code === 9 || code === 10 || code === 13 || code === 12;
-let graphemeSegmenter;
-
-function normalize(raw) {
-  let start = 0, end = raw.length;
-  while (start < end && space(raw.charCodeAt(start))) start++;
-  while (end > start && space(raw.charCodeAt(end - 1))) end--;
+// Upstream materialization supplies ORIGINAL item UTF-16 offsets. The only local work is
+// mapping the observed displayed text through whitespace/soft-hyphen spelling in that exact
+// interval. Cursors and engine grapheme/segment tables remain opaque. A normalization the
+// mapper cannot reproduce retains the native paragraph, never an approximate source address.
+export function mapFragment(run, fragment, {whiteSpace = 'normal'} = {}) {
+  const raw = typeof run === 'string' ? run : run?.raw;
+  if (run?.break === 'never') whiteSpace = 'normal';
+  const start = fragment?.sourceStart, end = fragment?.sourceEnd;
+  if (typeof raw !== 'string' || typeof fragment?.text !== 'string' ||
+      !Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start || end > raw.length ||
+      whiteSpace !== 'normal' && whiteSpace !== 'pre-wrap') return null;
   const pieces = [], offsets = [start];
-  for (let cursor = start; cursor < end;) {
-    if (space(raw.charCodeAt(cursor))) {
-      while (cursor < end && space(raw.charCodeAt(cursor))) cursor++;
-      pieces.push(' ');
-      offsets.push(cursor);
+  let lastSoftHyphen = -1;
+  for (let at = start; at < end;) {
+    const code = raw.charCodeAt(at);
+    if (code === 0xad) {
+      lastSoftHyphen = at;
+      offsets[offsets.length - 1] = ++at;
+    } else if (whiteSpace === 'normal' && space(code)) {
+      do { at++; } while (at < end && space(raw.charCodeAt(at)));
+      pieces.push(' '); offsets.push(at);
+    } else if (whiteSpace === 'pre-wrap' && (code === 10 || code === 13 || code === 12)) {
+      at += code === 13 && raw.charCodeAt(at + 1) === 10 && at + 1 < end ? 2 : 1;
+      offsets[offsets.length - 1] = at;
     } else {
-      const from = cursor;
-      while (cursor < end && !space(raw.charCodeAt(cursor))) offsets.push(++cursor);
-      pieces.push(raw.slice(from, cursor));
+      pieces.push(raw[at]); offsets.push(++at);
     }
   }
-  return {text: pieces.join(''), offsets, trimStart: start, trimEnd: end};
-}
-
-export function prepareRun(raw, font, letterSpacing = 0, measured = null) {
-  if (typeof raw !== 'string' || typeof font !== 'string' || !font.trim() || !finite(letterSpacing)) return null;
-  const normalized = normalize(raw);
-  // A paragraph's rich-inline plan has already measured this run. Map those same segments to source
-  // instead of measuring and segmenting it again; standalone callers still prepare their own run.
-  const prepared = measured || prepareWithSegments(normalized.text, font, {letterSpacing});
-  if (!Array.isArray(prepared.segments) || prepared.segments.join('') !== normalized.text) return null;
-  const segmentOffsets = [0];
-  for (const segment of prepared.segments) segmentOffsets.push(segmentOffsets.at(-1) + segment.length);
-  return {raw, font, letterSpacing, ...normalized, prepared, segmentOffsets, graphemes: new Map()};
-}
-
-function normalizedOffset(run, cursor) {
-  if (!run?.prepared || !cursor || !Number.isInteger(cursor.segmentIndex) || !Number.isInteger(cursor.graphemeIndex)) return null;
-  const {segmentIndex, graphemeIndex} = cursor;
-  const segments = run.prepared.segments;
-  if (segmentIndex < 0 || segmentIndex > segments.length || graphemeIndex < 0) return null;
-  if (segmentIndex === segments.length) return graphemeIndex === 0 ? run.text.length : null;
-  let offsets = run.graphemes.get(segmentIndex);
-  if (!offsets) {
-    graphemeSegmenter ||= new Intl.Segmenter(undefined, {granularity: 'grapheme'});
-    offsets = [0];
-    for (const part of graphemeSegmenter.segment(segments[segmentIndex])) offsets.push(part.index + part.segment.length);
-    run.graphemes.set(segmentIndex, offsets);
+  let text = pieces.join('');
+  if (lastSoftHyphen === end - 1 && fragment.text === text + '-') {
+    // Only the engine's actual materialized discretionary cut supplies this glyph.
+    offsets[offsets.length - 1] = lastSoftHyphen;
+    offsets.push(end); text += '-';
   }
-  return graphemeIndex < offsets.length ? run.segmentOffsets[segmentIndex] + offsets[graphemeIndex] : null;
-}
-
-export function cursorOffset(run, cursor) {
-  const offset = normalizedOffset(run, cursor);
-  return offset === null ? null : run.offsets[offset];
-}
-
-export function mapFragment(run, fragment) {
-  if (typeof fragment?.text !== 'string') return null;
-  const from = normalizedOffset(run, fragment.start), to = normalizedOffset(run, fragment.end);
-  if (from === null || to === null || to < from) return null;
-  const source = run.text.slice(from, to);
-  const plain = source.replaceAll('\u00ad', '');
-  const hyphen = fragment.text === plain + '-' && source.endsWith('\u00ad') &&
-    fragment.end.graphemeIndex === 0 && fragment.end.segmentIndex < run.prepared.segments.length;
-  if (fragment.text !== plain && !hyphen) return null;
-  const offsets = [run.offsets[from]];
-  for (let index = from; index < to; index++) {
-    if (run.text.charCodeAt(index) === 0xad) {
-      if (hyphen && index === to - 1) {
-        offsets.push(run.offsets[index + 1]);
-      } else offsets[offsets.length - 1] = run.offsets[index + 1];
-    } else {
-      offsets.push(run.offsets[index + 1]);
-    }
-  }
-  return {text: fragment.text, offsets, start: run.offsets[from], end: run.offsets[to]};
+  return text === fragment.text ? {text, offsets, start, end} : null;
 }
 
 // The line a picture is measured in (`lines`, spec/md-layout.mjs): the anchor's line box, its type's cap height, and where that
 // cap height stands in the first line box (the half-leading model: the baseline sits half the leading below the box's top plus
 // the ascent). Read from the font as the page lays it out, so a text size or a line spacing moves the picture with the words.
-export function createLineMeasurer() {
-  const fontMetrics = new Map(), measurers = new WeakMap();
+export function createLineMeasurer(authority = null) {
+  const measurers = new WeakMap();
   const finite = value => typeof value === 'number' && Number.isFinite(value);
   return function lineMetrics(element) {
     const view = element?.ownerDocument?.defaultView;
     if (!view) return null;
     const computed = view.getComputedStyle(element), size = parseFloat(computed.fontSize) || 16;
     const font = computed.fontStyle + ' ' + computed.fontWeight + ' ' + size + 'px ' + computed.fontFamily;
-    let metrics = fontMetrics.get(font);
+    const document = element.ownerDocument, epoch = authority?.captureFontAuthority(document);
+    // The factory is also serialized on its own by the offline typography script. Without
+    // an injected authority it stores only the canvas, and measures afresh in its loaded font.
+    if (authority) { if (!authority.fontReady(document, font, 'H')) return null; }
+    else {
+      try {
+        if (!document.fonts || document.fonts.status === 'loading' || document.fonts.check(font, 'H') !== true ||
+            [...document.fonts].some(face => face.status === 'error')) return null;
+      } catch (_) { return null; }
+    }
+    let state = measurers.get(document);
+    if (!state || state.epoch !== epoch) {
+      state = {epoch, context: state?.context || document.createElement('canvas').getContext('2d'), metrics: authority ? new Map() : null};
+      measurers.set(document, state);
+    }
+    let metrics = state.metrics?.get(font);
     if (!metrics) {
-      let context = measurers.get(element.ownerDocument);
-      if (!context) measurers.set(element.ownerDocument, context = element.ownerDocument.createElement('canvas').getContext('2d'));
+      const context = state.context;
       if (!context) return null;
       context.font = font;
       const capital = context.measureText('H');
       metrics = {ascent: capital.fontBoundingBoxAscent, descent: capital.fontBoundingBoxDescent, cap: capital.actualBoundingBoxAscent};
       if (![metrics.ascent, metrics.descent, metrics.cap].every(finite) || !(metrics.cap > 0)) return null;
-      // A face still loading measures as its fallback: keep the answer only once the face is in.
-      if (element.ownerDocument.fonts?.check?.(font) !== false && element.ownerDocument.fonts?.status !== 'loading') fontMetrics.set(font, metrics);
+      // Only bounded metrics of this document's currently loaded faces are retained.
+      if (state.metrics) {
+        if (state.metrics.size === 64) state.metrics.delete(state.metrics.keys().next().value);
+        state.metrics.set(font, metrics);
+      }
     }
     const line = parseFloat(computed.lineHeight) || metrics.ascent + metrics.descent;
     return {line, cap: metrics.cap, capTop: (line - metrics.ascent - metrics.descent) / 2 + metrics.ascent - metrics.cap};
   };
 }
 
-export const lineMetrics = createLineMeasurer();
+export const lineMetrics = createLineMeasurer({captureFontAuthority, fontReady});
 
 // `lines` tall: from the first line's cap height to the Nth line's baseline, N - 1 lines and one cap.
 export function linesHeight(lines, metrics) {
@@ -384,11 +364,12 @@ export function slotsForBand(width, obstacles, top, height, minWidth = 40) {
 // layout. Otherwise its lines flow around the outline. A short heading can fit beside the outline in a slot narrower
 // than minWidth, so start-aligned, unbalanced words need the same contact check.
 export function flowLines(flow, width, top, obstacles, lineHeight, minWidth, direction = 'ltr', balance = 0, align = 'start') {
-  const plan = linePlan(flow, width, top, obstacles, lineHeight, minWidth, direction, balance, slotsForBand, layoutNextRichInlineLineRange, materializeRichInlineLineRange);
+  const items = paragraphItems(flow);
+  const plan = linePlan(flow, width, top, obstacles, lineHeight, minWidth, direction, balance, slotsForBand, layoutNextRichInlineLineRange, materializeRichInlineLineRange, items);
   const side = align === 'center' ? 'center' : align === 'left' || align === 'right' ? align
     : (align === 'end') === (direction === 'rtl') ? 'left' : 'right';
   if (!plan || !obstacles?.length) return plan;
-  const free = linePlan(flow, width, top, [], lineHeight, minWidth, direction, balance, slotsForBand, layoutNextRichInlineLineRange, materializeRichInlineLineRange);
+  const free = linePlan(flow, width, top, [], lineHeight, minWidth, direction, balance, slotsForBand, layoutNextRichInlineLineRange, materializeRichInlineLineRange, items);
   if (!free) return plan;
   const meets = free.lines.some(line => {
     const words = line.fragments.reduce((sum, fragment) => sum + (fragment.gapBefore || 0) + (fragment.occupiedWidth || 0), 0);