@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/components/blocks/text/construct-reveal.js

@@ -1,20 +1,19 @@
 /**
- * preview-inline's construct-reveal trigger: an inline construct's markers stay CSS-hidden until
- * the caret enters its INCLUSIVE `[start, end]`, revealing the whole enclosing chain. Reveal is a
- * class flip on `data-construct-*` spans, so the DOM text never changes and raw offsets survive it
- * (spec: the preview-inline-affinity e2e requirement).
+ * What shows an inline construct's markers in preview-inline mode: they stay hidden by CSS until
+ * the caret enters the construct's `[start, end]`, bounds included, and then the whole enclosing
+ * chain shows. Showing them only toggles a class on `data-construct-*` spans, so the DOM text
+ * never changes and raw offsets survive it (the preview-inline-affinity e2e requirement).
  */
 import { tick } from 'svelte';
 import { inlineDescendants } from '../../../core/inline';
 import { resolvedInlineContent } from '../../../core/inline/inline-cache';
 import { isRevealableInlineKind } from '../../../schema/inline-construct-policy';
-import { toClampedRawOffset } from '../../../cursor/coordinate-spaces';
-import { CONSTRUCT_REVEAL_CLASS, domTextOffsetAtNode } from '../../../cursor/widget-offset';
+import { CONSTRUCT_REVEAL_CLASS, rawOffsetAt } from '../../../cursor/widget-offset';
 import { isInteractionTraceEnabled, traceRevealOpen, traceRevealFold } from '../../../debug/interaction-trace';
 // ── Chain math (pure) ────────────────────────────────────────────────────────
 /**
- * Every revealable construct whose inclusive `[start, end]` contains `offset`, outermost
- * first; at a boundary shared by adjacent siblings both are collected.
+ * Every construct that can show its markers whose `[start, end]` contains `offset`, bounds
+ * included, outermost first; at a boundary two siblings share, both are collected.
  */
 export function constructChainAtOffset(nodes, offset) {
     // A child lies inside its parent's range, so a node that misses the offset prunes its subtree.
@@ -39,15 +38,15 @@ export function createConstructReveal(deps) {
     /** Caret raw offset while the mode is on and the caret sits in this block. */
     function caretOffset() {
         const el = deps.getEl();
-        if (!el || deps.getPresentationMode() !== 'preview-inline')
+        if (!el || deps.reading.mode() !== 'preview-inline')
             return null;
         const sel = window.getSelection();
         if (!sel || sel.rangeCount === 0 || !sel.focusNode || !el.contains(sel.focusNode))
             return null;
-        return toClampedRawOffset(domTextOffsetAtNode(el, sel.focusNode, sel.focusOffset), deps.getAmbientLength());
+        return rawOffsetAt(el, sel.focusNode, sel.focusOffset);
     }
     function inlines() {
-        return resolvedInlineContent(deps.node, deps.linkRef);
+        return resolvedInlineContent(deps.node, deps.reading);
     }
     const toEntry = (n) => ({ kind: n.kind, start: n.start, end: n.end });
     /** The chain the current selection asks for; [] when nothing contains the caret. */
@@ -91,8 +90,8 @@ export function createConstructReveal(deps) {
         appliedSpans = next;
         appliedKey = key;
     }
-    // A fold to no chain must survive a tick: cross-block entry clears the native selection
-    // before the cross-block flag flips, manufacturing a transient fold-shaped state.
+    // Hiding everything has to survive a tick: entering a cross-block selection clears the
+    // browser selection before the cross-block flag is set, which briefly looks like no chain.
     function queueFoldRecheck() {
         if (foldRecheckQueued)
             return;
@@ -142,7 +141,7 @@ export function createConstructReveal(deps) {
                     chain.push(toEntry(n));
             }
         }
-        // Reveal-only: any fold an empty union implies belongs to the selection cadence.
+        // `prepareStep` only shows markers; hiding them is the selection handler's job.
         if (chain.length === 0)
             return;
         const key = chainKey(chain);

package/dist/components/blocks/text/delimiter-autopair.d.ts

@@ -1,15 +1,20 @@
 /**
- * A typed inline delimiter closes itself: a lone `$`, backtick, `*`, `_` or `~~` would pair with
- * whatever matching run comes later on the line, so the keystroke lands its twin after the caret.
- * Typing the closer over the twin steps past it, a closer typed by hand seats the next byte
- * outside, and the empty pair drops its twin when the first body byte makes it no construct.
- * `applyDelimiterAutoPair` is the one `beforeinput` arm every prose surface runs (G4.65).
+ * A typed inline delimiter (`$`, backtick, `*`, `_`, `~~`) writes its partner after the caret, so
+ * it cannot pair with a later run on the line. Typing the partner steps past it, and an empty pair
+ * the auto-pair wrote (`auto-pair-record.ts`) drops its partner when the first byte inside makes
+ * it no construct. Every prose block runs `applyDelimiterAutoPair` on `beforeinput` (G4.65).
  */
 import { type ContentRange } from '../../../core/inline';
-export type AutoPairEdit = {
+import type { GrammarView } from '../../../schema/block-openers';
+import type { Reading } from '../../../schema/reading';
+import type { BlockAutoPairs } from './auto-pair-record';
+export type AutoPairEdit = 
+/** `pair` is the empty pair the write leaves around the caret, which the auto-pair owns. */
+{
     kind: 'write';
     text: string;
     caret: number;
+    pair?: ContentRange;
 }
 /** The typed byte completed a construct's closer; what follows belongs outside it. */
  | {
@@ -17,32 +22,38 @@ export type AutoPairEdit = {
     text: string;
     caret: number;
 }
-/** Nothing written: the caret passes the twin. Over a construct's closer that run may be
- *  unpainted, and then only the SIDE moves, which the surface records as an edge affinity. */
+/** Nothing written: the caret passes its partner. Over a hidden closer only the caret's arrival
+ *  side changes. `pair` is the auto-pair's own empty pair the caret stepped past. */
  | {
     kind: 'step-over';
     caret: number;
     overConstruct: boolean;
+    pair?: ContentRange;
 };
+/** What the resolver reads about the line besides its bytes. */
+export interface AutoPairContext {
+    /** The empty pair the auto-pair wrote at this caret, or null: the same bytes typed by hand
+     *  are the user's, and a key between them touches one byte. */
+    ownPair: ContentRange | null;
+    /** Whether the written line still parses as this block: a grown `****` is a thematic break
+     *  and `~~~~` a fence, so such a pair steps past its partner instead. */
+    keepsKind?: (text: string) => boolean;
+}
+/** What a single typed byte does at a collapsed caret, or null to leave it to the browser.
+ *  `content` bounds the inline scan (a heading's `# ` is not prose); the caret must lie inside it. */
+export declare function resolveDelimiterAutoPair(text: string, content: ContentRange, caret: number, typed: string, reading: Reading, { ownPair, keepsKind }: AutoPairContext): AutoPairEdit | null;
 /**
- * What a single typed byte does at a collapsed caret, or null to leave the engine its insert.
- * `content` bounds the inline scan (a heading's `# ` is not prose); the caret must lie inside it.
- * `keepsBlockKind` says whether a written line still reloads as this block: a grown `****` is a
- * thematic break and `~~~~` a fence, so such a pair steps past a twin instead, or declines.
- */
-export declare function resolveDelimiterAutoPair(text: string, content: ContentRange, caret: number, typed: string, keepsBlockKind?: (text: string) => boolean): AutoPairEdit | null;
-/**
- * Inside a revealed source (`$ab|$`) the twin is the live closer, and typing it means "done":
- * the caret steps past it and the caller folds the reveal, so the formula renders at once.
+ * Inside a construct whose source is showing (`$ab|$`) the partner is the real closer, and typing
+ * it means "done": the caret steps past it and the caller hides the source, so it renders at once.
  */
-export declare function stepsOverRevealedCloser(text: string, caret: number, typed: string): boolean;
-/** Backspace at an empty pair takes both runs, between them (`**|**`) or right after them
- *  (`$$|`), as it does in any IDE. Exactly a pair of equal runs, one or two bytes each: a longer
- *  run is a fence or a literal the user built by hand. */
-export declare function resolveEmptyPairBackspace(text: string, caret: number): AutoPairEdit | null;
-/** What a prose surface lends the arm. Reactive reads are thunks, so nothing here goes stale. */
+export declare function stepsOverRevealedCloser(text: string, caret: number, typed: string, grammar: GrammarView): boolean;
+/** Backspace at the auto-pair's own empty pair takes both runs, between them (`**|**`) or right
+ *  after a stepped-over one (`$$|`), as it does in any IDE. */
+export declare function resolveEmptyPairBackspace(text: string, caret: number, ownPair: ContentRange | null, grammar: GrammarView): AutoPairEdit | null;
+/** What a prose block gives the handler. Reactive values arrive as functions, so none go stale. */
 export interface AutoPairSurface {
-    /** The bytes the caret indexes: the display text, or the revealed DOM text during a reveal. */
+    /** The bytes the caret counts into: the displayed text, or the DOM text while a construct's
+     *  source is showing. */
     text(): string;
     content(): ContentRange;
     caret(): number | null;
@@ -51,21 +62,27 @@ export interface AutoPairSurface {
     foldReveal(): {
         settled: Promise<void>;
     } | null;
-    /** Whether the closer a step-over passes is on screen; unpainted, only the side moves. */
-    markersPaint(): boolean;
     setCaret(offset: number): void;
-    /** The arrival the seat reads next: past the construct's delimiters. */
+    /** Record the arrival side the next typed byte reads: past the construct's delimiters. */
     seatOutside(): void;
-    /** One CST write plus the caret it parks. */
+    /** One CST write plus the caret it leaves behind. */
     write(text: string, caretBefore: number, caretAfter: number): void;
-    /** A step-over that leaves the line one an on-type completer claims (`$$`), which only a
-     *  content write consults. */
+    /** Whether a step-over leaves the line one an on-type completer takes (`$$`); only a content
+     *  write asks. */
     completesLine?(caret: number): boolean;
-    /** The resolver's block-kind guard, for a surface whose line can become another block. */
-    keepsBlockKind?(text: string): boolean;
+    /** Whether a line the pair would write still reads as this block's kind where it is stored. */
+    keepsKind(line: string): boolean;
+    /** How the block was drawn: a plugin's delimiter pairs only where the plugin is listed, and a
+     *  step-over past a hidden closer moves only the arrival side. */
+    reading: Reading;
+    /** This block's view of the editor's record of the pair the auto-pair last wrote. */
+    ownPairs: BlockAutoPairs;
 }
 /**
- * The `beforeinput` arm. True when the press was this seam's: the event is cancelled and the
- * surface has written, moved or re-seated the caret.
+ * The `beforeinput` handler. True when the key belonged here: the event is cancelled and the
+ * block has written bytes, moved the caret, or changed its arrival side.
  */
 export declare function applyDelimiterAutoPair(e: InputEvent, surface: AutoPairSurface): boolean;
+/** Keep the record in step with an edit the auto-pair made to `text`: a pair it wrote or stepped
+ *  past stays its own, and every other edit ends the pair. */
+export declare function noteOwnPair(ownPairs: BlockAutoPairs, text: string, edit: AutoPairEdit): void;

package/dist/components/blocks/text/delimiter-autopair.js

@@ -1,11 +1,10 @@
 /**
- * A typed inline delimiter closes itself: a lone `$`, backtick, `*`, `_` or `~~` would pair with
- * whatever matching run comes later on the line, so the keystroke lands its twin after the caret.
- * Typing the closer over the twin steps past it, a closer typed by hand seats the next byte
- * outside, and the empty pair drops its twin when the first body byte makes it no construct.
- * `applyDelimiterAutoPair` is the one `beforeinput` arm every prose surface runs (G4.65).
+ * A typed inline delimiter (`$`, backtick, `*`, `_`, `~~`) writes its partner after the caret, so
+ * it cannot pair with a later run on the line. Typing the partner steps past it, and an empty pair
+ * the auto-pair wrote (`auto-pair-record.ts`) drops its partner when the first byte inside makes
+ * it no construct. Every prose block runs `applyDelimiterAutoPair` on `beforeinput` (G4.65).
  */
-import { constructContentRange, inlineDescendants, parseInline } from '../../../core/inline';
+import { constructContentRange, inlineDescendants, readInline } from '../../../core/inline';
 import { isAutoPairTrigger } from '../../../core/inline/scan/plugin-syntax';
 const STEP = { single: true, inside: 'step-over' };
 const BUILTIN = {
@@ -16,78 +15,89 @@ const BUILTIN = {
     '~': { single: false, inside: 'grow' }
 };
 const isWordByte = (ch) => ch !== undefined && /[\p{L}\p{N}]/u.test(ch);
-function policyOf(ch) {
-    return BUILTIN[ch] ?? (isAutoPairTrigger(ch) ? STEP : null);
+// A plugin's delimiter pairs only in an editor that lists the plugin.
+function policyOf(ch, grammar) {
+    return BUILTIN[ch] ?? (isAutoPairTrigger(ch, grammar) ? STEP : null);
 }
 // ── The resolver ─────────────────────────────────────────────────────────────
-/**
- * What a single typed byte does at a collapsed caret, or null to leave the engine its insert.
- * `content` bounds the inline scan (a heading's `# ` is not prose); the caret must lie inside it.
- * `keepsBlockKind` says whether a written line still reloads as this block: a grown `****` is a
- * thematic break and `~~~~` a fence, so such a pair steps past a twin instead, or declines.
- */
-export function resolveDelimiterAutoPair(text, content, caret, typed, keepsBlockKind = () => true) {
+/** What a single typed byte does at a collapsed caret, or null to leave it to the browser.
+ *  `content` bounds the inline scan (a heading's `# ` is not prose); the caret must lie inside it. */
+export function resolveDelimiterAutoPair(text, content, caret, typed, reading, { ownPair, keepsKind = () => true }) {
     if (typed.length !== 1 || caret < content.start || caret > content.end)
         return null;
     const before = text[caret - 1];
     const after = text[caret];
-    const policy = policyOf(typed);
+    const policy = policyOf(typed, reading.grammar);
+    const inside = ownPair && isBetweenRuns(ownPair, caret) ? ownPair : null;
     if (!policy)
-        return collapseEmptyPair(text, content, caret, typed);
-    if (after === typed && closingRunAt(text, content, caret, typed)) {
+        return inside && collapseEmptyPair(text, content, caret, typed, inside, reading);
+    if (after === typed && closingRunAt(text, content, caret, typed, reading)) {
         return { kind: 'step-over', caret: caret + 1, overConstruct: true };
     }
     const paired = text.slice(0, caret) + typed + text.slice(caret);
-    if (closerEndsAt(paired, content, caret + 1, typed)) {
+    // The typed byte lengthens the content, so a scan of the paired line reads one byte further.
+    const pairedContent = { start: content.start, end: content.end + 1 };
+    if (closerEndsAt(paired, pairedContent, caret + 1, typed, reading)) {
         return { kind: 'close', text: paired, caret: caret + 1 };
     }
-    const pair = (next) => {
-        if (keepsBlockKind(next))
-            return write(next, caret + 1);
-        return after === typed ? { kind: 'step-over', caret: caret + 1, overConstruct: false } : null;
+    const pair = (next, pairRange) => {
+        if (keepsKind(next))
+            return write(next, caret + 1, pairRange);
+        if (after !== typed || !inside)
+            return null;
+        return { kind: 'step-over', caret: caret + 1, overConstruct: false, pair: inside };
     };
     if (after === typed) {
-        if (before === typed) {
-            if (policy.inside === 'step-over') {
-                return { kind: 'step-over', caret: caret + 1, overConstruct: false };
-            }
-            return pair(text.slice(0, caret) + typed + typed + text.slice(caret));
+        // A pair the user typed, or a byte in front of another run's opener, is spelling something
+        // out: only the auto-pair's own empty pair is stepped over or grown.
+        if (!inside)
+            return null;
+        if (policy.inside === 'step-over') {
+            return { kind: 'step-over', caret: caret + 1, overConstruct: false, pair: inside };
         }
-        // A byte in front of another run's opener is spelling something out, not opening a span.
-        return null;
+        const grown = text.slice(0, caret) + typed + typed + text.slice(caret);
+        return pair(grown, { start: inside.start, end: inside.end + 2 });
     }
-    if (before === typed && !closerEndsAt(text, content, caret, typed)) {
-        // `~|` plus `~`: the double run this delimiter pairs on, as long as it IS a lone run.
+    if (before === typed && !closerEndsAt(text, content, caret, typed, reading)) {
+        // `~|` plus `~`: the double run this delimiter pairs on, as long as it is a lone run.
         const single = text[caret - 2] !== typed;
         if (policy.inside === 'grow' && single) {
-            return pair(text.slice(0, caret) + typed.repeat(3) + text.slice(caret));
+            const grown = text.slice(0, caret) + typed.repeat(3) + text.slice(caret);
+            return pair(grown, { start: caret - 1, end: caret + 3 });
         }
         return null;
     }
     if (!policy.single || (policy.notAfterWord && isWordByte(before)))
         return null;
-    return pair(text.slice(0, caret) + typed + typed + text.slice(caret));
+    const opened = text.slice(0, caret) + typed + typed + text.slice(caret);
+    return pair(opened, { start: caret, end: caret + 2 });
 }
 /**
- * Inside a revealed source (`$ab|$`) the twin is the live closer, and typing it means "done":
- * the caret steps past it and the caller folds the reveal, so the formula renders at once.
+ * Inside a construct whose source is showing (`$ab|$`) the partner is the real closer, and typing
+ * it means "done": the caret steps past it and the caller hides the source, so it renders at once.
  */
-export function stepsOverRevealedCloser(text, caret, typed) {
-    return typed.length === 1 && policyOf(typed) !== null && text[caret] === typed;
+export function stepsOverRevealedCloser(text, caret, typed, grammar) {
+    return typed.length === 1 && policyOf(typed, grammar) !== null && text[caret] === typed;
 }
-/** Backspace at an empty pair takes both runs, between them (`**|**`) or right after them
- *  (`$$|`), as it does in any IDE. Exactly a pair of equal runs, one or two bytes each: a longer
- *  run is a fence or a literal the user built by hand. */
-export function resolveEmptyPairBackspace(text, caret) {
-    const pair = emptyPairEnding(text, caret) ?? emptyPairAround(text, caret);
-    if (!pair)
+/** Backspace at the auto-pair's own empty pair takes both runs, between them (`**|**`) or right
+ *  after a stepped-over one (`$$|`), as it does in any IDE. */
+export function resolveEmptyPairBackspace(text, caret, ownPair, grammar) {
+    if (!ownPair)
+        return null;
+    // The emphasis family grows instead of stepping, so its `**|` is a double opener to type after.
+    const stepped = caret === ownPair.end && policyOf(text[caret - 1], grammar)?.inside === 'step-over';
+    if (!isBetweenRuns(ownPair, caret) && !stepped)
         return null;
-    return write(text.slice(0, pair.start) + text.slice(pair.end), pair.start);
+    return write(text.slice(0, ownPair.start) + text.slice(ownPair.end), ownPair.start);
+}
+const write = (text, caret, pair) => pair ? { kind: 'write', text, caret, pair } : { kind: 'write', text, caret };
+// The caret splits the empty pair into its two equal runs.
+function isBetweenRuns(pair, caret) {
+    return caret > pair.start && caret - pair.start === pair.end - caret;
 }
-const write = (text, caret) => ({ kind: 'write', text, caret });
 /**
- * The `beforeinput` arm. True when the press was this seam's: the event is cancelled and the
- * surface has written, moved or re-seated the caret.
+ * The `beforeinput` handler. True when the key belonged here: the event is cancelled and the
+ * block has written bytes, moved the caret, or changed its arrival side.
  */
 export function applyDelimiterAutoPair(e, surface) {
     const typing = e.inputType === 'insertText';
@@ -99,23 +109,29 @@ export function applyDelimiterAutoPair(e, surface) {
     if (caret === null)
         return false;
     const text = surface.text();
+    const ownPair = surface.ownPairs.consult(text, caret);
     if (surface.isRevealing()) {
-        if (!typing || !stepsOverRevealedCloser(text, caret, e.data ?? ''))
+        if (!typing || !stepsOverRevealedCloser(text, caret, e.data ?? '', surface.reading.grammar)) {
             return false;
+        }
         e.preventDefault();
         surface.setCaret(caret + 1);
         void surface.foldReveal()?.settled;
         return true;
     }
     const edit = typing
-        ? resolveDelimiterAutoPair(text, surface.content(), caret, e.data ?? '', surface.keepsBlockKind)
-        : resolveEmptyPairBackspace(text, caret);
+        ? resolveDelimiterAutoPair(text, surface.content(), caret, e.data ?? '', surface.reading, {
+            ownPair,
+            keepsKind: surface.keepsKind
+        })
+        : resolveEmptyPairBackspace(text, caret, ownPair, surface.reading.grammar);
     if (!edit)
         return false;
     e.preventDefault();
+    noteOwnPair(surface.ownPairs, text, edit);
     switch (edit.kind) {
         case 'step-over':
-            if (edit.overConstruct && !surface.markersPaint())
+            if (edit.overConstruct && surface.reading.hidesDelimitersAtCaret())
                 surface.seatOutside();
             else if (surface.completesLine?.(edit.caret))
                 surface.write(text, caret, edit.caret);
@@ -131,59 +147,29 @@ export function applyDelimiterAutoPair(e, surface) {
             return true;
     }
 }
-// ── Runs ─────────────────────────────────────────────────────────────────────
-/** Length of the run of `ch` ending just before `at` (0 when `text[at - 1]` is not `ch`). */
-function runBefore(text, at, ch) {
-    let n = 0;
-    while (text[at - 1 - n] === ch)
-        n++;
-    return n;
-}
-function runAfter(text, at, ch) {
-    let n = 0;
-    while (text[at + n] === ch)
-        n++;
-    return n;
-}
-// `X..X|X..X`: equal runs of a pair delimiter, one or two bytes, with nothing of it either side.
-function emptyPairAround(text, caret) {
-    const d = text[caret - 1];
-    if (d === undefined || !policyOf(d))
-        return null;
-    const k = runBefore(text, caret, d);
-    if (k > 2 || runAfter(text, caret, d) !== k)
-        return null;
-    return { start: caret - k, end: caret + k };
-}
-// `XX|`: a stepped-over empty pair with the caret after it. Only the delimiters that step (the
-// emphasis family grows instead, and its `**|` is a double opener with content ahead).
-function emptyPairEnding(text, caret) {
-    const d = text[caret - 1];
-    if (d === undefined || policyOf(d)?.inside !== 'step-over' || text[caret] === d)
-        return null;
-    if (runBefore(text, caret, d) !== 2)
-        return null;
-    return { start: caret - 2, end: caret };
+/** Keep the record in step with an edit the auto-pair made to `text`: a pair it wrote or stepped
+ *  past stays its own, and every other edit ends the pair. */
+export function noteOwnPair(ownPairs, text, edit) {
+    const pair = edit.kind === 'close' ? undefined : edit.pair;
+    if (!pair)
+        ownPairs.forget();
+    else
+        ownPairs.remember(edit.kind === 'write' ? edit.text : text, pair);
 }
 // ── Constructs ───────────────────────────────────────────────────────────────
-// `X|X` plus the typed byte: keep the twin run only if the pair then parses as a construct.
-function collapseEmptyPair(text, content, caret, typed) {
-    const d = text[caret - 1];
-    if (d === undefined || !policyOf(d))
-        return null;
-    const k = runBefore(text, caret, d);
-    if (k > 2 || runAfter(text, caret, d) !== k)
-        return null;
+// `X|X` plus the typed byte: keep the partner run only if the pair then parses as a construct.
+function collapseEmptyPair(text, content, caret, typed, own, reading) {
     const paired = text.slice(0, caret) + typed + text.slice(caret);
     const shifted = { start: content.start, end: content.end + 1 };
-    if (constructAt(paired, shifted, caret - k, caret + 1 + k))
+    if (constructAt(paired, shifted, own.start, own.end + 1, reading))
         return null;
+    const k = caret - own.start;
     return write(text.slice(0, caret) + typed + text.slice(caret + k), caret + 1);
 }
 // The caret sits inside or at the start of the closing run of a construct this delimiter both
 // opens and closes, so the byte under it is that construct's own closer.
-function closingRunAt(text, content, caret, typed) {
-    for (const node of inlineDescendants(parseInline(text, content.start, content.end))) {
+function closingRunAt(text, content, caret, typed, reading) {
+    for (const node of inlineDescendants(readInline(text, content.start, content.end, reading.resolver, reading.grammar))) {
         if (node.kind === 'text' || text[node.start] !== typed || node.end <= caret)
             continue;
         let closer = node.end;
@@ -194,11 +180,9 @@ function closingRunAt(text, content, caret, typed) {
     }
     return false;
 }
-// A construct of `typed`'s family ends exactly at `end`, its last byte in the closing run. The
-// scan's bound grows past the content by the byte a caller has just inserted.
-function closerEndsAt(text, content, end, typed) {
-    const bound = Math.max(content.end, end);
-    for (const node of inlineDescendants(parseInline(text, content.start, bound))) {
+// A construct of `typed`'s family ends exactly at `end`, its last byte in the closing run.
+function closerEndsAt(text, content, end, typed, reading) {
+    for (const node of inlineDescendants(readInline(text, content.start, content.end, reading.resolver, reading.grammar))) {
         if (node.kind === 'text' || node.end !== end || text[end - 1] !== typed)
             continue;
         const inner = constructContentRange(node);
@@ -207,8 +191,8 @@ function closerEndsAt(text, content, end, typed) {
     }
     return false;
 }
-function constructAt(text, content, start, end) {
-    for (const node of inlineDescendants(parseInline(text, content.start, content.end))) {
+function constructAt(text, content, start, end, reading) {
+    for (const node of inlineDescendants(readInline(text, content.start, content.end, reading.resolver, reading.grammar))) {
         if (node.kind !== 'text' && node.start === start && node.end === end)
             return true;
     }

package/dist/components/blocks/text/edge-policy-dispatch.d.ts

@@ -1,40 +1,41 @@
 /**
- * The single caret-edge dispatch (G4.12): a plain Backspace/Delete or printable key at a caret
- * edge in a prose block resolves against a declarative policy — the construct class's for an
- * inline neighbour, the ancestor container's for a content-start key — never native
- * contenteditable mutation, which would corrupt the atomic bytes those stand for.
+ * The one place a caret-edge key is decided in a prose block. A plain Backspace, Delete or
+ * printable key at a caret edge resolves against a declared policy (the inline construct's beside
+ * the caret, or the ancestor container's at the content start), never native editing, which would
+ * corrupt the bytes those constructs stand for (G4.12).
  */
 import type { BlockEditActions } from '../../../action-contracts';
 import type { NodeView } from '../../../core/node-views';
-import type { LinkReferenceResolverRef } from '../../../editor-keys';
 import type { InlineNode } from '../../../core/nodes';
 import type { InlineWidgetEditingPolicy } from '../../../core/inline/inline-widgets';
+import { type LineEnding } from '../../../core/lines';
 import { type RawOffset } from '../../../cursor/coordinate-spaces';
 import type { EdgeAffinity } from '../../../cursor/edge-affinity';
-import type { PendingMarksState } from '../../../cursor/pending-marks';
-import { type EdgeDeletionSurface } from './construct-edge-delete';
-/** Whether `line` still reloads as `node`'s kind, the auto-pair resolver's guard. */
-export declare function keepsBlockKind(node: NodeView, line: string): boolean;
-/** The subset of the inline-widget vocabulary the internal island policies reuse,
- *  expressed in the same terms without leaking into the public API. */
+import type { PendingMarks } from '../../../cursor/pending-marks';
+import type { BlockAutoPairs } from './auto-pair-record';
+import type { Reading } from '../../../schema/reading';
+import type { StoredAs } from '../../../schema/stored-as';
+/** The part of the inline-widget editing policy the built-in widget rules reuse, in the same
+ *  terms but without widening the public API. */
 export type EdgePolicy = Pick<InlineWidgetEditingPolicy, 'onEdge' | 'deleteGranularity'>;
 /** Reactive state arrives as getters, so a captured value can't go stale under
  *  re-render. */
 export interface EdgePolicyDispatchDeps {
     get node(): NodeView;
     get index(): number;
-    /** The nearest ancestor container, or null at the document root — the declaration a
-     *  content-start key resolves against. */
+    /** The document's line ending, which a rewrite takes where the block has none of its own. */
+    getLineEnding: () => LineEnding;
+    /** The nearest ancestor container, or null at the document root. A key at the content start
+     *  resolves against its declaration. */
     get containerParent(): NodeView | null;
-    get linkRef(): LinkReferenceResolverRef | undefined;
+    /** How the editor reads its bytes, the grammar the render path drew widgets with included. */
+    get reading(): Reading;
     getEl: () => HTMLElement | null;
-    getAmbientLength: () => number;
-    /** The container prefix this surface renders under, which the join seam reads a candidate back
-     *  through. Optional because a surface that is not a container's child paints none, and '' is
-     *  the right answer there rather than an inherited assumption. */
-    getAmbientPrefix?: () => string;
-    /** Whether this block carries any decoration islands. Reads the same source the render
-     *  painted from, so a false can't disagree with the DOM and safely skips the scan. */
+    /** Where this block's bytes are stored, read when a rewrite asks, so a cut reads its candidate
+     *  back as it will be kept: a cell's text as text, a list item's behind its marker. */
+    storedAs: () => StoredAs;
+    /** Whether this block carries any decoration widgets. It reads the same source the render
+     *  drew from, so a false cannot disagree with the DOM and safely skips the scan. */
     hasIslands: () => boolean;
     /** Anchor/focus raw-content offsets of the live selection, or null when collapsed. */
     getRawSelection: () => {
@@ -42,51 +43,48 @@ export interface EdgePolicyDispatchDeps {
         end: RawOffset;
     } | null;
     blockEdit: BlockEditActions;
-    /** Park a caret for the post-render restore, tagged with the gesture for the trace.
-     *  `writtenText` is the text that offset addresses — a kind whose write sink rewrites
-     *  bytes moves it — and is omitted where the arm parks ahead of every changed byte. */
-    setPendingCursor: (offset: number | null, source: string, writtenText?: string) => void;
+    /** Remember a caret offset, counted in the stored bytes, for the restore after the next
+     *  render, tagged with the gesture for the debug trace. */
+    setPendingCursor: (offset: number | null, source: string) => void;
     setSnapTarget: (offset: number | null) => void;
-    /** A widget's source is revealed: the CST still reports it atomic, but the DOM is
-     *  editable text, so the widget branch stands down and lets native editing run. */
+    /** A widget's source is showing: the CST still calls it atomic, but the DOM holds editable
+     *  text, so the widget branch does nothing and lets native editing run. */
     isRevealing: () => boolean;
-    /** The reveal-vs-select entry seam; the dispatch owns classification, this owns
-     *  the entry execution and the reveal state machine. */
+    /** Enter the widget, either by showing its source or by selecting it. This dispatch decides
+     *  which widget a key is aimed at; the callback decides what entering it means. */
     enterWidget: (widget: {
         start: number;
         end: number;
         kind: InlineNode['kind'];
     }, fromTrailingEdge: boolean) => void;
-    /**
-     * Substitute the edge policy for a widget this surface renders on terms the kind's
-     * registration doesn't assume: a policy names an affordance, and a surface that paints
-     * none must answer differently rather than degrade. `undefined` keeps the registration.
-     */
+    /** Replace the edge policy for a widget this block draws on its own terms, where the kind's
+     *  registered policy names a gesture the block cannot show. `undefined` keeps the registered one. */
     widgetEdgePolicy?: (widget: {
         start: number;
         end: number;
         kind: InlineNode['kind'];
     }) => EdgePolicy | undefined;
-    /** Reading mode: island and ambient handling stand down wholesale, and the
-     *  widget branch commits nothing (a selected-widget still selects). */
+    /** Reading mode: the decoration-widget and marker-prefix branches do nothing at all, and the
+     *  widget branch writes nothing, though it still selects. */
     isReading: () => boolean;
-    /** The arrival side the typing seat consults; null when no arrival claimed one. */
+    /** Which side the caret arrived from, which decides where a typed byte lands; null when
+     *  nothing recorded one. */
     getEdgeAffinity: () => EdgeAffinity | null;
-    /** A seated delimiter that completed a construct leaves the caret meaning outside it. */
+    /** Typing a closing delimiter leaves the caret meaning outside the construct it finished. */
     noteOutside?: () => void;
-    /** The constructs a collapsed-caret toggle promised the next insertion. Read AND spent
-     *  here: the first byte after the chord is the one insertion they were pending for. */
-    pendingMarks: PendingMarksState;
-    /** What this surface installs a rewrite as, so the seams read a candidate back the way it will
-     *  be stored. Required: a cell answering `block` by silence would refuse its own text. */
-    installedAs: EdgeDeletionSurface;
+    /** The constructs a toggle at a collapsed caret promised the next insertion. Read and spent
+     *  here: the first byte after the chord is the insertion they were waiting for. */
+    pendingMarks: PendingMarks;
+    /** The editor's record of the pair the auto-pair last wrote, as this block sees it; a pair
+     *  written here renews it. */
+    ownPairs: BlockAutoPairs;
 }
 export interface EdgePolicyDispatch {
     /** A plain edge key against a caret-adjacent construct. Returns whether the event
      *  was consumed; a false return leaves the key to the shared keymap below. */
     handleKeydown(e: KeyboardEvent, caretOffset: RawOffset | null): boolean;
-    /** The declared order `handleKeydown` walks, ids and reasons only. The ORDER is the seam
-     *  (G4.12), so it is readable rather than something a test can only re-derive. */
+    /** The order `handleKeydown` walks, ids and reasons only. The order is what the rule fixes
+     *  (G4.12), so it is readable here rather than something a test has to re-derive. */
     readonly arms: readonly {
         id: string;
         reason: string;