@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/components/blocks/text/live-split-rebalance.d.ts

@@ -1,9 +1,9 @@
 /**
  * The live-mode split rewrite (live-mode.md § 4.4 close-and-reopen): Enter inside a construct
- * closes it before the cut and reopens it after, so neither half strands a run the reader never
- * saw. Bytes stay candidates until the parser agrees; null leaves `splitNode`'s byte-literal cut.
+ * closes it before the cut and reopens it after, so neither half strands a run the user never
+ * saw. Bytes stay candidates until the parser agrees; null leaves `splitNode`'s literal cut.
  */
-import type { LinkReferenceResolver } from '../../../core/inline/link-reference-resolver';
+import type { Reading } from '../../../schema/reading';
 import type { AnyInlineKind, InlineNode } from '../../../core/nodes';
 import { type LiveSplitRebalancer } from '../../../schema/inline-construct-policy';
 export declare const rebalanceLiveSplit: LiveSplitRebalancer;
@@ -13,7 +13,7 @@ interface SplitBytes {
     raw: string;
     contentStart: number;
     contentEnd: number;
-    /** Where the second half's content begins in `raw` — past a line ending the cut consumed. */
+    /** Where the second half's content begins in `raw`, past a line ending the cut consumed. */
     cut: number;
     firstResidue: string;
     secondResidue: string;
@@ -25,19 +25,15 @@ export interface ChainLink {
     contentStart: number;
     contentEnd: number;
 }
-/**
- * Every construct holding `offset`, outermost first — or null when one of them declines. A kind
- * with no policy row, one whose split behavior is plain and one whose content bounds are unknown
- * cannot be cut open, and cutting the constructs inside one would strand its pair. Exported for
- * the depth pin, which has to reach it with a tree no split this deep could be rendered at.
- */
+/** Every construct holding `offset`, outermost first, or null when one cannot be cut open, since
+ *  cutting the constructs inside it would strand its pair. Exported for the depth test. */
 export declare function splittableChainAt(inlines: readonly InlineNode[], offset: number): ChainLink[] | null;
 interface SeamParts {
-    /** Bytes before the seam, the block's own marker prefix included. */
+    /** Bytes before the cut, the block's own marker prefix included. */
     head: string;
     closers: string;
     openers: string;
-    /** Bytes after the seam, up to the block's content end. */
+    /** Bytes after the cut, up to the block's content end. */
     tail: string;
     closed: AnyInlineKind[];
     reopened: AnyInlineKind[];
@@ -52,5 +48,5 @@ interface RebalancedHalves {
  * A candidate answers every question below or it is not written. Exported for the verification
  * test, which has to reach it with a candidate no producer here would build.
  */
-export declare function parsesBack(bytes: SplitBytes, seam: SeamParts, candidate: RebalancedHalves, resolver: LinkReferenceResolver | undefined): boolean;
+export declare function parsesBack(bytes: SplitBytes, seam: SeamParts, candidate: RebalancedHalves, reading: Reading): boolean;
 export {};

package/dist/components/blocks/text/live-split-rebalance.js

@@ -1,29 +1,29 @@
 /**
  * The live-mode split rewrite (live-mode.md § 4.4 close-and-reopen): Enter inside a construct
- * closes it before the cut and reopens it after, so neither half strands a run the reader never
- * saw. Bytes stay candidates until the parser agrees; null leaves `splitNode`'s byte-literal cut.
+ * closes it before the cut and reopens it after, so neither half strands a run the user never
+ * saw. Bytes stay candidates until the parser agrees; null leaves `splitNode`'s literal cut.
  */
-import { constructContentRange, constructKinds, getContentRange, inlineDescendants, isProseKind, parseInline } from '../../../core/inline';
+import { constructContentRange, constructKinds, getContentRange, inlineDescendants, isProseKind, readInline } from '../../../core/inline';
 import { CONTENT_VISIBILITY, paintsOnlyChrome, renderedText } from '../../../core/inline/visibility';
+import { isBlankText } from '../../../core/lines';
 import { getInlineConstructPolicy } from '../../../schema/inline-construct-policy';
-import { soleProseReparse } from './screen-diff';
+import { readBlocks } from '../../../core/parser';
 // ── The rewrite ──────────────────────────────────────────────────────────────
-export const rebalanceLiveSplit = (node, offset, firstRaw, secondRaw, linkRef) => {
+export const rebalanceLiveSplit = (node, offset, firstRaw, secondRaw, reading) => {
     const read = readSplitBytes(node, offset, firstRaw, secondRaw);
     if (read === null)
         return null;
-    const resolver = linkRef?.current;
-    const inlines = parseInline(read.raw, read.contentStart, read.contentEnd, resolver);
-    // Chrome standing over nothing is all on screen (live-mode.md § 4.1), so closing and reopening
-    // it moves delimiters the reader is looking at: the byte-literal cut stands.
-    if (paintsOnlyChrome(inlines, read.raw))
+    const inlines = readInline(read.raw, read.contentStart, read.contentEnd, reading.resolver, reading.grammar);
+    // Markers standing over nothing are all on screen (live-mode.md § 4.1), so closing and
+    // reopening them would move delimiters the user is looking at: the literal cut stands.
+    if (paintsOnlyChrome(inlines, read.raw, { grammar: reading.grammar }))
         return null;
     const moved = wholeConstructEdge(inlines, offset);
     const at = moved ?? offset;
     const bytes = moved === null ? read : { ...read, cut: moved };
     const chain = splittableChainAt(inlines, at);
     // An empty chain with the cut where the caller put it is a cut no construct touches, and the
-    // byte-literal halves are already right; a MOVED cut is a rewrite in its own right.
+    // literal halves are already right; a cut that moved is a rewrite in its own right.
     if (chain === null || (chain.length === 0 && moved === null))
         return null;
     const seam = seamParts(bytes, chain, at);
@@ -33,9 +33,9 @@ export const rebalanceLiveSplit = (node, offset, firstRaw, secondRaw, linkRef) =
         assembleDroppingTerminalTrivia(bytes, seam)
     ];
     for (const candidate of candidates) {
-        // The dropped bytes are the verification's business, not the caller's: what it gets back
-        // is the two halves, whatever the candidate had to state to earn them.
-        if (candidate !== null && parsesBack(bytes, seam, candidate, resolver)) {
+        // The dropped bytes are the check's business, not the caller's: what the caller gets back
+        // is the two halves, whatever the candidate had to declare to earn them.
+        if (candidate !== null && parsesBack(bytes, seam, candidate, reading)) {
             return { firstRaw: candidate.firstRaw, secondRaw: candidate.secondRaw };
         }
     }
@@ -43,7 +43,7 @@ export const rebalanceLiveSplit = (node, offset, firstRaw, secondRaw, linkRef) =
 };
 /**
  * Read the caller's two halves back against the original, so a cut this rewrite did not make (a
- * container body-write rule, a suffix move, a consumed line ending) surfaces as a failed anchor.
+ * container body-write rule, a suffix move, a consumed line ending) shows up as a failed match.
  */
 function readSplitBytes(node, offset, firstRaw, secondRaw) {
     if (!isProseKind(node.kind))
@@ -69,12 +69,8 @@ function readSplitBytes(node, offset, firstRaw, secondRaw) {
     }
     return null;
 }
-/**
- * The edge a cut moves to rather than landing inside a childless never-extend construct: two
- * halves of a URL are not two URLs, and half an escape is a literal backslash, so the whole
- * construct goes to the half the caret was nearer (live-mode.md § 4.4). Null where the cut lands
- * in no such construct. Innermost wins, as everywhere else.
- */
+/** Where a cut inside a childless never-extend construct (a URL, an escape) moves to: the edge the
+ *  caret was nearer, so the construct goes whole to one half (`docs/design/live-mode.md` § 4.4). */
 function wholeConstructEdge(inlines, offset) {
     let found = null;
     for (const node of inlineDescendants(inlines)) {
@@ -86,12 +82,8 @@ function wholeConstructEdge(inlines, offset) {
     }
     return found;
 }
-/**
- * Every construct holding `offset`, outermost first — or null when one of them declines. A kind
- * with no policy row, one whose split behavior is plain and one whose content bounds are unknown
- * cannot be cut open, and cutting the constructs inside one would strand its pair. Exported for
- * the depth pin, which has to reach it with a tree no split this deep could be rendered at.
- */
+/** Every construct holding `offset`, outermost first, or null when one cannot be cut open, since
+ *  cutting the constructs inside it would strand its pair. Exported for the depth test. */
 export function splittableChainAt(inlines, offset) {
     const chain = [];
     const holds = (node) => holdsOffset(node, offset);
@@ -113,11 +105,8 @@ export function splittableChainAt(inlines, offset) {
     }
     return chain;
 }
-/**
- * Whether a cut at `offset` lands in this construct. One with children is content-INCLUSIVE so
- * its edges reach the chain (the handover cases); a childless one is strict-interior, its edges
- * being ordinary seams. Text is content, and nothing under it is a construct either.
- */
+/** Whether a cut at `offset` lands in this construct: one with children includes its content
+ *  bounds; one without counts only its strict interior, since its edges are ordinary cut points. */
 function holdsOffset(node, offset) {
     if (node.kind === 'text')
         return false;
@@ -126,11 +115,8 @@ function holdsOffset(node, offset) {
         ? offset >= content.start && offset <= content.end
         : offset > node.start && offset < node.end;
 }
-/**
- * Innermost first, so a closer written before its enclosing one nests the halves as the original
- * did. A side with no content takes the whole construct: a pair enclosing nothing is residue live
- * may never write.
- */
+/** Innermost first, so the halves nest as the original did. A side with no content takes the whole
+ *  construct, since live mode never writes a pair enclosing nothing. */
 function seamParts(bytes, chain, offset) {
     let leftEnd = offset;
     let rightStart = bytes.cut;
@@ -165,11 +151,8 @@ const assemble = (bytes, seam) => ({
     firstRaw: seam.head + seam.closers + bytes.firstResidue,
     secondRaw: seam.openers + seam.tail + bytes.secondResidue
 });
-/**
- * The same seam with a boundary space handed to the plain text beside it. Markdown opens and
- * closes a run against a word, never whitespace, so a space left inside kills the construct; a
- * space's formatting is invisible, so moving it is the reading that parses and looks unchanged.
- */
+/** The same cut with a boundary space handed to the plain text beside it: a run cannot open or close
+ *  against whitespace, and a space's formatting is invisible anyway. */
 function assembleSpaceOutside(bytes, seam) {
     const trailing = seam.closers !== '' && seam.head.endsWith(' ');
     const leading = seam.openers !== '' && seam.tail.startsWith(' ');
@@ -182,13 +165,10 @@ function assembleSpaceOutside(bytes, seam) {
             bytes.secondResidue
     };
 }
-/**
- * The seam with a whitespace-only tail dropped rather than handed to either half. A block's
- * TERMINAL whitespace is a hard break with no following line, so it paints nothing, and
- * live-mode.md § 4.5 licenses live to drop what it never showed.
- */
+/** The cut with a whitespace-only tail dropped: trailing whitespace draws nothing, and live mode
+ *  may drop what it never showed (`docs/design/live-mode.md` § 4.5). */
 function assembleDroppingTerminalTrivia(bytes, seam) {
-    if (seam.openers !== '' || seam.tail === '' || seam.tail.trim() !== '')
+    if (seam.openers !== '' || seam.tail === '' || !isBlankText(seam.tail))
         return null;
     return {
         firstRaw: seam.head + seam.closers + bytes.firstResidue,
@@ -200,40 +180,43 @@ function assembleDroppingTerminalTrivia(bytes, seam) {
  * A candidate answers every question below or it is not written. Exported for the verification
  * test, which has to reach it with a candidate no producer here would build.
  */
-export function parsesBack(bytes, seam, candidate, resolver) {
-    const first = soleProseBlock(candidate.firstRaw, resolver);
-    const second = soleProseBlock(candidate.secondRaw, resolver);
+export function parsesBack(bytes, seam, candidate, reading) {
+    const first = soleProseBlock(candidate.firstRaw, reading);
+    const second = soleProseBlock(candidate.secondRaw, reading);
     if (first === null || second === null)
         return false;
-    // Each half must be a block the RELOAD keeps. Empty is one; whitespace-only is not, since the
-    // document reads those bytes as blank trivia and the pair comes back a different shape.
-    if (isWhitespaceOnly(first.visible) || isWhitespaceOnly(second.visible))
+    // Each half must be a block a reparse keeps. Empty is one; whitespace-only is not, since the
+    // document reads those bytes as a blank line and the pair comes back a different shape.
+    if (readsAsBlankLine(first.visible) || readsAsBlankLine(second.visible))
         return false;
     if (!seam.closed.every((kind) => first.kinds.has(kind)))
         return false;
     if (!seam.reopened.every((kind) => second.kinds.has(kind)))
         return false;
-    // The render oracle below counts characters while CSS collapses a terminal run to nothing, so
-    // the "screen never showed it" rule is read here rather than trusted from the producer.
-    if (candidate.droppedTail !== undefined && candidate.droppedTail.trim() !== '')
+    // The render check below counts characters while CSS collapses a trailing run to nothing, so
+    // the "the screen never showed it" rule is tested here rather than taken on trust.
+    if (candidate.droppedTail !== undefined && !isBlankText(candidate.droppedTail))
         return false;
-    const whole = renderedText(parseInline(bytes.raw, bytes.contentStart, bytes.contentEnd, resolver), bytes.raw, CONTENT_VISIBILITY);
+    const whole = renderedText(readInline(bytes.raw, bytes.contentStart, bytes.contentEnd, reading.resolver, reading.grammar), bytes.raw, CONTENT_VISIBILITY, { grammar: reading.grammar });
     if (!whole.startsWith(first.visible))
         return false;
-    // The line ending the cut landed on is the one character a split legitimately consumes; a
-    // dropped tail is the only other, and the candidate names those bytes rather than the check
-    // inferring them.
+    // A split may consume only the line ending the cut landed on and a dropped tail, which the
+    // candidate names rather than the check inferring it.
     const rest = whole.slice(first.visible.length);
     const tail = second.visible + (candidate.droppedTail ?? '');
     return rest === tail || rest === '\n' + tail || rest === '\r\n' + tail;
 }
-const isWhitespaceOnly = (visible) => visible !== '' && visible.trim() === '';
-function soleProseBlock(raw, resolver) {
-    const sole = soleProseReparse(raw, resolver);
-    if (sole === null)
+const readsAsBlankLine = (visible) => visible !== '' && isBlankText(visible);
+/** A half read as a top-level fragment: exactly one prose block, or null. */
+function soleProseBlock(raw, reading) {
+    const blocks = readBlocks(raw, { grammar: reading.grammar, scope: 'fragment' }).children;
+    if (blocks.length !== 1 || !isProseKind(blocks[0].kind))
         return null;
+    const block = blocks[0];
+    const range = getContentRange(block);
+    const nodes = readInline(block.raw, range.start, range.end, reading.resolver, reading.grammar);
     return {
-        visible: renderedText(sole.nodes, sole.block.raw, CONTENT_VISIBILITY),
-        kinds: constructKinds(sole.nodes)
+        visible: renderedText(nodes, block.raw, CONTENT_VISIBILITY, { grammar: reading.grammar }),
+        kinds: constructKinds(nodes)
     };
 }

package/dist/components/blocks/text/marker-completion.d.ts

@@ -1,18 +1,13 @@
 /**
- * The space that finishes a container's marker. An opener firing on the bare marker byte
- * (`>`) mints the container before the space arrives, so that space belongs to the marker
- * and not to the empty child the caret landed in. Declared by the container
- * (`contentStartSpace`), never by kind name here.
+ * The space that finishes a container's marker. The parser creates the container on the bare
+ * marker byte (`>`), before the space arrives, so that space belongs to the marker and not to
+ * the child the caret landed in. The container declares this with `contentStartSpace`; nothing
+ * here is keyed on a kind name.
  */
 import type { NodeView } from '../../../core/node-views';
 export interface MarkerCompletion {
-    /**
-     * Claim a bare space at `caretOffset` for the container's marker, or decline it to the
-     * content. `parent` is the block's NEAREST ancestor container — a nested quote completes at
-     * its own depth — or null at the document root. One claim per child: a claimed space writes
-     * nothing, so only this memory tells press 2 from press 1, and press 2 is the only way to
-     * type a leading space inside an empty quoted line.
-     */
-    claimSpace(node: NodeView, parent: NodeView | null, caretOffset: number): boolean;
+    /** Take a bare space at `caretOffset` for the nearest container's marker (`parent`, null at the
+     *  root), once per child: a second space there is content, the only way to type a leading one. */
+    claimSpace(node: NodeView, parent: NodeView | null, index: number, caretOffset: number): boolean;
 }
 export declare function createMarkerCompletion(): MarkerCompletion;

package/dist/components/blocks/text/marker-completion.js

@@ -1,25 +1,26 @@
 /**
- * The space that finishes a container's marker. An opener firing on the bare marker byte
- * (`>`) mints the container before the space arrives, so that space belongs to the marker
- * and not to the empty child the caret landed in. Declared by the container
- * (`contentStartSpace`), never by kind name here.
+ * The space that finishes a container's marker. The parser creates the container on the bare
+ * marker byte (`>`), before the space arrives, so that space belongs to the marker and not to
+ * the child the caret landed in. The container declares this with `contentStartSpace`; nothing
+ * here is keyed on a kind name.
  */
 import { displayLength } from '../../../core/lines';
 import { isProseKind } from '../../../core/inline';
 import { tryGetBlockKindDescriptor } from '../../../schema/block-kind-descriptor';
+import { rawOffsetOfLeaf } from '../../../tree-operations/container-offsets';
 export function createMarkerCompletion() {
-    // The node, not a bare flag: a surface re-used for another child — or the same child re-minted
-    // by a commit's copy-path-on-write — owes a fresh completion.
+    // The node, not a bare flag: an element reused for another child, or the same child recreated
+    // by a commit's copy-before-write, needs a fresh completion.
     let claimedFor = null;
     return {
-        claimSpace(node, parent, caretOffset) {
-            if (caretOffset !== 0 || !parent)
-                return false;
-            if (!isProseKind(node.kind) || displayLength(node.raw) !== 0)
+        claimSpace(node, parent, index, caretOffset) {
+            if (caretOffset !== 0 || !parent || !isProseKind(node.kind))
                 return false;
             if (tryGetBlockKindDescriptor(parent.kind)?.contentStartSpace !== 'complete-marker') {
                 return false;
             }
+            if (displayLength(node.raw) !== 0 && !followsBareMarker(parent, index))
+                return false;
             if (claimedFor === node)
                 return false;
             claimedFor = node;
@@ -27,3 +28,9 @@ export function createMarkerCompletion() {
         }
     };
 }
+/** Whether the child's text starts straight after its container's marker, with no space between
+ *  (`>abc`): the marker still lacks the space, so a space typed there completes it. */
+function followsBareMarker(parent, index) {
+    const at = rawOffsetOfLeaf(parent, [index], 0);
+    return at !== null && at > 0 && !/\s/.test(parent.raw[at - 1]);
+}

package/dist/components/blocks/text/pending-mark-insert.d.ts

@@ -1,23 +1,21 @@
 /**
  * The bytes an insertion produces while marks are pending. A mark resolves against the caret's
- * construct chain (live-mode.md § 4.3): a kind the chain lacks WRAPS the insertion, a kind it
- * carries escapes it. Flanking rules mean a splice that READS right can PARSE wrong
- * (`**hello**X** world**` renders literal stars), so every candidate is re-parsed and checked.
+ * chain of enclosing constructs (live-mode.md § 4.3): a kind the chain lacks wraps the insertion,
+ * a kind it already has escapes it. Flanking rules mean a splice that reads right can parse wrong
+ * (`**hello**X** world**` renders literal stars), so every candidate is reparsed and checked.
  */
 import type { AnyInlineKind, InlineNode } from '../../../core/nodes';
 import { type InlineMarkKind } from '../../../schema/inline-construct-policy';
+import type { Reading } from '../../../schema/reading';
 export interface MarkedInsertion {
-    /** The block's whole display bytes after the insertion. */
+    /** The block's whole displayed text after the insertion. */
     raw: string;
-    /** Where the caret lands — after the inserted text, inside whatever now wraps it. */
+    /** Where the caret lands: after the inserted text, inside whatever now wraps it. */
     caret: number;
 }
-/**
- * The insertion `text` at `caretOffset` makes under `marks`. Null when the marks name nothing to
- * do, or when no candidate parses back to what was asked — markdown cannot express every
- * combination at every caret, and a byte that types plain beats one that shows delimiters.
- */
-export declare function resolveMarkedInsertion(display: string, caretOffset: number, text: string, marks: ReadonlySet<InlineMarkKind>, inlines: readonly InlineNode[]): MarkedInsertion | null;
+/** The insertion `text` at `caretOffset` makes under `marks`, or null when no candidate parses back
+ *  as asked. `reading` must be the one `inlines` was read with. */
+export declare function resolveMarkedInsertion(display: string, caretOffset: number, text: string, marks: ReadonlySet<InlineMarkKind>, inlines: readonly InlineNode[], reading: Reading): MarkedInsertion | null;
 export interface ChainNode {
     kind: AnyInlineKind;
     /** The mark a chord can toggle, or null for a construct no chord addresses. */
@@ -27,11 +25,6 @@ export interface ChainNode {
     contentStart: number;
     contentEnd: number;
 }
-/**
- * EVERY construct holding `offset`, outermost first: one missing from the chain is missing from
- * `intended`, which is what lets a candidate destroy it unnoticed. A construct with children is
- * content-INCLUSIVE, a childless one STRICT-interior, its edges being ordinary insertion points.
- * Exported for the depth pin, which has to reach it with a tree no insertion this deep could be
- * rendered at.
- */
+/** Every construct holding `offset`, outermost first; one missing here could be destroyed unnoticed.
+ *  Exported for the depth test. */
 export declare function constructChainAt(offset: number, inlines: readonly InlineNode[]): ChainNode[];

package/dist/components/blocks/text/pending-mark-insert.js

@@ -1,19 +1,16 @@
 /**
  * The bytes an insertion produces while marks are pending. A mark resolves against the caret's
- * construct chain (live-mode.md § 4.3): a kind the chain lacks WRAPS the insertion, a kind it
- * carries escapes it. Flanking rules mean a splice that READS right can PARSE wrong
- * (`**hello**X** world**` renders literal stars), so every candidate is re-parsed and checked.
+ * chain of enclosing constructs (live-mode.md § 4.3): a kind the chain lacks wraps the insertion,
+ * a kind it already has escapes it. Flanking rules mean a splice that reads right can parse wrong
+ * (`**hello**X** world**` renders literal stars), so every candidate is reparsed and checked.
  */
-import { constructContentRange, constructKinds, inlineDescendants, parseInline } from '../../../core/inline';
+import { constructContentRange, constructKinds, inlineDescendants, readInline } from '../../../core/inline';
 import { CONTENT_VISIBILITY, renderedText } from '../../../core/inline/visibility';
 import { getInlineConstructPolicy, getInlineMarkPolicy, listInlineMarks } from '../../../schema/inline-construct-policy';
 import { insertsExactly } from './screen-diff';
-/**
- * The insertion `text` at `caretOffset` makes under `marks`. Null when the marks name nothing to
- * do, or when no candidate parses back to what was asked — markdown cannot express every
- * combination at every caret, and a byte that types plain beats one that shows delimiters.
- */
-export function resolveMarkedInsertion(display, caretOffset, text, marks, inlines) {
+/** The insertion `text` at `caretOffset` makes under `marks`, or null when no candidate parses back
+ *  as asked. `reading` must be the one `inlines` was read with. */
+export function resolveMarkedInsertion(display, caretOffset, text, marks, inlines, reading) {
     if (marks.size === 0 || text.length === 0)
         return null;
     const chain = constructChainAt(caretOffset, inlines);
@@ -22,16 +19,15 @@ export function resolveMarkedInsertion(display, caretOffset, text, marks, inline
         .map((entry) => entry.kind)
         .filter((kind) => marks.has(kind) && !chain.some((node) => node.mark === kind));
     const removedKinds = new Set(removed.map((node) => node.kind));
-    // What must enclose the inserted text afterwards: every construct the caret was inside minus
-    // the ones this chord removes, plus the ones it adds. Non-markable ancestors are in it too —
-    // that is what stops an escape from carrying the byte out of a link it was inside.
+    // Ancestors with no mark stay in the intended chain, which stops an escape from carrying the
+    // byte out of a link it was inside.
     const intended = new Set([
         ...chain.map((node) => node.kind).filter((kind) => !removedKinds.has(kind)),
         ...applied
     ]);
-    const before = { visible: visibleText(display), kinds: constructKinds(inlines) };
+    const before = { visible: visibleText(display, reading), kinds: constructKinds(inlines) };
     for (const candidate of candidateInsertions(display, caretOffset, text, chain, removed, intended)) {
-        if (parsesAsIntended(candidate, text, intended, before)) {
+        if (parsesAsIntended(candidate, text, intended, before, reading)) {
             return { raw: candidate.raw, caret: candidate.textAt + text.length };
         }
     }
@@ -52,9 +48,8 @@ function* candidateInsertions(display, caretOffset, text, chain, removed, intend
     const escaped = chain.slice(depth);
     const outside = chain.slice(0, depth);
     const payload = marksToWrite(intended, outside);
-    // A link or a widget between the caret and the construct being escaped cannot be cut open: its
-    // closer is not a mirror of its opener the way a mark's is, and splicing inside one writes
-    // literal bytes into content. Only stepping outside is available there.
+    // A link or widget between the caret and the escaped construct cannot be cut open, since its
+    // closer does not mirror its opener, so only stepping outside is tried.
     if (escaped.every((node) => isSymmetricPair(node.kind))) {
         yield splitOpen(display, caretOffset, text, escaped, payload);
     }
@@ -63,9 +58,8 @@ function* candidateInsertions(display, caretOffset, text, chain, removed, intend
     for (const at of sides)
         yield spliceWrapped(display, at, text, payload);
 }
-/** The marks the insertion must declare for itself: the intended ones its surroundings do not
- *  already provide, outermost first. Rows rather than kinds, so nothing downstream can look a
- *  marker up and miss. */
+/** The marks the insertion must write for itself: the intended ones its surroundings do not
+ *  already provide, outermost first. */
 function marksToWrite(intended, provided) {
     return listInlineMarks().filter(({ kind }) => intended.has(kind) && !provided.some((node) => node.kind === kind));
 }
@@ -80,9 +74,8 @@ function spliceWrapped(display, at, text, payload) {
         textAt: at + openers.length
     };
 }
-/** Close every escaped construct before the insertion and reopen it after — the split that keeps
- *  the user's text where they put it. An empty half would leave a pair enclosing nothing, the
- *  invisible `****` residue live mode must never mint, so that side steps outside the run. */
+/** Close every escaped construct before the insertion and reopen it after. A side left empty
+ *  steps outside the run instead, since live mode never writes a pair around nothing. */
 function splitOpen(display, caretOffset, text, escaped, payload) {
     let leftEnd = caretOffset;
     let rightStart = caretOffset;
@@ -104,14 +97,10 @@ function splitOpen(display, caretOffset, text, escaped, payload) {
         textAt: leftEnd + closers.length + inner.textAt
     };
 }
-/**
- * Three questions, and a candidate answers all of them or it is not written. Did the mark TAKE —
- * do exactly the intended constructs enclose the inserted text? Did every construct the block
- * already held SURVIVE — a delimiter run shared between two pairings rebinds under any splice, and
- * the loser is a construct nobody asked to spend. And is the rewrite invisible otherwise?
- */
-function parsesAsIntended(candidate, text, intended, before) {
-    const nodes = parseInline(candidate.raw, 0, candidate.raw.length);
+/** A candidate is written only if exactly the intended constructs enclose the inserted text, every
+ *  construct the block held survives (a shared run can rebind), and nothing else shows a change. */
+function parsesAsIntended(candidate, text, intended, before, reading) {
+    const nodes = readInline(candidate.raw, 0, candidate.raw.length, reading.resolver, reading.grammar);
     const around = enclosingKinds(nodes, candidate.textAt, candidate.textAt + text.length);
     if (around.size !== intended.size)
         return false;
@@ -122,7 +111,7 @@ function parsesAsIntended(candidate, text, intended, before) {
     for (const kind of before.kinds)
         if (!after.has(kind))
             return false;
-    return insertsExactly(before.visible, visibleText(candidate.raw, nodes), text);
+    return insertsExactly(before.visible, visibleText(candidate.raw, reading, nodes), text);
 }
 /** The construct kinds covering `[start, end)`; `text` is content, not a construct. */
 function enclosingKinds(nodes, start, end) {
@@ -134,13 +123,10 @@ function enclosingKinds(nodes, start, end) {
     }
     return kinds;
 }
-/** What a reader sees, asked of the thing that actually paints it: only the render path knows
- *  which bytes a kind paints as markers (G4.33), so no private walk over the parse. The content
- *  reading, not the block's own: the first byte typed into content-empty chrome folds it away, and
- *  the diff above would read that fold as bytes lost. This arm only ADDS bytes, so no reading of
- *  it licenses dropping one the reader saw. */
-function visibleText(raw, parsed) {
-    return renderedText(parsed ?? parseInline(raw, 0, raw.length), raw, CONTENT_VISIBILITY);
+/** What the user sees, asked of the render (G4.33). The content reading rather than the block's
+ *  own: the first byte typed into an empty construct hides its markers, which is not a loss. */
+function visibleText(raw, reading, parsed) {
+    return renderedText(parsed ?? readInline(raw, 0, raw.length, reading.resolver, reading.grammar), raw, CONTENT_VISIBILITY, { grammar: reading.grammar });
 }
 /** Read off the kind's row rather than a second list, so a new format joins in one place. */
 function markOf(kind) {
@@ -151,13 +137,8 @@ function markOf(kind) {
 function isSymmetricPair(kind) {
     return getInlineConstructPolicy(kind)?.edgeAffinity === 'symmetric-pair';
 }
-/**
- * EVERY construct holding `offset`, outermost first: one missing from the chain is missing from
- * `intended`, which is what lets a candidate destroy it unnoticed. A construct with children is
- * content-INCLUSIVE, a childless one STRICT-interior, its edges being ordinary insertion points.
- * Exported for the depth pin, which has to reach it with a tree no insertion this deep could be
- * rendered at.
- */
+/** Every construct holding `offset`, outermost first; one missing here could be destroyed unnoticed.
+ *  Exported for the depth test. */
 export function constructChainAt(offset, inlines) {
     const holds = (node) => holdsOffset(node, offset);
     const chain = [];
@@ -176,8 +157,8 @@ export function constructChainAt(offset, inlines) {
     }
     return chain;
 }
-/** Whether `offset` sits inside this construct, on the reading the chain doc states. Text is
- *  content, and nothing under it is a construct either. */
+/** Whether `offset` sits inside this construct, on the reading `constructChainAt` describes. Text
+ *  is content, and nothing under it is a construct either. */
 function holdsOffset(node, offset) {
     if (node.kind === 'text')
         return false;

package/dist/components/blocks/text/screen-diff.d.ts

@@ -1,20 +1,10 @@
 /**
- * What a live rewrite claims it did to the SCREEN, as two predicates over the painter's before and
- * after readings (live-mode.md § 2), plus the sole-prose reparse a candidate must survive first.
- * Shared, so the verification arms ask the same questions of the same shapes rather than each
- * carrying its own walk.
+ * What a live rewrite says it did to the screen, as two checks over the text before and after
+ * (live-mode.md § 2). Shared, so every caller asks the same questions of the same shapes instead
+ * of writing its own traversal.
  */
-import type { LinkReferenceResolver } from '../../../core/inline/link-reference-resolver';
-import type { CstNode, InlineNode } from '../../../core/nodes';
 /** Whether `after` is `before` with `text` spliced in at one place and nothing else moved. */
 export declare function insertsExactly(before: string, after: string, text: string): boolean;
-/** Whether `after` is `before` with exactly `removed` gone from one place — the whole claim a cut
- *  makes to the reader, asked of the bytes the parser produced rather than the ones it was given. */
+/** Whether `after` is `before` with exactly `removed` gone from one place: everything a cut
+ *  promises the user, asked of the bytes the parser produced rather than the ones it was given. */
 export declare function removesExactly(before: string, after: string, removed: string): boolean;
-/** A candidate's admission gate: its bytes reload as exactly ONE prose block, whose inline tree the
- *  caller then reads its own oracle over. Null declines — a reload that splits or re-kinds the
- *  block is not what the caller is about to install. */
-export declare function soleProseReparse(raw: string, resolver?: LinkReferenceResolver): {
-    block: CstNode;
-    nodes: InlineNode[];
-} | null;

package/dist/components/blocks/text/screen-diff.js

@@ -1,11 +1,8 @@
 /**
- * What a live rewrite claims it did to the SCREEN, as two predicates over the painter's before and
- * after readings (live-mode.md § 2), plus the sole-prose reparse a candidate must survive first.
- * Shared, so the verification arms ask the same questions of the same shapes rather than each
- * carrying its own walk.
+ * What a live rewrite says it did to the screen, as two checks over the text before and after
+ * (live-mode.md § 2). Shared, so every caller asks the same questions of the same shapes instead
+ * of writing its own traversal.
  */
-import { getContentRange, isProseKind, parseInline } from '../../../core/inline';
-import { parse } from '../../../core/parser';
 /** Whether `after` is `before` with `text` spliced in at one place and nothing else moved. */
 export function insertsExactly(before, after, text) {
     if (after.length !== before.length + text.length)
@@ -15,8 +12,8 @@ export function insertsExactly(before, after, text) {
         at++;
     return (after.slice(at, at + text.length) === text && after.slice(at + text.length) === before.slice(at));
 }
-/** Whether `after` is `before` with exactly `removed` gone from one place — the whole claim a cut
- *  makes to the reader, asked of the bytes the parser produced rather than the ones it was given. */
+/** Whether `after` is `before` with exactly `removed` gone from one place: everything a cut
+ *  promises the user, asked of the bytes the parser produced rather than the ones it was given. */
 export function removesExactly(before, after, removed) {
     if (after.length !== before.length - removed.length)
         return false;
@@ -26,14 +23,3 @@ export function removesExactly(before, after, removed) {
     return (before.slice(at, at + removed.length) === removed &&
         after.slice(at) === before.slice(at + removed.length));
 }
-/** A candidate's admission gate: its bytes reload as exactly ONE prose block, whose inline tree the
- *  caller then reads its own oracle over. Null declines — a reload that splits or re-kinds the
- *  block is not what the caller is about to install. */
-export function soleProseReparse(raw, resolver) {
-    const blocks = parse(raw, { scope: 'fragment' }).children;
-    if (blocks.length !== 1 || !isProseKind(blocks[0].kind))
-        return null;
-    const block = blocks[0];
-    const range = getContentRange(block);
-    return { block, nodes: parseInline(block.raw, range.start, range.end, resolver) };
-}