@voithos-labs/aragonite 0.10.2 → 0.10.3

package/dist/components/blocks/text/TextEditableBlock.svelte

@@ -33,19 +33,21 @@
 	} from '../../../schema/inline-construct-policy';
 	import {
 		cycleHeading,
+		demoteEmptyAtxHeading,
 		demoteToParagraph,
 		insertHardBreak,
 		insertLiteralTab,
 		type TextEditResult
 	} from './text-keydown';
 	import { tryGetBlockKindDescriptor } from '../../../schema/block-kind-descriptor';
-	import { blockNodeAt } from '../../../tree-operations/node-ops';
+	import { blockNodeAt } from '../../../tree-operations/node-primitives';
 	import { createTextClipboard } from './text-clipboard';
 	import { createTextRender } from './text-render';
 	import { createWidgetInteraction } from './widget-interaction';
-	import { createEdgePolicyDispatch } from './edge-policy-dispatch';
+	import { createEdgePolicyDispatch, keepsBlockKind } from './edge-policy-dispatch';
 	import { hidesStructuralSuffix } from './hidden-suffix';
 	import { applyLiveRangeEdit, resolveSelectionEdit } from './live-selection-edit';
+	import { applyDelimiterAutoPair } from './delimiter-autopair';
 	import { createCompositionSeat } from './composition-seat';
 	import { createConstructReveal } from './construct-reveal';
 	import { assertInvariant } from '../../../assert';
@@ -56,7 +58,11 @@
 		handleSharedKeydown,
 		handleSharedBeforeInput
 	} from '../../../selection/shared-keydown';
-	import { createEditableSurface, consumePendingRestore } from '../editable-surface';
+	import {
+		createEditableSurface,
+		consumePendingRestore,
+		withKeydownVerdict
+	} from '../editable-surface';
 	import { wireSurfaceContexts, useParkFocusOnUnmount } from '../surface-wiring.svelte';
 	import {
 		domTextOffsetAtNode,
@@ -76,6 +82,7 @@
 	import { createAmbientCursorIO } from '../../../ambient/ambient-cursor';
 	import { type CommandId } from '../../../schema/commands';
 	import { reorderRunCommand } from '../../../editor-actions/reorder-action';
+	import { planTypedCompletion } from '../../../editor-actions/enter-completion';
 	import {
 		perfEnabled,
 		recordBlockRender,
@@ -111,6 +118,12 @@
 	const ambientPrefixText = $derived(
 		typeof ambientPrefix === 'string' ? ambientPrefix : ambientPrefix.text
 	);
+	// The hanging indent is the prefix's painted width: its text width by default, or what a
+	// prefix painting itself as chrome (the task box) declares.
+	const ambientIndent = $derived(
+		(typeof ambientPrefix === 'string' ? undefined : ambientPrefix.indent) ??
+			`${ambientPrefixText.length}ch`
+	);
 
 	const wiring = wireSurfaceContexts();
 	const {
@@ -361,6 +374,7 @@
 			widgetInteraction.enterWidget(widget, fromTrailingEdge),
 		isReading: () => readOnly,
 		getEdgeAffinity: () => edgeAffinity.get(),
+		noteOutside: edgeAffinity.noteExtreme,
 		pendingMarks,
 		installedAs: 'block'
 	});
@@ -668,9 +682,9 @@
 			// Only while this block still owns focus: a blur-commit also arms a pending
 			// offset, and restoring would yank the selection back into the blurred block.
 			// The clear runs regardless, so a skipped restore is dropped, never re-armed.
-			const applied = consumePendingRestore(el ?? null, pendingCursorOffset, (offset) =>
-				cursor.setRaw(asRawOffset(offset))
-			);
+			const applied = consumePendingRestore(el ?? null, pendingCursorOffset, (offset) => {
+				if (!widgetInteraction.revealInterior(offset)) cursor.setRaw(asRawOffset(offset));
+			});
 			tracePendingCursorConsume(pendingCursorOffset, applied);
 			pendingCursorOffset = null;
 		}
@@ -815,6 +829,8 @@
 		if (wiring.dispatchChord(e, { kind: node.kind, runCommand })) return;
 	}
 
+	const onKeyDownTraced = withKeydownVerdict(onKeyDown);
+
 	/**
 	 * A native ranged edit inside ONE block, in a mode that paints no delimiter: the engine would
 	 * write the runs the range crossed literally, so the edit goes through the join seam instead.
@@ -837,9 +853,33 @@
 		);
 	}
 
+	// The write takes the ranged edit's road above, so the surface repaints once with the caret
+	// inside the pair. During a reveal the caret indexes the DOM text, which has outrun `node.raw`.
+	function handleDelimiterAutoPair(e: InputEvent): boolean {
+		return applyDelimiterAutoPair(e, {
+			text: () => (widgetInteraction.isRevealing() ? readRawText() : getDisplayText()),
+			content: () => getContentRange(node),
+			caret: () => cursor.getRaw(),
+			hasSelection: () => cursor.getRawSelection() !== null,
+			isRevealing: widgetInteraction.isRevealing,
+			foldReveal: () => widgetInteraction.foldRevealBeforeMutation(),
+			markersPaint: () => paintsFocusedMarkers(presentationMode),
+			setCaret: (offset) => cursor.setRaw(asRawOffset(offset)),
+			seatOutside: edgeAffinity.noteExtreme,
+			completesLine: (caret) => planTypedCompletion(node, caret) !== null,
+			keepsBlockKind: (text) => keepsBlockKind(node, text),
+			write: (text, caretBefore, caretAfter) => {
+				const raw = text + trailingLineEnding(node.raw);
+				void blockEdit.updateBlockContent(index, raw, caretBefore, caretAfter);
+				setPendingCursorOffset(caretAfter, 'delimiter-autopair');
+			}
+		});
+	}
+
 	async function onBeforeInput(e: InputEvent): Promise<void> {
 		if (await handleSharedBeforeInput(e, sharedCtx)) return;
 		if (handleLiveSelectionEdit(e)) return;
+		if (handleDelimiterAutoPair(e)) return;
 		// Soft-keyboard/IME insertLineBreak slipped past onKeyDown — swallow; Shift+Enter there owns hard breaks.
 		if (e.inputType === 'insertLineBreak') {
 			e.preventDefault();
@@ -868,6 +908,13 @@
 		// Persist a revealed source edit before the caret is gone.
 		widgetInteraction.commitRevealOnBlur();
 		lastSnapTargetOffset = null;
+		demoteEmptyHeadingOnBlur();
+	}
+
+	function demoteEmptyHeadingOnBlur(): void {
+		if (readOnly || node.kind !== 'heading' || editableSurface.isDetached()) return;
+		const demoted = demoteEmptyAtxHeading(node.raw, getContentRange(node));
+		if (demoted) void blockEdit.updateBlockContent(index, demoted.newRaw, 0);
 	}
 
 	function onClick(e: MouseEvent): void {
@@ -933,10 +980,10 @@
 	contenteditable={readOnly ? 'false' : 'true'}
 	aria-readonly={readOnly ? 'true' : undefined}
 	role="textbox"
-	style:text-indent={ambientPrefixText ? `-${ambientLength}ch` : null}
-	style:padding-left={ambientPrefixText ? `${ambientLength}ch` : null}
+	style:text-indent={ambientPrefixText ? `-${ambientIndent}` : null}
+	style:padding-left={ambientPrefixText ? ambientIndent : null}
 	oninput={onInput}
-	onkeydown={onKeyDown}
+	onkeydown={onKeyDownTraced}
 	onbeforeinput={onBeforeInput}
 	oncopy={clipboardHandlers.onCopy}
 	oncut={clipboardHandlers.onCut}
@@ -986,7 +1033,7 @@
 	}
 
 	.text-editable-block.raw-block {
-		font-family: var(--font-editor, ui-monospace, monospace);
+		font-family: var(--font-code, ui-monospace, monospace);
 		font-size: 0.9em;
 		opacity: 0.85;
 	}
@@ -998,7 +1045,7 @@
 	}
 
 	.text-editable-block :global(.inline-code-content) {
-		font-family: var(--font-editor, ui-monospace, monospace);
+		font-family: var(--font-code, ui-monospace, monospace);
 		font-size: 0.9em;
 		background: var(--color-bg-secondary, rgba(128, 128, 128, 0.12));
 		border-radius: 3px;

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

@@ -0,0 +1,71 @@
+/**
+ * A typed inline delimiter closes itself: a lone `$`, backtick, `*`, `_` or `~~` would pair with
+ * whatever matching run comes later on the line, so the keystroke lands its twin after the caret.
+ * Typing the closer over the twin steps past it, a closer typed by hand seats the next byte
+ * outside, and the empty pair drops its twin when the first body byte makes it no construct.
+ * `applyDelimiterAutoPair` is the one `beforeinput` arm every prose surface runs (G4.65).
+ */
+import { type ContentRange } from '../../../core/inline';
+export type AutoPairEdit = {
+    kind: 'write';
+    text: string;
+    caret: number;
+}
+/** The typed byte completed a construct's closer; what follows belongs outside it. */
+ | {
+    kind: 'close';
+    text: string;
+    caret: number;
+}
+/** Nothing written: the caret passes the twin. Over a construct's closer that run may be
+ *  unpainted, and then only the SIDE moves, which the surface records as an edge affinity. */
+ | {
+    kind: 'step-over';
+    caret: number;
+    overConstruct: boolean;
+};
+/**
+ * What a single typed byte does at a collapsed caret, or null to leave the engine its insert.
+ * `content` bounds the inline scan (a heading's `# ` is not prose); the caret must lie inside it.
+ * `keepsBlockKind` says whether a written line still reloads as this block: a grown `****` is a
+ * thematic break and `~~~~` a fence, so such a pair steps past a twin instead, or declines.
+ */
+export declare function resolveDelimiterAutoPair(text: string, content: ContentRange, caret: number, typed: string, keepsBlockKind?: (text: string) => boolean): AutoPairEdit | null;
+/**
+ * Inside a revealed source (`$ab|$`) the twin is the live closer, and typing it means "done":
+ * the caret steps past it and the caller folds the reveal, so the formula renders at once.
+ */
+export declare function stepsOverRevealedCloser(text: string, caret: number, typed: string): boolean;
+/** Backspace at an empty pair takes both runs, between them (`**|**`) or right after them
+ *  (`$$|`), as it does in any IDE. Exactly a pair of equal runs, one or two bytes each: a longer
+ *  run is a fence or a literal the user built by hand. */
+export declare function resolveEmptyPairBackspace(text: string, caret: number): AutoPairEdit | null;
+/** What a prose surface lends the arm. Reactive reads are thunks, so nothing here goes stale. */
+export interface AutoPairSurface {
+    /** The bytes the caret indexes: the display text, or the revealed DOM text during a reveal. */
+    text(): string;
+    content(): ContentRange;
+    caret(): number | null;
+    hasSelection(): boolean;
+    isRevealing(): boolean;
+    foldReveal(): {
+        settled: Promise<void>;
+    } | null;
+    /** Whether the closer a step-over passes is on screen; unpainted, only the side moves. */
+    markersPaint(): boolean;
+    setCaret(offset: number): void;
+    /** The arrival the seat reads next: past the construct's delimiters. */
+    seatOutside(): void;
+    /** One CST write plus the caret it parks. */
+    write(text: string, caretBefore: number, caretAfter: number): void;
+    /** A step-over that leaves the line one an on-type completer claims (`$$`), which only a
+     *  content write consults. */
+    completesLine?(caret: number): boolean;
+    /** The resolver's block-kind guard, for a surface whose line can become another block. */
+    keepsBlockKind?(text: string): boolean;
+}
+/**
+ * The `beforeinput` arm. True when the press was this seam's: the event is cancelled and the
+ * surface has written, moved or re-seated the caret.
+ */
+export declare function applyDelimiterAutoPair(e: InputEvent, surface: AutoPairSurface): boolean;

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

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

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

@@ -13,6 +13,8 @@ import { type RawOffset } from '../../../cursor/coordinate-spaces';
 import type { EdgeAffinity } from '../../../cursor/edge-affinity';
 import type { PendingMarksState } from '../../../cursor/pending-marks';
 import { type EdgeDeletionSurface } from './construct-edge-delete';
+/** Whether `line` still reloads as `node`'s kind, the auto-pair resolver's guard. */
+export declare function keepsBlockKind(node: NodeView, line: string): boolean;
 /** The subset of the inline-widget vocabulary the internal island policies reuse,
  *  expressed in the same terms without leaking into the public API. */
 export type EdgePolicy = Pick<InlineWidgetEditingPolicy, 'onEdge' | 'deleteGranularity'>;
@@ -70,6 +72,8 @@ export interface EdgePolicyDispatchDeps {
     isReading: () => boolean;
     /** The arrival side the typing seat consults; null when no arrival claimed one. */
     getEdgeAffinity: () => EdgeAffinity | null;
+    /** A seated delimiter that completed a construct leaves the caret meaning outside it. */
+    noteOutside?: () => void;
     /** The constructs a collapsed-caret toggle promised the next insertion. Read AND spent
      *  here: the first byte after the chord is the one insertion they were pending for. */
     pendingMarks: PendingMarksState;

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

@@ -21,6 +21,12 @@ import { resolveEdgeSeat } from './edge-seat';
 import { deleteRangeRaw } 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',
@@ -389,6 +400,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 +482,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.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

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';