rapier-markdown-kit 1.2.7 → 1.2.9

package/dist/kit/will.d.mts

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+// Will/1: permissions a Markdown document gives agents, as HTML comments on their own lines.
+//   <!-- will/1 keep -->  ...  <!-- /will -->     keep: no change; append: add after the region's text only; edit: any change
+export type WillLaw = 'keep' | 'append' | 'edit';
+export type WillFault = 'malformed_marker' | 'unpaired_marker';
+/** A paired region; `start` to `end` is its text between the marker lines (UTF-16 offsets). */
+export interface WillRegion {
+  index: number; law: WillLaw; intent: string | null;
+  openerLine: number; openerStart: number; openerEnd: number; openerContentEnd: number;
+  closerLine: number; closerStart: number; closerEnd: number;
+  start: number; end: number;
+}
+export interface WillMarker { kind: 'open' | 'close' | 'near'; law: WillLaw | ''; intent: string | null; content: string; fault?: WillFault; line?: number; start?: number; end?: number; contentEnd?: number; }
+export interface Will {
+  /** True when the text has any marker line. */
+  present: boolean;
+  /** The first fault, or ''. A document with a fault is all keep. */
+  fault: WillFault | '';
+  faults: {mode: WillFault; line: number; start: number; end: number}[];
+  /** Every marker line, as [start, end) with its terminator. */
+  blocks: {start: number; end: number}[];
+  markers: WillMarker[];
+  regions: WillRegion[];
+  text: string;
+}
+/** A quick test for any marker line. */
+export function hasWillMarkers(text: string): boolean;
+export function parseWill(text: string): Will;
+/** The law over [start, end): 'keep' when a fault, a marker or a keep region is touched; 'append' inside an append region; else 'edit'. */
+export function willGovern(will: Will, start: number, end: number): WillLaw;
+/** The regions [start, end) touches (an empty range: the regions it stands in). */
+export function willRegionsIn(will: Will, start: number, end: number): WillRegion[];
+/** The region or marker line [start, end) touches, or null. */
+export function willTouchesMarker(will: Will, start: number, end: number): WillRegion | {law: 'keep'} | null;
+/** The intent words of the one region wholly containing [start, end), or ''. */
+export function willIntentOf(will: Will, start: number, end: number): string;
+/** Reads one line as a marker, or null. */
+export function willMarkerOf(line: string): WillMarker | null;
+/** The width of a line terminator ending at `last` (char code), with `prior` before it: 0, 1 or 2. */
+export function terminatorWidth(last: number, prior: number): number;
+/** The text without one trailing line terminator. */
+export function stripOneTerminator(text: string): string;

package/dist/layout/hyphenation.mjs

@@ -1,9 +1,6 @@
 // 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 [];
@@ -25,13 +22,6 @@ function englishCuts(word) {
   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;
@@ -40,14 +30,10 @@ export function paragraphHyphens(words, text, items, offsets, language, document
   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) {
@@ -69,8 +55,6 @@ export function paragraphHyphens(words, text, items, offsets, language, document
     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;
@@ -81,8 +65,6 @@ export function paragraphHyphens(words, text, items, offsets, language, document
     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;
@@ -91,8 +73,6 @@ export function paragraphHyphens(words, text, items, offsets, language, document
   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;
   }
@@ -105,8 +85,6 @@ export function paragraphHyphens(words, text, items, offsets, language, document
         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);
@@ -117,7 +95,6 @@ export function paragraphHyphens(words, text, items, offsets, language, document
         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;
     }

package/dist/layout/line-plan.mjs

@@ -4,8 +4,6 @@ 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);
 
-// 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' &&
@@ -27,12 +25,6 @@ function beforeChip(flow, range, line, cursor, items, next, materialize) {
   return null;
 }
 
-// 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;
@@ -63,8 +55,6 @@ function laterWholeWord(flow, cursor, line, items, bands, slot, next, materializ
   return false;
 }
 
-// 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;
@@ -104,8 +94,6 @@ export function linePlan(flow, width, top, obstacles, lineHeight, minWidth, dire
   return null;
 }
 
-// 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};
@@ -119,11 +107,6 @@ function measuredPlan(flow, width, lineHeight, fontSize, next, materialize) {
   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.
-// Otherwise the narrowest width that keeps the count, bisected to a pixel up from 0.8 of the mean line, laid greedy.
 function balanced(flow, width, fontSize, lines, greedy, lineHeight, layoutNextRichInlineLineRange, materializeRichInlineLineRange) {
   const count = greedy.length;
   if (count < 2 || count > 6 || lines.some((line, index) => line.x !== 0 || line.width !== width || line.y !== index * lineHeight) ||
@@ -137,7 +120,6 @@ function balanced(flow, width, fontSize, lines, greedy, lineHeight, layoutNextRi
     const last = range.fragments.at(-1), item = flow.items[last.itemIndex];
     return last.end.graphemeIndex === 0 && item?.prepared.kinds[last.end.segmentIndex - 1] === 'soft-hyphen';
   };
-  // Every break a line from `from` can end at inside the column, farthest first: each narrower try yields the break before.
   const reach = from => {
     const found = [];
     for (let limit = width, previous = Infinity; found.length < 4096;) {
@@ -195,8 +177,6 @@ function balanced(flow, width, fontSize, lines, greedy, lineHeight, layoutNextRi
   return solved?.length === count ? place(solved) : lines;
 }
 
-// Draw supplies its SVG advances. Every door uses the same line plan without a canvas;
-// the tokens retain the source offsets and keep words and Unicode clusters intact.
 export function measuredLines(tokens, width, lineHeight, fontSize) {
   if (!tokens.length) return [];
   const prepared = {kinds: tokens.map(token => token.space ? 'space' : 'text')}, flow = {items: [{prepared}]};

package/dist/layout/model.mjs

@@ -8,10 +8,6 @@ export {captureFontAuthority, createPreparationScope, invalidateRichMetrics, pre
 
 const finite = value => typeof value === 'number' && Number.isFinite(value);
 const space = code => code === 32 || code === 9 || code === 10 || code === 13 || code === 12;
-// 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';
@@ -38,16 +34,12 @@ export function mapFragment(run, fragment, {whiteSpace = 'normal'} = {}) {
   }
   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 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(authority = null) {
   const measurers = new WeakMap();
   const finite = value => typeof value === 'number' && Number.isFinite(value);
@@ -57,8 +49,6 @@ export function createLineMeasurer(authority = null) {
     const computed = view.getComputedStyle(element), size = parseFloat(computed.fontSize) || 16;
     const font = computed.fontStyle + ' ' + computed.fontWeight + ' ' + size + 'px ' + computed.fontFamily;
     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 {
@@ -79,7 +69,6 @@ export function createLineMeasurer(authority = null) {
       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;
-      // 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);
@@ -92,7 +81,6 @@ export function createLineMeasurer(authority = null) {
 
 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) {
   const finite = value => typeof value === 'number' && Number.isFinite(value);
   const height = Number.isInteger(lines) && lines > 0 && metrics && finite(metrics.line) && finite(metrics.cap)
@@ -100,15 +88,12 @@ export function linesHeight(lines, metrics) {
   return height > 0 ? height : null;
 }
 
-// A picture sized in lines keeps its standoff off the line after its last: below its foot (the Nth baseline) the gap stops
-// at that line's bottom, so exactly N lines stand beside it.
 export function linesSlices(slices, layout, metrics, y, height) {
   if (layout?.lines == null || !metrics || !(slices?.length)) return slices;
   const floor = y + height + Math.max(0, metrics.line - metrics.capTop - metrics.cap) - .5;
   return slices.filter(slice => slice.y < floor).map(slice => slice.y + slice.height > floor ? {...slice, height: floor - slice.y} : slice);
 }
 
-// Where a picture's top stands in its anchor before `y`: a picture sized in lines stands on the first line's cap height.
 export const linesTop = (layout, metrics) => layout?.lines != null && finite(metrics?.capTop) ? metrics.capTop : 0;
 
 export function imageBox(columnWidth, naturalWidth, naturalHeight, layout = {}, defaultWidth = naturalWidth, metrics = null) {
@@ -123,7 +108,6 @@ export function imageBox(columnWidth, naturalWidth, naturalHeight, layout = {},
   return finite(height) && height > 0 ? {x, width, height} : null;
 }
 
-// Fit-then-clamp: scale until the turned AABB fits the column, then clamp its x. One result for live editor, styled export and Share.
 export function rasterReserved(columnWidth, unrotated, rad) {
   if (!unrotated || ![columnWidth, unrotated.x, unrotated.width, unrotated.height].every(value => finite(value) && value >= 0) ||
       columnWidth <= 0 || unrotated.width <= 0 || unrotated.height <= 0) return null;
@@ -143,14 +127,8 @@ export function rasterReserved(columnWidth, unrotated, rad) {
 
 
 const shapeGrid = 48, alphaThreshold = .1, alphaOversample = 4, profileBands = new WeakMap();
-// Slices are cut at up to this many bands: a picture shown 6 px a band or finer keeps every row the profile holds.
 const sliceGridMax = shapeGrid * alphaOversample, slicePixelsPerBand = 6;
 
-// The picture's silhouette as 192 bands of horizontal runs, read from its alpha at that resolution both ways: a band holds the
-// ink of one sampled row, and a run's ends fall on a 192nd of the picture's width, so the standoff a slice adds (`pictureSlices`'
-// `gap`) is the least distance from the words to the paint however large the picture is drawn. At 48 rows and columns a run's
-// end drifted by a 48th of the width (9 px at 430), a thin stroke fell between two samples, and a tall picture's bands were
-// 20 px high. The descriptor an exported page carries (`serializeProfile`) still writes 48 bands.
 export function alphaProfile(image) {
   const src = image.currentSrc || image.getAttribute('src') || '';
   if (!image.complete || !image.naturalWidth || !image.naturalHeight || !src || /^data:image\/jpe?g[;,]/i.test(src)) return null;
@@ -185,7 +163,6 @@ export function alphaProfile(image) {
     spanAt(t) { const runs = runsAt(t); return runs.length ? [runs[0][0], runs.at(-1)[1]] : null; }};
 }
 
-// Scanline intersection over a normalized polygon; the one implementation for live and export wrap=box.
 export function polygonProfile(corners) {
   return {spanAt(t) {
     const xs = [];
@@ -200,15 +177,12 @@ export function polygonProfile(corners) {
   }};
 }
 
-// w'=w|cos|+h|sin|, h'=w|sin|+h|cos| (markdown-standard.md). Shared by browser.js, interchange.js and share.js.
 export function rotatedBoundsRad(width, height, rad) {
   if (!rad) return {width, height};
   return {width: width * Math.abs(Math.cos(rad)) + height * Math.abs(Math.sin(rad)),
     height: width * Math.abs(Math.sin(rad)) + height * Math.abs(Math.cos(rad))};
 }
 
-// The `wrap=box` obstacle for a turned raster: its own untilted rectangle's four corners, rotated
-// `rad` about its centre, normalized into the turned bounding box's own [0,1] space.
 export function rasterTiltProfile(width, height, rad) {
   const cs = Math.cos(rad), sn = Math.sin(rad), rotated = rotatedBoundsRad(width, height, rad);
   const local = [[-width / 2, -height / 2], [width / 2, -height / 2], [width / 2, height / 2], [-width / 2, height / 2]];
@@ -216,7 +190,6 @@ export function rasterTiltProfile(width, height, rad) {
     (rotated.height / 2 + lx * sn + ly * cs) / rotated.height]));
 }
 
-// Each 48x48 cell of the turned box is unrotated into the raster's own pixels and sampled.
 export function rotatedRasterAlpha(baseAlpha, width, height, rad) {
   if (!baseAlpha) return null;
   if (!rad) return baseAlpha;
@@ -241,7 +214,6 @@ export function rotatedRasterAlpha(baseAlpha, width, height, rad) {
   return bandsProfile(bands);
 }
 
-// One occupancy descriptor: the editor's profile sampled at 48 band centres, shipped as data-rapier-occupancy, read back here.
 export function bandsProfile(bands) {
   if (!Array.isArray(bands) || !bands.length) return null;
   const at = t => bands[Math.max(0, Math.min(bands.length - 1, Math.floor(t * bands.length)))] || [];
@@ -258,7 +230,6 @@ export function serializeProfile(profile, count = shapeGrid) {
     const clean = (runs || []).map(([a, b]) => [Math.max(0, Math.min(1, +a)), Math.max(0, Math.min(1, +b))]).filter(([a, b]) => Number.isFinite(a) && Number.isFinite(b) && b > a);
     bands.push(clean.map(([a, b]) => {
       let left = Math.round(a * 1e4), right = Math.round(b * 1e4);
-      // A narrow occupied run must not round to an invalid zero-width descriptor.
       if (left === right) { left = Math.floor(a * 1e4); right = Math.ceil(b * 1e4); }
       return (left / 1e4) + '-' + (right / 1e4);
     }).join(','));
@@ -273,14 +244,8 @@ export function parseProfile(text) {
   return bandsProfile(bands);
 }
 
-// The standoff is round: a band's own rows are pushed out by the whole gap, and the rows above and below it, out to a gap away,
-// by what a circle of that radius allows at their distance, in three steps. A square standoff stood up to 14 px off a slanted
-// stroke and 10 off a level one; this stands 10 off both, within a step.
 const shoulderSteps = 3, shoulders = Array.from({length: shoulderSteps}, (_, k) => ({from: k / shoulderSteps, to: (k + 1) / shoulderSteps, reach: Math.sqrt(1 - ((k + .5) / shoulderSteps) ** 2)}));
 
-// The reference scale at an element (docs/markdown-standard.md, "The reference scale"): its unit, `--md-unit` (a registered
-// length, 16 px at M), over 16. Every length the planner adds of its own (the standoff, a band's height, the room between two
-// pictures) is that many reference pixels times it, so a zoom moves no word against a picture.
 export function frameScale(element) {
   const view = element?.ownerDocument?.defaultView;
   const unit = view ? parseFloat(view.getComputedStyle(element).getPropertyValue('--md-unit')) : NaN;
@@ -290,7 +255,6 @@ export function frameScale(element) {
 export function pictureSlices(profile, x, y, width, height, scale = 1) {
   const gap = 10 * scale;
   if (!profile) return [{x: x - gap, y: y - gap, width: width + gap * 2, height: height + gap * 2}];
-  // A band is at most 6 reference px high at the shown size, never coarser than the descriptor's 48 nor finer than the profile's 192.
   const count = Math.max(shapeGrid, Math.min(sliceGridMax, Math.ceil((finite(height) && height > 0 ? height : 0) / (slicePixelsPerBand * scale))));
   let byCount = profileBands.get(profile);
   if (!byCount) profileBands.set(profile, byCount = new Map());
@@ -300,14 +264,12 @@ export function pictureSlices(profile, x, y, width, height, scale = 1) {
     let previous = new Map();
     for (let index = 0; index < count; index++) {
       const top = index / count, bottom = (index + 1) / count;
-      // Sampled just inside the bottom edge: on the edge itself a band profile answers with the next band's row and the slice runs a row long.
       const runs = [top, (top + bottom) / 2, bottom - 1e-9].flatMap(t => {
         if (profile.runsAt) return profile.runsAt(t) || [];
         const span = profile.spanAt(t);
         return span ? [span] : [];
       }).filter(run => Number.isFinite(run[0]) && Number.isFinite(run[1]) && run[1] > run[0])
         .sort((a, b) => a[0] - b[0]);
-      // Preserve transparent holes and gaps; only overlapping runs share an obstacle.
       const merged = [];
       for (const run of runs) {
         const tail = merged.at(-1);
@@ -361,10 +323,6 @@ export function slotsForBand(width, obstacles, top, height, minWidth = 40) {
   return slots;
 }
 
-// A picture moves a block's words only where its outline (with its standoff) meets them. The block is laid as it lies with no
-// picture beside it, balanced and aligned in the whole column; when no line of words there meets an obstacle, that is its
-// 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 items = paragraphItems(flow);
   const plan = linePlan(flow, width, top, obstacles, lineHeight, minWidth, direction, balance, slotsForBand, layoutNextRichInlineLineRange, materializeRichInlineLineRange, items);
@@ -383,8 +341,6 @@ export function flowLines(flow, width, top, obstacles, lineHeight, minWidth, dir
   return meets ? plan : free;
 }
 
-// ---- The one wrap shape (live: globalThis.RapierImageLayout; export: modules["layout/model.mjs"]) ----
-// `obstacles` in the paragraph's coordinates. Null when nothing to flow around or too narrow for a float.
 export function wrapShape(side, obstacles, width, top) {
 	const clamp = (value, low, high) => Math.min(high, Math.max(low, value));
 	const rows = obstacles.filter(obstacle => (obstacle.x > width - (obstacle.x + obstacle.width) ? 'right' : 'left') === side);
@@ -417,10 +373,6 @@ export function wrapShape(side, obstacles, width, top) {
 	return {boxWidth, boxHeight, startY, points};
 }
 
-// ---- What a block draws at its edge moves with its words (live and export alike) ----
-// A bordered box (a disclosure) cannot follow an outline line by line: it stands clear of it. `obstacles` in the box's
-// border-box coordinates, its band [top, top + height]: the insets that end the box where the outline begins on each
-// side, `fits` false when they leave less than `floor`; null when the outline does not meet the box.
 export function boxClearance(obstacles, width, top, height, floor) {
 	let left = 0, right = 0;
 	for (const row of obstacles) {
@@ -431,14 +383,12 @@ export function boxClearance(obstacles, width, top, height, floor) {
 	return left || right ? {left, right, fits: width - left - right >= floor} : null;
 }
 
-// Where an element's content begins at the inline start (a right edge counts negative in a right-to-left block).
 function contentStart(element) {
 	const style = element.ownerDocument.defaultView.getComputedStyle(element), box = element.getBoundingClientRect();
 	return style.direction === 'rtl' ? -(box.right - (parseFloat(style.paddingRight) || 0) - (parseFloat(style.borderRightWidth) || 0))
 		: box.left + (parseFloat(style.paddingLeft) || 0) + (parseFloat(style.borderLeftWidth) || 0);
 }
 
-// The lines of words in `root` (text outside `skip`), each with its block, where it starts and where its block's content starts.
 export function edgeLines(root, skip = () => false) {
 	const doc = root.ownerDocument, view = doc.defaultView, lines = [], starts = new Map();
 	const walker = doc.createTreeWalker(root, 4);
@@ -460,9 +410,6 @@ export function edgeLines(root, skip = () => false) {
 	return lines;
 }
 
-// After a picture's floats settle: how far each line moved from where its block's lines began without them (`before`,
-// edgeLines read first). A list item's marker moves as far as its first line; a quote's bar moves to stand beside its
-// moved lines as it stood beside them before, in runs of one shift from the quote's top to its bottom.
 export function edgeMarks(root, before, skip = () => false) {
 	const view = root.ownerDocument.defaultView, home = new Map();
 	const byBlock = rows => {
@@ -488,7 +435,6 @@ export function edgeMarks(root, before, skip = () => false) {
 		const shift = shiftOf(item);
 		if (shift > .5) markers.push({item, shift});
 	}
-	// A numbered item's dotted line runs to the next circle: where the two circles moved apart it is not drawn (`steps`).
 	const steps = [];
 	for (const list of within('ol')) {
 		const items = [...list.children].filter(child => child.tagName === 'LI');
@@ -517,7 +463,6 @@ export function edgeMarks(root, before, skip = () => false) {
 	return {markers, bars, steps};
 }
 
-// ---- The one "paragraph holds only the picture": one meaningful child, the image or an <a> wrapping only it ----
 export function imageOnly(paragraph, image) {
 	const meaningful = node => [...node.childNodes].filter(child => child.nodeType !== 8 &&
 		!(child.nodeType === 3 && !child.textContent.trim()));

package/dist/layout/paragraph-fit.mjs

@@ -1,10 +1,4 @@
 // SPDX-License-Identifier: MIT
-// Original paragraph-wide optimization over immutable Pretext geometry. Four spacing
-// classes and the discretionary run length are the actual transition policy, not
-// buckets approximating a continuous history. The numerical solver requests exact
-// missing edges; the preparation scope observes them before declaring a plan current.
-// Normal spaces retain 60–180% of their natural advance. At most two consecutive
-// discretionary endings are allowed, and the final line starts whole.
 export function createParagraphFitter() {
   const indexes = new WeakMap();
   function prepare(input) {
@@ -15,7 +9,6 @@ export function createParagraphFitter() {
       segment.words.forEach((word, index) => {
         prefix.push(prefix.at(-1) + word.width + (word.gap?.width || 0));
         gaps.push(gaps.at(-1) + (word.gap?.width || 0));
-        // Conservative bound for interior whole words; no substring-width subtraction.
         minimum.push(minimum.at(-1) + Math.max(0, word.width - word.endTrim) + Math.max(0, (word.gap?.width || 0) * .6));
         word.breaks.forEach((cut, cutIndex) => points.push({word: index, cut, cutIndex, end: cut.offset, next: cut.offset, kind: cut.kind}));
         points.push({word: index + 1, cut: null, cutIndex: -1, end: word.end, next: word.gap?.end ?? word.end,
@@ -24,22 +17,23 @@ export function createParagraphFitter() {
       if (segment.words.length) points[0].end = points[0].next = segment.words[0].start;
       return {...segment, prefix, gaps, minimum, points};
     });
-    // Numeric indexes are private and never written after this point. Their opaque
-    // handle keeps hot numeric arrays out of public custody without freezing them
-    // into a different element representation on each engine.
     const handle = Object.freeze({});
     indexes.set(handle, {text: input.text, segments});
     return handle;
   }
 
-  function* solveSteps(handle, width, {indent = 0, left = 0, right = 0} = {}, known) {
+  function* solveSteps(handle, width, {indent = 0, left = 0, right = 0, widths = null} = {}, known) {
     const prepared = indexes.get(handle);
     if (!prepared || ![width, indent, left, right].every(Number.isFinite) || width <= 0) return null;
+    const measures = Array.isArray(widths) && widths.every(value => Number.isFinite(value) && value > 0) ? widths : [];
+    const measure = line => line < measures.length ? measures[line] : width;
+    const widest = Math.max(width, ...measures);
     const lines = []; let work = 0, visited = 0, totalCost = 0;
     for (let segmentIndex = 0; segmentIndex < prepared.segments.length; segmentIndex++) {
       const {words, points, prefix, gaps, minimum} = prepared.segments[segmentIndex];
       if (!words.length) continue;
-      const ceiling = width + Math.max(0, left) + Math.max(0, right) + Math.max(0, -indent);
+      const base = lines.length, classes = Math.max(1, measures.length - base + 1);
+      const ceiling = widest + Math.max(0, left) + Math.max(0, right) + Math.max(0, -indent);
       const lastIndex = points.length - 1;
       let smallest = Infinity;
       for (let index = 0; index < words.length - 1; index++) smallest = Math.min(smallest, words[index].gap?.width || 0);
@@ -48,14 +42,11 @@ export function createParagraphFitter() {
       natural += words[0].startExtra;
       const opening = Math.min(Math.max(0, left), words[0].opening);
       const closing = Math.min(Math.max(0, right), words.at(-1).closing);
-      const target = width - (segmentIndex === 0 ? indent : 0) + opening + closing;
+      const target = measure(base) - (segmentIndex === 0 ? indent : 0) + opening + closing;
       const count = words.length - 1;
       const delta = !count ? 0 : Math.max(-smallest * .4, Math.min(0, (target - natural) / count));
       const overflow = natural + delta * count - target;
       const cost = 1 + 100 * Math.max(0, overflow / target) ** 2;
-      // Every edge costs at least one and every transition penalty is nonnegative.
-      // This is the original start-to-final arithmetic, so a valid single edge below
-      // two is the exact global optimum. Keep legal cuts for the overflow exception.
       if (Number.isFinite(natural) && target > 0 && cost < 2 && minimum[words.length - 1] - minimum[Math.min(words.length - 1, 1)] <= ceiling + .02 &&
           !(overflow > .02 && (count || words.at(-1).breaks.length))) {
         lines.push({start: points[0].next, end: points[lastIndex].end, next: points[lastIndex].next, kind: 'end', glyph: '',
@@ -63,16 +54,11 @@ export function createParagraphFitter() {
         totalCost += cost; work++; continue;
       }
 
-      // A point's predecessors are final before that point is visited. Store its
-      // winning cost and backpointer directly; later points cannot observe an old
-      // replaced state. Build source line records only for the final chosen path.
-      const costs = new Float64Array(points.length * 12);
+      const stride = classes * 12;
+      const costs = new Float64Array(points.length * stride);
       const previous = new Float64Array(costs.length), spacing = new Float64Array(costs.length);
-      const prefixes = [], suffixes = [], reachable = new Uint16Array(points.length);
+      const prefixes = [], suffixes = [], reachable = new Uint16Array(points.length * classes);
       reachable[0] = 1 << 3;
-      // The final line rejects a discretionary start. In its last word, automatic
-      // points cannot lead to any later cut either. Authored soft points need a later
-      // ordinary cut to reset that state. Retain breaks.length for overflow policy.
       let lastPlain = lastIndex - 1;
       while (lastPlain > 0 && (points[lastPlain].kind === 'soft' || points[lastPlain].kind === 'auto')) lastPlain--;
       for (let endIndex = 1; endIndex < points.length; endIndex++) {
@@ -88,9 +74,9 @@ export function createParagraphFitter() {
           while (minWord > start.word) smallest = Math.min(smallest, words[--minWord].gap?.width || 0);
           if (final && (start.kind === 'soft' || start.kind === 'auto')) continue;
           if (start.cut && end.cut && start.word === end.word && (start.kind === 'auto' || end.kind === 'auto')) continue;
-          // Metric work is useful only if a prior state can actually reach this edge.
-          const available = reachable[startIndex] & (discretionary ? 0x6db : 0xfff);
-          if (!available) continue;
+          let any = 0;
+          for (let lineClass = 0; lineClass < classes; lineClass++) any |= reachable[startIndex * classes + lineClass];
+          if (!(any & (discretionary ? 0x6db : 0xfff))) continue;
           let natural;
           if (start.cut && end.cut && start.word === end.word) {
             natural = yield {segment: segmentIndex, word: start.word, from: start.cutIndex, to: end.cutIndex};
@@ -117,49 +103,53 @@ export function createParagraphFitter() {
           const count = lastWord - start.word, gapWidth = gaps[lastWord] - gaps[start.word];
           const opening = start.cut ? 0 : Math.min(Math.max(0, left), words[start.word].opening);
           const closing = end.cut ? 0 : Math.min(Math.max(0, right), words[lastWord].closing);
-          const target = width - (segmentIndex === 0 && startIndex === 0 ? indent : 0) + opening + closing;
-          if (target <= 0) continue;
-          const remaining = target - natural;
-          const delta = !count ? 0 : Math.max(-smallest * .4, Math.min(final ? 0 : smallest * .8, remaining / count));
-          const overflow = natural + delta * count - target;
-          // A truly unbreakable word/atom can stand alone at its natural width. Never
-          // fabricate an emergency source cut or eject the surrounding paragraph.
-          if (overflow > .02 && (count || start.cut || end.cut || words[lastWord].breaks.length)) continue;
-          const residual = Math.max(0, remaining - delta * count);
-          const ratio = gapWidth > 0 ? delta * count / gapWidth : 0;
-          const fitness = final ? 1 : ratio < -.075 ? 0 : ratio <= .2 ? 1 : ratio <= .5 ? 2 : 3;
-          let local = 1 + 100 * Math.max(0, overflow / target) ** 2;
-          if (final && startIndex) local += 100 * Math.max(0, .45 - natural / target) ** 2 + (count === 0 ? 25 : 0);
-          else if (!final) local += (ratio < 0 ? 100 : 12.5) * ratio ** 2 + 2400 * (residual / target) ** 2;
           const priorDiscretionary = start.kind === 'soft' || start.kind === 'auto';
-          if (discretionary) local += 12 + (priorDiscretionary ? 12 : 0);
           if (final && priorDiscretionary) continue;
-          // The mask visits exactly the occupied slots, in the original ascending
-          // slot order, retaining both the objective and its deterministic ties.
-          for (let active = available; active; active &= active - 1) {
-            const slot = 31 - Math.clz32(active & -active), priorIndex = startIndex * 12 + slot;
-            const hyphens = discretionary ? slot % 3 + 1 : 0;
-            if (hyphens > 2) continue;
-            work++;
-            const cost = costs[priorIndex] + local + (!final && startIndex ? .6 * (fitness - Math.floor(slot / 3)) ** 2 : 0);
-            const stateIndex = fitness * 3 + hyphens;
-            const index = endIndex * 12 + stateIndex;
-            if (reachable[endIndex] & 1 << stateIndex && costs[index] <= cost) continue;
-            costs[index] = cost; previous[index] = priorIndex; spacing[index] = delta;
-            reachable[endIndex] |= 1 << stateIndex;
+          for (let lineClass = 0; lineClass < classes; lineClass++) {
+            const available = reachable[startIndex * classes + lineClass] & (discretionary ? 0x6db : 0xfff);
+            if (!available) continue;
+            const target = measure(base + lineClass) - (segmentIndex === 0 && startIndex === 0 ? indent : 0) + opening + closing;
+            if (target <= 0) continue;
+            const remaining = target - natural;
+            const delta = !count ? 0 : Math.max(-smallest * .4, Math.min(final ? 0 : smallest * .8, remaining / count));
+            const overflow = natural + delta * count - target;
+            if (overflow > .02 && (count || start.cut || end.cut || words[lastWord].breaks.length)) continue;
+            const residual = Math.max(0, remaining - delta * count);
+            const ratio = gapWidth > 0 ? delta * count / gapWidth : 0;
+            const fitness = final ? 1 : ratio < -.075 ? 0 : ratio <= .2 ? 1 : ratio <= .5 ? 2 : 3;
+            let local = 1 + 100 * Math.max(0, overflow / target) ** 2;
+            if (final && startIndex) local += 100 * Math.max(0, .45 - natural / target) ** 2 + (count === 0 ? 25 : 0);
+            else if (!final) local += (ratio < 0 ? 100 : 12.5) * ratio ** 2 + 2400 * (residual / target) ** 2;
+            if (discretionary) local += 12 + (priorDiscretionary ? 12 : 0);
+            const set = !final && count && residual > 0 ? remaining / count : delta;
+            const nextClass = Math.min(lineClass + 1, classes - 1);
+            for (let active = available; active; active &= active - 1) {
+              const slot = 31 - Math.clz32(active & -active), priorIndex = startIndex * stride + lineClass * 12 + slot;
+              const hyphens = discretionary ? slot % 3 + 1 : 0;
+              if (hyphens > 2) continue;
+              work++;
+              const cost = costs[priorIndex] + local + (!final && startIndex ? .6 * (fitness - Math.floor(slot / 3)) ** 2 : 0);
+              const stateIndex = fitness * 3 + hyphens;
+              const index = endIndex * stride + nextClass * 12 + stateIndex;
+              const bit = endIndex * classes + nextClass;
+              if (reachable[bit] & 1 << stateIndex && costs[index] <= cost) continue;
+              costs[index] = cost; previous[index] = priorIndex; spacing[index] = set;
+              reachable[bit] |= 1 << stateIndex;
+            }
           }
         }
       }
       let best = -1;
-      for (let slot = 0; slot < 12; slot++) if (reachable[lastIndex] & 1 << slot) {
-        const index = lastIndex * 12 + slot;
-        if (best < 0 || costs[index] < costs[best]) best = index;
-      }
+      for (let lineClass = 0; lineClass < classes; lineClass++) for (let slot = 0; slot < 12; slot++)
+        if (reachable[lastIndex * classes + lineClass] & 1 << slot) {
+          const index = lastIndex * stride + lineClass * 12 + slot;
+          if (best < 0 || costs[index] < costs[best]) best = index;
+        }
       if (best < 0) return null;
       totalCost += costs[best];
       const chosen = [];
       for (let endIndex = lastIndex; endIndex;) {
-        const priorIndex = previous[best], startIndex = Math.floor(priorIndex / 12);
+        const priorIndex = previous[best], startIndex = Math.floor(priorIndex / stride);
         const start = points[startIndex], end = points[endIndex], lastWord = end.cut ? end.word : end.word - 1;
         chosen.push({start: start.next, end: end.end, next: end.next, kind: end.kind, glyph: end.cut?.glyph || '',
           wordSpacing: spacing[best], opening: start.cut ? 0 : Math.min(Math.max(0, left), words[start.word].opening),