rapier-markdown-kit 1.2.33 → 1.2.42

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

@@ -1,8 +1,7 @@
-/*! Pretext Unreleased (bac1774c0) | MIT; BSD/Unicode/ICU notices in LICENSE | Copyright (c) 2026 Pretext contributors */
+/*! Pretext 1.0.0 + main (0d102a5cd) | MIT; BSD/Unicode/ICU notices in LICENSE | Copyright (c) 2026 Pretext contributors */
 import { findGraphemeEnds,                    } from './graphemes.js'
-import { canWebKitLineStartWith, DEFAULT_IGNORABLE, getBlinkDefaultLocale, hasProperty, MARK } from './line-breaks.js'
+import { DEFAULT_IGNORABLE, getBlinkDefaultLocale, hasProperty, MARK } from './line-breaks.js'
 import { webkitGenericFamilies, webkitGenericFamilyNames, webkitScriptLanguages, webkitScriptSubtags } from './generated/webkit-generic-families.js'
-                                                               
                                                           
 
 // What preparation knows of a segment in a font. Each is created with all its fields,
@@ -12,6 +11,9 @@ import { webkitGenericFamilies, webkitGenericFamilyNames, webkitScriptLanguages,
                                                                                            
                                                                                        
                                                                                                
+                                                                                            
+                                                                                             
+                                
  
 
 // A text segment's kerning with a U+0020 beside it, in the Chromium profile (getSpaceKerning).
@@ -28,23 +30,9 @@ import { webkitGenericFamilies, webkitGenericFamilyNames, webkitScriptLanguages,
                                                                                             
                                                                                          
                                   
-                                                                                      
-                                                                                 
-                                                         
-                                          
-                  
-                         
-                           
-                                         
-          
  
 
                              
-                                                                                   
-                                                                                        
-                                                                                       
-                                                             
-                                                  
                                                                                           
                                                                                         
                                                                                           
@@ -102,13 +90,16 @@ import { webkitGenericFamilies, webkitGenericFamilyNames, webkitScriptLanguages,
                                 
                                                                               
                                                                                 
-                                                                     
+                                                                                  
+                                                                 
                                         
                                                                                        
                                                                                                
                                                                                                
+                                                                                          
+                                                                                                  
                                                                                                  
-                                                                                      
+                                                   
                                  
                                                                            
                                                  
@@ -135,11 +126,23 @@ import { webkitGenericFamilies, webkitGenericFamilyNames, webkitScriptLanguages,
                                                                               
                                                                     
                                              
-                                                                                 
+                                                                                        
+                                                                                          
+                                                                                        
+                                                                                           
+                                                                             
+                                                                                                   
                                                                                      
-                                                                                
-                                                                                  
-                                      
+                                                                                       
+                                                                                           
+                                                                                         
+                                                                                         
+                                                                      
+                                                                                         
+                                                                                          
+                                                                                          
+                              
+                             
                                                                               
                                                                                    
                                                                                   
@@ -167,6 +170,24 @@ import { webkitGenericFamilies, webkitGenericFamilyNames, webkitScriptLanguages,
                                                              
                                                                                   
                                                                          
+                                                                             
+                                                                                 
+                                                                               
+                                                                                 
+                                                                               
+                                                                                    
+                                                                                   
+                                                                       
+                                                                           
+                                                                                   
+                                                                                   
+                                                                              
+                                                                                 
+                                                                                     
+                                                                             
+                                                                                  
+                                                                                   
+                                               
                                                                             
                                                                                   
                                                                
@@ -213,12 +234,6 @@ import { webkitGenericFamilies, webkitGenericFamilyNames, webkitScriptLanguages,
                                                                                            
                                                                                            
                                  
-                                                                                        
-                                                                                        
-                                                                                      
-                                                                                          
-                    
-                                    
                                                                                            
                                                                                       
                                 
@@ -234,7 +249,7 @@ import { webkitGenericFamilies, webkitGenericFamilyNames, webkitScriptLanguages,
                                                                                        
                                                      
                                     
-                                                                                    
+                                                                                              
                                                                                  
                                                                                        
                                                                                      
@@ -242,6 +257,14 @@ import { webkitGenericFamilies, webkitGenericFamilyNames, webkitScriptLanguages,
                                                                                     
                                                                                       
                                                                                           
+                                                                                         
+                                                                                       
+                                                                                           
+                                                                                              
+                                                                                             
+                                                                                        
+                                                                                          
+                                                      
                                          
                                                                                           
                                                                                               
@@ -307,6 +330,20 @@ import { webkitGenericFamilies, webkitGenericFamilyNames, webkitScriptLanguages,
                                          
                                 
                                                                                                 
+                                                                                                      
+                                                                                          
+                                                                                    
+                                                                                                  
+                                                                                                
+                                                                                               
+                                                                                             
+                                                                                                
+                                                                                            
+                                                                                              
+                                                                                           
+                                             
+                                         
+                                                                                                
                                                                                               
                                                                                              
                                                                                         
@@ -349,6 +386,11 @@ import { webkitGenericFamilies, webkitGenericFamilyNames, webkitScriptLanguages,
                                                                                                                      
                                                                                                  
                                                                                  
+                                                                                             
+                                                                                          
+                          
+                                                                                      
+                      
                                                                                                    
                                                                                              
                                                                                         
@@ -359,6 +401,7 @@ import { webkitGenericFamilies, webkitGenericFamilyNames, webkitScriptLanguages,
                                                                                           
                                            
                                                  
+                                                                                            
  
 let measureState                      = null
 // What preparation keeps per font. It all goes together, when the caches clear or the
@@ -378,12 +421,19 @@ let measureState                      = null
                                                                                                  
                                                                 
                                                       
+                                                                                           
+                                                                                             
+                                                                                           
+                                        
+                                              
+                                                                                                                              
                                                                                  
                                                                                                    
                                                                                           
                                                                                                                 
                                                                                             
                                                                                                                    
+                                                                                                              
  
 let cachedEngineProfile                       = null
 
@@ -404,6 +454,19 @@ const MAX_PREFIX_FIT_GRAPHEMES = 96
 // `font-variant-ligatures: none` (2026-09-30).
 const LETTER_SPACED_SHAPING = '0.000001px'
 
+// The most segments the fonts' caches hold between them when a preparation starts
+// (getPreparationLanguage): past it they are all dropped, as clearCache() drops them, before
+// that preparation measures anything. A handle keeps its own widths, so nothing prepared
+// changes; text prepared afterwards is measured again. Prose adds segments ever more slowly,
+// but ids, numbers and URLs never repeat, so without a bound the caches grow for as long as the
+// page lives. The bound is a safety net well above what a page uses, not a tuned size: the
+// 11,290 plain texts of the harness's real-usage sample, 883,084 units, fill in one font 71,294
+// segments in the Chromium profile, 90,023 in Gecko's and 115,367 in WebKit's, 241-363 B each in
+// JavaScriptCore, and a bound under a page's own count has its text measured again and again:
+// at 65,536, preparing those texts a second time asks Canvas 81,286 to 196,534 times, where
+// under no bound it asks nothing (the harness's stand-in Canvas, 2026-10-12).
+const MAX_CACHED_SEGMENTS = 1 << 18
+
 // Graphemes the emoji font may draw a glyph in, which Canvas widths then tell
 // (countEmojiGlyphs): those holding an emoji-presentation character or a pictograph,
 // or an emoji character followed by U+FE0F, such as a keycap base like `1`. U+FE0F
@@ -551,6 +614,11 @@ export function setLocaleLanguage(locale                    )       {
 // else the page's, or null without a document. The Chromium profile lays out a page
 // without one under Blink's default locale (laysOutUnderDefaultLocale).
 export function getPreparationLanguage(profile               )                {
+  // A preparation starts with this read, so the fonts' caches are bounded here, between two
+  // preparations (MAX_CACHED_SEGMENTS), and not where a font is looked up: a rich-inline
+  // paragraph looks one up for each of its items, and caches dropped between two of them would
+  // have one paragraph measured partly from the caches and partly anew.
+  if (measureState !== null && measureState.segments > MAX_CACHED_SEGMENTS) clearMeasurementCaches()
   let language = localeLanguage ?? null
   if (localeLanguage === undefined && typeof document !== 'undefined') {
     const lang = (document.documentElement                                  )?.lang
@@ -583,26 +651,62 @@ export function zeros(count        )           {
   return out
 }
 
-// A text's width as Canvas spaces it under a letter spacing, or null where the context
-// can't take the spacing. Under none, that is the text's width in the font, which the
-// font's segment cache asks once. Under a spacing it is asked each time, borrowing the
-// font's context for the synchronous call, never enters a segment cache, and
-// letterSpacing is restored even when assignment or measurement fails.
-export function measureWithLetterSpacing(text        , letterSpacing        , emojiCorrection        , measurement                 )                {
-  if (!measurement.state.takesLetterSpacing) return null
-  if (letterSpacing === 0) return getTextWidth(text, measurement, emojiCorrection)
-  // Counted before the spacing is set: the count measures stretches into the font's segment cache.
-  const corrected = emojiCorrection === 0 ? 0 : countEmojiGlyphs(text, measurement) * emojiCorrection
-  const context = getContext(measurement)
-  const previous = context.letterSpacing
+// The Canvas letterSpacing a text is measured under to count the glyphs it spaces: far
+// wider than any text asked about, so the text's width over it rounds to the count with
+// nothing taken off, and a power of two, which float32 widths add whole. A text 2^19 px
+// wide under no spacing would count a glyph more.
+const GLYPH_COUNT_SPACING = 2 ** 20
+
+// The spacings of a segment whose graphemes each take one, and of any segment where Canvas
+// can't be asked.
+export const noExtraSpacings           = []
+
+// Per grapheme of a text segment, how many letter spacings it takes more than one, where
+// the engine spaces glyphs (EngineProfile's letterSpacesGlyphs). Canvas spaces by the
+// engine's rule, so a prefix of the segment measured under a letter spacing holds that
+// spacing once for each of its glyphs with an advance, and a grapheme takes what its
+// prefix has more than the prefix before it: WebKit fits a cut word by its prefixes too
+// (TextUtil::breakWord). A grapheme can take none, as the alef of lam-alef, or fewer,
+// where it joins the glyphs before it into one. Past MAX_PREFIX_FIT_GRAPHEMES each
+// grapheme is asked alone, which keeps a giant segment linear and misses a glyph two of
+// its graphemes share. A text's count is kept for the font (FontMeasurement's
+// glyphCounts), so words that start alike ask about a prefix once: one more Canvas call
+// for each prefix new to the font, which WebKit shapes each time, since it keeps no width
+// measured under a letter spacing (TextMeasurementCache.h:165-167). Under a context that
+// takes no letterSpacing every grapheme takes one.
+export function getExtraSpacings(seg        , measurement                 )           {
+  if (!measurement.state.takesLetterSpacing) return noExtraSpacings
+  const ends = new Int32Array(seg.length)
+  const count = findGraphemeEnds(getEngineProfile().graphemeTable, seg, 0, seg.length, ends)
+  const prefixes = count <= MAX_PREFIX_FIT_GRAPHEMES
+  const counts = measurement.glyphCounts
+  // The font's context once Canvas is asked, under the counting spacing from then on, so
+  // it changes its spacing once, and not at all for a segment whose prefixes are counted.
+  let context                                                                      = null
+  let extras = noExtraSpacings
   try {
-    context.letterSpacing = `${letterSpacing}px`
-    if (Number.parseFloat(context.letterSpacing) !== letterSpacing) return null
-    const width = context.measureText(text).width - corrected
-    return Number.isFinite(width) ? width : null
+    let before = 0
+    for (let i = 0, start = 0; i < count; start = ends[i++] ) {
+      const text = seg.slice(prefixes ? 0 : start, ends[i])
+      let glyphs = counts.get(text)
+      if (glyphs === undefined) {
+        if (context === null) {
+          context = getContext(measurement)
+          context.letterSpacing = `${GLYPH_COUNT_SPACING}px`
+        }
+        glyphs = Math.round(context.measureText(text).width / GLYPH_COUNT_SPACING)
+        counts.set(text, glyphs)
+      }
+      const extra = glyphs - (prefixes ? before : 0) - 1
+      before = glyphs
+      if (extra === 0 && extras.length === 0) continue
+      if (extras.length === 0) extras = zeros(count)
+      extras[i] = extra
+    }
   } finally {
-    context.letterSpacing = previous
+    if (context !== null) context.letterSpacing = measurement.letterSpacing
   }
+  return extras
 }
 
 // The lookup internalizes seg, and a string V8 hashes for the first time there gets a one-byte
@@ -622,23 +726,37 @@ export function getFollowingSpaceMetrics(seg        , measurement
 }
 
 function addMetrics(cache                             , seg        , text        , measurement                 )                 {
-  const metrics                 = { width: getContext(measurement).measureText(text).width, emojiCount: -1, fit: null, spaceKerning: null }
+  const metrics                 = { width: getContext(measurement).measureText(text).width, emojiCount: -1, fit: null, spaceKerning: null, extraSpacings: null }
   cache.set(seg, metrics)
+  measurement.state.segments++
+  if (!measurement.measuredKana && kanaRe.test(seg)) measurement.measuredKana = true
   return metrics
 }
 
+// A character of the Hiragana and Katakana blocks, U+3041 to U+30FF, two of them in a row, and
+// how many the blocks hold.
+const kanaRe = /[\u3041-\u30FF]/
+export const kanaPairRe = /[\u3041-\u30FF]{2}/
+const KANA_COUNT = 0x30ff - 0x3041 + 1
+
 // The kerning of every segment that takes none.
 export const noSpaceKerning               = { after: 0, before: 0 }
 
+// Whether a character is a kana or an ideograph, which Canvas shapes as a word of its own: it
+// cuts a string before one that follows another, and keeps with a letter the marks and CJK
+// punctuation after it (NextWordEndIndex, plain_text_node.cc:92-153, over
+// kIsCjkIdeographOrSymbolRanges, character_property_data.h:40-80, of which these are the
+// letters).
+function isCanvasWordLetter(code        )          {
+  return (code >= 0x3041 && code <= 0x3096) || (code >= 0x30a1 && code <= 0x30fa) ||
+    (code >= 0x3400 && code <= 0x9fff) || (code >= 0xf900 && code <= 0xfaff)
+}
+
 // Whether a character takes no kerning with a space, and Canvas isn't asked.
 function takesNoSpaceKerning(code        )          {
-  // A combining mark or half of a surrogate pair is part of a longer cluster.
-  return hasProperty(code, MARK) || (code & 0xf800) === 0xd800 ||
-    // Canvas shapes each ideograph and kana as a word of its own, so it shows no kerning beside
-    // one (NextWordEndIndex, plain_text_node.cc:92-153, over kIsCjkIdeographOrSymbolRanges,
-    // character_property_data.h:40-80, of which these are the letters).
-    (code >= 0x3041 && code <= 0x3096) || (code >= 0x30a1 && code <= 0x30fa) ||
-    (code >= 0x3400 && code <= 0x9fff) || (code >= 0xf900 && code <= 0xfaff) ||
+  // A combining mark or half of a surrogate pair is part of a longer cluster. Canvas shows no
+  // kerning beside a letter it shapes as a word of its own.
+  return hasProperty(code, MARK) || (code & 0xf800) === 0xd800 || isCanvasWordLetter(code) ||
     // Premise: no font kerns a Hangul syllable with the space (RESEARCH.md, Kerning At Line Edges).
     (code >= 0xac00 && code <= 0xd7a3)
 }
@@ -686,7 +804,7 @@ function getCharacterSpaceKerning(code        , spaceFirst         , measurement
 }
 
 // The kerning Blink's layout gives a text segment's edges with a U+0020 beside them
-// (EngineProfile.kernsSpacesInScriptRun), read from Canvas with U+2028 for the space: Blink
+// (EngineProfile.kernsAcrossCanvasWords), read from Canvas with U+2028 for the space: Blink
 // draws U+2028 with the space glyph (HarfBuzzGetGlyph, harfbuzz_face.cc:103-113) and its Canvas
 // doesn't cut there. Premise: the segment's last and first character stand for the word, past
 // default ignorables, which HarfBuzz's lookups pass over, and a first character with a combining
@@ -707,6 +825,138 @@ export function getSpaceWidth(measurement                 )         {
   return measurement.spaceWidth ??= getSegmentMetrics(' ', measurement).width
 }
 
+// Twelve kana in a row, nine of whose eleven pairs or more kern in each Japanese face measured
+// that kerns kana at all (getFontKanaKerning).
+const KANA_PROBE = '\u30D7\u30C0\u30B0\u30BF\u30CE\u30E0\u30D6\u30A4\u30E1\u3048\u305A\u307A'
+
+// The font's context for kana: Canvas shapes a string whole, as Blink's layout shapes a run,
+// under text-rendering: optimizeLegibility where the lookups of the first font with a space
+// cover the space glyph (FontFallbackList::ComputeCanShapeWordByWord, font_fallback_list.cc:264-277),
+// as those of the Japanese fonts of macOS do. It is a context of its own: the first measures
+// everything else as it did, and a kana alone measures the same on both. It is set to the
+// list the font's kana are asked in (getFontKanaKerning), and isn't asked whether it takes the
+// list (contextTakesFont): the font's own list is one the first context, made the same way,
+// took, and where a shorter one is no font string, as a list cut inside a calc() size, the
+// context keeps the list before it and reads what it read under that one, so the search goes
+// on to the next list or ends on the font's own.
+function getWholeRunContext(measurement                 )                                                               {
+  const state = measurement.state
+  if (state.wholeRunContext === null) {
+    state.wholeRunContext = createContext(state.language)
+    state.wholeRunContext.textRendering = 'optimizeLegibility'
+  }
+  if (state.wholeRunFont !== measurement.kanaFont) state.wholeRunContext.font = state.wholeRunFont = measurement.kanaFont
+  return state.wholeRunContext
+}
+
+// Whether two measurements of one string are of the same glyphs at the same places: as wide,
+// with the same ink edges, to float32 rounding (getKanaKerning has the bound).
+function sameInk(a             , b             )          {
+  const bound = a.width / 0x400000
+  return Math.abs(a.width - b.width) <= bound && Math.abs(a.actualBoundingBoxLeft - b.actualBoundingBoxLeft) <= bound &&
+    Math.abs(a.actualBoundingBoxRight - b.actualBoundingBoxRight) <= bound
+}
+
+// What is kept of the font's kerning between kana, or null for a font that shows none: one in
+// which KANA_PROBE, shaped whole, is as wide with kerning off (getFontSpaceKerning has what
+// `fontKerning` turns off). Canvas shapes a string whole by the list's first font alone, where
+// Blink's layout shapes the kana of a run together whatever font leads the list
+// (InlineNode::ShapeText, inline_node.cc:1551-1718), so a list that shows no kerning is asked
+// again without its first family, then without its first two, and so on: once the first
+// font's lookups cover the space glyph, as the kana's own font's do, Canvas shapes the probe
+// whole. A shorter list stands for the font only where the same font draws its kana, which
+// two answers tell. It draws the probe with the same glyphs, as wide and with the same ink
+// edges with kerning off: the first that doesn't ends the search, since a family left out
+// drew the kana. And the kerning Canvas does show under the font's own list, a kana's with a
+// U+3002 it keeps in the kana's word (NextWordEndIndex, plain_text_node.cc:129-153), is the
+// shorter list's and isn't nothing: Hiragino Sans GB draws Hiragino Sans's kana and kerns
+// none. A font that shows no kerning under any list stays as wide as Canvas measures its kana
+// apart. Asked once per font, with two measurements for each list tried and three more for
+// one that shows kerning. Premises: a font that kerns kana kerns one of the probe's pairs
+// (RESEARCH.md, Kerning At Line Edges, has the fonts measured), and one of its hiragana with
+// U+3002 (ENGINE_FOLLOWUPS.md, Kerning between kana).
+export function getFontKanaKerning(measurement                 )                      {
+  if (measurement.kanaKerning === undefined) {
+    measurement.kanaKerning = null
+    const font = measurement.canvasFont
+    const size = fontSizeRe.exec(font)
+    const start = size === null ? 0 : size.index + size[0].length
+    const families = size === null ? null : font.slice(start).match(familyRe)
+    const lists = families === null ? 1 : families.length
+    let own                     = null
+    for (let i = 0; i < lists; i++) {
+      const list = i === 0 ? font : font.slice(0, start) + families .slice(i).join(',')
+      measurement.kanaFont = list
+      const context = getWholeRunContext(measurement)
+      const kerned = context.measureText(KANA_PROBE).width
+      context.fontKerning = 'none'
+      const unkerned = context.measureText(KANA_PROBE)
+      context.fontKerning = 'auto'
+      if (own === null) own = unkerned
+      else if (!sameInk(own, unkerned)) break
+      if (kerned === unkerned.width) continue
+      if (i > 0) {
+        // Each hiragana letter before a U+3002: Canvas shapes each pair as one word under any list.
+        let pairs = ''
+        for (let code = 0x3041; code <= 0x3096; code++) pairs += String.fromCharCode(code, 0x3002)
+        const shorter = context.measureText(pairs).width
+        measurement.kanaFont = font
+        const ownContext = getWholeRunContext(measurement)
+        const ownKerned = ownContext.measureText(pairs).width
+        ownContext.fontKerning = 'none'
+        const ownUnkerned = ownContext.measureText(pairs).width
+        ownContext.fontKerning = 'auto'
+        if (ownKerned === ownUnkerned || Math.abs(shorter - ownKerned) > ownKerned / 0x400000) break
+        measurement.kanaFont = list
+      }
+      measurement.kanaKerning = new Float64Array(KANA_COUNT * KANA_COUNT).fill(NaN)
+      break
+    }
+    if (measurement.kanaKerning === null) measurement.kanaFont = font
+  }
+  return measurement.kanaKerning
+}
+
+// The kerning Blink's layout gives text[at - 1] and text[at] that no measured width holds, or
+// 0: that of two characters of the kana blocks that were measured apart. `start` is where the
+// segment that holds text[at] starts. Two segments are measured apart, so a segment's first
+// character takes its kerning with the one before it. Inside a segment Canvas cuts before a
+// kana letter where the word before it holds a letter already. A mark such as U+30FC stays in
+// the word before it, and a word that marks or CJK punctuation began takes the first letter
+// after them (NextWordEndIndex's has_any_script, plain_text_node.cc:129-153), so Canvas has
+// measured those pairs together; a character below the CJK ranges is in a word of other
+// scripts, which ends before the letter. Each pair is asked of Canvas once per font and kept
+// in the font's table by its two characters, where a pair not asked about yet is NaN.
+export function getKanaKerning(text        , start        , at        , measurement                 , kernings              )         {
+  const second = text.charCodeAt(at)
+  if (second < 0x3041 || second > 0x30ff) return 0
+  const first = text.charCodeAt(at - 1)
+  if (first < 0x3041 || first > 0x30ff) return 0
+  if (at > start) {
+    if (!isCanvasWordLetter(second)) return 0
+    // What Canvas's word held before the marks that end it.
+    let k = at - 1
+    let code = first
+    while (code >= 0x3041 && code <= 0x30ff && !isCanvasWordLetter(code)) {
+      if (k === start) return 0
+      code = text.charCodeAt(--k)
+    }
+    if (code >= 0x2e80 && !isCanvasWordLetter(code)) return 0
+  }
+  const index = (first - 0x3041) * KANA_COUNT + second - 0x3041
+  const kerning = kernings[index] 
+  return Number.isNaN(kerning) ? kernings[index] = measureKanaKerning(text.slice(at - 1, at + 1), measurement) : kerning
+}
+
+// The kerning of two kana in a row: the two in one string on the context that shapes a string
+// whole, less each alone.
+function measureKanaKerning(pair        , measurement                 )         {
+  const pairWidth = getWholeRunContext(measurement).measureText(pair).width
+  const kerning = pairWidth - getSegmentMetrics(pair[0] , measurement).width - getSegmentMetrics(pair[1] , measurement).width
+  // As for a character and a space, up to the pair's width / 2^22 is rounding.
+  return Math.abs(kerning) <= pairWidth / 0x400000 ? 0 : kerning
+}
+
 // A text's width in the font, less the emoji correction.
 export function getTextWidth(text        , measurement                 , emojiCorrection        )         {
   return getCorrectedSegmentWidth(text, getSegmentMetrics(text, measurement), measurement, emojiCorrection)
@@ -742,15 +992,14 @@ export function getEngineProfile()                {
 }
 
 function buildEngineProfile()                {
-  const ua = typeof navigator === 'undefined' ? '' : navigator.userAgent
+  // A navigator can lack a userAgent, as React Native's does, where lib.dom's type says it is a
+  // string: such a runtime names no engine, like one with no navigator.
+  const ua = typeof navigator === 'undefined' ? '' : (navigator                          ).userAgent ?? ''
   // Engines Pretext doesn't recognize take Blink's profile (RESEARCH.md, Decisions Log,
   // 2026-09-26).
   const engine = getLayoutEngine(ua) ?? 'blink'
-  // Fresh-entry observations are verified only for desktop Blink and Gecko.
-  const isDesktop = /Windows NT|Macintosh|X11/.test(ua) && !/Android|Mobile|iPhone|iPad|iPod/.test(ua)
 
   return {
-    entryFitBasis: isDesktop && engine === 'blink' ? 'fresh' : isDesktop && engine === 'gecko' ? 'original' : 'disabled',
     lineBreakScan: engine,
     graphemeTable: engine === 'webkit' ? 'apple/char' : engine === 'gecko' ? 'gecko/char' : 'chromium/char',
     lineFitEpsilon: engine === 'webkit' ? 1 / 64 : 0.005,
@@ -758,12 +1007,12 @@ function buildEngineProfile()                {
     prefixFitMinWidth: engine === 'webkit' ? 0 : 80,
     cutWordKeepsLigatures: engine === 'gecko',
     measureTextWithFollowingSpace: engine === 'webkit',
-    kernsSpacesInScriptRun: engine === 'blink',
+    kernsAcrossCanvasWords: engine === 'blink',
     letterSpaceDiscretionaryHyphen: engine !== 'blink',
     letterSpacingInAppUnits: engine === 'gecko',
     canvasLetterSpacingDropsLigatures: engine !== 'webkit',
     unspacedCursive: engine === 'blink' ? 'run' : engine === 'gecko' ? 'cluster' : 'none',
-    shapesMarksAcrossSoftHyphen: engine === 'blink',
+    letterSpacesGlyphs: engine === 'webkit',
     unfitHyphenRetreat: engine === 'blink' ? 'reduced-width' : engine === 'gecko' ? 'full-width' : 'full-width-or-first',
     hyphenFromPrimaryFont: engine !== 'gecko',
     letterSpaceTabStops: engine !== 'webkit',
@@ -772,15 +1021,15 @@ function buildEngineProfile()                {
     tabsInAppUnits: engine === 'gecko',
     hangTabs: engine !== 'gecko',
     zeroWidthGlueTakesLine: engine !== 'gecko',
-    keepsLineStartPunctuation: engine === 'webkit',
     hidesControlCharacters: engine === 'gecko',
     hanKerning: engine === 'blink',
     hangsIdeographicSpace: engine !== 'webkit',
     laysOutUnderDefaultLocale: engine === 'blink',
-    namesGenericFamiliesByLanguage: engine === 'webkit',
+    namesGenericFamiliesByLanguage: engine === 'webkit' && !/^(?:Linux|Win32|Haiku|$)/.test(navigator.platform),
     hardBreakItemRetreat: engine === 'blink' ? 'item' : engine === 'webkit' ? 'fit' : 'last-grapheme',
     paddedOpeningFit: engine === 'blink' ? 'start' : engine === 'webkit' ? 'placed' : 'both',
     emptyAtomicAlwaysFits: engine === 'gecko',
+    zeroWidthSpaceStaysAfterAtomic: engine === 'gecko',
     hangsSpacesPerTextFrame: engine === 'gecko',
     testsHyphenBeforeAtomic: engine !== 'webkit',
     transformsSegmentBreaksAcrossItems: engine === 'blink',
@@ -802,31 +1051,71 @@ export function getEmojiCorrection(font        , measurement                 )
   if (correction !== null) return correction
 
   const fontSize = parseFontSize(font)
+  // Canvas's width is there already when an earlier text asked and the page had no box to read.
+  const askedBefore = measurement.emojiWidth !== 0
   const canvasW = measurement.emojiWidth = getContext(measurement).measureText('\u{1F600}').width
   correction = 0
-  // document.body is null until the parser reaches <body>, which lib.dom's type leaves out.
-  if (
-    canvasW > fontSize + 0.5 &&
-    typeof document !== 'undefined' &&
-    (document.body                      ) !== null
-  ) {
-    const span = document.createElement('span')
-    span.style.font = font
-    span.style.display = 'inline-block'
-    span.style.visibility = 'hidden'
-    span.style.position = 'absolute'
-    span.textContent = '\u{1F600}'
-    document.body.appendChild(span)
-    const domW = span.getBoundingClientRect().width
-    document.body.removeChild(span)
+  if (canvasW > fontSize + 0.5 && typeof document !== 'undefined') {
+    const domW = readEmojiWidth(font)
+    // A document with no box for the span, as in an iframe that is display: none, has no
+    // width to read. The text goes uncorrected, as in a worker, and nothing is kept: the next
+    // text that may hold an emoji asks again.
+    if (Number.isNaN(domW)) return 0
     if (canvasW - domW > 0.5) {
       correction = canvasW - domW
+      // Advances cut from a segment before this reading hold emoji uncorrected.
+      if (askedBefore) {
+        for (const metrics of measurement.metrics.values()) metrics.fit = null
+        for (const metrics of measurement.followingSpaceMetrics.values()) metrics.fit = null
+      }
     }
   }
   measurement.emojiCorrection = correction
   return correction
 }
 
+// The page's width of one emoji in the font, or NaN where the page has no box for it. The
+// span takes two things from the page, the font asked for and the page's language, which
+// picks fonts as it does for Canvas (-webkit-locale is where Blink and WebKit keep it, and
+// `all` resets it; Gecko's -x-lang is internal and `all` leaves it). Everything else is at
+// its initial value, and important, so that nothing the page declares reaches the span,
+// inherited from <body> or matched by a rule: a letter-spacing, a text-indent or a padding
+// would be read as part of the emoji, and a vertical writing-mode gives a line's height.
+function readEmojiWidth(font        )         {
+  // The span goes in <body>, beside the page's text, and in <html> where that gives it no
+  // box: document.body is null until the parser reaches <body>, and a <body> that is
+  // display: none, as a page hidden until it is ready, has no boxes. A document whose root
+  // isn't <html>, as an SVG file's, has neither a body nor a head, and lays out no HTML.
+  // lib.dom's types leave the nulls out.
+  const body = document.body                      
+  if (body === null && (document.head                      ) === null) return NaN
+  const span = document.createElement('span')
+  span.style.cssText = 'all:initial!important;-webkit-locale:inherit!important;display:inline-block!important;visibility:hidden!important;position:absolute!important'
+  span.style.setProperty('font', font, 'important')
+  span.textContent = '\u{1F600}'
+  let width = body === null ? NaN : readWidthIn(body, span)
+  if (Number.isNaN(width)) width = readWidthIn(document.documentElement, span)
+  return width
+}
+
+// The span's width under a parent. Its resolved width is its box's used width in the span's
+// own pixels, and `auto`, so NaN, where it has no box (nsComputedDOMStyle::DoGetWidth,
+// nsComputedDOMStyle.cpp:1803-1814; StyleExtractorCustom.h:570-576 in WebKit; Blink hands the
+// property the element's LayoutObject, css_computed_style_declaration.cc:381-383), but it is
+// written with six significant digits. Its rectangle has every digit, but is the box as
+// drawn: a transform or a zoom above the span scales it, and it is 0 with no box, which read
+// as an emoji 0px wide. So the rectangle's width is taken where it is the resolved one
+// within those digits, and the resolved one where something scales the span. The rectangle
+// is asked first: before the parser reaches <body>, Firefox makes the document's first boxes
+// for a rectangle and not for a resolved width, which is `auto` until then.
+function readWidthIn(parent             , span             )         {
+  parent.appendChild(span)
+  const drawn = span.getBoundingClientRect().width
+  const width = parseFloat(getComputedStyle(span).width)
+  parent.removeChild(span)
+  return Math.abs(drawn - width) <= width * 1e-5 ? drawn : width
+}
+
 // Canvas reports a width as a 32-bit float (CanvasRenderingContext2D.cpp:5277 in Firefox,
 // text_metrics.cc:179 in Chrome), so a few equal advances measure that many times one
 // only within that float's rounding, 2^-24 of the width each time one is rounded: 2e-6 px
@@ -911,20 +1200,16 @@ export function getSegmentFit(
   // When metrics measured seg together with one following U+0020, the width of
   // that space alone. The last grapheme then keeps its kerning with the space.
   followingSpaceWidth                = null,
-  // Whether to find the segment's WebKit line-start prohibitions.
-  withLineStartProhibitions = false,
 )             {
   if (metrics.fit !== null && metrics.fit.mode === mode) return metrics.fit
   const profile = getEngineProfile()
   const ends = new Int32Array(seg.length)
   const count = findGraphemeEnds(profile.graphemeTable, seg, 0, seg.length, ends)
-  if (count <= 1) return metrics.fit = { mode, advances: null, lineStartExtras: null, lineStartProhibitions: null, entryGeometry: null }
-  let prohibitions                    = null
-  if (withLineStartProhibitions) {
-    for (let i = 1; i < count; i++) if (!canWebKitLineStartWith(seg.charCodeAt(ends[i - 1] ))) (prohibitions ??= new Uint8Array(count))[i] = 1
-  }
+  if (count <= 1) return metrics.fit = { mode, advances: null, lineStartExtras: null }
   let advances          
   let lineStartExtras                  = null
+  // Whether each advance is of a grapheme measured after the one before it alone.
+  let pairs = false
   if (mode === 'reshaped-lines') {
     // Blink shapes a line of a cut word again where the cut falls between letters shaped
     // together (EngineProfile's cutWordFit). Premise: a line holds the letters whose width,
@@ -940,19 +1225,42 @@ export function getSegmentFit(
     advances = alone
     if (!addUpTo(alone, width)) {
       advances = measureFitAdvances(seg, ends, count, 'pair-context', metrics, measurement, emojiCorrection, followingSpaceWidth)
-      if (count <= MAX_PREFIX_FIT_GRAPHEMES && !addUpTo(advances, width)) {
-        advances = measureFitAdvances(seg, ends, count, 'segment-prefixes', metrics, measurement, emojiCorrection, followingSpaceWidth)
-      }
+      pairs = count > MAX_PREFIX_FIT_GRAPHEMES || addUpTo(advances, width)
+      if (!pairs) advances = measureFitAdvances(seg, ends, count, 'segment-prefixes', metrics, measurement, emojiCorrection, followingSpaceWidth)
       lineStartExtras = [0]
       for (let i = 1; i < count; i++) lineStartExtras.push(alone[i]  - advances[i] )
     }
   } else {
     // Past MAX_PREFIX_FIT_GRAPHEMES, prefixes give way to pairs.
     const prefixes = mode === 'segment-prefixes' && count <= MAX_PREFIX_FIT_GRAPHEMES
-    advances = measureFitAdvances(seg, ends, count, mode === 'segment-prefixes' && !prefixes ? 'pair-context' : mode, metrics, measurement, emojiCorrection, followingSpaceWidth)
+    pairs = mode !== 'sum-graphemes' && !prefixes
+    advances = measureFitAdvances(seg, ends, count, pairs ? 'pair-context' : mode, metrics, measurement, emojiCorrection, followingSpaceWidth)
     if (prefixes && profile.cutWordKeepsLigatures) countLigaturesOnFirstLetter(seg, ends, advances, measurement, emojiCorrection)
   }
-  return metrics.fit = { mode, advances, lineStartExtras, lineStartProhibitions: prohibitions, entryGeometry: null }
+  // Two kana that Canvas shapes apart inside the segment, as in a keep-all group, kern in
+  // Blink's layout as two segments do, and a line cut between them is shaped again without
+  // the kerning (addKanaKerning in prepare.ts has the rule): one that tightens the pair goes
+  // on the second kana's advance, which gives it back where a line starts with it, and one
+  // that widens it on the first's. Canvas cuts only before a kana letter, which starts a
+  // grapheme. An advance measured after the grapheme before it alone is of a string that
+  // starts at that grapheme, and Canvas's words are read from there: a mark that starts
+  // it is in one word with the letter after it, whose advance has their kerning already.
+  if (profile.kernsAcrossCanvasWords && measurement.kanaKerning !== null && kanaPairRe.test(seg)) {
+    const kernings = getFontKanaKerning(measurement)
+    if (kernings !== null) {
+      for (let g = 1; g < count; g++) {
+        const kerning = getKanaKerning(seg, pairs && g > 1 ? ends[g - 2]  : 0, ends[g - 1] , measurement, kernings)
+        if (kerning > 0) {
+          advances[g - 1] = advances[g - 1]  + kerning
+        } else if (kerning < 0) {
+          advances[g] = advances[g]  + kerning
+          lineStartExtras ??= zeros(count)
+          lineStartExtras[g] = lineStartExtras[g]  - kerning
+        }
+      }
+    }
+  }
+  return metrics.fit = { mode, advances, lineStartExtras }
 }
 
 // Moves the advance of each later letter of a ligature onto the ligature's first letter, in a
@@ -1053,31 +1361,57 @@ function measureFitAdvances(
 // prefixes and line-edge facts all come from that shaping. The context isn't touched
 // here: text that is all in the font's caches measures nothing (getContext).
 export function getFontMeasurement(font        , language               , letterSpaced         )                  {
-  // Preparation starts here, with the language it resolved. After that language
-  // changes, start again with a new context and empty caches; clearing the caches
-  // alone would re-measure with fonts resolved under the old language.
+  // Measuring starts here, for a text and for each item of a rich-inline paragraph, with the
+  // language the preparation resolved. After that language changes, start again with a new
+  // context and empty caches; clearing the caches alone would re-measure with fonts resolved
+  // under the old language.
   if (measureState === null || measureState.language !== language) measureState = createMeasureState(language)
   const state = measureState
   const shaped = letterSpaced && state.shapesLetterSpaced
   const fonts = shaped ? state.letterSpacedFonts : state.fonts
+  // The first measurement after a lookup sets the font again, the same string too: Firefox's
+  // context takes a face added to document.fonts only when its font is assigned, and the
+  // question below leaves the context on a font of its own, whether it throws or not.
+  state.font = ''
   let measurement = fonts.get(font)
   if (measurement === undefined) {
     const canvasFont = state.genericFamilies === null ? font : getCanvasFont(font, state.genericFamilies)
-    measurement = { state, canvasFont, letterSpacing: shaped ? LETTER_SPACED_SHAPING : '0px', metrics: new Map(), followingSpaceMetrics: new Map(), spaceKerning: undefined, emojiCorrection: null, emojiWidth: 0, hyphenText: null, spaceWidth: null, hanKerning: undefined, ligaturePairs: new Map() }
+    if (!contextTakesFont(state.context, canvasFont)) throw new RangeError(`font must be a font string Canvas takes, a size in px then a family, such as 16px Inter, not "${font}"`)
+    measurement = { state, canvasFont, letterSpacing: shaped ? LETTER_SPACED_SHAPING : '0px', metrics: new Map(), followingSpaceMetrics: new Map(), spaceKerning: undefined, measuredKana: false, kanaKerning: undefined, kanaFont: canvasFont, emojiCorrection: null, emojiWidth: 0, hyphenText: null, spaceWidth: null, hanKerning: undefined, ligaturePairs: new Map(), glyphCounts: new Map() }
     fonts.set(font, measurement)
   }
-  // The first measurement after a lookup sets the font again, the same string too: Firefox's
-  // context takes a face added to document.fonts only when its font is assigned.
-  state.font = ''
   return measurement
 }
 
+// Whether a Canvas context takes a font string. A context ignores a string that isn't a CSS font
+// shorthand and keeps the font it had (the HTML standard's font setter): a family before its
+// size, a string with no family, `var(--font)`, or an empty string, which
+// getComputedStyle(element).font is where the element sets a longhand the shorthand can't hold.
+// Firefox's OffscreenCanvas also ignores a size relative to a font, such as 1.2em or 120%, which
+// it has no element to resolve against (SetFontInternalDisconnected,
+// CanvasRenderingContext2D.cpp:4478-4490), and Firefox's and Safari's a system font such as
+// `caption` (Firefox 157.0.1, Safari 27.0, 2026-10-11). Every width would then be measured in
+// whatever font the context held last, so Pretext refuses such a string rather than guess at it,
+// as it refuses a letter spacing that isn't finite (readLetterSpacing). The context is set to a
+// font of the question's, then to the caller's, and still reads the first only where the
+// caller's was ignored; a caller's font that reads back as the first is asked again after
+// another. A context that doesn't read the question's font back as written refuses nothing.
+// Only the context's `font` is written and read, no element and no style, and nothing is
+// measured. Asked once for each font measurement, never for a text.
+function contextTakesFont(context                                                              , font        )          {
+  context.font = '1px serif'
+  context.font = font
+  if (context.font !== '1px serif') return true
+  context.font = '2px serif'
+  context.font = font
+  return context.font !== '2px serif'
+}
+
 // The font's context, set to the font and its shaping. Every measurement in a font takes
 // its context from here as it measures, so none reads a width under another font's
 // setting, whatever was looked up or prepared in between, and text that is all cached,
 // which measures nothing, sets nothing. What changes the context after that puts it back
-// before it returns (getHyphenText, measureWithLetterSpacing, getFontSpaceKerning,
-// isLigature).
+// before it returns (getHyphenText, getExtraSpacings, getFontSpaceKerning, isLigature).
 export function getContext(measurement                 )                                                               {
   const state = measurement.state
   if (state.font !== measurement.canvasFont) state.context.font = state.font = measurement.canvasFont
@@ -1085,18 +1419,20 @@ export function getContext(measurement                 )
   return state.context
 }
 
-function createMeasureState(language               )               {
-  let context                                                              
-  if (typeof OffscreenCanvas !== 'undefined') {
-    context = new OffscreenCanvas(1, 1).getContext('2d') 
-  } else if (typeof document !== 'undefined') {
-    context = document.createElement('canvas').getContext('2d') 
-  } else {
-    throw new Error('Text measurement requires OffscreenCanvas or a DOM canvas context.')
-  }
-  // A context's `lang` follows the page's, and preparation's can be setLocale()'s or
-  // Blink's default locale instead.
+// A context's `lang` follows the page's, and preparation's can be setLocale()'s or Blink's
+// default locale instead.
+function createContext(language               )                                                               {
+  // jsdom and happy-dom have a document whose canvas gives no 2D context: getContext() returns null there.
+  let context                                                                      = null
+  if (typeof OffscreenCanvas !== 'undefined') context = new OffscreenCanvas(1, 1).getContext('2d')
+  else if (typeof document !== 'undefined') context = document.createElement('canvas').getContext('2d')
+  if (context === null) throw new Error('Text measurement requires OffscreenCanvas or a DOM canvas context.')
   if (language !== null && 'lang' in context) context.lang = language
+  return context
+}
+
+function createMeasureState(language               )               {
+  const context = createContext(language)
   const profile = getEngineProfile()
   const takesLetterSpacing = typeof context.letterSpacing === 'string'
   return {
@@ -1104,15 +1440,20 @@ function createMeasureState(language               )               {
     context,
     font: '',
     letterSpacing: '0px',
+    wholeRunContext: null,
+    wholeRunFont: '',
     genericFamilies: language !== null && profile.namesGenericFamiliesByLanguage ? getWebKitGenericFamilies(language, context) : null,
     takesLetterSpacing,
     shapesLetterSpaced: takesLetterSpacing && profile.canvasLetterSpacingDropsLigatures,
     fonts: new Map(),
     letterSpacedFonts: new Map(),
+    segments: 0,
   }
 }
 
 export function clearMeasurementCaches()       {
-  measureState?.fonts.clear()
-  measureState?.letterSpacedFonts.clear()
+  if (measureState === null) return
+  measureState.fonts.clear()
+  measureState.letterSpacedFonts.clear()
+  measureState.segments = 0
 }