rapier-markdown-kit 1.1.101 → 1.1.104

package/dist/agent/vendor/pretext/layout.js

@@ -1,308 +1,370 @@
-/*! Pretext 0.0.9 | MIT | Copyright (c) 2026 Pretext contributors */
-import { computeSegmentLevels } from './bidi.js';
-import { analyzeText, clearAnalysisCaches, getBreakablePreferredBreaks, getCjkTextUnits, getSharedGraphemeSegmenter, isCJK, isNumericRunSegment, isIndependentSymbolRun, setAnalysisLocale } from './analysis.js';
-import { clearMeasurementCaches, getCorrectedSegmentWidth, getSegmentBreakableFitAdvances, getEngineProfile, getFontMeasurementState, getSegmentMetrics, textMayContainEmoji } from './measurement.js';
-import { countPreparedLines, measurePreparedLineGeometry, normalizePreparedLineStart, stepPreparedLineGeometryFromChunk, walkPreparedLinesRaw } from './line-break.js';
-import { buildLineTextFromRange, clearLineTextCaches, getLineTextCache } from './line-text.js';
-function createEmptyPrepared(includeSegments) {
-    if (includeSegments) {
-        return {
-            widths: [],
-            lineEndFitAdvances: [],
-            lineEndPaintAdvances: [],
-            kinds: [],
-            simpleLineWalkFastPath: true,
-            segLevels: null,
-            breakableFitAdvances: [],
-            breakablePreferredBreaks: [],
-            letterSpacing: 0,
-            spacingGraphemeCounts: [],
-            discretionaryHyphenWidth: 0,
-            tabStopAdvance: 0,
-            chunks: [],
-            segments: []
-        };
-    }
-    return {
-        widths: [],
-        lineEndFitAdvances: [],
-        lineEndPaintAdvances: [],
-        kinds: [],
-        simpleLineWalkFastPath: true,
-        segLevels: null,
-        breakableFitAdvances: [],
-        breakablePreferredBreaks: [],
-        letterSpacing: 0,
-        spacingGraphemeCounts: [],
-        discretionaryHyphenWidth: 0,
-        tabStopAdvance: 0,
-        chunks: []
-    };
+/*! Pretext Unreleased (bac1774c0) | MIT; BSD/Unicode/ICU notices in LICENSE | Copyright (c) 2026 Pretext contributors */
+// Prepare text with engine segmentation rules and cached Canvas measurements, then
+// lay it out with arithmetic. Preparation touches the DOM in three places: the emoji
+// correction's span, read once per font where Canvas measures an emoji wider than its
+// font size; the page's `<html lang>`, unless setLocale() gave a language; and, without
+// OffscreenCanvas, a canvas element never attached. Layout itself does no measurement
+// or string work.
+// Rich APIs add source cursors and text materialization.
+// Browser measurement limitations are documented in README.md and PLATFORM_BUGS.md.
+// Based on Sebastian Markbage's text-layout research (github.com/chenglou/text-layout).
+
+import { clearWordSegmenter } from './line-breaks.js'
+import {
+  analyzeText,
+  KIND_BITS,
+  SEGMENT_KINDS,
+                        
+                      
+                                              
+} from './analysis.js'
+import {
+  clearMeasurementCaches,
+  getEngineProfile,
+  getPreparationLanguage,
+  readLetterSpacing,
+  setLocaleLanguage,
+} from './measurement.js'
+import { measureAnalysis } from './prepare.js'
+import {
+  countPreparedLines,
+  normalizeMaxWidth,
+  normalizePreparedLineStart,
+  stepPreparedLineGeometryFromStart,
+  walkPreparedLinesRaw,
+                             
+} from './line-break.js'
+import { buildLineTextFromRange,                       } from './line-text.js'
+
+// --- Public types ---
+
+                                              
+
+// Keep the compact height-prediction handle opaque so the public API does not accidentally
+// calcify around the current parallel-array representation.
+                            
+                                    
+ 
+
+// The handle that also keeps each segment's text, which the functions that return
+// line text need (layoutWithLines(), layoutNextLine() and materializeLineRange()),
+// and its kind, for the app's own rendering. Its type shows those two and each
+// segment's width, read-only, and none of the line walkers' other storage, which
+// changes with engine fixes (RESEARCH.md, Decisions Log, 2026-10-06).
+                                                       
+                                                                                           
+                                                                                                     
+                                                                                          
+ 
+
+// What the two handles hold: the line walkers' data and, from prepareWithSegments(),
+// the segments' text and kinds. getInternalPrepared() reads a public handle as the
+// first; createLayoutLine() and layoutNextLine(), which pass theirs on to the line
+// text as it came, assert the second in place.
+                                                                
+                                                                                                       
+
+                            
+                                                     
+                                                                                        
+ 
+
+                            
+                                                      
+                                                                        
+ 
+
+                         
+                   
+                      
+ 
+
+                          
+                                                                    
+                                                                                                             
+                                                                              
+                                                                          
+ 
+
+                               
+                                                                                                             
+                                                                              
+                                                                          
+ 
+
+                                                
+                                                                       
+ 
+
+                                                 
+
+                              
+                             
+                           
+                        
+ 
+
+// --- Public API ---
+
+function prepareInternal(
+  text        ,
+  font        ,
+  includeSegments         ,
+  options                 ,
+)                       {
+  const wordBreak = options?.wordBreak ?? 'normal'
+  const engineProfile = getEngineProfile()
+  const letterSpacing = readLetterSpacing(options?.letterSpacing, engineProfile)
+  // One language read: break rules and measurement both follow it.
+  const language = getPreparationLanguage(engineProfile)
+  const analysis = analyzeText(text, engineProfile, options?.whiteSpace, wordBreak, language)
+  return measureAnalysis(analysis, 0, analysis.flags.length, font, includeSegments, letterSpacing, engineProfile, language, true, null)
 }
-function countRenderedSpacingGraphemes(text, kind) {
-    if (kind === 'zero-width-break' || kind === 'soft-hyphen' || kind === 'hard-break') {
-        return 0;
-    }
-    if (kind === 'tab') return 1;
-    let count = 0;
-    const graphemeSegmenter = getSharedGraphemeSegmenter();
-    for (const _ of graphemeSegmenter.segment(text))count++;
-    return count;
+
+// Prepare text for layout. Segments the text, measures each segment via canvas,
+// and stores the widths for fast relayout at any width. Call once per text block
+// (e.g. when a comment first appears). The result is width-independent — the
+// same PreparedText can be laid out at any maxWidth and lineHeight via layout().
+//
+// Steps:
+//   1. Normalize white space as white-space: normal or pre-wrap does
+//   2. Find break opportunities with the engine's own line-break scan
+//   3. Split the text into segments between them ("better." as one unit)
+//   4. Measure each segment via canvas measureText, cache by (segment, font).
+//      A run of combining marks that glue or a control separates from its grapheme
+//      measures after that grapheme, and WebKit measures a word with the space after it
+//   5. Measure where each text segment of two or more graphemes can break under
+//      overflow-wrap: break-word: by graphemes, pairs or prefixes, per engine
+//   6. Correct emoji canvas inflation (probed once per font)
+//   7. Record what changes at a line's edges: Blink's halts of CJK punctuation,
+//      U+3000 hangs, how much narrower a soft hyphen's neighbors measure joined,
+//      fresh-line widths inside segments with invisible characters, and the
+//      characters WebKit keeps after an overflowing first one
+export function prepare(text        , font        , options                 )               {
+  return prepareInternal(text, font, false, options)                
 }
-function addInternalLetterSpacing(width, graphemeCount, letterSpacing) {
-    return graphemeCount > 1 ? width + (graphemeCount - 1) * letterSpacing : width;
+
+// Rich variant used by callers that need enough information to render the
+// laid-out lines themselves.
+export function prepareWithSegments(text        , font        , options                 )                           {
+  const prepared = prepareInternal(text, font, true, options)                                    
+  // Each segment's kind by name, from its flags.
+  const kinds                     = []
+  for (let i = 0; i < prepared.segmentFlags.length; i++) kinds.push(SEGMENT_KINDS[prepared.segmentFlags[i]  & KIND_BITS] )
+  prepared.kinds = kinds
+  return prepared
 }
-function measureAnalysis(analysis, font, includeSegments, wordBreak, letterSpacing) {
-    const engineProfile = getEngineProfile();
-    const { cache, emojiCorrection } = getFontMeasurementState(font, textMayContainEmoji(analysis.normalized));
-    const discretionaryHyphenWidth = getCorrectedSegmentWidth('-', getSegmentMetrics('-', cache), emojiCorrection) + (letterSpacing === 0 ? 0 : letterSpacing * 2);
-    const spaceWidth = getCorrectedSegmentWidth(' ', getSegmentMetrics(' ', cache), emojiCorrection);
-    const tabStopAdvance = spaceWidth * 8;
-    const hasLetterSpacing = letterSpacing !== 0;
-    if (analysis.len === 0) return createEmptyPrepared(includeSegments);
-    const widths = [];
-    const lineEndFitAdvances = [];
-    const lineEndPaintAdvances = [];
-    const kinds = [];
-    let simpleLineWalkFastPath = !hasLetterSpacing;
-    const segStarts = includeSegments ? [] : null;
-    const breakableFitAdvances = [];
-    const breakablePreferredBreaks = [];
-    const spacingGraphemeCounts = [];
-    const segments = includeSegments ? [] : null;
-    const chunks = [];
-    let chunkStartSegmentIndex = 0;
-    function pushMeasuredSegment(text, width, lineEndFitAdvance, lineEndPaintAdvance, kind, start, breakableFitAdvance, breakablePreferredBreak, spacingGraphemeCount) {
-        if (kind !== 'text' && kind !== 'space' && kind !== 'zero-width-break') {
-            simpleLineWalkFastPath = false;
-        }
-        widths.push(width);
-        lineEndFitAdvances.push(lineEndFitAdvance);
-        lineEndPaintAdvances.push(lineEndPaintAdvance);
-        kinds.push(kind);
-        segStarts?.push(start);
-        breakableFitAdvances.push(breakableFitAdvance);
-        breakablePreferredBreaks.push(breakablePreferredBreak);
-        if (hasLetterSpacing) spacingGraphemeCounts.push(spacingGraphemeCount);
-        if (segments !== null) segments.push(text);
-    }
-    function pushMeasuredTextSegment(text, textMetrics, kind, start, allowOverflowBreaks) {
-        const spacingGraphemeCount = hasLetterSpacing ? countRenderedSpacingGraphemes(text, kind) : 0;
-        const width = addInternalLetterSpacing(getCorrectedSegmentWidth(text, textMetrics, emojiCorrection), spacingGraphemeCount, letterSpacing);
-        const baseLineEndFitAdvance = kind === 'space' || kind === 'preserved-space' || kind === 'zero-width-break' ? 0 : width;
-        const lineEndFitAdvance = baseLineEndFitAdvance === 0 ? 0 : baseLineEndFitAdvance + (spacingGraphemeCount > 0 ? letterSpacing : 0);
-        const lineEndPaintAdvance = kind === 'space' || kind === 'zero-width-break' ? 0 : width;
-        if (allowOverflowBreaks && text.length > 1) {
-            let fitMode = 'sum-graphemes';
-            if (letterSpacing !== 0) {
-                fitMode = 'segment-prefixes';
-            } else if (isNumericRunSegment(text)) {
-                fitMode = 'pair-context';
-            } else if (engineProfile.preferPrefixWidthsForBreakableRuns) {
-                fitMode = 'segment-prefixes';
-            }
-            const fitAdvances = getSegmentBreakableFitAdvances(text, textMetrics, cache, emojiCorrection, fitMode);
-            const preferredBreaks = fitAdvances === null || wordBreak === 'keep-all' ? null : getBreakablePreferredBreaks(text);
-            pushMeasuredSegment(text, width, lineEndFitAdvance, lineEndPaintAdvance, kind, start, fitAdvances, preferredBreaks, spacingGraphemeCount);
-            return;
-        }
-        pushMeasuredSegment(text, width, lineEndFitAdvance, lineEndPaintAdvance, kind, start, null, null, spacingGraphemeCount);
-    }
-    for(let mi = 0; mi < analysis.len; mi++){
-        const segText = analysis.texts[mi];
-        const segKind = analysis.kinds[mi];
-        const segStart = analysis.starts[mi];
-        if (segKind === 'soft-hyphen') {
-            pushMeasuredSegment(segText, 0, discretionaryHyphenWidth, discretionaryHyphenWidth, segKind, segStart, null, null, 0);
-            continue;
-        }
-        if (segKind === 'hard-break') {
-            const endSegmentIndex = widths.length;
-            pushMeasuredSegment(segText, 0, 0, 0, segKind, segStart, null, null, 0);
-            chunks.push({
-                startSegmentIndex: chunkStartSegmentIndex,
-                endSegmentIndex,
-                consumedEndSegmentIndex: widths.length
-            });
-            chunkStartSegmentIndex = widths.length;
-            continue;
-        }
-        if (segKind === 'tab') {
-            pushMeasuredSegment(segText, 0, 0, 0, segKind, segStart, null, null, hasLetterSpacing ? countRenderedSpacingGraphemes(segText, segKind) : 0);
-            continue;
-        }
-        if (segKind === 'text' && isCJK(segText)) {
-            const measuredUnits = getCjkTextUnits(segText, engineProfile, wordBreak);
-            for(let i = 0; i < measuredUnits.length; i++){
-                const unit = measuredUnits[i];
-                const unitMetrics = getSegmentMetrics(unit.text, cache);
-                pushMeasuredTextSegment(unit.text, unitMetrics, 'text', segStart + unit.start, unit.overflow === 'grapheme' || analysis.isWordLike[mi] && (wordBreak === 'keep-all' || unit.overflow === 'word-like'));
-            }
-            continue;
-        }
-        pushMeasuredTextSegment(segText, getSegmentMetrics(segText, cache), segKind, segStart, segKind === 'text' && (analysis.isWordLike[mi] || isIndependentSymbolRun(segText)));
-    }
-    if (chunkStartSegmentIndex < widths.length) {
-        chunks.push({
-            startSegmentIndex: chunkStartSegmentIndex,
-            endSegmentIndex: widths.length,
-            consumedEndSegmentIndex: widths.length
-        });
-    }
-    const segLevels = segStarts === null ? null : computeSegmentLevels(analysis.normalized, segStarts);
-    if (segments !== null) {
-        return {
-            widths,
-            lineEndFitAdvances,
-            lineEndPaintAdvances,
-            kinds,
-            simpleLineWalkFastPath,
-            segLevels,
-            breakableFitAdvances,
-            breakablePreferredBreaks,
-            letterSpacing,
-            spacingGraphemeCounts,
-            discretionaryHyphenWidth,
-            tabStopAdvance,
-            chunks,
-            segments
-        };
-    }
-    return {
-        widths,
-        lineEndFitAdvances,
-        lineEndPaintAdvances,
-        kinds,
-        simpleLineWalkFastPath,
-        segLevels,
-        breakableFitAdvances,
-        breakablePreferredBreaks,
-        letterSpacing,
-        spacingGraphemeCounts,
-        discretionaryHyphenWidth,
-        tabStopAdvance,
-        chunks
-    };
+
+function getInternalPrepared(prepared              )                       {
+  return prepared                        
 }
-function prepareInternal(text, font, includeSegments, options) {
-    const wordBreak = options?.wordBreak ?? 'normal';
-    const letterSpacing = options?.letterSpacing ?? 0;
-    const analysis = analyzeText(text, getEngineProfile(), options?.whiteSpace, wordBreak);
-    return measureAnalysis(analysis, font, includeSegments, wordBreak, letterSpacing);
+
+// Layout prepared text at a given max width and caller-provided lineHeight.
+// Pure arithmetic on cached widths — no canvas calls, no DOM reads, no string
+// operations, and no per-line allocations. Call on every resize. Lines break
+// where the engine's page breaks them, under the CSS the README lists
+// (README.md, Caveats).
+export function layout(prepared              , maxWidth        , lineHeight        )               {
+  // The resize hot path counts the same lines as `layoutWithLines()` without
+  // building line ranges or text.
+  const lineCount = countPreparedLines(getInternalPrepared(prepared), normalizeMaxWidth(maxWidth))
+  return { lineCount, height: lineCount * lineHeight }
 }
-export function prepare(text, font, options) {
-    return prepareInternal(text, font, false, options);
+
+// Reported widths are clamped at zero wherever a line is built. A line's
+// advance can be negative: the rest of a word after an emergency break can
+// hold only invisible characters and the word's kerning with a following
+// space, and letter spacing can be strongly negative. Line breaking keeps the
+// signed advance.
+function createLayoutLine(
+  prepared                          ,
+  width        ,
+  startSegmentIndex        ,
+  startGraphemeIndex        ,
+  endSegmentIndex        ,
+  endGraphemeIndex        ,
+)             {
+  return {
+    text: buildLineTextFromRange(
+      prepared                                    ,
+      startSegmentIndex,
+      startGraphemeIndex,
+      endSegmentIndex,
+      endGraphemeIndex,
+    ),
+    width: Math.max(0, width),
+    start: {
+      segmentIndex: startSegmentIndex,
+      graphemeIndex: startGraphemeIndex,
+    },
+    end: {
+      segmentIndex: endSegmentIndex,
+      graphemeIndex: endGraphemeIndex,
+    },
+  }
 }
-export function prepareWithSegments(text, font, options) {
-    return prepareInternal(text, font, true, options);
+
+function createLayoutLineRange(
+  width        ,
+  startSegmentIndex        ,
+  startGraphemeIndex        ,
+  endSegmentIndex        ,
+  endGraphemeIndex        ,
+)                  {
+  return {
+    width: Math.max(0, width),
+    start: {
+      segmentIndex: startSegmentIndex,
+      graphemeIndex: startGraphemeIndex,
+    },
+    end: {
+      segmentIndex: endSegmentIndex,
+      graphemeIndex: endGraphemeIndex,
+    },
+  }
 }
-function getInternalPrepared(prepared) {
-    return prepared;
+
+export function materializeLineRange(
+  prepared                          ,
+  line                 ,
+)             {
+  return createLayoutLine(
+    prepared,
+    line.width,
+    line.start.segmentIndex,
+    line.start.graphemeIndex,
+    line.end.segmentIndex,
+    line.end.graphemeIndex,
+  )
 }
-export function layout(prepared, maxWidth, lineHeight) {
-    const lineCount = countPreparedLines(getInternalPrepared(prepared), maxWidth);
-    return {
-        lineCount,
-        height: lineCount * lineHeight
-    };
-}
-function createLayoutLine(prepared, cache, width, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex) {
-    return {
-        text: buildLineTextFromRange(prepared, cache, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex),
-        width,
-        start: {
-            segmentIndex: startSegmentIndex,
-            graphemeIndex: startGraphemeIndex
-        },
-        end: {
-            segmentIndex: endSegmentIndex,
-            graphemeIndex: endGraphemeIndex
-        }
-    };
-}
-function createLayoutLineRange(width, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex) {
-    return {
+
+// Batch low-level line-range pass. This is the non-materializing counterpart
+// to layoutWithLines(), useful for shrinkwrap and other aggregate stats work.
+// It, measureLineStats(), measureNaturalWidth() and layoutNextLineRange() return
+// widths and cursors and no text, from the line-break data layout() reads, so they
+// take a prepare() handle as well (RESEARCH.md, Decisions Log, 2026-10-06).
+export function walkLineRanges(
+  prepared              ,
+  maxWidth        ,
+  onLine                                 ,
+)         {
+  return walkPreparedLinesRaw(
+    getInternalPrepared(prepared),
+    normalizeMaxWidth(maxWidth),
+    (width, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex) => {
+      onLine(createLayoutLineRange(
         width,
-        start: {
-            segmentIndex: startSegmentIndex,
-            graphemeIndex: startGraphemeIndex
-        },
-        end: {
-            segmentIndex: endSegmentIndex,
-            graphemeIndex: endGraphemeIndex
-        }
-    };
+        startSegmentIndex,
+        startGraphemeIndex,
+        endSegmentIndex,
+        endGraphemeIndex,
+      ))
+    },
+  )
 }
-export function materializeLineRange(prepared, line) {
-    return createLayoutLine(prepared, getLineTextCache(prepared), line.width, line.start.segmentIndex, line.start.graphemeIndex, line.end.segmentIndex, line.end.graphemeIndex);
+
+export function measureLineStats(
+  prepared              ,
+  maxWidth        ,
+)            {
+  const stats = { lineCount: 0, maxLineWidth: 0 }
+  walkPreparedLinesRaw(getInternalPrepared(prepared), normalizeMaxWidth(maxWidth), undefined, stats)
+  return stats
 }
-export function walkLineRanges(prepared, maxWidth, onLine) {
-    if (prepared.widths.length === 0) return 0;
-    return walkPreparedLinesRaw(getInternalPrepared(prepared), maxWidth, (width, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex)=>{
-        onLine(createLayoutLineRange(width, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex));
-    });
+
+// Intrinsic-width helper for rich/userland layout work. This asks "how wide is
+// the prepared text when container width is not the thing forcing wraps?".
+// Explicit hard breaks still count, so this returns the widest forced line.
+export function measureNaturalWidth(prepared              )         {
+  return measureLineStats(prepared, Number.POSITIVE_INFINITY).maxLineWidth
 }
-export function measureLineStats(prepared, maxWidth) {
-    return measurePreparedLineGeometry(getInternalPrepared(prepared), maxWidth);
+
+// Steps one streamed line from `start` into the result's cursors: the
+// normalized line start and the line end. Returns the reported width, or null
+// after the last line.
+function stepNextLine(
+  prepared              ,
+  start              ,
+  maxWidth        ,
+  lineStart              ,
+  lineEnd              ,
+)                {
+  const internal = getInternalPrepared(prepared)
+  lineEnd.segmentIndex = start.segmentIndex
+  lineEnd.graphemeIndex = start.graphemeIndex
+  if (!normalizePreparedLineStart(internal, lineEnd)) return null
+
+  lineStart.segmentIndex = lineEnd.segmentIndex
+  lineStart.graphemeIndex = lineEnd.graphemeIndex
+  const width = stepPreparedLineGeometryFromStart(internal, lineEnd, maxWidth)
+  return width === null ? null : Math.max(0, width)
 }
-export function measureNaturalWidth(prepared) {
-    let maxWidth = 0;
-    walkPreparedLinesRaw(getInternalPrepared(prepared), Number.POSITIVE_INFINITY, (width)=>{
-        if (width > maxWidth) maxWidth = width;
-    });
-    return maxWidth;
+
+export function layoutNextLine(
+  prepared                          ,
+  start              ,
+  maxWidth        ,
+)                    {
+  const lineStart = { segmentIndex: 0, graphemeIndex: 0 }
+  const end = { segmentIndex: 0, graphemeIndex: 0 }
+  const width = stepNextLine(prepared, start, maxWidth, lineStart, end)
+  if (width === null) return null
+
+  const text = buildLineTextFromRange(
+    prepared                                    ,
+    lineStart.segmentIndex,
+    lineStart.graphemeIndex,
+    end.segmentIndex,
+    end.graphemeIndex,
+  )
+  return { text, width, start: lineStart, end }
 }
-export function layoutNextLine(prepared, start, maxWidth) {
-    const internal = getInternalPrepared(prepared);
-    const end = {
-        segmentIndex: start.segmentIndex,
-        graphemeIndex: start.graphemeIndex
-    };
-    const chunkIndex = normalizePreparedLineStart(internal, end);
-    if (chunkIndex < 0) return null;
-    const lineStartSegmentIndex = end.segmentIndex;
-    const lineStartGraphemeIndex = end.graphemeIndex;
-    const width = stepPreparedLineGeometryFromChunk(internal, end, chunkIndex, maxWidth);
-    if (width === null) return null;
-    return createLayoutLine(prepared, getLineTextCache(prepared), width, lineStartSegmentIndex, lineStartGraphemeIndex, end.segmentIndex, end.graphemeIndex);
+
+export function layoutNextLineRange(
+  prepared              ,
+  start              ,
+  maxWidth        ,
+)                         {
+  const lineStart = { segmentIndex: 0, graphemeIndex: 0 }
+  const end = { segmentIndex: 0, graphemeIndex: 0 }
+  const width = stepNextLine(prepared, start, maxWidth, lineStart, end)
+  return width === null ? null : { width, start: lineStart, end }
 }
-export function layoutNextLineRange(prepared, start, maxWidth) {
-    const internal = getInternalPrepared(prepared);
-    const end = {
-        segmentIndex: start.segmentIndex,
-        graphemeIndex: start.graphemeIndex
-    };
-    const chunkIndex = normalizePreparedLineStart(internal, end);
-    if (chunkIndex < 0) return null;
-    const lineStartSegmentIndex = end.segmentIndex;
-    const lineStartGraphemeIndex = end.graphemeIndex;
-    const width = stepPreparedLineGeometryFromChunk(internal, end, chunkIndex, maxWidth);
-    if (width === null) return null;
-    return createLayoutLineRange(width, lineStartSegmentIndex, lineStartGraphemeIndex, end.segmentIndex, end.graphemeIndex);
-}
-export function layoutWithLines(prepared, maxWidth, lineHeight) {
-    const lines = [];
-    if (prepared.widths.length === 0) return {
-        lineCount: 0,
-        height: 0,
-        lines
-    };
-    const graphemeCache = getLineTextCache(prepared);
-    const lineCount = walkPreparedLinesRaw(getInternalPrepared(prepared), maxWidth, (width, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex)=>{
-        lines.push(createLayoutLine(prepared, graphemeCache, width, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex));
-    });
-    return {
-        lineCount,
-        height: lineCount * lineHeight,
-        lines
-    };
+
+// Rich layout API for callers that want the actual line contents and widths.
+// Caller still supplies lineHeight at layout time. Mirrors layout()'s break
+// decisions, but keeps extra per-line bookkeeping so it should stay off the
+// resize hot path.
+export function layoutWithLines(prepared                          , maxWidth        , lineHeight        )                    {
+  const lines               = []
+  const lineCount = walkPreparedLinesRaw(
+    getInternalPrepared(prepared),
+    normalizeMaxWidth(maxWidth),
+    (width, startSegmentIndex, startGraphemeIndex, endSegmentIndex, endGraphemeIndex) => {
+      lines.push(createLayoutLine(
+        prepared,
+        width,
+        startSegmentIndex,
+        startGraphemeIndex,
+        endSegmentIndex,
+        endGraphemeIndex,
+      ))
+    },
+  )
+
+  return { lineCount, height: lineCount * lineHeight, lines }
 }
-export function clearCache() {
-    clearAnalysisCaches();
-    clearLineTextCaches();
-    clearMeasurementCaches();
+
+export function clearCache()       {
+  clearWordSegmenter()
+  clearMeasurementCaches()
 }
-export function setLocale(locale) {
-    setAnalysisLocale(locale);
-    clearCache();
+
+// Sets the language later preparation breaks and measures under in place of
+// `<html lang>`, which a worker doesn't have; an empty one is a page's without a
+// language. Without a locale, preparation reads `<html lang>` again. Prepared
+// handles keep theirs (RESEARCH.md, Decisions Log, 2026-09-26).
+export function setLocale(locale         )       {
+  setLocaleLanguage(locale)
+  clearCache()
 }