punctilio 4.3.1 → 5.0.1

package/src/dashes.ts

@@ -1,18 +1,20 @@
-import { cachedRegExp, DEFAULT_SEPARATOR, LATIN_LETTERS, UNICODE_SYMBOLS } from "./constants.js"
-import { boundaryCountAt, type ProseView, replaceAllInView, type ReplaceAllOptions, withProseView } from "./prose-view.js"
+import { cachedRegExp, LATIN_LETTERS, NBSP_CHARS, SPACE_CHARS, UNICODE_SYMBOLS } from "./constants.js"
+import { boundaryCountAt, overInput, type ProseView, replaceAllInView, type ReplaceAllOptions } from "./prose-view.js"
 import { namedGroups } from "./utils.js"
 
 export const DASH_STYLES = ["american", "british", "none"] as const
 export type DashStyle = (typeof DASH_STYLES)[number]
 
 export interface DashOptions {
-  /** Boundary marker for HTML element boundaries. Default: "" */
-  separator?: string
   /** "american" (unspaced em), "british" (spaced en), "none". Default: "american" */
   dashStyle?: DashStyle
 }
 
-const { EN_DASH, EM_DASH, MINUS, MULTIPLICATION, PLUS_MINUS, SUPERSCRIPT_ST, SUPERSCRIPT_ND, SUPERSCRIPT_RD, SUPERSCRIPT_TH, LEFT_DOUBLE_QUOTE, RIGHT_DOUBLE_QUOTE, LEFT_SINGLE_QUOTE, RIGHT_SINGLE_QUOTE } = UNICODE_SYMBOLS
+const {
+  EN_DASH, EM_DASH, MINUS, MULTIPLICATION, PLUS_MINUS,
+  LEFT_DOUBLE_QUOTE, RIGHT_DOUBLE_QUOTE, LEFT_SINGLE_QUOTE, RIGHT_SINGLE_QUOTE,
+  SUPERSCRIPT_ST, SUPERSCRIPT_ND, SUPERSCRIPT_RD, SUPERSCRIPT_TH,
+} = UNICODE_SYMBOLS
 
 // Prevents false-positive ranges in model names like "Llama-2-7B".
 export const numberRangeDisallowedPrefixes = ["-", EN_DASH, EM_DASH, MINUS] as const
@@ -35,11 +37,54 @@ const monthPattern = months.join("|")
 const WORD_CHAR_RE = /\w/
 const LATIN_LETTER_RE = new RegExp(`[${LATIN_LETTERS}]`)
 
+/**
+ * Glyphs the symbol passes fold word characters into (multiplication `x` →
+ * `×`, ordinal suffixes → superscripts). The dash rules run before those
+ * passes, so their word-character tests must treat a folded glyph like the
+ * word character it folds from — otherwise a range blocked at `6x3` converts
+ * once a re-run sees `6×3`.
+ */
+const FOLDED_WORD_CHARS = new Set<string>([
+  MULTIPLICATION,
+  ...SUPERSCRIPT_ST, ...SUPERSCRIPT_ND, ...SUPERSCRIPT_RD, ...SUPERSCRIPT_TH,
+])
+
+/** `\w` extended with {@link FOLDED_WORD_CHARS} for fold-stable `\b` checks. */
+function isWordChar(ch: string | undefined): boolean {
+  return ch !== undefined && (WORD_CHAR_RE.test(ch) || FOLDED_WORD_CHARS.has(ch))
+}
+
+/**
+ * Glyphs the math-symbol pass folds two-character operators into (`=~` → `≈`,
+ * `!=` → `≠`, ...). The fold tolerates one node boundary at its junction, so
+ * it can consume the character that sat between a boundary and a dash.
+ */
+const FOLDED_MATH_OPERATORS = new Set<string>([
+  UNICODE_SYMBOLS.APPROXIMATE,
+  UNICODE_SYMBOLS.GREATER_EQUAL,
+  UNICODE_SYMBOLS.LESS_EQUAL,
+  UNICODE_SYMBOLS.NOT_EQUAL,
+  UNICODE_SYMBOLS.PLUS_MINUS,
+])
+
+/**
+ * Glyphs the symbol passes fold from a source ending in a dash char (`<-` →
+ * `←`, `+-` → `±`). Where a trailing hyphen blocks a dash rule, its folded
+ * glyph must keep blocking, or the rule fires only on the re-run.
+ */
+const FOLDED_FROM_TRAILING_DASH = new Set<string>([
+  UNICODE_SYMBOLS.ARROW_LEFT,
+  UNICODE_SYMBOLS.PLUS_MINUS,
+])
+
+/** Mirror of {@link FOLDED_FROM_TRAILING_DASH} for sources starting with a
+ * dash char (`->` → `→`). */
+const FOLDED_FROM_LEADING_DASH = new Set<string>([UNICODE_SYMBOLS.ARROW_RIGHT])
+
 /**
  * Runs one boundary-gated regex pass over the view and commits it immediately.
- * v4 chained `text.replace` calls, each operating on the previous pass's full
- * output; committing after every pass reproduces that sequencing so a later
- * pass sees the earlier edits and never queues an overlapping edit.
+ * Committing after every pass sequences the passes so a later pass sees the
+ * earlier edits and never queues an overlapping edit.
  */
 function pass(
   view: ProseView,
@@ -54,11 +99,13 @@ function pass(
 // ---------------------------------------------------------------------------
 // Boundary-tolerance helpers over a ProseView
 //
-// v4 wove `${escapedSep}?` into patterns to tolerate the sentinel at specific
-// positions. Over a clean ProseView, `replaceAllInView` skips any match with an
-// interior boundary unless `allowBoundaries` opts in. Each pass below builds an
-// `allowBoundaries` callback that admits a match only when every interior
-// boundary sits at a position where the v4 pattern carried a separator weave.
+// The boundary-tolerance positions throughout this module reproduce the
+// element-boundary semantics of the pre-v5 sentinel-marked pipeline; they are
+// pinned by the golden corpus and the migration's differential fuzz. Over a
+// clean ProseView, `replaceAllInView` skips any match with an interior boundary
+// unless `allowBoundaries` opts in. Each pass below builds an `allowBoundaries`
+// callback that admits a match only when every interior boundary sits at a
+// tolerated slot offset.
 // ---------------------------------------------------------------------------
 
 /** Interior boundary offsets of a match, strictly inside (matchStart, matchEnd). */
@@ -75,9 +122,9 @@ function interiorBoundaryOffsets(match: RegExpExecArray, view: ProseView): numbe
 
 /**
  * True iff every interior boundary of the match lands on a tolerated offset,
- * with no offset carrying more boundaries than its budget. A v4 `${chr}?` slot
- * tolerates exactly one boundary; two stacked boundaries (an empty fragment)
- * exceed the single-separator budget and block the match, as in v4.
+ * with no offset carrying more boundaries than its budget. A tolerated slot
+ * admits exactly one boundary; two stacked boundaries (an empty fragment)
+ * exceed the single-boundary budget and block the match.
  */
 function interiorBoundariesAllowed(
   match: RegExpExecArray,
@@ -108,8 +155,7 @@ const MAX_BOUNDARY_SEPARATORS = 3
 function wordBoundaryStartOk(view: ProseView, matchStart: number): boolean {
   if (matchStart === 0) return true
   const nb = boundaryCountAt(view, matchStart)
-  const prev = view.text[matchStart - 1]
-  const prevWord = prev !== undefined && WORD_CHAR_RE.test(prev)
+  const prevWord = isWordChar(view.text[matchStart - 1])
   if (nb === 0) return !prevWord // `\b` needs a non-word char immediately left
   // A separator sits left (non-word) so `\b` holds; the lookbehind blocks only
   // when a word char is within ≤MAX boundaries.
@@ -124,13 +170,17 @@ function wordBoundaryStartOk(view: ProseView, matchStart: number): boolean {
  */
 function wordBoundaryEndOk(view: ProseView, pos: number): boolean {
   const text = view.text
-  // `wordBoundaryEndOk` is only ever called at the end of a digit run, so `pos`
-  // is always ≥ 1 and `text[pos - 1]` is a real char.
-  const prevChar = text[pos - 1] as string
-  const leftWord = WORD_CHAR_RE.test(prevChar)
+  // `wordBoundaryEndOk` is only ever called at the end of a digit, letter, or
+  // suffix run, so `pos` is always ≥ 1 and `text[pos - 1]` is a real char.
+  const leftWord = isWordChar(text[pos - 1])
+  // A multiplication sign one space to the right blocks like the word char
+  // it folds from: the multiplication pass renders `5X 8` as `5 × 8`, and a
+  // range blocked at `3-5X` must stay blocked at `3-5 ×`.
+  if (text[pos] !== undefined && SPACE_CHAR_RE.test(text[pos]) && text[pos + 1] === MULTIPLICATION) {
+    return false
+  }
   const nb = boundaryCountAt(view, pos)
-  const nextClean = text[pos]
-  const nextCleanWord = nextClean !== undefined && WORD_CHAR_RE.test(nextClean)
+  const nextCleanWord = isWordChar(text[pos])
   // The marked char right after pos is a separator when nb > 0 (non-word).
   const rightWord = nb > 0 ? false : nextCleanWord
   if (leftWord === rightWord) return false // no `\b`
@@ -145,23 +195,22 @@ function wordBoundaryEndOk(view: ProseView, pos: number): boolean {
 const CURRENCY_RE = /[$€£¥₹]/
 
 /** Convert number ranges to en-dash (e.g., "1-5" → "1–5"). */
-export function enDashNumberRange(text: string, options: DashOptions = {}): string {
-  const separator = options.separator ?? DEFAULT_SEPARATOR
-  return withProseView(text, separator, (view) => {
+export function enDashNumberRange(input: string): string
+export function enDashNumberRange(input: ProseView): void
+export function enDashNumberRange(input: string | ProseView): string | void {
+  return overInput(input, (view) => {
     convertPositiveRanges(view)
     convertNegativeRanges(view)
   })
 }
 
 /**
- * v4's positive-range regex was `phoneAreaCode? \b (?:p\.?|[currency])?\d[\d.,]*
- * -{1,3} [currency]?\d[\d.,]* (?:${chr}?[-−]${chr}?\d+)* (?:[AaPp][Mm]|[xKBTM])?
- * \b`, scanned with the `g` flag. The lookbehinds (`notAfterDash`) and the
- * separator weaves cannot survive over clean text, and — critically — the
- * `g`-flag consume/advance behaviour determines which sub-ranges a later pass
- * sees. The scan below reproduces it: at each offset it attempts the structural
- * match (boundary-aware), consuming its span on success (whether or not the
- * dash converts) and advancing one character otherwise. So a multi-segment
+ * The positive-range shape is `phoneAreaCode? \b (?:p\.?|[currency])?\d[\d.,]*
+ * -{1,3} [currency]?\d[\d.,]* (?:[-−]\d+)* (?:[AaPp][Mm]|[xKBTMCF])? \b`, scanned
+ * left to right. The consume/advance behaviour determines which sub-ranges a
+ * later pass sees. The scan below realizes it: at each offset it attempts the
+ * structural match (boundary-aware), consuming its span on success (whether or
+ * not the dash converts) and advancing one character otherwise. So a multi-segment
  * number whose head fails to form a structural match (e.g. boundary-broken
  * "2024-01-15") still exposes a later sub-range ("01-15"), while a structurally
  * matching but non-converting number hides its inner dashes.
@@ -177,17 +226,17 @@ function convertPositiveRanges(view: ProseView): void {
 }
 
 /**
- * Attempts v4's `phoneAreaCode? \b rangeStart -{1,3} rangeEnd following* suffix?
+ * Attempts the `phoneAreaCode? \b rangeStart -{1,3} rangeEnd following* suffix?
  * \b` structural match beginning at clean offset `i`, converting the dash when
- * v4's gates pass. Returns the consumed end offset on a structural match (so the
+ * the gates pass. Returns the consumed end offset on a structural match (so the
  * scan skips it), or null when no structural match begins at `i`.
  */
 function matchPositiveRangeAt(view: ProseView, i: number): number | null {
   // Optional phoneAreaCode (`\d{3}-` or `(\d{3}) `); when it ends in a dash that
-  // dash can instead be the range dash, so both interpretations are tried. v4's
-  // `rangeStart` carries no leading separator slot, so a boundary right where it
-  // would begin (just past the area code) invalidates the area-code reading: v4
-  // falls back to treating the area-code digits as the range start.
+  // dash can instead be the range dash, so both interpretations are tried.
+  // `rangeStart` carries no leading slot, so a boundary right where it would
+  // begin (just past the area code) invalidates the area-code reading: fall back
+  // to treating the area-code digits as the range start.
   const areaCode = readPhoneAreaCode(view, i)
   const startStarts = areaCode === null || view.hasBoundary(i + areaCode) ? [i] : [i + areaCode, i]
   for (const startStart of startStarts) {
@@ -200,10 +249,10 @@ function matchPositiveRangeAt(view: ProseView, i: number): number | null {
 const THREE_DIGITS_RE = /^\d\d\d/
 const THREE_DIGITS_IN_PARENS_RE = /^\(\d\d\d\)/
 
-/** v4's `phoneAreaCode` = `\d{3}-|\(\d{3}\) ?` at `i`; returns its length or null. */
+/** `phoneAreaCode` = `\d{3}-|\(\d{3}\) ?` at `i`; returns its length or null. */
 function readPhoneAreaCode(view: ProseView, i: number): number | null {
   const text = view.text
-  // `\d{3}-` with no separator woven into the digits or before the dash.
+  // `\d{3}-` with no boundary inside the digits or before the dash.
   if (THREE_DIGITS_RE.test(text.slice(i, i + 3)) && text[i + 3] === "-"
     && !view.hasBoundary(i + 1) && !view.hasBoundary(i + 2) && !view.hasBoundary(i + 3)) {
     return 4
@@ -217,8 +266,8 @@ function readPhoneAreaCode(view: ProseView, i: number): number | null {
 
 /**
  * Matches `\b rangeStart -{1,3} rangeEnd following* suffix? \b` boundary-aware,
- * beginning the start at `startStart`. Converts the dash on a v4-converting
- * match. Returns the consumed end offset (structural span end) or null.
+ * beginning the start at `startStart`. Converts the dash on a converting match.
+ * Returns the consumed end offset (structural span end) or null.
  */
 function matchRangeBody(view: ProseView, startStart: number): number | null {
   const text = view.text
@@ -226,10 +275,10 @@ function matchRangeBody(view: ProseView, startStart: number): number | null {
   const start = readStartRun(view, startStart)
   if (start === null) return null
   const startSpanEnd = startStart + start.length
-  // One `${chr}?` between start and the dash tolerates a single boundary there.
+  // One slot between start and the dash tolerates a single boundary there.
   if (boundaryCountAt(view, startSpanEnd) > 1) return null
   // Dash run of 1..3 hyphens that never spans an interior boundary (a boundary
-  // between two hyphens truncates the run, as in v4's `-{1,3}`).
+  // between two hyphens truncates the run).
   if (text[startSpanEnd] !== "-") return null
   let dashEnd = startSpanEnd + 1
   while (text[dashEnd] === "-" && dashEnd - startSpanEnd < 3 && !view.hasBoundary(dashEnd)) dashEnd++
@@ -243,7 +292,7 @@ function matchRangeBody(view: ProseView, startStart: number): number | null {
 
   const end = readEndRun(view, dashEnd)
   if (end === null) return null
-  // v4's greedy end `[\d.,]*` and greedy `following*` backtrack together; the
+  // The greedy end `[\d.,]*` and greedy `following*` backtrack together; the
   // structural match commits at the longest end whose tail completes.
   for (let len = end.length; len >= end.minLen; len--) {
     const endPos = end.firstDigitStart + len
@@ -259,8 +308,8 @@ function matchRangeBody(view: ProseView, startStart: number): number | null {
 }
 
 /**
- * v4's `(?:p\.?|[currency])?\d[\d.,]*` start run, boundary-truncated. v4's `wb`
- * (`(?<!\w${chr}{0,3})\b`) anchors the start at a word boundary, so the currency
+ * The `(?:p\.?|[currency])?\d[\d.,]*` start run, boundary-truncated. The `wb`
+ * (`(?<!\w)\b`) anchors the start at a word boundary, so the currency
  * alternative is unreachable: a leading currency symbol is non-word, and the only
  * `\b` sits after it, at the digit — so the currency is never part of `start`
  * (e.g. "$100-2000" reads start "100", which the 3+4 phone gate then blocks). The
@@ -270,8 +319,8 @@ function readStartRun(view: ProseView, pos: number): { length: number } | null {
   const text = view.text
   let i = pos
   if (text[i] === "p") {
-    // v4's `p\.?\d` is contiguous (no separator slot), so a boundary between `p`,
-    // an optional `.`, and the first digit breaks the prefix.
+    // `p\.?\d` is contiguous (no interior slot), so a boundary between `p`, an
+    // optional `.`, and the first digit breaks the prefix.
     if (view.hasBoundary(i + 1)) return null
     i++
     if (text[i] === ".") {
@@ -279,7 +328,7 @@ function readStartRun(view: ProseView, pos: number): { length: number } | null {
       i++
     }
   }
-  // v4's `\d` is required after the optional `p\.?` prefix. The prefix chars are
+  // `\d` is required after the optional `p\.?` prefix. The prefix chars are
   // never digits, so a missing digit here means no start run begins.
   if (!/\d/.test(text[i] ?? "")) return null
   i++
@@ -296,12 +345,12 @@ interface EndRun {
   minLen: number
 }
 
-/** v4's `[currency]?\d[\d.,]*` end run starting at `pos`, boundary-truncated. */
+/** The `[currency]?\d[\d.,]*` end run starting at `pos`, boundary-truncated. */
 function readEndRun(view: ProseView, pos: number): EndRun | null {
   const text = view.text
   let i = pos
   if (CURRENCY_RE.test(text[i] ?? "")) {
-    // v4 has no separator slot between the currency symbol and the digit.
+    // No slot between the currency symbol and the digit.
     if (view.hasBoundary(i + 1)) return null
     i++
   }
@@ -320,7 +369,7 @@ interface ResolvedTail {
 
 /**
  * Resolves the tail at `endPos`: finds the longest `following` whose
- * `suffix? wbe` completes (v4's greedy choice). `followingEmpty` reports whether
+ * `suffix? wbe` completes (the greedy choice). `followingEmpty` reports whether
  * that following is empty (the convert condition); `consumedEnd` is the tail's
  * end including any suffix (for the scan's consume/advance). Returns null when
  * no following completes.
@@ -339,9 +388,9 @@ function resolvePositiveTail(view: ProseView, endPos: number): ResolvedTail | nu
 
 /**
  * Negative ranges: −5-5 → −5–5, −5--2 → −5–−2. A separate hand scan (not a regex)
- * because the end run, like v4's `(?<end>${chr}?\d[\d.,]*)`, must truncate at node
- * boundaries before its tail is resolved: over clean text a regex would fuse
- * separator-split digits into one run (e.g. "8{sep}{sep}{sep}{sep}{sep}0" reads as
+ * because the end run (`\d[\d.,]*`, with one tolerated boundary at its head)
+ * must truncate at node boundaries before its tail is resolved: a regex would
+ * fuse boundary-split digits into one run (e.g. "8{b}{b}{b}{b}{b}0" reads as
  * "80") and mis-place or miss the conversion. The scan mirrors `matchRangeBody`:
  * at each MINUS-led start it resolves the longest end whose `following* suffix?
  * wbe` tail completes, converting only when that tail leaves `following` empty.
@@ -363,25 +412,25 @@ function convertNegativeRanges(view: ProseView): void {
 }
 
 /**
- * Attempts v4's `(?<![LAT]) ${MINUS}\d[\d.,]* -{1,3} -? end following* suffix? wbe`
- * beginning the MINUS at clean offset `i`. Converts the dash run when v4's gates
+ * Attempts `(?<![LAT]) ${MINUS}\d[\d.,]* -{1,3} -? end following* suffix? wbe`
+ * beginning the MINUS at clean offset `i`. Converts the dash run when the gates
  * pass. Returns the consumed structural end offset, or null when no match begins.
  */
 function matchNegativeRangeAt(view: ProseView, i: number): number | null {
   const text = view.text
-  // v4's `(?<![LAT])`: a Latin letter directly before the MINUS (no intervening
+  // `(?<![LAT])`: a Latin letter directly before the MINUS (no intervening
   // boundary, which would hide it) blocks the match.
   if (boundaryCountAt(view, i) === 0) {
     const before = text[i - 1]
     if (before !== undefined && LATIN_LETTER_RE.test(before)) return null
   }
 
-  // start = `${MINUS}\d[\d.,]*${chr}?`: the digits after MINUS must not cross a
-  // boundary (v4's `start` body has no separator slot before its trailing one).
+  // start = `${MINUS}\d[\d.,]*`: the digits after MINUS must not cross a
+  // boundary (the `start` body has no interior slot before its trailing one).
   if (!/\d/.test(text[i + 1] ?? "")) return null
   let startEnd = i + 1
   while (/[\d.,]/.test(text[startEnd] ?? "") && !view.hasBoundary(startEnd)) startEnd++
-  // One `${chr}?` between start and the dash tolerates a single boundary there.
+  // One slot between start and the dash tolerates a single boundary there.
   if (boundaryCountAt(view, startEnd) > 1) return null
   if (text[startEnd] !== "-") return null
 
@@ -392,12 +441,12 @@ function matchNegativeRangeAt(view: ProseView, i: number): number | null {
   const dashRunLen = dashRunEnd - startEnd
   const hasNeg = dashRunLen >= 2
   const negEnd = dashRunEnd
-  // The `(?<end>${chr}?...)` head separator slot tolerates one boundary.
+  // The `end` head slot tolerates one boundary.
   if (boundaryCountAt(view, negEnd) > 1) return null
 
   const end = readNegEndRun(view, negEnd)
   if (end === null) return null
-  // v4's greedy end and `following*` backtrack together; commit at the longest end
+  // The greedy end and `following*` backtrack together; commit at the longest end
   // whose tail completes, converting only when that tail's `following` is empty.
   for (let len = end.length; len >= 1; len--) {
     const endPos = end.firstDigitStart + len
@@ -419,7 +468,7 @@ interface NegEndRun {
   length: number
 }
 
-/** v4's negative `end` body `\d[\d.,]*` starting at `pos`, boundary-truncated. */
+/** The negative `end` body `\d[\d.,]*` starting at `pos`, boundary-truncated. */
 function readNegEndRun(view: ProseView, pos: number): NegEndRun | null {
   const text = view.text
   if (!/\d/.test(text[pos] ?? "")) return null
@@ -430,9 +479,9 @@ function readNegEndRun(view: ProseView, pos: number): NegEndRun | null {
 
 /**
  * Boundary-aware `following` end positions, shortest (empty) first, walking
- * segments `${chr}?[-(−)]${chr}?\d+`. Separators are zero-width in clean text;
- * each `${chr}?` tolerates one boundary, and each `\d+` stops at a boundary.
- * `allowMinus` admits a MINUS as a segment's dash (positive ranges).
+ * segments `[-(−)]\d+`. Each segment tolerates one boundary on each side of its
+ * dash, and each `\d+` stops at a boundary. `allowMinus` admits a MINUS as a
+ * segment's dash (positive ranges).
  */
 function followingCandidates(view: ProseView, endSpanEnd: number, allowMinus: boolean): number[] {
   const candidates = [endSpanEnd]
@@ -452,39 +501,34 @@ function followingCandidates(view: ProseView, endSpanEnd: number, allowMinus: bo
   return candidates
 }
 
-// First characters of the four superscript ordinal pairs. \w does not match these
-// Unicode chars, so wordBoundaryEndOk treats them as non-word — but they carry the
-// same blocking semantics as the plain letters they render (st/nd/rd/th).
-const SUPERSCRIPT_ORDINAL_FIRST_RE = new RegExp(
-  `[${SUPERSCRIPT_ST[0]}${SUPERSCRIPT_ND[0]}${SUPERSCRIPT_RD[0]}${SUPERSCRIPT_TH[0]}]`,
-)
+/**
+ * Single-letter range suffixes: the multipliers `x`/`K`/`B`/`T`/`M` and the
+ * temperature units `C`/`F`. The degree pass rewrites `5C` to `5 °C` — a
+ * space a re-run's word boundary sees through — so the range must already
+ * convert with the unit attached. `X` and `×` are deliberately absent: an
+ * unconverted `1-10X` folds to `1-10×`, which the word-boundary check (which
+ * treats `×` as the word char it folds from) keeps blocking on re-runs.
+ */
+const RANGE_SUFFIX_RE = /[xKBTMCF]/
 
 /**
- * v4's `(?<suffix>${chr}?(?:[AaPp][Mm]|[xKBTM]))?${wbe}` at `pos`. Returns the
- * end offset after the optional suffix when the tail completes (wbe passes), or
- * null when it does not. Two non-`\w` glyphs the v5 symbol passes emit
- * (superscript ordinals, `×`) abut the digit run and must block conversion even
- * though `wbe` would read them as a clean word boundary; both return null first.
+ * The `(?:[AaPp][Mm]|[xKBTMCF])?${wbe}` suffix at `pos`, with one tolerated
+ * boundary before the suffix. Returns the end offset after the optional suffix
+ * when the tail completes (wbe passes), or null when it does not.
  */
 function suffixWbeEnd(view: ProseView, pos: number, allowAmPm: boolean): number | null {
-  const text = view.text
-  // A superscript ordinal immediately following the digit run blocks conversion:
-  // `52ⁿᵈ` is an ordinal, not a range endpoint (same semantics as `52nd`).
-  if (SUPERSCRIPT_ORDINAL_FIRST_RE.test(text[pos] ?? "")) return null
-  // `×` (MULTIPLICATION) is the Unicode form of `x` produced by the symbols pass.
-  // It is non-\w so wordBoundaryEndOk would treat it as a clean boundary, but
-  // `55×5` is multiplication, not a range endpoint — block the same as `52nd`.
-  if (text[pos] === MULTIPLICATION) return null
   if (wordBoundaryEndOk(view, pos)) return pos
-  // An optional suffix: one ${chr}? (zero-width, ≤1 boundary) then am/pm or one
-  // of x/K/B/T/M, followed by wbe. The suffix letters sit at the clean `pos`.
+  // An optional suffix: one tolerated boundary then am/pm or one of
+  // {@link RANGE_SUFFIX_RE}'s letters, followed by wbe. The suffix letters sit
+  // at the clean `pos`.
   if (boundaryCountAt(view, pos) > 1) return null
-  // `[AaPp][Mm]` is contiguous in v4 — a boundary between the two letters breaks
-  // the suffix.
+  const text = view.text
+  // `[AaPp][Mm]` is contiguous — a boundary between the two letters breaks the
+  // suffix.
   if (allowAmPm && /[ap]/i.test(text[pos] ?? "") && /m/i.test(text[pos + 1] ?? "") && !view.hasBoundary(pos + 1)) {
     return wordBoundaryEndOk(view, pos + 2) ? pos + 2 : null
   }
-  if (/[xKBTM]/.test(text[pos] ?? "")) {
+  if (RANGE_SUFFIX_RE.test(text[pos] ?? "")) {
     return wordBoundaryEndOk(view, pos + 1) ? pos + 1 : null
   }
   return null
@@ -492,20 +536,83 @@ function suffixWbeEnd(view: ProseView, pos: number, allowAmPm: boolean): number
 
 const NOT_AFTER_DASH_RE = new RegExp(`[${DISALLOWED_PREFIX_CLASS_FRAGMENT}${LATIN_LETTERS}${MULTIPLICATION}${PLUS_MINUS}.+]`)
 
+const SPACE_CHAR_RE = new RegExp(`[${SPACE_CHARS}]`)
+
 /**
- * v4's `notAfterDash` was a single-char negative lookbehind. A node boundary
- * immediately before the start hides the clean char (v4 saw the separator, not
- * the dash/letter), so the guard only fires when a disallowed clean char sits
+ * Offset of the dot reachable backwards across one inter-dot gap ending at the
+ * dot at `dotIndex` (the mirror of the ellipsis pass's forward gap rule: the
+ * gap is nothing, one space character, or one node boundary). -1 when none.
+ */
+function ellipsisPrevDot(view: ProseView, dotIndex: number): number {
+  const text = view.text
+  if (text[dotIndex - 1] === ".") {
+    // Empty gap: at most one boundary between the two dots.
+    return boundaryCountAt(view, dotIndex) <= 1 ? dotIndex - 1 : -1
+  }
+  // Space gap: one space character with no boundary on either side of it.
+  if (boundaryCountAt(view, dotIndex) === 0 && dotIndex >= 2 && SPACE_CHAR_RE.test(text[dotIndex - 1])
+    && text[dotIndex - 2] === "." && boundaryCountAt(view, dotIndex - 1) === 0) {
+    return dotIndex - 2
+  }
+  return -1
+}
+
+/** True iff the dot at `dotIndex` can close a `...`/`. . .` triple. */
+function endsFoldableEllipsisDots(view: ProseView, dotIndex: number): boolean {
+  const second = ellipsisPrevDot(view, dotIndex)
+  return second >= 0 && ellipsisPrevDot(view, second) >= 0
+}
+
+/**
+ * `notAfterDash` is a single-char negative lookbehind. A node boundary
+ * immediately before the start hides the clean char (a boundary is not the
+ * dash/letter), so the guard only fires when a disallowed clean char sits
  * directly before the start with no intervening boundary.
+ *
+ * A `.` that closes a dot triple does not block: the ellipsis pass (which
+ * runs after the dash rules) folds the triple to `…` and pads a following
+ * digit with a space, so a re-run would see a plain space here and convert —
+ * converting now reaches that fixed point in one pass. A line-leading em dash
+ * does not block for the same reason: the em-dash spacing normalizer pads it
+ * before a digit (`^—5` → `— 5`), mirroring that rule's one tolerated
+ * boundary at line start.
  */
 function notAfterDashOk(view: ProseView, startOffset: number): boolean {
   if (startOffset === 0) return true
   if (boundaryCountAt(view, startOffset) > 0) return true
   const prev = view.text[startOffset - 1]
-  return prev === undefined || !NOT_AFTER_DASH_RE.test(prev)
+  // A multiplication sign one space slot further left blocks like the `x` it
+  // folds from: the multiplication pass renders `5x8` as `5 × 8`, so a range
+  // blocked at `x8-6` must stay blocked at `× 8-6`.
+  if (prev !== undefined && SPACE_CHAR_RE.test(prev) && view.text[startOffset - 2] === MULTIPLICATION) {
+    return false
+  }
+  if (prev === undefined || !NOT_AFTER_DASH_RE.test(prev)) return true
+  if (prev === "." && endsFoldableEllipsisDots(view, startOffset - 1)) return true
+  const dashIndex = startOffset - 1
+  if (prev === EM_DASH && boundaryCountAt(view, dashIndex) <= 1
+    && (dashIndex === 0 || view.text[dashIndex - 1] === "\n" || emDashBehindLeadingSpaces(view, dashIndex))) {
+    return true
+  }
+  // An en dash behind leading spaces converts the same way: the spaced-dash
+  // rule renders it as a line-leading em dash, which the normalizer then pads.
+  return prev === EN_DASH && boundaryCountAt(view, dashIndex) <= 1
+    && emDashBehindLeadingSpaces(view, dashIndex)
+}
+
+/**
+ * True iff only plain spaces sit between text start and the em dash at
+ * `emIndex`. The spaced-dash rule collapses that run, leaving the em dash
+ * line-leading, which the spacing normalizer then pads before a digit — the
+ * same state the `\n` arm of {@link notAfterDashOk} accepts.
+ */
+function emDashBehindLeadingSpaces(view: ProseView, emIndex: number): boolean {
+  let j = emIndex
+  while (j > 0 && view.text[j - 1] === " ") j--
+  return j < emIndex && j === 0
 }
 
-/** v4 range-number gates: reject year-month, phone-shaped, and toll-free pairs. */
+/** Range-number gates: reject year-month, phone-shaped, and toll-free pairs. */
 function rangeNumbersConvert(startNum: string, endNum: string): boolean {
   if (/^(?:19|20)\d{2}$/.test(startNum) && /^(?:0[1-9]|1[0-2])$/.test(endNum)) return false
   // Skip 3+4 digit phone-shaped patterns (555-1234, or the second half of
@@ -525,23 +632,52 @@ function rangeNumbersConvert(startNum: string, endNum: string): boolean {
 // ---------------------------------------------------------------------------
 
 /** Convert month ranges to en-dash (e.g., "January-March" → "January–March"). */
-export function enDashDateRange(text: string, options: DashOptions = {}): string {
-  const dashStyle = options.dashStyle ?? "american"
-  if (dashStyle === "none") return text
-  const separator = options.separator ?? DEFAULT_SEPARATOR
+export function enDashDateRange(input: string, options?: DashOptions): string
+export function enDashDateRange(input: ProseView, options?: DashOptions): void
+export function enDashDateRange(input: string | ProseView, options: DashOptions = {}): string | void {
+  return overInput(input, (view) => enDashDateRangeOverView(view, options.dashStyle ?? "american"))
+}
+
+function enDashDateRangeOverView(view: ProseView, dashStyle: DashStyle): void {
+  if (dashStyle === "none") return
   const [pre, post] = dashStyle === "british" ? [" ", " "] : ["", ""]
 
-  return withProseView(text, separator, (view) => {
-    // Atomic-optional year groups (lookahead + backref). The capture inside the
-    // lookahead is locked in once matched, so the year group commits without
-    // backtracking.
-    const startYear = `(?=(?<startYear> \\d{4})?)\\k<startYear>`
-    const endYear = `(?=(?<endYear> \\d{4})?)\\k<endYear>`
-    const pattern = `\\b(?<startMonth>${monthPattern})${startYear}(?<preSpace> ?)-(?<postSpace> ?)(?<endMonth>${monthPattern})${endYear}\\b`
-    pass(
-      view,
-      cachedRegExp(pattern, "g"),
-      (match, v) => {
+  // Atomic-optional year groups (lookahead + backref). The capture inside the
+  // lookahead is locked in once matched, so the year group commits without
+  // backtracking. The year space also matches NBSP/NNBSP: the nbsp pass (which
+  // runs after the dash rules) glues "March 2025" with an NBSP, and the year
+  // must still capture on a re-run so the trailing-boundary gate sees the same
+  // end position.
+  const startYear = `(?=(?<startYear>[ ${NBSP_CHARS}]\\d{4})?)\\k<startYear>`
+  const endYear = `(?=(?<endYear>[ ${NBSP_CHARS}]\\d{4})?)\\k<endYear>`
+  const pattern = `\\b(?<startMonth>${monthPattern})${startYear}(?<preSpace> ?)-(?<postSpace> ?)(?<endMonth>${monthPattern})${endYear}\\b`
+  pass(
+    view,
+    cachedRegExp(pattern, "g"),
+    (match, v) => {
+      // The pattern's trailing `\b` sees a folded glyph (`×`, a superscript
+      // ordinal) as a non-word char, but the source character it folds from is
+      // a word char that blocks the match ("March 2025x3"); re-check the end
+      // boundary fold-stably.
+      if (!wordBoundaryEndOk(v, match.index + match[0].length)) return null
+      const groups = namedGroups<{
+        startMonth: string
+        startYear?: string
+        preSpace: string
+        postSpace: string
+        endMonth: string
+        endYear?: string
+      }>(matchArgs(match))
+      // Replace `[preSpace]-[postSpace]` (the dash and its spaces) with the
+      // styled en-dash, leaving the months and any boundaries around them.
+      const startLen = groups.startMonth.length + (groups.startYear?.length ?? 0)
+      const dashSpan = groups.preSpace.length + 1 + groups.postSpace.length
+      const dashStart = match.index + startLen
+      v.replace(dashStart, dashStart + dashSpan, `${pre}${EN_DASH}${post}`)
+      return null
+    },
+    {
+      allowBoundaries: (match, v) => {
         const groups = namedGroups<{
           startMonth: string
           startYear?: string
@@ -550,38 +686,19 @@ export function enDashDateRange(text: string, options: DashOptions = {}): string
           endMonth: string
           endYear?: string
         }>(matchArgs(match))
-        // Replace `[preSpace]-[postSpace]` (the dash and its spaces) with the
-        // styled en-dash, leaving the months and any boundaries around them.
         const startLen = groups.startMonth.length + (groups.startYear?.length ?? 0)
-        const dashSpan = groups.preSpace.length + 1 + groups.postSpace.length
+        // One boundary is tolerated after the start year and one before the end
+        // month, bracketing the dash and spaces.
         const dashStart = match.index + startLen
-        v.replace(dashStart, dashStart + dashSpan, `${pre}${EN_DASH}${post}`)
-        return null
-      },
-      {
-        allowBoundaries: (match, v) => {
-          const groups = namedGroups<{
-            startMonth: string
-            startYear?: string
-            preSpace: string
-            postSpace: string
-            endMonth: string
-            endYear?: string
-          }>(matchArgs(match))
-          const startLen = groups.startMonth.length + (groups.startYear?.length ?? 0)
-          // v4 tolerated one separator after the start year (`preSep`) and one
-          // before the end month (`postSep`), bracketing the dash and spaces.
-          const dashStart = match.index + startLen
-          const dashEnd = dashStart + groups.preSpace.length + 1 + groups.postSpace.length
-          const tolerated = new Map<number, number>()
-          tolerated.set(dashStart, 1)
-          tolerated.set(dashEnd, 1)
-          if (!interiorBoundariesAllowed(match, v, tolerated)) return false
-          return wordBoundaryStartOk(v, match.index) && wordBoundaryEndOk(v, match.index + match[0].length)
-        },
+        const dashEnd = dashStart + groups.preSpace.length + 1 + groups.postSpace.length
+        const tolerated = new Map<number, number>()
+        tolerated.set(dashStart, 1)
+        tolerated.set(dashEnd, 1)
+        if (!interiorBoundariesAllowed(match, v, tolerated)) return false
+        return wordBoundaryStartOk(v, match.index) && wordBoundaryEndOk(v, match.index + match[0].length)
       },
-    )
-  })
+    },
+  )
 }
 
 // ---------------------------------------------------------------------------
@@ -589,9 +706,10 @@ export function enDashDateRange(text: string, options: DashOptions = {}): string
 // ---------------------------------------------------------------------------
 
 /** Convert hyphens to minus signs in numeric contexts (e.g., "-5" → "−5"). */
-export function minusReplace(text: string, options: DashOptions = {}): string {
-  const separator = options.separator ?? DEFAULT_SEPARATOR
-  return withProseView(text, separator, (view) => {
+export function minusReplace(input: string): string
+export function minusReplace(input: ProseView): void
+export function minusReplace(input: string | ProseView): string | void {
+  return overInput(input, (view) => {
     minusSubtractionOfNegative(view)
     minusSpacedSubtraction(view)
     minusDirectNegative(view)
@@ -600,14 +718,14 @@ export function minusReplace(text: string, options: DashOptions = {}): string {
 
 /** Pattern 1a/1b: spaced math subtraction after a digit (`5 - 3`, `5 - -3`). */
 function minusSubtractionOfNegative(view: ProseView): void {
-  // "5 - -3" → "5 − −3"; the negative hyphen is consumed first. v4's `${chr}?`
-  // before `num` tolerates one boundary there (the `- -` prefix has 4 chars).
+  // "5 - -3" → "5 − −3"; the negative hyphen is consumed first. The slot before
+  // `num` tolerates one boundary there (the `- -` prefix has 4 chars).
   pass(
     view,
     cachedRegExp(`(?<=\\d) - -(?<num>\\d*\\.?\\d+)`, "g"),
     (match, v) => {
       // Replace only the ` - -` prefix; `num` (which may carry interior
-      // boundaries v4 truncated at) stays untouched.
+      // boundaries that truncate it) stays untouched.
       if (!minusSubtractionPrefixOk(match, v, 4)) return null
       v.replace(match.index, match.index + 4, ` ${MINUS} ${MINUS}`)
       return null
@@ -633,27 +751,27 @@ function minusSpacedSubtraction(view: ProseView): void {
 const NUM_BODY_RE = /^\d*\.?\d+/
 
 /**
- * v4's subtraction patterns wove one `${chr}?` after the leading digit (in the
- * lookbehind, at the match start) and one before `num` (`(?<num>${chr}?\d*\.?\d+)`).
- * The `${chr}?-` prefix span ([match.index, match.index + prefixLen)) must stay
- * separator-free; one boundary may sit at `num`'s head. v4's `num` body
- * (`\d*\.?\d+`) carries no separator slot, so it stops at the first interior
- * boundary: a boundary that truncates `num` to a still-valid number (e.g. "12"
- * in "5 - 12{sep}5") leaves v4 matching, but one that strips the mandatory `\d+`
- * (e.g. "." in "5 - .{sep}5") breaks v4's match. The targeted edit only rewrites
- * the ` - ` prefix, so a converting match must keep v4's `num` satisfiable.
+ * The subtraction patterns tolerate one boundary after the leading digit (at
+ * the match start) and one before `num`. The `-` prefix span ([match.index,
+ * match.index + prefixLen)) must stay boundary-free; one boundary may sit at
+ * `num`'s head. The `num` body (`\d*\.?\d+`) carries no interior slot, so it
+ * stops at the first interior boundary: a boundary that truncates `num` to a
+ * still-valid number (e.g. "12" in "5 - 12{b}5") leaves the match standing, but
+ * one that strips the mandatory `\d+` (e.g. "." in "5 - .{b}5") breaks it. The
+ * targeted edit only rewrites the ` - ` prefix, so a converting match must keep
+ * `num` satisfiable.
  */
 function minusSubtractionPrefixOk(match: RegExpExecArray, view: ProseView, prefixLen: number): boolean {
-  // The `${chr}?` in v4's lookbehind (`(?<=\d${chr}?)`) sits at the match start
-  // between the leading digit and the space; it tolerates at most one boundary.
+  // The slot in the lookbehind (`(?<=\d)`) sits at the match start between the
+  // leading digit and the space; it tolerates at most one boundary.
   if (boundaryCountAt(view, match.index) > 1) return false
   const numStart = match.index + prefixLen
   for (const b of view.boundaries) {
     if (b > match.index && b < numStart) return false
   }
-  // The `${chr}?` before `num` tolerates at most one boundary at the num head.
+  // The slot before `num` tolerates at most one boundary at the num head.
   if (boundaryCountAt(view, numStart) > 1) return false
-  // v4's `num` stops at the first interior boundary; the clean run up to it must
+  // `num` stops at the first interior boundary; the clean run up to it must
   // still satisfy `\d*\.?\d+` (the mandatory trailing `\d+`).
   const numEnd = match.index + match[0].length
   let truncatedEnd = numEnd
@@ -665,15 +783,27 @@ function minusSubtractionPrefixOk(match: RegExpExecArray, view: ProseView, prefi
 }
 
 const MINUS_BEFORE_CLASS_RE = new RegExp(`[\\s("'${LEFT_DOUBLE_QUOTE}${RIGHT_DOUBLE_QUOTE}${LEFT_SINGLE_QUOTE}${RIGHT_SINGLE_QUOTE}]`)
-const NUM_BEFORE_2B_BLOCK_RE = new RegExp(`[\\d.,${LATIN_LETTERS}]`)
+// The folded word glyphs block like the word chars they fold from ("1x|-0"
+// and "1×|-0" must agree), the folded math operators block like the operator
+// chars they fold from (the `!=` → `≠` fold consumes the `=` that blocked
+// Pattern 2 in "!=-1"), and the folded terminals — plus the bare `!` the
+// `!!` normalization leaves — block like the `!`/`?`/`.` runs they fold from
+// ("?|!-0" folds to "⁈|-0" with the hyphen stranded boundary-adjacent).
+const FOLDED_WORD_CLASS_FRAGMENT = [...FOLDED_WORD_CHARS].join("")
+const FOLDED_MATH_CLASS_FRAGMENT = [...FOLDED_MATH_OPERATORS].join("")
+const FOLDED_TERMINAL_CLASS_FRAGMENT = [
+  UNICODE_SYMBOLS.ELLIPSIS, UNICODE_SYMBOLS.DOUBLE_QUESTION, UNICODE_SYMBOLS.QUESTION_EXCLAMATION,
+  UNICODE_SYMBOLS.EXCLAMATION_QUESTION, UNICODE_SYMBOLS.DOUBLE_EXCLAMATION, UNICODE_SYMBOLS.INTERROBANG, "!",
+].join("")
+const NUM_BEFORE_2B_BLOCK_RE = new RegExp(`[\\d.,${LATIN_LETTERS}${FOLDED_WORD_CLASS_FRAGMENT}${FOLDED_MATH_CLASS_FRAGMENT}${FOLDED_TERMINAL_CLASS_FRAGMENT}]`)
 
 /**
- * Direct negative numbers. v4 ran two passes: Pattern 2 converts `-\d` after
- * line start, whitespace, `(`, or a quote; Pattern 2b converts `${chr}-\d` (a
- * separator-led hyphen) when no digit/`.`/`,`/Latin precedes the separator —
- * which prevents `1${chr}-2` and `GPT${chr}-3` from reading as negatives. In
- * the view, Pattern 2 fires when the clean char before the hyphen qualifies and
- * no boundary intrudes; Pattern 2b fires when a boundary leads the hyphen.
+ * Direct negative numbers, in two cases: Pattern 2 converts `-\d` after line
+ * start, whitespace, `(`, or a quote; Pattern 2b converts a boundary-led hyphen
+ * `-\d` when no digit/`.`/`,`/Latin precedes the boundary — which prevents
+ * `1{b}-2` and `GPT{b}-3` from reading as negatives. Pattern 2 fires when the
+ * clean char before the hyphen qualifies and no boundary intrudes; Pattern 2b
+ * fires when a boundary leads the hyphen.
  */
 function minusDirectNegative(view: ProseView): void {
   pass(
@@ -681,11 +811,11 @@ function minusDirectNegative(view: ProseView): void {
     cachedRegExp(`-(?<num>\\d*\\.?\\d+)`, "gm"),
     (match, v) => {
       const start = match.index
-      // v4's `num` (`\d*\.?\d+`) carries no separator slot, so it stops at the
-      // first interior boundary; the clean run up to it must still satisfy
+      // `num` (`\d*\.?\d+`) carries no interior slot, so it stops at the first
+      // interior boundary; the clean run up to it must still satisfy
       // `\d*\.?\d+`. A boundary right after the hyphen (head) leaves no digits
-      // ("-{sep}5"), and one that strips the mandatory `\d+` ("-.{sep}1") breaks
-      // the match, but one past a valid number ("-5{sep}5") leaves it intact.
+      // ("-{b}5"), and one that strips the mandatory `\d+` ("-.{b}1") breaks the
+      // match, but one past a valid number ("-5{b}5") leaves it intact.
       const numEnd = start + match[0].length
       let numTruncEnd = numEnd
       for (const b of v.boundaries) {
@@ -698,9 +828,9 @@ function minusDirectNegative(view: ProseView): void {
       // hyphen has either a boundary or a clean char immediately before it.)
       const nb = boundaryCountAt(v, start)
       if (nb > 0) {
-        // Pattern 2b: the marked char before the separator run must not be a
-        // digit, `.`, `,`, or Latin letter. With ≥2 stacked separators that char
-        // is another separator (admitted); with one, it is the clean char left.
+        // Pattern 2b: the char before the boundary run must not be a digit,
+        // `.`, `,`, or Latin letter. With ≥2 stacked boundaries that char is
+        // another boundary (admitted); with one, it is the clean char left.
         if (nb < 2) {
           const before = v.text[start - 1]
           if (before !== undefined && NUM_BEFORE_2B_BLOCK_RE.test(before)) return null
@@ -747,21 +877,21 @@ function isDashChar(ch: string | undefined): boolean {
  * before a word char (the suspended/hanging hyphen, "Yes-men and -women") is
  * skipped. The arrow guard rejects shapes like "- >" so `foo -> bar` stays.
  *
- * v4's dash core (`[${EN}${EM}][-${EN}${EM}]*|-{2,}|-(?!sep*[LAT\d])`) never
- * spanned a separator, so a node boundary inside the dash run truncates the run
- * — the boundary becomes the `sepAfter` slot and any dashes past it are left
- * untouched. The replacer reproduces this by truncating the run at the first
- * interior boundary and re-validating the dash core on the truncated form.
+ * The dash core (`[${EN}${EM}][-${EN}${EM}]*|-{2,}|-(?![LAT\d])`) never spans a
+ * boundary, so a node boundary inside the dash run truncates the run — the
+ * boundary becomes the trailing slot and any dashes past it are left untouched.
+ * The replacer realizes this by truncating the run at the first interior
+ * boundary and re-validating the dash core on the truncated form.
  */
 function convertSpacedDashes(view: ProseView, rendered: string): void {
-  // v4's `(?<=[^\s]|^)` lookbehind is validated in the replacer instead, since a
-  // separator (non-space) also satisfies it, letting a match begin even when the
+  // The `(?<=[^\s]|^)` lookbehind is validated in the replacer instead, since a
+  // boundary (non-space) also satisfies it, letting a match begin even when the
   // clean char to the left is whitespace. The cheap `(?<![ ])` anchor keeps each
   // `[ ]+` run starting at its leftmost space, avoiding quadratic backtracking.
   const pattern = `(?<![ ])[ ]+(?<dashStart>[-${EN_DASH}${EM_DASH}])`
-  // v4's regex consumed the trailing `[ ]*` inside each match, advancing past it;
-  // this clean pattern does not, so a later match could begin inside a previous
-  // match's consumed trailing spaces. Track the last consumed offset and skip.
+  // The full shape consumes the trailing `[ ]*`, advancing past it; this pattern
+  // does not, so a later match could begin inside a previous match's consumed
+  // trailing spaces. Track the last consumed offset and skip.
   let consumedThrough = -1
   pass(
     view,
@@ -770,8 +900,8 @@ function convertSpacedDashes(view: ProseView, rendered: string): void {
       const text = v.text
       const groups = namedGroups<{ dashStart: string }>(matchArgs(match))
       const firstDash = match.index + match[0].length - groups.dashStart.length
-      // v4's greedy `[ ]+` starts at the leftmost position whose `(?<=[^\s]|^)`
-      // holds: line/text start, a non-whitespace clean char, or a separator. A
+      // The greedy `[ ]+` starts at the leftmost position whose `(?<=[^\s]|^)`
+      // holds: line/text start, a non-whitespace clean char, or a boundary. A
       // boundary inside the leading spaces restarts the match just after it (the
       // spaces before it stay with the previous node). The previous match's
       // consumed span is also a floor: leading spaces it already consumed are not
@@ -785,24 +915,33 @@ function convertSpacedDashes(view: ProseView, rendered: string): void {
          stops at this dash, so `consumedThrough` never reaches past `firstDash`. */
       if (matchStart >= firstDash + 1) return null
       // Validate the lookbehind at matchStart: start of text/line, a boundary
-      // immediately left (separator), or a non-whitespace clean char.
+      // immediately left, or a non-whitespace clean char.
       const leftOk = matchStart === 0
         || view.hasBoundary(matchStart)
         || (text[matchStart - 1] !== undefined && !/\s/.test(text[matchStart - 1]))
       if (!leftOk) return null
+      // A dash char left of the leading spaces (boundaries are zero-width, so
+      // this reads through them) marks this run as the tail of an
+      // already-spaced dash ("x – -"): the overlap consumption above leaves
+      // it on the pass that converts the head, and the head's edits can
+      // rewrite the linking context so the consumption never re-links; block
+      // the tail deterministically. Glyphs folded from a trailing dash (`←`,
+      // `±`) block like the hyphen that sat in this slot before the fold.
+      const charBeforeSpaces = text[matchStart - 1]
+      if (matchStart > 0
+        && (isDashChar(charBeforeSpaces) || FOLDED_FROM_TRAILING_DASH.has(charBeforeSpaces))) return null
       // The leading spaces between matchStart and the dash must be at least one
-      // (v4's `[ ]+` is one-or-more) — a boundary directly before the dash leaves
+      // (`[ ]+` is one-or-more) — a boundary directly before the dash leaves
       // none, which is the boundary-led pattern's job, not this one.
       if (matchStart === firstDash) return null
-      // A separator between the leading spaces and the dash breaks v4's
-      // `[ ]+dashCore` (no separator slot there); neither spaced nor boundary-led
-      // matches, so skip.
+      // A boundary between the leading spaces and the dash breaks `[ ]+dashCore`
+      // (no slot there); neither spaced nor boundary-led matches, so skip.
       if (view.hasBoundary(firstDash)) return null
-      // Maximal dash run from firstDash that does not cross a boundary (v4's core
-      // never spanned a separator).
+      // Maximal dash run from firstDash that does not cross a boundary (the core
+      // never spans a boundary).
       let fullRunEnd = firstDash + 1
       while (isDashChar(text[fullRunEnd]) && !v.hasBoundary(fullRunEnd)) fullRunEnd++
-      // v4's dashCore (`-{2,}` greedy, then single `-`) backtracks past the arrow
+      // The dashCore (`-{2,}` greedy, then single `-`) backtracks past the arrow
       // guard AND the trailing `[ ]*(?=\S|$)`, so try run ends longest-first and
       // take the first one whose whole tail validates.
       const chosen = chooseSpacedDashRun(v, firstDash, fullRunEnd)
@@ -816,7 +955,7 @@ function convertSpacedDashes(view: ProseView, rendered: string): void {
 }
 
 /**
- * Picks v4's dashCore from the maximal dash run [firstDash, fullRunEnd). v4 tries
+ * Picks the dashCore from the maximal dash run [firstDash, fullRunEnd). Tries
  * `[EN EM][-EN EM]*`, then `-{2,}` (greedy), then a single `-`, backtracking past
  * the arrow guard and the trailing `[ ]*(?=\S|$)`. Returns the chosen run end and
  * the trailing-spaces end (`scan`) to replace, or null when no branch validates.
@@ -835,7 +974,7 @@ function chooseSpacedDashRun(view: ProseView, firstDash: number, fullRunEnd: num
     }
     return null
   }
-  // v4's `-{2,}` and single-`-` branches match hyphens only, so a leading-hyphen
+  // The `-{2,}` and single-`-` branches match hyphens only, so a leading-hyphen
   // run stops at the first EN/EM dash (e.g. "-–" is a single `-` core, not a
   // two-dash run that would swallow the EN dash).
   let hyphenRunEnd = firstDash
@@ -863,19 +1002,19 @@ interface SpacedTrailing {
 }
 
 /**
- * v4's trailing `[ ]*(?:${chr} [ ]*)?(?=\S|$)`. The leading `[ ]*` (before any
- * separator) is deleted; spaces after a separator are kept (they belong to the
- * next node) but still consumed. The lookahead then requires a non-space char, a
- * boundary, or end of text. Returns the edit/consumed offsets, or null on failure.
+ * The trailing `[ ]*(?:[ ]*)?(?=\S|$)` with one tolerated boundary. The leading
+ * `[ ]*` (before any boundary) is deleted; spaces after a boundary are kept
+ * (they belong to the next node) but still consumed. The lookahead then requires
+ * a non-space char, a boundary, or end of text. Returns the edit/consumed
+ * offsets, or null on failure.
  */
 function spacedTrailingEnd(view: ProseView, runEnd: number): SpacedTrailing | null {
   const text = view.text
   let editEnd = runEnd
   while (text[editEnd] === " " && !view.hasBoundary(editEnd)) editEnd++
-  // v4's `(?:${chr} [ ]*)?(?=\S|$)` is a greedy optional group: try consuming a
-  // single sepAfter separator and its kept trailing spaces first, then fall back
-  // to no separator. `(?=\S|$)` is satisfied by a boundary (a non-space
-  // separator), a non-space clean char, or end of text.
+  // The trailing optional group is greedy: try consuming a single boundary and
+  // its kept trailing spaces first, then fall back to no boundary. `(?=\S|$)` is
+  // satisfied by a boundary (non-space), a non-space clean char, or end of text.
   if (boundaryCountAt(view, editEnd) === 1) {
     let consumedEnd = editEnd
     while (text[consumedEnd] === " " && (consumedEnd === editEnd || !view.hasBoundary(consumedEnd))) consumedEnd++
@@ -885,17 +1024,17 @@ function spacedTrailingEnd(view: ProseView, runEnd: number): SpacedTrailing | nu
   return null
 }
 
-/** v4's `(?=\S|$)`: end of text, a node boundary, or a non-space clean char. */
+/** `(?=\S|$)`: end of text, a node boundary, or a non-space clean char. */
 function lookaheadNonSpace(view: ProseView, pos: number): boolean {
   return pos === view.text.length || view.hasBoundary(pos) || !/\s/.test(view.text[pos])
 }
 
 /**
- * v4's `(?!${sep}?-*${sep}?>)` arrow guard, boundary-aware. The two `${sep}?`
- * slots bracket the `-*` hyphen run: one boundary may sit before the run and one
- * after. With no hyphens both slots collapse to the run-end offset (up to two
- * boundaries there); a boundary inside the hyphen run, or more than the two
- * slots allow, hides the `>` (so the dash is not an arrow and converts).
+ * The `(?!-*>)` arrow guard, boundary-aware. Two slots bracket the `-*` hyphen
+ * run: one boundary may sit before the run and one after. With no hyphens both
+ * slots collapse to the run-end offset (up to two boundaries there); a boundary
+ * inside the hyphen run, or more than the two slots allow, hides the `>` (so the
+ * dash is not an arrow and converts).
  */
 function spacedArrowAhead(view: ProseView, runEnd: number): boolean {
   const text = view.text
@@ -905,24 +1044,26 @@ function spacedArrowAhead(view: ProseView, runEnd: number): boolean {
     h++
   }
   if (h === runEnd) {
-    // No hyphens: both ${sep}? slots fall at this offset (≤2 boundaries total).
+    // No hyphens: both slots fall at this offset (≤2 boundaries total).
     if (boundaryCountAt(view, runEnd) > 2) return false
   } else {
-    if (boundaryCountAt(view, runEnd) > 1) return false // first ${sep}?
-    if (boundaryCountAt(view, h) > 1) return false // second ${sep}?
+    if (boundaryCountAt(view, runEnd) > 1) return false // first slot
+    if (boundaryCountAt(view, h) > 1) return false // second slot
   }
-  return text[h] === ">"
+  // `≥` guards like the `>=` it folds from: the math pass folds the `>` this
+  // guard keys on, and a dash blocked before `–>=` must stay blocked at `–≥`.
+  return text[h] === ">" || text[h] === UNICODE_SYMBOLS.GREATER_EQUAL
 }
 
 /**
- * Dashes where a separator alone precedes the dash run: "word{sep}– rest". v4's
- * pattern `(?<=[^\s])${sep}[dash]+[ ]+` required a separator immediately before
- * the dash run, a non-space marked char before that separator, and at least one
- * trailing space. Because the leading separator is required, this only fires
- * where a node boundary opens a dash run, so the pass scans boundaries rather
- * than the clean text. The "non-space before the separator" is satisfied by a
- * real non-space clean char (single boundary) or by another stacked separator
- * (two or more boundaries — a separator is itself non-space).
+ * Dashes where a boundary alone precedes the dash run: "word{b}– rest". The
+ * shape `(?<=[^\s])[dash]+[ ]+` with a leading boundary requires a boundary
+ * immediately before the dash run, a non-space char before that boundary, and
+ * at least one trailing space. Because the leading boundary is required, this
+ * only fires where a node boundary opens a dash run, so the pass scans
+ * boundaries rather than the clean text. The "non-space before the boundary" is
+ * satisfied by a real non-space clean char (single boundary) or by another
+ * stacked boundary (two or more boundaries — a boundary is itself non-space).
  */
 function convertBoundaryLedDashes(view: ProseView, rendered: string): void {
   const text = view.text
@@ -935,19 +1076,33 @@ function convertBoundaryLedDashes(view: ProseView, rendered: string): void {
     prevOffset = b
     if (b < lastProcessedEnd) continue
     if (!isDashChar(text[b])) continue
-    // Non-space before the separator: ≥2 stacked separators, or a non-space
-    // clean char immediately left.
+    // Non-space before the boundary: ≥2 stacked boundaries, or a non-space
+    // clean char immediately left. A folded math operator there marks the
+    // fold-stranded configuration: the math pass consumes one character
+    // across this junction (`=` + `~—` folds to `≈` + `—`), so the character
+    // that blocked this rule on the source text is gone, and converting now
+    // would diverge from that blocked first pass.
     if (stackedHere < 2) {
       const before = text[b - 1]
-      if (before === undefined || /\s/.test(before)) continue
+      if (before === undefined || /\s/.test(before) || FOLDED_MATH_OPERATORS.has(before)) continue
     }
     // Dash run from the boundary, not crossing a further boundary.
     let runEnd = b + 1
     while (isDashChar(text[runEnd]) && !view.hasBoundary(runEnd)) runEnd++
-    // Required trailing space run; stop at a boundary (sepAfter).
+    // Required trailing space run; stop at a boundary.
     let spaceEnd = runEnd
     while (text[spaceEnd] === " " && !view.hasBoundary(spaceEnd)) spaceEnd++
     if (spaceEnd === runEnd) continue // no trailing space
+    // A dash (or a glyph folded from a dash-led source) after the spaces
+    // blocks when the rendered form ends in a dash: consuming the spaces
+    // would fuse the rendered dash with it into a run the next pass
+    // collapses (see the same guard in the multiple-dash rule). A boundary
+    // at the junction prevents the fusion, so only a same-node follower
+    // blocks.
+    const afterSpaces = text[spaceEnd]
+    if (afterSpaces !== undefined && !view.hasBoundary(spaceEnd)
+      && isDashChar(rendered[rendered.length - 1])
+      && (isDashChar(afterSpaces) || FOLDED_FROM_LEADING_DASH.has(afterSpaces))) continue
     edits.push([b, spaceEnd])
     lastProcessedEnd = spaceEnd
   }
@@ -956,12 +1111,12 @@ function convertBoundaryLedDashes(view: ProseView, rendered: string): void {
 }
 
 /**
- * Multiple dashes: "word--word", "word---word", `"quote"--"quote"`. v4's
- * `(?<=[LAT\d quote])${sep}?[dash]{2,50}${sep}?(?=[LAT quote space])` tolerated
- * one separator on each side of the run but its `[dash]{2,50}` never spanned a
- * separator. A boundary inside the run truncates it (and the 2..50 count must
- * still hold for the truncated run); two stacked boundaries on either edge
- * exceed the single `${sep}?` slot and block the match.
+ * Multiple dashes: "word--word", "word---word", `"quote"--"quote"`. The shape
+ * `(?<=[LAT\d quote])[dash]{2,50}(?=[LAT quote space])` tolerates one boundary
+ * on each side of the run, but its `[dash]{2,50}` never spans a boundary. A
+ * boundary inside the run truncates it (and the 2..50 count must still hold for
+ * the truncated run); two stacked boundaries on either edge exceed the single
+ * slot and block the match.
  */
 function convertMultipleDashes(view: ProseView, rendered: string): void {
   const before = `[${LATIN_LETTERS}\\d${QUOTE_CHARS}]`
@@ -975,18 +1130,36 @@ function convertMultipleDashes(view: ProseView, rendered: string): void {
     (match, v) => {
       const text = v.text
       const start = match.index
-      // Two stacked boundaries before the run exceed sepBefore's one-sep budget.
+      // Two stacked boundaries before the run exceed the leading slot's budget.
       if (boundaryCountAt(v, start) >= 2) return null
-      // Truncate the run at the first interior boundary (v4's class stops there).
+      // Truncate the run at the first interior boundary (the class stops there).
       let runEnd = start + 1
       while (isDashChar(text[runEnd]) && !v.hasBoundary(runEnd)) runEnd++
       if (runEnd - start < 2 || runEnd - start > 50) return null
-      // sepAfter tolerates one boundary; v4's trailing lookahead then checks the
-      // clean char after the run is [LAT quote space].
+      // The trailing slot tolerates one boundary; the trailing lookahead then
+      // checks the clean char after the run is [LAT quote space].
       if (boundaryCountAt(v, runEnd) >= 2) return null
       const next = text[runEnd]
       if (next === undefined || !afterRe.test(next)) return null
-      v.replace(start, runEnd, rendered)
+      // Consume the trailing space run (not crossing a boundary): the rendered
+      // dash carries its own spacing, and a re-run's spaced-dash rule would
+      // otherwise collapse the leftover spaces into it. When the rendered
+      // form ends in a dash (the unspaced American em dash), a dash (or a
+      // glyph folded from a dash-led source) after the spaces keeps them:
+      // consuming would fuse the rendered dash with it into a fresh run, and
+      // the spaced-dash rule's dash-tail guard already holds the leftover
+      // spaces still.
+      let editEnd = runEnd
+      while (text[editEnd] === " " && !v.hasBoundary(editEnd)) editEnd++
+      // A boundary at the junction prevents the fusion (dash runs never span
+      // boundaries), so only a same-node follower blocks.
+      const afterSpaces = text[editEnd]
+      if (editEnd > runEnd && afterSpaces !== undefined && !v.hasBoundary(editEnd)
+        && isDashChar(rendered[rendered.length - 1])
+        && (isDashChar(afterSpaces) || FOLDED_FROM_LEADING_DASH.has(afterSpaces))) {
+        editEnd = runEnd
+      }
+      v.replace(start, editEnd, rendered)
       return null
     },
     { allowBoundaries: () => true },
@@ -994,11 +1167,10 @@ function convertMultipleDashes(view: ProseView, rendered: string): void {
 }
 
 /**
- * Dashes at start of line: "^- " → styled dash. v4 wove one optional `${chr}?`
- * at line start (before the dashes); it sits at the match start, never interior.
- * The dash run has no interior separator slot, so a boundary inside the run
- * blocks the match — the default interior-boundary rejection, which is what we
- * want here.
+ * Dashes at start of line: "^- " → styled dash. One boundary is tolerated at
+ * line start (before the dashes); it sits at the match start, never interior.
+ * The dash run has no interior slot, so a boundary inside the run blocks the
+ * match — the default interior-boundary rejection, which is what we want here.
  */
 function convertLeadingLineDashes(view: ProseView, localizedDash: string): void {
   pass(view, cachedRegExp(`^-+ `, "gm"), () => `${localizedDash} `)
@@ -1011,8 +1183,8 @@ function convertUnspacedEmDashes(view: ProseView, rendered: string): void {
     view,
     cachedRegExp(pattern, "g"),
     (match, v) => {
-      // v4's `(?<sepBefore>${chr}?)${EM_DASH}(?<sepAfter>${chr}?)` tolerated one
-      // boundary on each side; two or more exceed the slot and block the match.
+      // One boundary is tolerated on each side of the em-dash; two or more
+      // exceed the slot and block the match.
       if (boundaryCountAt(v, match.index) > 1) return null
       if (boundaryCountAt(v, match.index + match[0].length) > 1) return null
       v.replace(match.index, match.index + match[0].length, rendered)
@@ -1034,12 +1206,11 @@ function normalizeEmDashSpacing(view: ProseView): void {
 
 /**
  * Remove spaces directly around an em-dash that has non-whitespace on both
- * sides. v4's `(?<=\S|^)${sep}?[ ]*${EM}[ ]*${sep}?(?=\S|$)` only consumed the
- * spaces immediately adjacent to the dash; a separator between a space and the
- * dash kept that space (the leading `[ ]*` could not reach across the marker).
- * The walk therefore stops space consumption at node boundaries, and the
- * `\S|^` / `\S|$` anchors treat a boundary (a non-space marker) as satisfying
- * the anchor.
+ * sides. Only the spaces immediately adjacent to the dash are consumed; a
+ * boundary between a space and the dash keeps that space (space consumption
+ * cannot reach across a boundary). The walk therefore stops space consumption
+ * at node boundaries, and the `\S|^` / `\S|$` anchors treat a boundary (a
+ * non-space) as satisfying the anchor.
  */
 function removeSpacesAroundEmDash(view: ProseView): void {
   pass(
@@ -1057,9 +1228,15 @@ function removeSpacesAroundEmDash(view: ProseView): void {
       const leftAnchored = left === 0 || v.hasBoundary(left) || !/\s/.test(text[left - 1])
       const rightAnchored = right === text.length || v.hasBoundary(right) || !/\s/.test(text[right])
       if (!leftAnchored || !rightAnchored) return null
-      // Drop the adjacent space runs; the em-dash and any edge boundaries stay.
-      if (left < d) v.replace(left, d, "")
-      if (right > d + 1) v.replace(d + 1, right, "")
+      // Drop the adjacent space runs; the em-dash and any edge boundaries
+      // stay. A side whose anchor is another dash keeps its spaces: deleting
+      // them would fuse the dashes into a run the multiple-dash rule then
+      // collapses on the next pass. Glyphs folded from a dash-edged source
+      // (`±`, `←`, `→`) anchor like the dash they fold from.
+      const leftAnchor = text[left - 1]
+      const rightAnchor = text[right]
+      if (left < d && !isDashChar(leftAnchor) && !FOLDED_FROM_TRAILING_DASH.has(leftAnchor)) v.replace(left, d, "")
+      if (right > d + 1 && !isDashChar(rightAnchor) && !FOLDED_FROM_LEADING_DASH.has(rightAnchor)) v.replace(d + 1, right, "")
       return null
     },
   )
@@ -1071,8 +1248,8 @@ function preserveLineLeadingEmDashSpace(view: ProseView): void {
     view,
     cachedRegExp(`^${EM_DASH}(?<after>[A-Z0-9])`, "gm"),
     (match, v) => {
-      // v4's `^${chr}?${EM_DASH}` tolerated one boundary between the line start
-      // and the em-dash; two or more exceed that slot and block the match.
+      // One boundary is tolerated between the line start and the em-dash; two or
+      // more exceed that slot and block the match.
       if (boundaryCountAt(v, match.index) > 1) return null
       const groups = namedGroups<{ after: string }>(matchArgs(match))
       return `${EM_DASH} ${groups.after}`
@@ -1084,18 +1261,18 @@ function preserveLineLeadingEmDashSpace(view: ProseView): void {
 // Public dash pipeline
 // ---------------------------------------------------------------------------
 
-export function hyphenReplace(text: string, options: DashOptions = {}): string {
-  const separator = options.separator ?? DEFAULT_SEPARATOR
+export function hyphenReplace(input: string, options?: DashOptions): string
+export function hyphenReplace(input: ProseView, options?: DashOptions): void
+export function hyphenReplace(input: string | ProseView, options: DashOptions = {}): string | void {
   const style = options.dashStyle ?? "american"
-  if (style === "none") return text
-  text = minusReplace(text, options)
-  text = enDashDateRange(text, options)
-  text = enDashNumberRange(text, options)
-  text = withProseView(text, separator, (view) => {
+  return overInput(input, (view) => {
+    if (style === "none") return
+    minusReplace(view)
+    enDashDateRangeOverView(view, style)
+    enDashNumberRange(view)
     convertParentheticalDashes(view, style)
     if (style === "american") normalizeEmDashSpacing(view)
   })
-  return text
 }
 
 const { WORD_JOINER } = UNICODE_SYMBOLS
@@ -1115,9 +1292,13 @@ const { WORD_JOINER } = UNICODE_SYMBOLS
  * `nbspTransform` (U+00A0 breaks `Fig. 1` searches). Apply only in rendered
  * HTML; do not write into Markdown source.
  */
-export function dashWordJoiner(text: string): string {
-  const re = cachedRegExp(`(?<=[^\\s${WORD_JOINER}])[${EM_DASH}${EN_DASH}]`, "gu")
-  return text.replace(re, `${WORD_JOINER}$&`)
+export function dashWordJoiner(input: string): string
+export function dashWordJoiner(input: ProseView): void
+export function dashWordJoiner(input: string | ProseView): string | void {
+  return overInput(input, (view) => {
+    const re = cachedRegExp(`(?<=[^\\s${WORD_JOINER}])[${EM_DASH}${EN_DASH}]`, "gu")
+    replaceAllInView(view, re, (match) => `${WORD_JOINER}${match[0]}`)
+  })
 }
 
 /** Reconstructs `.replace()`-style callback args from a RegExpExecArray. */