@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/components/blocks/text/live-join-seam.js

@@ -1,35 +1,33 @@
 /**
- * The live-mode join rewrite (live-mode.md § 4.5): a literal concatenation surfaces the runs a
- * truncation left unpaired and the closer/opener pair a split's inverse abuts around nothing. Both
- * are dropped here and nowhere else, and only once the joined block re-parses to ONE prose block
- * showing what the two sides showed.
+ * The live-mode join rewrite (live-mode.md § 4.5): joining two blocks literally would show the
+ * delimiter runs a truncation left unpaired, and the closer/opener pair a split's inverse pushes
+ * together around nothing. Both are dropped here and nowhere else, and only once the joined bytes,
+ * read back where they will be stored, show what the two sides showed.
  */
-import { constructContentRange, getContentRange, inlineDescendants, isProseKind, parseInline } from '../../../core/inline';
+import { constructContentRange, getContentRange, inlineDescendants, isProseKind, readInline } from '../../../core/inline';
 import { CONTENT_VISIBILITY, paintsOnlyChrome, renderedText } from '../../../core/inline/visibility';
-import { trimTrailingLineEnding } from '../../../core/lines';
-import { parse } from '../../../core/parser';
+import { readBack, readSource, shownOf } from '../../../core/inline/live-edit/read-back';
+import { isBlankText, trimTrailingLineEnding } from '../../../core/lines';
 import { getInlineConstructPolicy } from '../../../schema/inline-construct-policy';
-import { soleProseReparse } from './screen-diff';
 // ── The rewrite ──────────────────────────────────────────────────────────────
 export const cleanLiveJoinSeam = (join) => {
-    const resolver = join.linkRef?.current;
-    const left = readSide(join.start, 'before', resolver);
-    const right = readSide(join.end, 'after', resolver);
+    const { typed, store } = join;
+    const left = readSide(join.start, 'before', store.reading);
+    const right = readSide(join.end, 'after', store.reading);
     if (left === null || right === null)
         return null;
-    // Nothing stands on the seam, so the literal join is already the answer — and the ordinary
-    // Backspace between two plain paragraphs pays no parse for it.
+    // Nothing sits at the join, so the plain concatenation is already the answer, and an ordinary
+    // Backspace between two paragraphs pays for no parse.
     if (!standsOnSeam(left) && !standsOnSeam(right))
         return null;
     if (!anchorsOnMerged(join, left, right))
         return null;
-    // The caller splices `typed` at the seam once this returns, so the bytes verified below are the
+    // The caller splices `typed` at the join once this returns, so the bytes checked below are the
     // bytes written: a typed run changes the flanking a kept delimiter pairs against.
-    const typed = join.typed ?? '';
     const shown = shownAfterJoin(left, right, typed);
     const pairs = abuttingPairSpans(join, left, right);
-    // Least destructive first: keep the runs the two sides can still pair across the seam, and fall
-    // back to dropping every stranded one. Identical readings render once.
+    // Two readings, least destructive first: keep the runs the two sides can still pair across the
+    // join, else drop every stranded one.
     const readings = [unpairedSpans(join, left, right), everyDanglingSpan(join, left, right)];
     const spanSets = readings.map((dangling) => [...dangling, ...pairs]);
     const candidates = (sameSpans(spanSets[0], spanSets[1]) ? [spanSets[0]] : spanSets).map((spans) => {
@@ -39,61 +37,58 @@ export const cleanLiveJoinSeam = (join) => {
             spans,
             raw,
             seam,
-            read: readCandidate(raw.slice(0, seam) + typed + raw.slice(seam), resolver, join)
+            read: readCandidate(raw.slice(0, seam) + typed + raw.slice(seam), store)
         };
     });
-    // § 4.1's other half: a run the leanest reading keeps can be one the cut left enclosing nothing,
-    // and a pair over nothing passes the screen check. Least destructive is read among the rest.
+    // A pair left over nothing also passes the screen check, so among the readings that pass, the
+    // one leaving the fewest such pairs wins (`docs/design/live-mode.md` § 4.1).
     const floor = Math.min(...candidates.map(({ read }) => read?.residue ?? Infinity));
     for (const { raw: candidate, seam, read } of candidates) {
         if (read === null || read.visible !== shown || read.residue > floor)
             continue;
-        // A candidate that changed nothing IS the literal join: declining says so, and keeps the
-        // caller off a rewrite path it does not need.
+        // A candidate that changed nothing is the plain concatenation: refusing says so, and keeps
+        // the caller off a rewrite path it does not need.
         if (candidate === join.mergedRaw)
             return null;
-        // The split half's terminal-trivia rule, on the join: a whitespace-only survivor paints
-        // nothing and reloads as blank trivia, a different shape than the block written.
+        // The split half's trailing-whitespace rule, applied to the join: a survivor that is only
+        // whitespace draws nothing and reparses as a blank line, not the block that was written.
         const display = trimTrailingLineEnding(candidate);
-        if (display !== '' && display.trim() === '') {
+        if (display !== '' && isBlankText(display)) {
             return { raw: candidate.slice(display.length), seam: 0 };
         }
         return { raw: candidate, seam };
     }
     return null;
 };
-/** Every byte a reading drops ahead of the seam moves the caret's landing with it. */
+/** Every byte a reading drops before the join moves the caret with it. */
 const droppedBefore = (spans, seam) => spans
     .filter((span) => span.end <= seam)
     .reduce((total, span) => total + span.end - span.start, 0);
 const standsOnSeam = (side) => side.dangling.length > 0 || side.touching.length > 0;
 const sameSpans = (a, b) => a.length === b.length && a.every((span, i) => span.start === b[i].start && span.end === b[i].end);
-/**
- * Read one endpoint's surviving bytes and the constructs its cut leaves at the seam. Null where
- * the cleanup has no business running: a non-prose kind, an offset outside the content, or a cut
- * through a family that declares no close-and-reopen, whose bytes mean nothing apart.
- */
-function readSide(endpoint, keep, resolver) {
+/** One endpoint's surviving bytes and the constructs its cut leaves at the join. Null for a
+ *  non-prose kind, an offset outside the content, or a cut through a family that cannot reopen. */
+function readSide(endpoint, keep, reading) {
     const { node, offset } = endpoint;
     if (!isProseKind(node.kind))
         return null;
     const content = getContentRange(node);
     if (offset < content.start || offset > content.end)
         return null;
-    const inlines = parseInline(node.raw, content.start, content.end, resolver);
-    // Chrome standing over nothing is all on screen (live-mode.md § 4.1), so a run surviving this
-    // cut is bytes the reader saw, not a stranded one: the literal join stands.
-    if (paintsOnlyChrome(inlines, node.raw))
+    const inlines = readInline(node.raw, content.start, content.end, reading.resolver, reading.grammar);
+    // Markers standing over nothing are all on screen (live-mode.md § 4.1), so a run that survives
+    // this cut is bytes the user saw, not a stranded one: the plain concatenation stands.
+    if (paintsOnlyChrome(inlines, node.raw, { grammar: reading.grammar }))
         return null;
     const { ranged, atomic } = classifyConstructs(inlines);
     // Neither an atomic construct's interior nor the middle of a delimiter run leaves halves any
-    // reading of the seam can repair. Live's caret cannot land there; a plugin's can.
+    // reading can repair. A live-mode caret cannot land there; a plugin's can.
     if (atomic.some((span) => offset > span.start && offset < span.end))
         return null;
     if (ranged.some((c) => splitsARun(c, offset)))
         return null;
-    // Dangling is about the PARTNER, so content-range containment is not the test: a cut at a
-    // construct's content start leaves its opener behind just as one in the middle does.
+    // What matters is whether the partner delimiter survives, not whether the cut lies inside the
+    // content range: a cut at a construct's content start leaves its opener behind too.
     const dangling = ranged.filter((c) => keep === 'before'
         ? c.content.start <= offset && offset < c.node.end
         : c.node.start < offset && offset <= c.content.end);
@@ -101,6 +96,7 @@ function readSide(endpoint, keep, resolver) {
         return null;
     return {
         raw: node.raw,
+        grammar: reading.grammar,
         content,
         cut: offset,
         inlines,
@@ -108,11 +104,11 @@ function readSide(endpoint, keep, resolver) {
         touching: touchingChain(ranged, offset, keep)
     };
 }
-/** Text is content, not a construct, and nothing under it is one either — the descent predicate
- *  the two censuses below share. */
+/** Text is content, not a construct, and nothing under it is one either. The two scans below
+ *  share this test when they descend. */
 const isConstruct = (node) => node.kind !== 'text';
-/** Constructs with a content range (outermost first) apart from those without one, whose bytes
- *  the seam can only step around. */
+/** Constructs with a content range (outermost first), kept apart from those without one, whose
+ *  bytes the join can only step around. */
 function classifyConstructs(inlines) {
     const ranged = [];
     const atomic = [];
@@ -129,15 +125,12 @@ function classifyConstructs(inlines) {
     return { ranged, atomic };
 }
 const splitsARun = (c, at) => (at > c.node.start && at < c.content.start) || (at > c.content.end && at < c.node.end);
-/** Whether the family declares its delimiters cuttable and rejoinable at all (live-mode.md § 4.4). */
+/** Whether the family can be cut and rejoined (`docs/design/live-mode.md` § 4.4). */
 function isRejoinable(kind) {
     return getInlineConstructPolicy(kind)?.splitBehavior === 'close-and-reopen';
 }
-/**
- * The nested chain of closers ending at `cut` (or openers starting there), peeled outermost
- * first: `**a *b***` cut at its end gives the strong, then the emphasis its closer wraps. This is
- * the shape `live-split-rebalance` writes, read back.
- */
+/** The nested chain of closers ending at `cut` (or openers starting there), outermost first:
+ *  `**a *b***` cut at its end gives the strong emphasis, then the emphasis. */
 function touchingChain(constructs, cut, keep) {
     const chain = [];
     let at = cut;
@@ -149,30 +142,27 @@ function touchingChain(constructs, cut, keep) {
         at = keep === 'before' ? link.content.end : link.content.start;
     }
 }
-/** Whether the merged bytes are still the two sides' bytes end to end — a normalizer that
- *  rewrote either one moves every offset below, so the cleanup stands down instead. */
+/** Whether the merged bytes are still the two sides' bytes end to end. Anything that rewrote
+ *  either side moves every offset below, so the cleanup does nothing instead. */
 function anchorsOnMerged(join, left, right) {
     return (join.mergedRaw.slice(0, join.seam) === left.raw.slice(0, left.cut) &&
         join.mergedRaw.startsWith(right.raw.slice(right.cut, right.content.end), join.seam));
 }
 // ── The spans a join may drop ────────────────────────────────────────────────
-/** A left-side span is already in merged coordinates; a right-side one shifts by the seam. */
+/** A left-side span is already in merged coordinates; a right-side one shifts by the join. */
 const rightSpan = (join, right, span) => ({
     start: join.seam + span.start - right.cut,
     end: join.seam + span.end - right.cut
 });
 const openerRun = (c) => ({ start: c.node.start, end: c.content.start });
 const closerRun = (c) => ({ start: c.content.end, end: c.node.end });
-/** Whether two constructs are written with the same delimiters — the byte-level test for "these
- *  are one construct's two halves", which kind equality alone cannot make (`__a__` vs `**a**`). */
+/** Whether two constructs are written with the same delimiters: the byte-level test for "these
+ *  are one construct's two halves", which matching kinds alone cannot make (`__a__` vs `**a**`). */
 const sameDelimiters = (left, lc, right, rc) => left.raw.slice(lc.node.start, lc.content.start) ===
     right.raw.slice(rc.node.start, rc.content.start) &&
     left.raw.slice(lc.content.end, lc.node.end) === right.raw.slice(rc.content.end, rc.node.end);
-/**
- * The runs a truncation stranded that the join does NOT put back together: the left's opener
- * chain and the right's closer chain, minus the leading pairs whose kinds line up — those two
- * halves make one construct across the seam, which is what the reader had.
- */
+/** The runs a truncation stranded that the join does not rejoin: the left's openers and the right's
+ *  closers, minus the leading pairs whose kinds line up and so make one construct again. */
 function unpairedSpans(join, left, right) {
     let paired = 0;
     while (paired < left.dangling.length &&
@@ -192,11 +182,8 @@ function everyDanglingSpan(join, left, right) {
         ...right.dangling.map((c) => rightSpan(join, right, closerRun(c)))
     ];
 }
-/**
- * The closer/opener pair a split's inverse brings back to back: same kinds nested the same way,
- * written with the same bytes, enclosing nothing between them. Whole chain or nothing — dropping
- * an outer pair while an inner one stays would leave both halves' runs unbalanced.
- */
+/** The closer/opener chain a split's inverse brings back to back around nothing, same kinds and
+ *  bytes. Dropped whole or not at all, since a partial drop leaves the runs unbalanced. */
 function abuttingPairSpans(join, left, right) {
     const closing = left.touching;
     const opening = right.touching;
@@ -228,26 +215,18 @@ function withoutSpans(raw, spans) {
     return out + raw.slice(at);
 }
 // ── Verification ─────────────────────────────────────────────────────────────
-/**
- * What the reader is owed: what each side ALREADY SHOWED of the bytes that survive. Read off the
- * pre-join parse, never off the joined halves — either of those bakes the defect this checks for
- * into its own expectation.
- */
+/** What the user must still see, read off each side's parse from before the join: reading the
+ *  joined halves would bake the fault this checks for into the expectation. */
 const shownAfterJoin = (left, right, typed) => visibleSide(left, 'before') + typed + visibleSide(right, 'after');
-/**
- * What a reader sees, asked of the thing that paints it: the render path's own DOM with every
- * marker span dropped. The clip decides only WHERE the bytes stop; a construct the cut crosses
- * contributes its content, since its delimiter runs paint nothing either way — which `readSide`
- * has already established by declining a side whose chrome paints.
- */
+/** What the user sees of one side, asked of the render with every marker dropped. A construct the
+ *  cut crosses still gives its content, since `readSide` refused any side whose markers paint. */
 function visibleSide(side, keep) {
-    return renderedText(clipNodes(side.inlines, side.cut, keep), side.raw, CONTENT_VISIBILITY);
+    return renderedText(clipNodes(side.inlines, side.cut, keep), side.raw, CONTENT_VISIBILITY, {
+        grammar: side.grammar
+    });
 }
-/**
- * The `keep` side of `level`, rebuilt: a construct the cut crosses hands its place to its own
- * clipped children. Exported for the depth pin, which has to reach the rebuild with a tree no
- * side this deep could be rendered at.
- */
+/** The `keep` side of `level`, rebuilt: a construct the cut crosses is replaced by its clipped
+ *  children. Exported for the depth test. */
 export function clipNodes(level, cut, keep) {
     const before = keep === 'before';
     // A crossed construct is emitted as its children, in its own place, so the pre-order's
@@ -271,7 +250,7 @@ export function clipNodes(level, cut, keep) {
         if (node.children && node.children.length > 0)
             continue;
         // A code span carries its content as bytes rather than children, so the surviving part of
-        // it is that byte range read as text — which is exactly what the span paints.
+        // it is that byte range read as text, which is exactly what the span shows.
         const start = before ? content.start : Math.max(content.start, cut);
         const end = before ? Math.min(content.end, cut) : content.end;
         if (end > start)
@@ -279,46 +258,30 @@ export function clipNodes(level, cut, keep) {
     }
     return out;
 }
-/**
- * The candidate read back as the caller will install it: what it shows, and how many constructs its
- * row unwraps are left standing over nothing. Null where a join produces something the caller cannot
- * install — two blocks, a kind with no inline content, or a body the container would re-read.
- */
-function readCandidate(raw, resolver, join) {
-    if (!keepsContainerMarker(join.ambientPrefix ?? '', raw))
-        return null;
-    const sole = soleProseReparse(raw, resolver);
-    if (sole === null)
+/** The candidate read back where it will be stored: what it shows, and how many unwrapping
+ *  constructs stand over nothing. Null where that position would not keep it as one prose block. */
+function readCandidate(raw, store) {
+    const read = readBack(raw, store);
+    if (read === null)
         return null;
-    const { block, nodes } = sole;
+    const { inlines } = read;
+    const source = readSource(read);
+    const render = { grammar: store.reading.grammar };
     return {
-        visible: renderedText(nodes, block.raw, CONTENT_VISIBILITY),
-        // Chrome standing over nothing is all on screen (§ 4.1), so a block that paints hides no pair.
-        residue: paintsOnlyChrome(nodes, block.raw) ? 0 : countResidue(nodes, block.raw)
+        visible: shownOf(read, store),
+        // Markers over nothing are all on screen (§ 4.1), so a block that shows them hides no pair.
+        residue: paintsOnlyChrome(inlines, source, render) ? 0 : countResidue(inlines, source, render)
     };
 }
-/**
- * Whether the container still reads its own marker off the candidate. The item's marker is not in
- * these bytes but absorbs from them, so a body the cut left starting with a space reloads under a
- * WIDER marker than the live tree holds — the load/save cycle would then change the tree.
- */
-function keepsContainerMarker(prefix, raw) {
-    if (prefix === '')
-        return true;
-    const blocks = parse(prefix + raw, { scope: 'fragment' }).children;
-    if (blocks.length !== 1)
-        return false;
-    return blocks[0].marker === prefix;
-}
-/** Constructs the reader would meet as nothing at all: no painted byte, and a row that unwraps
+/** Constructs the user would meet as nothing at all: no visible byte, and a policy that unwraps
  *  them when emptied rather than leaving delimiters over nothing. */
-function countResidue(nodes, raw) {
+function countResidue(nodes, raw, render) {
     let found = 0;
     for (const node of inlineDescendants(nodes, isConstruct)) {
         if (node.kind === 'text')
             continue;
         if (node.end > node.start &&
-            renderedText([node], raw, CONTENT_VISIBILITY) === '' &&
+            renderedText([node], raw, CONTENT_VISIBILITY, render) === '' &&
             getInlineConstructPolicy(node.kind)?.autoUnwrapOnEmpty === true) {
             found++;
         }

package/dist/components/blocks/text/live-selection-edit.d.ts

@@ -1,19 +1,12 @@
 /**
- * What a native ranged edit writes in live mode. The range it targets can span delimiter runs the
- * user never saw and contenteditable takes those literally, so the edit is re-expressed as a JOIN
- * of what survives on either side and crosses the shared seam (live-mode.md § 4.5). Every editable
- * prose surface routes its `beforeinput` through {@link resolveLiveRangeEdit}, so a gesture family
- * cannot reach the bytes by being absent from a list.
+ * What a browser range edit writes in live mode, read off the `beforeinput` event. The range can
+ * span delimiter runs the user never saw, which contenteditable would take literally, so the edit
+ * goes through `replaceRangeInLeaf` (`docs/design/live-mode.md` § 4.5). Every prose block routes
+ * its `beforeinput` through {@link resolveLiveRangeEdit}.
  */
 import type { NodeView } from '../../../core/node-views';
-import type { PresentationMode } from '../../../presentation-mode';
-import type { InlineResolverRef } from '../../../schema/inline-construct-policy';
-export interface SelectionEdit {
-    /** The block's whole bytes after the edit, trailing line ending included. */
-    raw: string;
-    caret: number;
-}
-/** The raw-offset readers a native ranged edit needs from its surface. */
+import type { StoredAs } from '../../../schema/stored-as';
+/** The raw-offset lookups a browser range edit needs from the block. */
 export interface LiveEditCursor {
     rawRangeOf(range: AbstractRange): {
         start: number;
@@ -24,8 +17,8 @@ export interface LiveEditCursor {
         end: number;
     } | null;
 }
-/** Rewrite the block's bytes, or SWALLOW the press: an input this seam owns whose payload it may
- *  not read writes nothing, since the engine's version would splice the hidden runs literally. */
+/** Rewrite the block's bytes, or consume the key and write nothing: an input handled here whose
+ *  payload cannot be read writes nothing, since the browser would splice the hidden runs. */
 export type LiveRangeEdit = LiveRangeRewrite | {
     kind: 'swallow';
 };
@@ -38,31 +31,9 @@ export interface LiveRangeRewrite {
     raw: string;
     caret: number;
 }
-/**
- * What a prose surface does with a `beforeinput` in live mode. Null wherever the press is not this
- * seam's or the seam has nothing to clean — there the engine's own edit is already right, and
- * leaving it native keeps its grapheme and IME behavior.
- */
-export declare function resolveLiveRangeEdit(e: InputEvent, node: NodeView, cursor: LiveEditCursor, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined, ambientPrefix?: string): LiveRangeEdit | null;
-/**
- * The whole surface arm around {@link resolveLiveRangeEdit}: stand down while a source reveal has
- * outrun the CST, resolve, preventDefault what the seam owns, then swallow or hand the rewrite to
- * the surface's own `commit`. Shared so a new precondition lands on every surface at once.
- */
-export declare function applyLiveRangeEdit(e: InputEvent, node: NodeView, cursor: LiveEditCursor, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined, ambientPrefix: string, isRevealing: () => boolean, commit: (edit: LiveRangeRewrite) => void): boolean;
-/**
- * The bytes replacing `[start, end)` with `typed`, or null when the seam had nothing to clean.
- * Exported for the callers that already hold a range of their own (the composition commit, the
- * gesture fuzzer) rather than an event to read one off.
- */
-export declare function resolveSelectionEdit(node: NodeView, selection: {
-    start: number;
-    end: number;
-}, typed: string, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined, ambientPrefix?: string): SelectionEdit | null;
-/** The rewrite of `[start, end)` to `typed` a gesture the surface consumed installs, where a
- *  delete is the empty one. The seam's cleaned bytes where it has them, else the literal display
- *  splice with the caret past the insert: the fallback's one home, so no arm can drift. */
-export declare function replaceRangeRaw(node: NodeView, range: {
-    start: number;
-    end: number;
-}, typed: string, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined, ambientPrefix: string): SelectionEdit;
+/** What a prose block does with a `beforeinput` in live mode. Null where there is nothing to clean,
+ *  so the browser keeps its own edit and its grapheme and IME behavior. */
+export declare function resolveLiveRangeEdit(e: InputEvent, node: NodeView, cursor: LiveEditCursor, store: StoredAs): LiveRangeEdit | null;
+/** The wrapper every block runs around {@link resolveLiveRangeEdit}, shared so a new precondition
+ *  reaches every block. Does nothing while a shown source has outrun the CST. */
+export declare function applyLiveRangeEdit(e: InputEvent, node: NodeView, cursor: LiveEditCursor, store: StoredAs, isRevealing: () => boolean, commit: (edit: LiveRangeRewrite) => void): boolean;

package/dist/components/blocks/text/live-selection-edit.js

@@ -1,42 +1,32 @@
 /**
- * What a native ranged edit writes in live mode. The range it targets can span delimiter runs the
- * user never saw and contenteditable takes those literally, so the edit is re-expressed as a JOIN
- * of what survives on either side and crosses the shared seam (live-mode.md § 4.5). Every editable
- * prose surface routes its `beforeinput` through {@link resolveLiveRangeEdit}, so a gesture family
- * cannot reach the bytes by being absent from a list.
+ * What a browser range edit writes in live mode, read off the `beforeinput` event. The range can
+ * span delimiter runs the user never saw, which contenteditable would take literally, so the edit
+ * goes through `replaceRangeInLeaf` (`docs/design/live-mode.md` § 4.5). Every prose block routes
+ * its `beforeinput` through {@link resolveLiveRangeEdit}.
  */
-import { snapToScalarBoundary, trailingLineEnding, trimTrailingLineEnding } from '../../../core/lines';
-import { cleanJoinedRaw } from '../../../tree-operations/node-ops';
-/**
- * What a prose surface does with a `beforeinput` in live mode. Null wherever the press is not this
- * seam's or the seam has nothing to clean — there the engine's own edit is already right, and
- * leaving it native keeps its grapheme and IME behavior.
- */
-export function resolveLiveRangeEdit(e, node, cursor, presentationMode, linkRef, ambientPrefix = '') {
-    if (presentationMode !== 'live' || !rewritesTargetRange(e))
+import { replaceRangeInLeaf } from '../../../tree-operations/leaf-range';
+/** What a prose block does with a `beforeinput` in live mode. Null where there is nothing to clean,
+ *  so the browser keeps its own edit and its grapheme and IME behavior. */
+export function resolveLiveRangeEdit(e, node, cursor, store) {
+    if (!store.reading.hidesDelimitersAtCaret() || !rewritesTargetRange(e))
         return null;
-    const range = pendingEditRange(e, cursor);
-    if (!range)
+    const target = pendingEditRange(e, cursor);
+    if (!target)
         return null;
     const insert = replacementText(e);
-    if (range.start === range.end)
-        return parkedCaretInsertion(node, cursor, range.start, insert);
-    const edit = resolveSelectionEdit(node, range, insert ?? '', presentationMode, linkRef, ambientPrefix);
-    if (!edit)
+    if (target.start === target.end) {
+        return parkedCaretInsertion(node, cursor, target.start, insert, store);
+    }
+    const edit = replaceRangeInLeaf(node, target, insert ?? '', store);
+    if (edit.matchesBrowserEdit)
         return null;
     return insert === null
         ? { kind: 'swallow' }
-        : { kind: 'rewrite', range, raw: edit.raw, caret: edit.caret };
+        : { kind: 'rewrite', range: edit.range, raw: edit.raw, caret: edit.caret };
 }
-/**
- * A collapsed insertion has no seam to clean, but Chromium inserts at its canonical spelling of
- * the caret's pixel, UPSTREAM across a hidden run, while the DOM caret may sit where a commit
- * parked it, past that run (after a `)` just typed). A target behind the caret is that
- * canonicalization, and the byte belongs where the caret is, the side the keydown seat settled. A
- * target at or past the caret is the engine landing the byte itself, which a split's reopened run
- * relies on: parked at its start, the byte goes inside.
- */
-function parkedCaretInsertion(node, cursor, engineTarget, insert) {
+/** A collapsed insertion Chromium aimed back across a hidden run (just after a typed `)`) goes where
+ *  the caret is. A target at or past the caret stands, since a split's reopened run relies on it. */
+function parkedCaretInsertion(node, cursor, engineTarget, insert, store) {
     if (!insert)
         return null;
     const selection = window.getSelection();
@@ -45,23 +35,15 @@ function parkedCaretInsertion(node, cursor, engineTarget, insert) {
     const caret = cursor.rawRangeOf(selection.getRangeAt(0))?.start ?? null;
     if (caret === null || engineTarget >= caret)
         return null;
-    const display = trimTrailingLineEnding(node.raw);
-    return {
-        kind: 'rewrite',
-        range: { start: caret, end: caret },
-        raw: display.slice(0, caret) + insert + display.slice(caret) + trailingLineEnding(node.raw),
-        caret: caret + insert.length
-    };
+    const edit = replaceRangeInLeaf(node, { start: caret, end: caret }, insert, store);
+    return { kind: 'rewrite', range: edit.range, raw: edit.raw, caret: edit.caret };
 }
-/**
- * The whole surface arm around {@link resolveLiveRangeEdit}: stand down while a source reveal has
- * outrun the CST, resolve, preventDefault what the seam owns, then swallow or hand the rewrite to
- * the surface's own `commit`. Shared so a new precondition lands on every surface at once.
- */
-export function applyLiveRangeEdit(e, node, cursor, presentationMode, linkRef, ambientPrefix, isRevealing, commit) {
+/** The wrapper every block runs around {@link resolveLiveRangeEdit}, shared so a new precondition
+ *  reaches every block. Does nothing while a shown source has outrun the CST. */
+export function applyLiveRangeEdit(e, node, cursor, store, isRevealing, commit) {
     if (isRevealing())
         return false;
-    const edit = resolveLiveRangeEdit(e, node, cursor, presentationMode, linkRef, ambientPrefix);
+    const edit = resolveLiveRangeEdit(e, node, cursor, store);
     if (!edit)
         return false;
     e.preventDefault();
@@ -69,72 +51,15 @@ export function applyLiveRangeEdit(e, node, cursor, presentationMode, linkRef, a
         commit(edit);
     return true;
 }
-/**
- * The bytes replacing `[start, end)` with `typed`, or null when the seam had nothing to clean.
- * Exported for the callers that already hold a range of their own (the composition commit, the
- * gesture fuzzer) rather than an event to read one off.
- */
-export function resolveSelectionEdit(node, selection, typed, presentationMode, linkRef, ambientPrefix = '') {
-    // Both ends off any scalar interior before the slice: a half-pair here is unrecoverable
-    // bytes, not a recoverable edit. Snapping the same direction cannot invert the range.
-    const start = snapToScalarBoundary(node.raw, selection.start);
-    const end = snapToScalarBoundary(node.raw, selection.end);
-    if (start >= end)
-        return null;
-    const mergedRaw = node.raw.slice(0, start) + node.raw.slice(end);
-    // `typed` rides the seam rather than being spliced past it: the bytes the cleanup verifies have
-    // to be the bytes this returns, or the flanking it checked is not the flanking that ships.
-    const joined = cleanJoinedRaw({
-        mergedRaw,
-        seam: start,
-        start: { node, offset: start },
-        end: { node, offset: end },
-        linkRef,
-        typed,
-        ambientPrefix
-    }, presentationMode);
-    if (joined.raw === mergedRaw)
-        return null;
-    // The insert lands where the two sides now meet — the paste-at-a-cleaned-seam rule: cleanup
-    // runs in the DELETE half, and the commit's own re-parse settles what the new bytes make of it.
-    return {
-        raw: joined.raw.slice(0, joined.seam) + typed + joined.raw.slice(joined.seam),
-        caret: joined.seam + typed.length
-    };
-}
-/** The rewrite of `[start, end)` to `typed` a gesture the surface consumed installs, where a
- *  delete is the empty one. The seam's cleaned bytes where it has them, else the literal display
- *  splice with the caret past the insert: the fallback's one home, so no arm can drift. */
-export function replaceRangeRaw(node, range, typed, presentationMode, linkRef, ambientPrefix) {
-    const cleaned = resolveSelectionEdit(node, range, typed, presentationMode, linkRef, ambientPrefix);
-    if (cleaned)
-        return cleaned;
-    const display = trimTrailingLineEnding(node.raw);
-    return {
-        raw: display.slice(0, range.start) +
-            typed +
-            display.slice(range.end) +
-            trailingLineEnding(node.raw),
-        caret: range.start + typed.length
-    };
-}
 // ── Reading the event ────────────────────────────────────────────────────────
-/**
- * The range the pending edit will rewrite. `getTargetRanges()` is the authority — a word or line
- * delete at a COLLAPSED caret reports the run, not the caret — and is feature-detected because
- * jsdom implements no such method.
- */
+/** The range the pending edit will rewrite, from `getTargetRanges()`, since a word delete reports
+ *  the run rather than the caret. Feature-detected because jsdom has no such method. */
 function pendingEditRange(e, cursor) {
     const targets = typeof e.getTargetRanges === 'function' ? e.getTargetRanges() : [];
     return targets.length > 0 ? cursor.rawRangeOf(targets[0]) : cursor.getRawSelection();
 }
-/**
- * The inputs that rewrite the range they target: every delete family — word, line, drag, cut,
- * forward, backward — plus the two that replace it with text. Paste and composition carry seams of
- * their own; composing is excluded by the NAME and by the flag rather than by listing the two
- * delete types today's engines spell, since `composition-seat.ts` owns that window end to end and a
- * second resolution here writes the block twice.
- */
+/** The inputs that rewrite the range they target. Composition is excluded by name and flag, since
+ *  `composition-seat.ts` handles it start to finish and a second write here would double it. */
 function rewritesTargetRange(e) {
     if (e.isComposing || /composition/i.test(e.inputType))
         return false;
@@ -142,9 +67,8 @@ function rewritesTargetRange(e) {
         e.inputType === 'insertText' ||
         e.inputType === 'insertReplacementText');
 }
-/** What an input writes over its range, or null for a payload this seam may not read: text riding
- *  a `dataTransfer` would reach the commit's re-parse without the paste transforms (G4.11), and a
- *  swallowed press is sounder than turning a replacement into a delete. */
+/** What an input writes over its range, or null for `dataTransfer` text, which would skip the paste
+ *  transforms (G4.11); consuming the key beats turning a replacement into a delete. */
 function replacementText(e) {
     return e.inputType.startsWith('delete') ? '' : e.data;
 }