@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/components/blocks/text/edge-policy-dispatch.js

@@ -1,32 +1,27 @@
 /**
- * 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 { resolvedInlineContent } from '../../../core/inline/inline-cache';
-import { getContentRange } from '../../../core/inline';
+import { getContentRange, sameLineSuffix } from '../../../core/inline';
 import { getInlineWidgetEditing } from '../../../core/inline/inline-widgets';
-import { trimTrailingLineEnding, trailingLineEnding } from '../../../core/lines';
+import { trailingLineEnding, trimTrailingLineEnding } from '../../../core/lines';
 import {} from '../../../cursor/coordinate-spaces';
-import { hasSelection as hasSelectionHelper } from '../../../cursor/content-offsets';
-import { landableRawBounds, revealsNoMarkers, screenVisibilityOf } from '../../../cursor/widget-offset';
-import { ambientSpanOf } from '../../../ambient/ambient-dom';
+import { hiddenSuffixLength, landableRawBounds, markerPrefixOf, revealsNoMarkers, screenVisibilityOf } from '../../../cursor/widget-offset';
 import { recordIslandKeyScan } from '../../../perf/instruments';
 import { caretIsInTextContent, hasModifier, isPlainTypingKey } from './click-snap-guard';
 import { createMarkerCompletion } from './marker-completion';
 import { resolveEdgeDeletion } from './construct-edge-delete';
-import { hidesStructuralSuffix } from './hidden-suffix';
 import { resolveEdgeSeat } from './edge-seat';
-import { deleteRangeRaw } from './live-selection-edit';
+import { replaceRangeInLeaf } from '../../../tree-operations/leaf-range';
+import { openHardBreakLine } from './text-keydown';
 import { resolveMarkedInsertion } from './pending-mark-insert';
 import { widgetAtCursor } from './widget-adjacency';
-import { resolveDelimiterAutoPair } from './delimiter-autopair';
-import { soleProseReparse } from './screen-diff';
-/** Whether `line` still reloads as `node`'s kind, the auto-pair resolver's guard. */
-export function keepsBlockKind(node, line) {
-    return soleProseReparse(line + trailingLineEnding(node.raw))?.block.kind === node.kind;
-}
+import { noteOwnPair, resolveDelimiterAutoPair } from './delimiter-autopair';
+import { keepsKindAt } from '../../../core/inline/live-edit/read-back';
+import { hidesMarkers } from '../../../presentation-mode';
 const REPLACE_ISLAND_POLICY = {
     onEdge: 'select',
     deleteGranularity: 'select-then-delete'
@@ -52,7 +47,7 @@ export function createEdgePolicyDispatch(deps) {
         },
         {
             id: 'reading-mode',
-            reason: 'islands and the ambient marker are destructive-only view guards, so reading skips every arm below; the widget arm above still selects, committing nothing',
+            reason: 'inline widgets and the container’s marker prefix are destructive-only view guards, so reading skips every branch below; the widget branch above still selects, committing nothing',
             cut: true,
             claims: () => deps.isReading()
         },
@@ -66,13 +61,8 @@ export function createEdgePolicyDispatch(deps) {
             reason: 'a selection into the ambient span blocks native delete silently, with no beforeinput',
             claims: handleAmbient
         },
-        // The four below claim only what would otherwise reach native editing or the block-merge
-        // command; the more specific families above still own a key aimed at one of theirs.
-        {
-            id: 'hidden-suffix-delete',
-            reason: 'the merge this press would reach concatenates past the block’s own hidden structure',
-            claims: handleHiddenSuffixDelete
-        },
+        // The three below handle only what would otherwise reach native editing or the block-merge
+        // command; the more specific families above still take a key aimed at one of theirs.
         {
             id: 'construct-edge-delete',
             reason: 'a destructive key beside an unpainted delimiter run takes content, never a marker',
@@ -97,32 +87,34 @@ export function createEdgePolicyDispatch(deps) {
         return false;
     }
     function inlinesOf(node) {
-        return resolvedInlineContent(node, deps.linkRef);
+        return resolvedInlineContent(node, deps.reading);
     }
     function display() {
         return trimTrailingLineEnding(deps.node.raw);
     }
-    /** One display-space rewrite, one CST commit. `caretBefore` anchors the undo entry, so it
-     *  is the pre-edit caret — the rewrite's own start everywhere but the seats, which moved it. */
+    /** One rewrite of the displayed text, one CST commit. `caretBefore` anchors the undo entry, so
+     *  it is the caret before the edit: the rewrite's own start, unless a hidden run moved it. */
     function writeDisplay(next, caretAfter, source, caretBefore) {
-        void deps.blockEdit.updateBlockContent(deps.index, next + trailingLineEnding(deps.node.raw), caretBefore, caretAfter);
-        deps.setPendingCursor(caretAfter, source, next);
+        const write = deps.blockEdit.updateBlockContent(deps.index, next + trailingLineEnding(deps.node.raw, deps.getLineEnding()), 'authored', caretBefore, caretAfter);
+        if (write.admitted)
+            deps.setPendingCursor(write.caret, source);
     }
+    /** `[start, end)` replaced by `insert` through the in-leaf range replace, the store read at the
+     *  key. */
     function editDisplay(start, end, insert, source = 'island', caretBefore = start) {
-        const d = display();
-        writeDisplay(d.slice(0, start) + insert + d.slice(end), start + insert.length, source, caretBefore);
+        const edit = replaceRangeInLeaf(deps.node, { start, end }, insert, deps.storedAs());
+        const write = deps.blockEdit.updateBlockContent(deps.index, edit.raw, 'authored', caretBefore, edit.caret);
+        if (write.admitted)
+            deps.setPendingCursor(write.caret, source);
     }
-    // ── The seams the arms below defer to ────────────────────────────────────
-    /**
-     * The rung a range rewrite can be asked about. Past the reading cut a surface revealing no
-     * marker is live, the one mode whose seam has unpainted runs to clean; every other rung takes
-     * the literal edit the engine would have written.
-     */
-    function joinSeamMode(el) {
-        return revealsNoMarkers(el) ? 'live' : undefined;
+    /** The selected range, or null at a plain caret; every branch reads it here. Empty when both ends
+     *  clamp into the marker prefix, so a branch that writes bytes checks `end > start` first. */
+    function heldRange() {
+        return deps.getRawSelection();
     }
+    // ── The shared helpers the branches below use ────────────────────────────
     /** What the construct-edge rule (live-mode.md § 4.4) does with a destructive key here, or null
-     *  where the surface paints its markers and the byte beside the caret is one the reader saw. */
+     *  where the block draws its markers and the byte beside the caret is one the user can see. */
     function edgeDeletionAt(el, caret, direction) {
         if (!revealsNoMarkers(el))
             return null;
@@ -133,22 +125,40 @@ export function createEdgePolicyDispatch(deps) {
             direction,
             screen: screenVisibilityOf(el),
             inlines: inlinesOf(deps.node),
-            installedAs: deps.installedAs
+            store: deps.storedAs()
         });
     }
-    /** A press with no sound rewrite writes nothing: the engine's version would paint the
+    /** A keypress with no safe rewrite writes nothing: the browser's version would show the
      *  delimiters the rule was hiding. */
     function applyEdgeDeletion(deletion, caretBefore) {
         if ('swallow' in deletion)
             return;
         writeDisplay(deletion.raw, deletion.caret, 'construct-delete', caretBefore);
+        // Pended after the write, since the write clears pending marks; the caret has not moved, so
+        // the format waits for the next insertion (live-mode.md § 4.4).
+        for (const kind of deletion.unwrappedMarks)
+            deps.pendingMarks.toggle(kind);
     }
-    /** Where a printable byte belongs when the caret sits at an unpainted delimiter run
+    /** Where a printable byte belongs when the caret sits at a hidden delimiter run
      *  (live-mode.md § 4.2), or null when no run is touched and the caret's own offset stands. */
     function typingSeatAt(el, caret, typed) {
         if (!revealsNoMarkers(el))
             return null;
-        return resolveEdgeSeat(caret, inlinesOf(deps.node), deps.getEdgeAffinity(), deps.node.raw, screenVisibilityOf(el), typed);
+        return resolveEdgeSeat(caret, inlinesOf(deps.node), deps.getEdgeAffinity(), deps.node.raw, screenVisibilityOf(el), typed, deps.reading);
+    }
+    /** A printable byte the browser would drop at an element-level caret. Over a range it replaces
+     *  through the join rules; at a caret the hidden-run rules pick which side it lands on. */
+    function writeTypedByte(el, caretOffset, typed, source) {
+        const range = heldRange();
+        if (range && range.end > range.start) {
+            const edit = replaceRangeInLeaf(deps.node, range, typed, deps.storedAs());
+            const write = deps.blockEdit.updateBlockContent(deps.index, edit.raw, 'authored', range.start, edit.caret);
+            if (write.admitted)
+                deps.setPendingCursor(write.caret, source);
+            return;
+        }
+        const seatedAt = typingSeatAt(el, caretOffset, typed)?.offset ?? caretOffset;
+        editDisplay(seatedAt, seatedAt, typed, source, caretOffset);
     }
     // ── CST inline widget ────────────────────────────────────────────────────
     function handleCstWidget(e, caretOffset) {
@@ -160,34 +170,35 @@ export function createEdgePolicyDispatch(deps) {
         // Forward keys enter the widget after the caret, backward keys the one before, so
         // a caret between two adjacent widgets enters the one the key is aimed at.
         const direction = e.key === 'ArrowRight' || e.key === 'Delete' ? 'forward' : 'backward';
-        const widgetAt = widgetAtCursor(caretOffset, inlinesOf(node), node.raw, direction);
+        const { grammar } = deps.reading;
+        const widgetAt = widgetAtCursor(caretOffset, inlinesOf(node), node.raw, direction, grammar);
         if (!widgetAt)
             return false;
-        // Unchorded only: a modifier makes the key a word-scoped platform command, and
-        // entering here would swap that word-step for the modal widget-selected state.
-        const plainEdgeKey = !e.shiftKey && !hasModifier(e);
+        // Past the early return: every keystroke in every prose block reaches the line above, so
+        // the work below stays off that path.
+        const range = heldRange();
+        // No modifier, and a collapsed caret: a modifier makes the key a word-scoped platform
+        // command, and a selected range is an edit of that range, not an entry into a construct.
+        const plainEdgeKey = !e.shiftKey && !hasModifier(e) && !range;
         const enterFromRight = plainEdgeKey && widgetAt.atRight && (e.key === 'ArrowLeft' || e.key === 'Backspace');
         const enterFromLeft = plainEdgeKey && !widgetAt.atRight && (e.key === 'ArrowRight' || e.key === 'Delete');
         if (enterFromRight || enterFromLeft) {
             const isDestructive = e.key === 'Backspace' || e.key === 'Delete';
-            const policy = deps.widgetEdgePolicy?.(widgetAt) ?? getInlineWidgetEditing(widgetAt.kind);
-            // A step-over widget reads as one character to navigation, so decline and let
-            // native carry the caret across. Only navigation steps over; a destructive key
-            // still runs the atomic-delete branch below.
+            const policy = deps.widgetEdgePolicy?.(widgetAt) ?? getInlineWidgetEditing(widgetAt.kind, grammar);
+            // A step-over widget reads as one character to navigation, so the browser carries the
+            // caret across; a destructive key still runs the atomic-delete branch below.
             if (!isDestructive && policy?.onEdge === 'step-over')
                 return false;
             e.preventDefault();
             deps.setSnapTarget(null);
             if (isDestructive && policy?.deleteGranularity === 'atomic' && !deps.isReading()) {
-                // One press takes the whole construct, anchored at the pre-delete caret so
-                // Ctrl+Z lands there.
-                const newRaw = node.raw.slice(0, widgetAt.start) + node.raw.slice(widgetAt.end);
-                void deps.blockEdit.updateBlockContent(deps.index, newRaw, caretOffset, widgetAt.start);
-                deps.setPendingCursor(widgetAt.start, 'widget');
+                // One keypress takes the whole construct, anchored at the caret before the delete
+                // so Ctrl+Z lands there.
+                editDisplay(widgetAt.start, widgetAt.end, '', 'widget', caretOffset);
                 return true;
             }
-            // `onEdge: 'select'`, plus the reveal-capable kinds `enterWidget` routes to
-            // their source reveal instead.
+            // `onEdge: 'select'`, plus the kinds `enterWidget` sends to their source instead of
+            // selecting.
             deps.enterWidget(widgetAt, enterFromRight);
             return true;
         }
@@ -200,19 +211,12 @@ export function createEdgePolicyDispatch(deps) {
             !deps.isReading()) {
             e.preventDefault();
             deps.setSnapTarget(null);
-            const typed = e.key;
-            // This branch owns only the fact that the engine drops the key beside a widget; which
-            // side of an unpainted run the byte belongs on is still the seat's answer.
-            const seatedAt = typingSeatAt(el, caretOffset, typed)?.offset ?? caretOffset;
-            const newRaw = node.raw.slice(0, seatedAt) + typed + node.raw.slice(seatedAt);
-            const postEdit = seatedAt + typed.length;
-            void deps.blockEdit.updateBlockContent(deps.index, newRaw, caretOffset, postEdit);
-            deps.setPendingCursor(postEdit, 'widget', newRaw);
+            writeTypedByte(el, caretOffset, e.key, 'widget');
             return true;
         }
         return false;
     }
-    // ── Decoration island ────────────────────────────────────────────────────
+    // ── Decoration widgets ───────────────────────────────────────────────────
     function islandsInDom(el) {
         recordIslandKeyScan();
         const out = [];
@@ -237,12 +241,12 @@ export function createEdgePolicyDispatch(deps) {
         sel.addRange(range);
     }
     function handleIsland(e, caretOffset) {
-        // Modifier chords stay native; the island rules own only the plain edge presses.
+        // Modifier chords stay with the browser; these rules take only the plain edge keys.
         const isDestructive = !hasModifier(e) && (e.key === 'Backspace' || e.key === 'Delete');
         const isTyping = isPlainTypingKey(e);
         if (!isDestructive && !isTyping)
             return false;
-        // Island-free blocks, the common case, skip the per-keystroke DOM scan entirely.
+        // Blocks with no decoration widgets, the common case, skip the per-keystroke DOM scan.
         if (!deps.hasIslands())
             return false;
         const el = deps.getEl();
@@ -251,11 +255,11 @@ export function createEdgePolicyDispatch(deps) {
         const islands = islandsInDom(el);
         if (islands.length === 0)
             return false;
-        // Second press: the native selection already wraps a replace island, so delete its
+        // Second keypress: the browser selection already wraps a replace widget, so delete its
         // whole hidden range through the CST as one undo entry.
         if (isDestructive) {
-            const selection = deps.getRawSelection();
-            if (selection && selection.start < selection.end) {
+            const selection = heldRange();
+            if (selection) {
                 const selected = islands.find((i) => islandPolicy(i).onEdge === 'select' &&
                     i.start === selection.start &&
                     i.end === selection.end);
@@ -264,15 +268,15 @@ export function createEdgePolicyDispatch(deps) {
                     editDisplay(selected.start, selected.end, '');
                     return true;
                 }
-                // A different non-empty selection — leave it to the normal delete paths.
+                // A different non-empty selection: leave it to the normal delete paths.
                 return false;
             }
         }
         if (caretOffset === null)
             return false;
         const contentLength = display().length;
-        // First press: selecting the whole island is the only visible thing to eat, since
-        // the range it hides has no on-screen bytes of its own.
+        // First keypress: selecting the whole widget is the only visible thing to delete, since
+        // the range it hides has no bytes of its own on screen.
         if (isDestructive) {
             const wantTrailingEdge = e.key === 'Backspace';
             const target = islands.find((i) => islandPolicy(i).onEdge === 'select' &&
@@ -283,8 +287,8 @@ export function createEdgePolicyDispatch(deps) {
                 return true;
             }
         }
-        // A step-over island is transparent to the adjacent real byte; at a true block
-        // boundary there is none, so fall through and let block merge fire.
+        // A step-over widget is transparent to the real byte beside it; at a true block
+        // boundary there is none, so fall through and let the block merge run.
         const widget = islands.find((i) => islandPolicy(i).onEdge === 'step-over' && i.start === caretOffset);
         if (!widget)
             return false;
@@ -295,9 +299,8 @@ export function createEdgePolicyDispatch(deps) {
                 : null;
         if (direction !== null) {
             e.preventDefault();
-            // The adjacent RAW byte is not always the adjacent real one: beside an unpainted
-            // delimiter run the construct-edge rule owns which byte a press takes (§ 4.4), and
-            // this arm outranks it, so it asks rather than splices.
+            // Beside a hidden delimiter run the construct-edge rule decides which byte a key takes
+            // (`docs/design/live-mode.md` § 4.4), and this branch outranks it, so it asks that rule.
             const deletion = edgeDeletionAt(el, caretOffset, direction);
             if (deletion)
                 applyEdgeDeletion(deletion, caretOffset);
@@ -307,28 +310,28 @@ export function createEdgePolicyDispatch(deps) {
                 editDisplay(caretOffset, caretOffset + 1, '');
             return true;
         }
-        // Cross-browser defence: some engines drop printable keys at an element-level caret
-        // adjacent to a contenteditable=false island. Chromium types natively, masking this
-        // branch in e2e, so it is unit-pinned instead.
+        // Some browsers drop printable keys at an element-level caret beside a non-editable widget.
+        // Chromium types them, so a unit test, not e2e, covers this branch.
         if (isTyping && !caretIsInTextContent(el, window.getSelection())) {
             e.preventDefault();
-            editDisplay(caretOffset, caretOffset, e.key);
+            writeTypedByte(el, caretOffset, e.key, 'island');
             return true;
         }
         return false;
     }
-    // ── Ambient marker overlap ─────────────────────────────────────────────────
-    // A selection reaching into the contenteditable="false" ambient span blocks native
-    // Backspace/Delete silently — no beforeinput fires — so delete through the CST.
+    // ── Container marker prefix overlap ────────────────────────────────────────
+    // A selection reaching into the contenteditable="false" marker prefix blocks the browser's
+    // Backspace and Delete silently, with no beforeinput, so delete through the CST instead.
     function handleAmbient(e) {
         if (e.key !== 'Backspace' && e.key !== 'Delete')
             return false;
-        if (!hasSelectionHelper())
+        const range = heldRange();
+        if (!range)
             return false;
         const el = deps.getEl();
-        if (!el || deps.getAmbientLength() <= 0)
+        if (!el)
             return false;
-        const ambient = ambientSpanOf(el);
+        const ambient = markerPrefixOf(el);
         const sel = window.getSelection();
         const touchesAmbient = !!ambient &&
             !!sel &&
@@ -337,57 +340,35 @@ export function createEdgePolicyDispatch(deps) {
         if (!touchesAmbient)
             return false;
         e.preventDefault();
-        const range = deps.getRawSelection();
-        if (range && range.start < range.end) {
-            // Consumed at KEYDOWN, so no `beforeinput` carries this range to the shared seam: the arm
-            // asks it here, or a literal splice prints the runs the cut stranded (live-mode.md § 4.5).
-            const edit = deleteRangeRaw(deps.node, range, joinSeamMode(el), deps.linkRef, deps.getAmbientPrefix?.() ?? '');
-            void deps.blockEdit.updateBlockContent(deps.index, edit.raw, range.start, edit.caret);
-            deps.setPendingCursor(edit.caret, 'ambient-delete');
+        // A selection holding only the marker prefix covers no content byte, so there is nothing
+        // to delete and the press is consumed with no commit.
+        if (range.end > range.start) {
+            // Handled at keydown, so this branch asks the join rules itself, or a literal splice would
+            // print the delimiter runs the cut stranded (`docs/design/live-mode.md` § 4.5).
+            const edit = replaceRangeInLeaf(deps.node, range, '', deps.storedAs());
+            const write = deps.blockEdit.updateBlockContent(deps.index, edit.raw, 'authored', range.start, edit.caret);
+            if (write.admitted)
+                deps.setPendingCursor(write.caret, 'ambient-delete');
         }
         return true;
     }
-    // ── Hidden structural suffix ───────────────────────────────────────────────
-    /**
-     * Delete at the content end of a block whose own structure sits after it: the merge this press
-     * would reach concatenates past that suffix, so the press is consumed. The rule itself lives in
-     * `hidden-suffix.ts`; the command arm asks the same question from its own coordinates.
-     */
-    function handleHiddenSuffixDelete(e, caretOffset) {
-        if (e.key !== 'Delete')
-            return false;
-        if (e.shiftKey || hasModifier(e))
-            return false;
-        if (caretOffset === null || hasSelectionHelper())
-            return false;
-        if (caretOffset !== getContentRange(deps.node).end)
-            return false;
-        if (!hidesStructuralSuffix(deps.getEl(), deps.node, display().length))
-            return false;
-        e.preventDefault();
-        return true;
-    }
-    // ── Hidden construct edge (the destructive arm) ────────────────────────────
-    /**
-     * A plain Backspace/Delete against an inline construct's unpainted delimiter run: the rewrite
-     * takes the adjacent CONTENT character instead of a byte the reader never saw, plus the
-     * delimiters that leaves enclosing nothing (live-mode.md § 4.4).
-     */
+    // ── Hidden construct edge (deleting) ───────────────────────────────────────
+    /** A plain Backspace or Delete against a hidden delimiter run takes the neighbouring content
+     *  character instead of a byte the user never saw (`docs/design/live-mode.md` § 4.4). */
     function handleConstructEdgeDelete(e, caretOffset) {
         if (e.key !== 'Backspace' && e.key !== 'Delete')
             return false;
         if (e.shiftKey || hasModifier(e))
             return false;
-        if (caretOffset === null || hasSelectionHelper())
+        if (caretOffset === null || heldRange())
             return false;
         const el = deps.getEl();
         if (!el)
             return false;
-        // The landable start is visual column 0, where Backspace is a block gesture (merge or
-        // inert): an atomic run straddling the start would otherwise take the first visible
-        // glyph forward.
+        // At the first offset the caret can sit at, Backspace is a block gesture (merge, or nothing),
+        // not a delete of the first visible character past a hidden run.
         if (e.key === 'Backspace') {
-            const bounds = landableRawBounds(el, deps.getAmbientLength());
+            const bounds = landableRawBounds(el);
             if (bounds && caretOffset <= bounds.start)
                 return false;
         }
@@ -399,57 +380,57 @@ export function createEdgePolicyDispatch(deps) {
         applyEdgeDeletion(deletion, caretOffset);
         return true;
     }
-    // ── Pending marks (the toggle seat) ────────────────────────────────────────
-    /**
-     * The byte that completes a hard break made at the END of a block. `insertHardBreak` writes
-     * `\\` plus the block's ending there, but that ending IS the block's trailing one, so the
-     * display stops at the backslash and the caret has nowhere to sit past it. The next
-     * printable key is what supplies the following line: it lands AFTER the break rather than
-     * between the backslash and its newline, where it would read as content and undo the break.
-     */
+    // ── Hard break at the block end, pending marks ─────────────────────────────
+    /** A key typed on a hard break at the end of a block's content goes on the new line, not
+     *  between the backslash and its line ending, where it would undo the break. */
     function handleTransitionalHardBreak(e, caretOffset) {
         if (deps.isReading())
             return false;
-        if (!isPlainTypingKey(e) || caretOffset === null || hasSelectionHelper())
+        if (!isPlainTypingKey(e) || caretOffset === null || heldRange())
             return false;
         const d = display();
-        // Only at the very end, and only when the block's last byte is the break's backslash.
-        if (caretOffset !== d.length || !d.endsWith('\\'))
+        const contentEnd = getContentRange(deps.node).end;
+        // A heading's closing run stays on the heading's line, so the new line starts past it.
+        const lineEnd = contentEnd + sameLineSuffix(deps.node).length;
+        const el = deps.getEl();
+        // The caret past the backslash, or where the new line is drawn (`paintPendingBreak`, past
+        // the run); a hidden run draws its whole span at that one spot.
+        const onBreak = el !== null && hiddenSuffixLength(el) > 0
+            ? caretOffset >= contentEnd && caretOffset <= lineEnd
+            : caretOffset === contentEnd ||
+                (hidesMarkers(deps.reading.mode()) && caretOffset === lineEnd);
+        const text = d.slice(0, contentEnd);
+        if (!onBreak || !text.endsWith('\\'))
             return false;
         // An escaped backslash (`\\\\`) is content, not a break.
-        if (d.endsWith('\\\\'))
+        if (text.endsWith('\\\\'))
             return false;
         // Backslash before ASCII punctuation is an escape (`\|`, `\*`), never a break's backslash.
         if (/^[!-/:-@[-`{-~]$/.test(e.key))
             return false;
-        const ending = trailingLineEnding(deps.node.raw);
+        const ending = trailingLineEnding(deps.node.raw, deps.getLineEnding());
         e.preventDefault();
         deps.setSnapTarget(null);
-        const next = d + ending + e.key;
-        writeDisplay(next, next.length, 'transitional-hard-break', caretOffset);
+        const opened = openHardBreakLine(d, lineEnd, ending, e.key);
+        writeDisplay(opened.display, opened.caret, 'transitional-hard-break', caretOffset);
         return true;
     }
-    /**
-     * A printable key while a collapsed-caret toggle has marks pending. Marks are the newer
-     * instruction about the same bytes, so they outrank the arrival side the seat below reads
-     * (live-mode.md § 4.2) and this arm runs first.
-     */
+    /** A printable key while a toggle at a collapsed caret has marks pending. The marks are the newer
+     *  instruction, so they outrank the arrival side (`docs/design/live-mode.md` § 4.3). */
     function handlePendingMarks(e, caretOffset) {
-        if (deps.isReading())
-            return false;
-        if (!isPlainTypingKey(e) || caretOffset === null || hasSelectionHelper())
+        if (!isPlainTypingKey(e) || caretOffset === null || heldRange())
             return false;
-        // Locally sound like the seat below: only a surface that paints no delimiter can be asked
-        // to write one the user never sees. A mode flip clears the marks, so this strands nothing.
+        // Only a block that draws no delimiters holds pending marks; switching mode clears them, so
+        // nothing is stranded.
         const el = deps.getEl();
         if (!el || !revealsNoMarkers(el))
             return false;
-        // Spend on the preconditions, not on the outcome: one insertion was promised the set,
-        // and this is it whether or not the rewrite below finds anything to do.
+        // Spent on the conditions above, not on the outcome: one insertion was promised the
+        // marks, and this is it whether or not the rewrite below finds anything to do.
         const marks = deps.pendingMarks.consume();
         if (!marks)
             return false;
-        const marked = resolveMarkedInsertion(display(), caretOffset, e.key, marks, inlinesOf(deps.node));
+        const marked = resolveMarkedInsertion(display(), caretOffset, e.key, marks, inlinesOf(deps.node), deps.reading);
         if (!marked)
             return false;
         e.preventDefault();
@@ -458,34 +439,32 @@ export function createEdgePolicyDispatch(deps) {
         return true;
     }
     // ── Container marker completion ────────────────────────────────────────────
-    /**
-     * A bare space at the content start of an empty child whose container declares
-     * `contentStartSpace`. Consumed, not written: the container's `rebuildRaw` re-emits it the
-     * moment content arrives, so inserting it here would double the marker's own space. The
-     * claim is once per child; a later space at the same seat is content.
-     */
+    /** A bare space at a child's content start, while its container's marker lacks its space, is
+     *  consumed once: the container's `rebuildRaw` writes it back, so writing it here would double it. */
     function handleMarkerCompletion(e, caretOffset) {
         const bareSpace = e.key === ' ' && !e.shiftKey && !hasModifier(e);
-        if (!bareSpace || caretOffset === null || hasSelectionHelper())
+        if (!bareSpace || caretOffset === null || heldRange())
             return false;
-        if (!markerCompletion.claimSpace(deps.node, deps.containerParent, caretOffset))
+        const { node, containerParent, index } = deps;
+        if (!markerCompletion.claimSpace(node, containerParent, index, caretOffset))
             return false;
         e.preventDefault();
         return true;
     }
-    // ── Hidden construct edge (the typing seat) ────────────────────────────────
-    /**
-     * A printable key at an inline construct's unpainted delimiter run. Chromium canonicalizes a
-     * collapsed caret upstream across a non-rendered run, so the DOM caret cannot carry the answer
-     * and the byte is written through the CST at the offset the policy and arrival name.
-     */
+    // ── Hidden construct edge (typing) ─────────────────────────────────────────
+    /** A printable key at a hidden delimiter run is written through the CST, since Chromium moves a
+     *  collapsed caret back across a run it does not render (`docs/design/live-mode.md` § 4.2). */
     function handleConstructSeat(e, caretOffset) {
-        if (!isPlainTypingKey(e) || caretOffset === null || hasSelectionHelper())
+        if (!isPlainTypingKey(e) || caretOffset === null || heldRange())
             return false;
-        // A delimiter typed over its own closer is the auto-pair's step-over, which the beforeinput
-        // arm owns (delimiter-autopair.ts); seated outside the run it would be typed instead.
+        // A delimiter typed over its own closing one is the auto-pair's step-over, handled on
+        // beforeinput (delimiter-autopair.ts); placed outside the run it would be typed instead.
         const content = getContentRange(deps.node);
-        const autoPair = resolveDelimiterAutoPair(display(), content, caretOffset, e.key);
+        const { reading, ownPairs } = deps;
+        const text = display();
+        const autoPair = resolveDelimiterAutoPair(text, content, caretOffset, e.key, reading, {
+            ownPair: ownPairs.consult(text, caretOffset)
+        });
         if (autoPair?.kind === 'step-over')
             return false;
         const el = deps.getEl();
@@ -494,11 +473,16 @@ export function createEdgePolicyDispatch(deps) {
             return false;
         e.preventDefault();
         deps.setSnapTarget(null);
-        // The seat decides WHERE the byte lands; what a delimiter keystroke writes there is still
-        // the auto-pair's answer, or a byte seated past a run would arrive without its twin. The
-        // kind rides the trace: it names the construct whose hidden edge the caret sat at.
-        const paired = resolveDelimiterAutoPair(display(), content, seat.offset, e.key, (line) => keepsBlockKind(deps.node, line));
+        // The hidden-run rules decide where the byte lands; the auto-pair still decides what a delimiter
+        // writes there, or it would arrive without its closing partner.
+        const store = deps.storedAs();
+        const paired = resolveDelimiterAutoPair(text, content, seat.offset, e.key, reading, {
+            ownPair: ownPairs.consult(text, seat.offset),
+            // Each auto-pair caller asks this itself until the caret-edge key table gives it one caller.
+            keepsKind: (line) => keepsKindAt(deps.node, line, store)
+        });
         if (paired && paired.kind !== 'step-over') {
+            noteOwnPair(ownPairs, text, paired);
             writeDisplay(paired.text, paired.caret, `seat:${seat.kind}`, caretOffset);
             if (paired.kind === 'close')
                 deps.noteOutside?.();