@voithos-labs/aragonite 0.10.2 → 0.10.4

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

@@ -18,9 +18,15 @@ 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 { replaceRangeRaw } from './live-selection-edit';
 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;
+}
 const REPLACE_ISLAND_POLICY = {
     onEdge: 'select',
     deleteGranularity: 'select-then-delete'
@@ -34,6 +40,11 @@ export function createEdgePolicyDispatch(deps) {
             reason: 'an explicit instruction about the very next byte, so it outranks every classification below, which decide by where the caret happens to be',
             claims: handlePendingMarks
         },
+        {
+            id: 'transitional-hard-break',
+            reason: 'a hard break at the end of a block has no following line yet, so its own position is where the next byte starts that line',
+            claims: handleTransitionalHardBreak
+        },
         {
             id: 'cst-widget',
             reason: 'a key aimed at an atomic construct is the widget branch’s before any byte rule',
@@ -101,6 +112,12 @@ export function createEdgePolicyDispatch(deps) {
         const d = display();
         writeDisplay(d.slice(0, start) + insert + d.slice(end), start + insert.length, source, caretBefore);
     }
+    /** The range this surface holds, or null at a caret. A key aimed at one edits the RANGE: the
+     *  caret the arms read is only its start. */
+    function heldRange() {
+        const selection = deps.getRawSelection();
+        return selection && selection.start < selection.end ? selection : null;
+    }
     // ── The seams the arms below defer to ────────────────────────────────────
     /**
      * The rung a range rewrite can be asked about. Past the reading cut a surface revealing no
@@ -139,6 +156,20 @@ export function createEdgePolicyDispatch(deps) {
             return null;
         return resolveEdgeSeat(caret, inlinesOf(deps.node), deps.getEdgeAffinity(), deps.node.raw, screenVisibilityOf(el), typed);
     }
+    /** A printable byte an arm claimed because the engine drops it at an element-level caret. Over
+     *  a held range it REPLACES through the join seam, the road a mid-block range takes; at a caret
+     *  the seat answers which side of an unpainted run it lands on. */
+    function writeTypedByte(el, caretOffset, typed, source) {
+        const range = heldRange();
+        if (range) {
+            const edit = replaceRangeRaw(deps.node, range, typed, joinSeamMode(el), deps.linkRef, deps.getAmbientPrefix?.() ?? '');
+            void deps.blockEdit.updateBlockContent(deps.index, edit.raw, range.start, edit.caret);
+            deps.setPendingCursor(edit.caret, source, edit.raw);
+            return;
+        }
+        const seatedAt = typingSeatAt(el, caretOffset, typed)?.offset ?? caretOffset;
+        editDisplay(seatedAt, seatedAt, typed, source, caretOffset);
+    }
     // ── CST inline widget ────────────────────────────────────────────────────
     function handleCstWidget(e, caretOffset) {
         if (deps.isRevealing())
@@ -152,9 +183,11 @@ export function createEdgePolicyDispatch(deps) {
         const widgetAt = widgetAtCursor(caretOffset, inlinesOf(node), node.raw, direction);
         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);
+        // Below the bail: every keystroke in every prose block reaches the line above.
+        const range = heldRange();
+        // Unchorded, and at a CARET: a modifier makes the key a word-scoped platform command, and
+        // a held range is an edit of the range, not an entry into the construct beside its start.
+        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) {
@@ -189,14 +222,7 @@ 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;
@@ -243,8 +269,8 @@ export function createEdgePolicyDispatch(deps) {
         // Second press: the native selection already wraps a replace island, 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);
@@ -301,7 +327,7 @@ export function createEdgePolicyDispatch(deps) {
         // branch in e2e, so it is unit-pinned instead.
         if (isTyping && !caretIsInTextContent(el, window.getSelection())) {
             e.preventDefault();
-            editDisplay(caretOffset, caretOffset, e.key);
+            writeTypedByte(el, caretOffset, e.key, 'island');
             return true;
         }
         return false;
@@ -326,11 +352,11 @@ export function createEdgePolicyDispatch(deps) {
         if (!touchesAmbient)
             return false;
         e.preventDefault();
-        const range = deps.getRawSelection();
-        if (range && range.start < range.end) {
+        const range = heldRange();
+        if (range) {
             // 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?.() ?? '');
+            const edit = replaceRangeRaw(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');
         }
@@ -389,6 +415,35 @@ export function createEdgePolicyDispatch(deps) {
         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.
+     */
+    function handleTransitionalHardBreak(e, caretOffset) {
+        if (deps.isReading())
+            return false;
+        if (!isPlainTypingKey(e) || caretOffset === null || hasSelectionHelper())
+            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('\\'))
+            return false;
+        // An escaped backslash (`\\\\`) is content, not a break.
+        if (d.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);
+        e.preventDefault();
+        deps.setSnapTarget(null);
+        const next = d + ending + e.key;
+        writeDisplay(next, next.length, '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
@@ -442,14 +497,28 @@ export function createEdgePolicyDispatch(deps) {
     function handleConstructSeat(e, caretOffset) {
         if (!isPlainTypingKey(e) || caretOffset === null || hasSelectionHelper())
             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.
+        const content = getContentRange(deps.node);
+        const autoPair = resolveDelimiterAutoPair(display(), content, caretOffset, e.key);
+        if (autoPair?.kind === 'step-over')
+            return false;
         const el = deps.getEl();
         const seat = el && typingSeatAt(el, caretOffset, e.key);
         if (!seat)
             return false;
         e.preventDefault();
         deps.setSnapTarget(null);
-        // The kind rides the trace: it names the construct whose hidden edge the caret sat at, the
-        // question this seam answered, so a trace line without it cannot be read.
+        // 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));
+        if (paired && paired.kind !== 'step-over') {
+            writeDisplay(paired.text, paired.caret, `seat:${seat.kind}`, caretOffset);
+            if (paired.kind === 'close')
+                deps.noteOutside?.();
+            return true;
+        }
         editDisplay(seat.offset, seat.offset, e.key, `seat:${seat.kind}`, caretOffset);
         return true;
     }

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

@@ -59,10 +59,10 @@ export declare function resolveSelectionEdit(node: NodeView, selection: {
     start: number;
     end: number;
 }, typed: string, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined, ambientPrefix?: string): SelectionEdit | null;
-/** The delete of `[start, end)` a destructive gesture installs: the seam's cleaned rewrite where
- *  it has one, else the literal display splice with the caret at the cut — the fallback's one
- *  home, so no arm carrying it can drift. */
-export declare function deleteRangeRaw(node: NodeView, range: {
+/** 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;
-}, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined, ambientPrefix: string): SelectionEdit;
+}, typed: string, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined, ambientPrefix: string): SelectionEdit;

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

@@ -19,6 +19,8 @@ export function resolveLiveRangeEdit(e, node, cursor, presentationMode, linkRef,
     if (!range)
         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)
         return null;
@@ -26,6 +28,31 @@ export function resolveLiveRangeEdit(e, node, cursor, presentationMode, linkRef,
         ? { kind: 'swallow' }
         : { kind: 'rewrite', 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) {
+    if (!insert)
+        return null;
+    const selection = window.getSelection();
+    if (!selection || selection.rangeCount === 0 || !selection.isCollapsed)
+        return null;
+    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
+    };
+}
 /**
  * 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
@@ -75,17 +102,20 @@ export function resolveSelectionEdit(node, selection, typed, presentationMode, l
         caret: joined.seam + typed.length
     };
 }
-/** The delete of `[start, end)` a destructive gesture installs: the seam's cleaned rewrite where
- *  it has one, else the literal display splice with the caret at the cut — the fallback's one
- *  home, so no arm carrying it can drift. */
-export function deleteRangeRaw(node, range, presentationMode, linkRef, ambientPrefix) {
-    const cleaned = resolveSelectionEdit(node, range, '', presentationMode, linkRef, ambientPrefix);
+/** 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) + display.slice(range.end) + trailingLineEnding(node.raw),
-        caret: range.start
+        raw: display.slice(0, range.start) +
+            typed +
+            display.slice(range.end) +
+            trailingLineEnding(node.raw),
+        caret: range.start + typed.length
     };
 }
 // ── Reading the event ────────────────────────────────────────────────────────

package/dist/components/blocks/text/text-clipboard.js

@@ -6,7 +6,7 @@ import { resolvedInlineContent } from '../../../core/inline/inline-cache';
 import { isInlineWidget } from '../../../core/inline/inline-widgets';
 import { createClipboardHandlers } from '../editable-surface';
 import { pasteDispatch } from '../../../tree-operations/paste/dispatch';
-import { deleteRangeRaw } from './live-selection-edit';
+import { replaceRangeRaw } from './live-selection-edit';
 export function createTextClipboard(deps) {
     function getSelectedTextFromRaw() {
         const offsets = deps.cursor.getRawSelection();
@@ -77,7 +77,7 @@ export function createTextClipboard(deps) {
                 return;
             // A cut is a delete, so it crosses the same join seam: in live the range can span
             // delimiter runs the reader never saw, and a raw splice would print them.
-            const edit = deleteRangeRaw(deps.node, selOffsets, deps.getPresentationMode(), deps.linkRef, deps.getAmbientPrefix());
+            const edit = replaceRangeRaw(deps.node, selOffsets, '', deps.getPresentationMode(), deps.linkRef, deps.getAmbientPrefix());
             void deps.blockEdit.updateBlockContent(deps.index, edit.raw, selOffsets.start);
             deps.setPendingCursor(edit.caret);
         },

package/dist/components/blocks/text/text-keydown.d.ts

@@ -1,5 +1,5 @@
 /**
- * Pure raw/caret transforms for TextEditableBlock keydown branches — heading-level
+ * Pure raw/caret transforms for TextEditableBlock's structural gestures — heading-level
  * swap, demotion to prose, hard-break insertion, literal-tab insertion. The component
  * owns the plumbing; these own the string math.
  */
@@ -21,6 +21,12 @@ export declare function dropStructuralPrefix(raw: string, contentStart: number,
 /** Drop everything past `contentEnd` but the block's own trailing line ending — the setext
  *  underline, which sits after every caret the content range admits. */
 export declare function dropStructuralSuffix(raw: string, contentEnd: number, preEditOffset: number): TextEditResult;
+/**
+ * An ATX heading left with no text is a marker standing over nothing: unfocused it paints
+ * nothing (the chrome-only stamp is focus-scoped), so the block would survive invisibly and
+ * resurface as a `#` on the next click. On blur it becomes the empty paragraph it looks like.
+ */
+export declare function demoteEmptyAtxHeading(raw: string, content: ContentRange): TextEditResult | null;
 /**
  * Re-mark the block's CONTENT with an ATX prefix for `level`, replacing whatever structural bytes
  * the current kind keeps — the same content range {@link demoteToParagraph} reads, so an indented

package/dist/components/blocks/text/text-keydown.js

@@ -1,5 +1,5 @@
 /**
- * Pure raw/caret transforms for TextEditableBlock keydown branches — heading-level
+ * Pure raw/caret transforms for TextEditableBlock's structural gestures — heading-level
  * swap, demotion to prose, hard-break insertion, literal-tab insertion. The component
  * owns the plumbing; these own the string math.
  */
@@ -33,6 +33,16 @@ export function dropStructuralSuffix(raw, contentEnd, preEditOffset) {
         caretOffset: Math.min(preEditOffset, contentEnd)
     };
 }
+/**
+ * An ATX heading left with no text is a marker standing over nothing: unfocused it paints
+ * nothing (the chrome-only stamp is focus-scoped), so the block would survive invisibly and
+ * resurface as a `#` on the next click. On blur it becomes the empty paragraph it looks like.
+ */
+export function demoteEmptyAtxHeading(raw, content) {
+    if (content.start === 0 || content.end > content.start)
+        return null;
+    return demoteToParagraph(raw, content, 0);
+}
 /**
  * Re-mark the block's CONTENT with an ATX prefix for `level`, replacing whatever structural bytes
  * the current kind keeps — the same content range {@link demoteToParagraph} reads, so an indented

package/dist/components/blocks/text/text-render.d.ts

@@ -6,7 +6,7 @@
  */
 import type { AmbientPrefix } from '../../../block-component';
 import type { DocumentView, NodeView } from '../../../core/node-views';
-import type { PresentationMode } from '../../../presentation-mode';
+import { type PresentationMode } from '../../../presentation-mode';
 import type { ResolveImageUrl, ResolveLinkUrl } from '../../../editor-keys';
 import type { LinkReferenceResolver } from '../../../core/inline/link-reference-resolver';
 import { type ImageLoadPolicy } from '../../../core/inline-render';

package/dist/components/blocks/text/text-render.js

@@ -4,6 +4,7 @@
  * factory owns the imperative inline-DOM construction and carries a live caret across
  * a decoration-driven rebuild the edit path's pending restore doesn't cover.
  */
+import { hidesMarkers } from '../../../presentation-mode';
 import { buildAmbientSpan } from '../../../ambient/ambient-dom';
 import { computeInlineContent, contentLengthOf, getContentRange, isProseKind } from '../../../core/inline';
 import { renderInlineNodes } from '../../../core/inline-render';
@@ -90,7 +91,8 @@ export function createTextRender(deps) {
             buildPortalWidget,
             // Attribute-only stamps for the construct-reveal trigger, mode-gated so the
             // other modes' DOM stays byte-identical.
-            tagConstructMarkers: deps.presentationMode === 'preview-inline'
+            tagConstructMarkers: deps.presentationMode === 'preview-inline',
+            pendingBreakSeat: hidesMarkers(deps.presentationMode)
         }));
         return frag;
     }

package/dist/components/blocks/text/widget-interaction.d.ts

@@ -69,6 +69,9 @@ export interface WidgetInteraction {
     /** Snap a click that landed outside any text node to the nearest widget edge, or open a
      *  reveal-source widget it hit. */
     snapClickToWidgetEdge(clickX: number | null, clickY: number | null, press?: WidgetPress): void;
+    /** A caret restored strictly inside a reveal-source widget — a formula that just closed
+     *  around it — opens that source there instead of being pushed past the island. */
+    revealInterior(offset: number): boolean;
     /** A reveal-source widget currently shows its editable `$…$` source. */
     isRevealing(): boolean;
     /** Escape (cancel to rendered) while source is shown. Enter is deliberately NOT