@voithos-labs/aragonite 0.10.2 → 0.10.3

package/dist/components/blocks/editable-leaf.js

@@ -1,20 +1,26 @@
 /**
- * The editable-leaf seam a plugin block component builds on: a text-editing block surface with
- * native caret/IME/undo/cross-block-selection parity, in one factory so a plugin never touches an
- * editor context key. Two modes: `plain` commits per keystroke, `render-primary` reveals its
- * source and commits on blur. Call synchronously during init. Contract: plugin-guide § The
- * editable leaf.
+ * The editable-leaf seam a plugin block component builds on: native caret/IME/undo/selection
+ * parity in one factory, so a plugin never touches an editor context key. `plain` commits per
+ * keystroke; `render-primary` reveals its source and commits on blur. A painted source
+ * (`renderSource`) edits only its own DOM: every byte still enters the CST through
+ * `commitReveal`'s one `updateBlockContent`. Call synchronously during init. Contract:
+ * plugin-guide § The editable leaf.
  */
 import { getContext } from 'svelte';
 import { createAttachmentKey } from 'svelte/attachments';
 import { EDITOR_POLICIES_KEY, EDITOR_SERVICES_KEY } from '../../editor-keys';
 import { asDomTextOffset } from '../../cursor/coordinate-spaces';
-import { setCursorOffset, getCursorOffset, getSelectionOffsets } from '../../cursor/content-offsets';
+import { setCursorOffset, getCursorOffset, getSelectionOffsets, getRangeOffsets } from '../../cursor/content-offsets';
 import { handleSharedKeydown } from '../../selection/shared-keydown';
-import { createEditableSurface, createClipboardHandlers, consumePendingRestore } from './editable-surface';
+import { createEditableSurface, createClipboardHandlers, consumePendingRestore, withKeydownVerdict } from './editable-surface';
 import { wireSurfaceContexts } from './surface-wiring.svelte';
 import { createContentOffsetBackend, anchorTrailingNewline } from './plain-text-backend';
+import { CONTENT_EMPTY_ATTR, chromeFreeText, clampToLandableRaw, holdsOnlyMarkerChrome } from '../../cursor/widget-offset';
 import { parkFocusOnEditorRoot } from '../../selection/native-bridge';
+import { assertInvariant } from '../../assert';
+import { checkRenderedTextFidelity } from '../../invariants/render-fidelity';
+import { resolveBinding } from '../../schema/commands';
+import { eventToChord } from '../../schema/keybindings';
 import { resetForPointerDown } from '../../selection/cross-block/pointer';
 import { placeCaret } from '../../selection/caret-doors';
 import { createSourceReveal } from '../../cursor/reveal-source';
@@ -25,6 +31,7 @@ import {} from '../../schema/commands';
 import {} from '../../schema/block-commands';
 import { owningPluginEditor } from '../../schema/plugin-install';
 import { reorderRunCommand } from '../../editor-actions/reorder-action';
+import { createTextBatch } from '../../editor-actions/commit/text-batch';
 /**
  * The node → metadata bridge (plus `commandHooks`) a minted block command resolves
  * against on the leaf tier — the container factory's `buildContainerKindTarget` sibling.
@@ -48,9 +55,9 @@ export function createEditableLeaf(deps) {
     // Plain mode's source is always the editable view.
     const isRevealed = mode === 'render-primary' ? deps.isRevealed : () => true;
     const wiring = wireSurfaceContexts();
-    const { blockEdit, stickyColumn, edgeAffinity, selection, getDoc, getBlockElByPath, getEditorRoot, pluginEditor, events: editorEvents } = wiring.deps;
+    const { blockEdit, focusActions, stickyColumn, edgeAffinity, selection, getDoc, getBlockElByPath, getEditorRoot, pluginEditor, activePlugins, events: editorEvents } = wiring.deps;
     const { reorder } = getContext(EDITOR_SERVICES_KEY);
-    const { presentationMode: getPresentationModeCtx, theme: getThemeCtx, onPasteImage } = getContext(EDITOR_POLICIES_KEY);
+    const { presentationMode: getPresentationModeCtx, theme: getThemeCtx, keybindingOverrides, onPasteImage } = getContext(EDITOR_POLICIES_KEY);
     const getPresentationMode = () => getPresentationModeCtx?.() ?? 'source';
     const getTheme = () => getThemeCtx?.() ?? 'dark';
     // Resolved by the kind's recorded owner, like the command context's `editor`.
@@ -123,13 +130,29 @@ export function createEditableLeaf(deps) {
         showSource: () => {
             traceRevealOpen('leaf');
             revealedBase = sourceText();
+            clearSourceHistory();
             deps.setRevealed?.(true);
         },
         showRendered: () => {
             revealedBase = null;
+            clearSourceHistory();
             deps.setRevealed?.(false);
         }
     });
+    // Every open goes through here rather than the kernel directly, so a chrome-only source is
+    // completed (see `EditableLeafDeps.completeBareSource`) whatever door revealed it.
+    async function revealSource(atSourceOffset = 0) {
+        await revealKernel.reveal(atSourceOffset);
+        const el = deps.getEl();
+        if (!el || !deps.completeBareSource || !isRevealed() || isReading())
+            return;
+        const completed = deps.completeBareSource(el.textContent ?? '');
+        if (!completed)
+            return;
+        paintSource(el, completed.text);
+        deps.onSourceEdit?.(completed.text);
+        setCursorOffset(el, asDomTextOffset(completed.caret));
+    }
     // ── Commit ─────────────────────────────────────────────────────────────────
     // Returns the commit's own promise, so a caller that has to act on the committed bytes
     // (a single-line Enter's split) can wait for the write to land.
@@ -138,14 +161,29 @@ export function createEditableLeaf(deps) {
         // caret follows the edit position.
         return Promise.resolve(blockEdit.updateBlockContent(deps.getIndex(), edited + trailingLineEnding(deps.getNode().raw), preEditOffset, edited.length));
     }
-    async function commitReveal() {
+    // A blur that arrives with a cross-block range live is the release of a drag that began in
+    // this source and left it: the fold waits one frame, so the range's rects measured real text
+    // under the pointer, then folds unless focus came back — else the source stays open with
+    // nothing focused in it and no further blur to close it.
+    let foldFrame = 0;
+    function foldAfterRange() {
+        if (foldFrame)
+            return;
+        foldFrame = requestAnimationFrame(() => {
+            foldFrame = 0;
+            const el = deps.getEl();
+            if (!isRevealed() || (el && el.contains(document.activeElement)))
+                return;
+            void commitReveal(true);
+        });
+    }
+    async function commitReveal(force = false) {
         if (mode !== 'render-primary' || !isRevealed())
             return;
-        // A cross-block selection sweeping through keeps the source revealed so its rects
-        // measure real text, and focusout is this fold's only entry — so the leaf stays in
-        // source view until the user focuses it and leaves again.
-        if (selection.isCrossBlock)
+        if (selection.isCrossBlock && !force) {
+            foldAfterRange();
             return;
+        }
         // Only wired to onFocusOut — the block leaf folds on blur, never Escape-cancel.
         traceRevealFold('blur');
         const edited = deps.getEl()?.textContent ?? sourceText();
@@ -169,7 +207,7 @@ export function createEditableLeaf(deps) {
             // and block-level traversal passes over.
             if (isReading())
                 return;
-            void revealKernel.reveal(offset);
+            void revealSource(offset);
             return;
         }
         surface.parkCaret(offset);
@@ -184,7 +222,7 @@ export function createEditableLeaf(deps) {
                     return;
                 // Through the kernel like every other open, so this entry gets the same trace pair,
                 // length assert and reveal base; it seats a caret at 0, which the column re-seats.
-                await revealKernel.reveal();
+                await revealSource();
             }
             if (!deps.getEl())
                 return;
@@ -196,6 +234,30 @@ export function createEditableLeaf(deps) {
     }
     const getCommandContext = () => buildLeafCommandContext(deps, blockEdit, pluginEditor);
     // ── View sync ──────────────────────────────────────────────────────────────
+    // The one place source bytes become DOM, so G1.28 is asserted here for every painter rather
+    // than trusted per plugin. A painter's chrome-only case (a fence with no body line) takes the
+    // same stamp a code block does, so its markers paint while focused.
+    function paintSource(el, text) {
+        if (deps.renderSource) {
+            const painted = deps.renderSource(text);
+            assertInvariant('rendered-text-fidelity', () => checkRenderedTextFidelity(painted.textContent ?? '', text));
+            el.replaceChildren(painted);
+            el.toggleAttribute(CONTENT_EMPTY_ATTR, holdsOnlyMarkerChrome(el));
+        }
+        else {
+            el.textContent = text;
+        }
+        anchorTrailingNewline(el);
+    }
+    function repaintSource() {
+        const el = deps.getEl();
+        if (!el || !deps.renderSource || composing)
+            return;
+        const offset = getCursorOffset(el);
+        paintSource(el, el.textContent ?? '');
+        if (offset !== null)
+            setCursorOffset(el, asDomTextOffset(offset));
+    }
     function syncSource() {
         const text = sourceText();
         const el = deps.getEl();
@@ -204,23 +266,73 @@ export function createEditableLeaf(deps) {
         const pending = pendingCursor;
         pendingCursor = null;
         if ((el.textContent ?? '') !== text) {
-            el.textContent = text;
-            anchorTrailingNewline(el);
+            paintSource(el, text);
+            // The local entries were taken against bytes an external rewrite just replaced.
+            clearSourceHistory();
             // Restore only under a live caret — an external rewrite (undo, structural
             // replace) must not steal focus.
             consumePendingRestore(el, pending, (offset) => setCursorOffset(el, asDomTextOffset(offset)));
         }
     }
-    // ── Event handlers ─────────────────────────────────────────────────────────
+    let sourceUndo = [];
+    let sourceRedo = [];
+    // The document's own keystroke batch, not a second timer: a burst of typing inside the
+    // reveal takes one entry there, so it takes one here.
+    let batchBaseText = '';
+    const sourceBatch = createTextBatch({
+        pushSnapshot: (_leafPath, offset) => {
+            sourceUndo.push({ text: batchBaseText, caret: offset });
+            sourceRedo = [];
+        }
+    });
+    function clearSourceHistory() {
+        sourceBatch.interrupt();
+        sourceUndo = [];
+        sourceRedo = [];
+    }
+    function restoreSourceEntry(el, from, to) {
+        const entry = from.pop();
+        if (!entry)
+            return;
+        // The restored text is what the next keystroke must snapshot, so it opens its own batch.
+        sourceBatch.interrupt();
+        to.push({ text: el.textContent ?? '', caret: getCursorOffset(el) ?? 0 });
+        paintSource(el, entry.text);
+        setCursorOffset(el, asDomTextOffset(entry.caret));
+        deps.onSourceEdit?.(entry.text);
+    }
+    /**
+     * The one entry every reveal edit crosses, so the batching rule lives here rather than at
+     * each gesture: one character replaced by at most one non-newline character is the shape a
+     * keystroke has, and nothing else coalesces. Enter, a paste, a cut and a selection replace
+     * each take an entry of their own and end the burst before them.
+     */
+    function recordSourceEdit(text, caret, keystroke) {
+        if (!keystroke) {
+            sourceBatch.interrupt();
+            sourceUndo.push({ text, caret });
+            sourceRedo = [];
+            return;
+        }
+        batchBaseText = text;
+        sourceBatch.keystroke(deps.getPath(), caret);
+    }
     // Splice `insert` over the source text node's [start, end) and reseat the caret. A
     // DOM-text mutation keeps the offset walk exact where a native Enter/cut/paste would
     // inject <div>/<br> that vanish from textContent.
     function spliceSourceText(el, start, end, insert) {
         const text = el.textContent ?? '';
-        el.textContent = text.slice(0, start) + insert + text.slice(end);
-        anchorTrailingNewline(el);
+        const keystroke = end - start <= 1 && insert.length <= 1 && insert !== '\n';
+        if (deps.renderSource)
+            recordSourceEdit(text, getCursorOffset(el) ?? start, keystroke);
+        const next = text.slice(0, start) + insert + text.slice(end);
+        paintSource(el, next);
+        deps.onSourceEdit?.(next);
         preEditOffset = start;
         setCursorOffset(el, asDomTextOffset(start + insert.length));
+        // Armed once the edit has settled, so the window measures the gap the user leaves.
+        if (deps.renderSource && keystroke)
+            sourceBatch.armPause();
         if (mode === 'plain')
             editableSurface.onInput();
     }
@@ -267,6 +379,44 @@ export function createEditableLeaf(deps) {
         if (composing || !el)
             return;
         preEditOffset = getCursorOffset(el) ?? 0;
+        // Undo INSIDE an open painted reveal steps back through this session's own edits: the
+        // document's history sees the session as one entry written on blur, so until the local
+        // stack is spent the chord has nothing else to mean. Resolved through the keymap like every
+        // chord, so a host's rebinding or disable reaches it.
+        if (deps.renderSource && isRevealed()) {
+            const command = historyCommandFor(e);
+            if (command === 'history.undo' && sourceUndo.length > 0) {
+                e.preventDefault();
+                restoreSourceEntry(el, sourceUndo, sourceRedo);
+                return;
+            }
+            if (command === 'history.redo' && sourceRedo.length > 0) {
+                e.preventDefault();
+                restoreSourceEntry(el, sourceRedo, sourceUndo);
+                return;
+            }
+        }
+        // Backspace in a painted source that holds nothing but its own chrome deletes the block, as
+        // it does in a code block: an empty body has no byte the press could mean, and a seat that
+        // only steps out (or eats the one blank line) leaves a block the user just asked to be rid
+        // of. In every mode — the gate is the byte BEFORE the caret: whitespace, or nothing, so a
+        // press that sits right after a visible marker still edits that marker in source mode.
+        if (e.key === 'Backspace' && !e.shiftKey && !e.ctrlKey && !e.metaKey && !e.altKey) {
+            const offset = deps.renderSource ? getCursorOffset(el) : null;
+            const text = el.textContent ?? '';
+            if (offset !== null &&
+                (offset === 0 || /\s/.test(text[offset - 1] ?? '')) &&
+                !hasSelectionIn(el) &&
+                chromeFreeText(el).trim() === '') {
+                e.preventDefault();
+                revealedBase = null;
+                deps.setRevealed?.(false);
+                const index = deps.getIndex();
+                await blockEdit.deleteBlock(index);
+                void focusActions.moveFocus(index - 1, 'end');
+                return;
+            }
+        }
         if ((await handleSharedKeydown(e, editableSurface.sharedCtx)) || editableSurface.isDetached())
             return;
         if (dispatchChord(e))
@@ -290,6 +440,56 @@ export function createEditableLeaf(deps) {
             spliceSourceText(el, offset, offset, '\n');
         }
     }
+    /**
+     * A painted source takes plain text edits here, not from the engine: Chromium treats a lone
+     * `\n` text node as a placeholder and replaces it on insert (a fresh `$$` block lost the line
+     * before its closer), and a native delete has no notion of hidden chrome. The edit range is
+     * clamped to the landable span, so nothing reaches a fence line. Composition stays native.
+     */
+    function onBeforeInput(e) {
+        if (!deps.renderSource || composing || e.isComposing)
+            return;
+        const el = deps.getEl();
+        if (!el)
+            return;
+        let insert;
+        switch (e.inputType) {
+            case 'insertText':
+                insert = e.data ?? '';
+                break;
+            case 'insertLineBreak':
+            case 'insertParagraph':
+                insert = '\n';
+                break;
+            case 'deleteContentBackward':
+            case 'deleteContentForward':
+            case 'deleteWordBackward':
+            case 'deleteWordForward':
+                insert = '';
+                break;
+            default:
+                return;
+        }
+        const target = e.getTargetRanges()[0];
+        const range = target ? getRangeOffsets(el, target) : null;
+        if (!range)
+            return;
+        e.preventDefault();
+        const start = clampToLandableRaw(el, range.start, 0);
+        const end = Math.max(start, clampToLandableRaw(el, range.end, 0));
+        spliceSourceText(el, start, end, insert);
+    }
+    function historyCommandFor(e) {
+        const chord = eventToChord(e);
+        if (!chord)
+            return undefined;
+        return resolveBinding(chord, deps.getNode().kind, keybindingOverrides(), activePlugins)
+            ?.command;
+    }
+    function hasSelectionIn(el) {
+        const sel = window.getSelection();
+        return Boolean(sel && !sel.isCollapsed && el.contains(sel.anchorNode));
+    }
     function onPointerDown(e) {
         void crossBlock.handlePointerDown(e);
     }
@@ -303,17 +503,25 @@ export function createEditableLeaf(deps) {
         const descriptor = tryGetBlockKindDescriptor(deps.getNode().kind);
         return descriptor?.caretTargetAtPoint?.(host, e.clientX, e.clientY)?.offset ?? 0;
     }
+    // The press only notes where it landed: revealing on the press swallowed every drag that
+    // began on a rendered equation. The editor's own drag runs from such a press (its root
+    // handler), and the CLICK — a release that did not move — is what reveals.
+    let renderPress = null;
     function onRenderPointerDown(e) {
-        // Shift-click extends a selection; a plain click reveals. Reading mode: no reveal
-        // and no preventDefault, so native selection over the rendered view stays live.
-        if (e.shiftKey || isReading())
+        renderPress = e.shiftKey || isReading() ? null : { x: e.clientX, y: e.clientY };
+    }
+    function onRenderClick(e) {
+        const press = renderPress;
+        renderPress = null;
+        if (!press || e.shiftKey || isReading())
+            return;
+        if (Math.abs(e.clientX - press.x) > 3 || Math.abs(e.clientY - press.y) > 3)
             return;
-        e.preventDefault();
         // The reveal lands a caret, so this owes the shared preamble. NOT through
         // crossBlock.handlePointerDown: that hit-tests against the SOURCE text, which the
         // rendered view is not.
-        resetForPointerDown(selection, stickyColumn, edgeAffinity, e.shiftKey);
-        void revealKernel.reveal(revealOffsetAt(e));
+        resetForPointerDown(selection, stickyColumn, edgeAffinity, false);
+        void revealSource(revealOffsetAt(e));
     }
     // The revealed source owns the press and has already spent the chord, so a spread the fold
     // does not unmount must not re-run either on the way up.
@@ -322,6 +530,10 @@ export function createEditableLeaf(deps) {
             if (!isRevealed())
                 onRenderPointerDown(e);
         },
+        onclick: (e) => {
+            if (!isRevealed())
+                onRenderClick(e);
+        },
         onkeydown: (e) => {
             if (!isRevealed())
                 void dispatchChord(e);
@@ -333,7 +545,8 @@ export function createEditableLeaf(deps) {
         role: 'textbox',
         spellcheck: 'false',
         oninput: editableSurface.onInput,
-        onkeydown: handleKeydown,
+        onbeforeinput: onBeforeInput,
+        onkeydown: withKeydownVerdict(handleKeydown),
         oncopy: clipboard.onCopy,
         oncut: clipboard.onCut,
         onpaste: clipboard.onPaste,
@@ -373,6 +586,7 @@ export function createEditableLeaf(deps) {
         get sourceText() {
             return sourceText();
         },
+        repaintSource,
         surfaceProps,
         renderProps,
         getPresentationMode,
@@ -403,7 +617,7 @@ export function createEditableLeaf(deps) {
         reveal: (offset = 0) => {
             if (mode !== 'render-primary')
                 return Promise.resolve(surface.focus(offset));
-            return isReading() ? Promise.resolve() : revealKernel.reveal(offset);
+            return isReading() ? Promise.resolve() : revealSource(offset);
         },
         commitSource: (edited) => void commitSource(edited)
     };

package/dist/components/blocks/editable-surface.d.ts

@@ -22,6 +22,12 @@ import type { SelectionState } from '../../selection/selection-state.svelte';
 import { type RawOffset } from '../../cursor/coordinate-spaces';
 import { type CrossBlockHandlers } from '../../selection/cross-block/dispatch';
 import type { SharedKeydownContext } from '../../selection/shared-keydown';
+/**
+ * Binds a surface's keydown handler so the interaction trace records ONE verdict per event,
+ * after the handler's own await chain settles. That record is the e2e harness's only positive
+ * signal that a gesture which must change nothing has finished. Disabled, one boolean read.
+ */
+export declare function withKeydownVerdict(handle: (e: KeyboardEvent) => Promise<void>): (e: KeyboardEvent) => void;
 /**
  * Per-surface cursor I/O in raw-content coordinates (ambient marker excluded).
  * `buildRange` maps a raw-offset span to a DOM Range for selection writes.
@@ -186,6 +192,9 @@ export interface ClipboardSurfaceDeps {
     copyPreHook?: (e: ClipboardEvent) => boolean;
     /** Pre-cross-block cut arm (selected-widget splice, intra-table rect cut). */
     cutPreHook?: (e: ClipboardEvent) => boolean | Promise<boolean>;
+    /** Pre-cross-block paste arm, handed the normalized text while a live rectangle is still
+     *  readable (a grid into a table's cells). True when it consumed the paste. */
+    pastePreHook?: (text: string) => boolean | Promise<boolean>;
     /** The intra-block copy payload; owns its preventDefault. Omit to write the
      *  visible selection string (code, leaf); text and the cell slice their raw. */
     copyTail?: (e: ClipboardEvent) => void;

package/dist/components/blocks/editable-surface.js

@@ -17,9 +17,24 @@ import { createCrossBlockHandlers } from '../../selection/cross-block/dispatch';
 import { writeCrossBlockCopy, writeCrossBlockCut } from '../../selection/cross-block/clipboard';
 import { createImagePasteArm } from '../paste-image-arm';
 import { clampToLandableRaw, revealsNoMarkers } from '../../cursor/widget-offset';
-import { traceCompositionStart, traceCompositionEnd } from '../../debug/interaction-trace';
+import { isInteractionTraceEnabled, traceCompositionEnd, traceCompositionStart, traceKeydownVerdict } from '../../debug/interaction-trace';
 import { assertInvariant } from '../../assert';
 import { checkCompositionEndPaired } from '../../invariants/inline-transitions';
+// ── Keydown verdict ─────────────────────────────────────────────────────────
+/**
+ * Binds a surface's keydown handler so the interaction trace records ONE verdict per event,
+ * after the handler's own await chain settles. That record is the e2e harness's only positive
+ * signal that a gesture which must change nothing has finished. Disabled, one boolean read.
+ */
+export function withKeydownVerdict(handle) {
+    return (e) => {
+        if (!isInteractionTraceEnabled()) {
+            void handle(e);
+            return;
+        }
+        void handle(e).then(() => traceKeydownVerdict(e.key, e.defaultPrevented));
+    };
+}
 /**
  * Guarded pending-caret restore. Applies only while `el` still holds focus, so a blur
  * between arming the restore and the render drops it instead of yanking the global
@@ -92,7 +107,9 @@ export function createEditableSurface(deps) {
         const el = deps.getEl();
         if (!el)
             return;
-        el.focus();
+        // `preventScroll`: seating a caret must not move the page — the reveal path scrolls when a
+        // target is off-screen; an implicit focus scroll jumped the document on every table edit.
+        el.focus({ preventScroll: true });
         if (offset === CURSOR_EXACT_START) {
             deps.backend.setRaw(asRawOffset(0));
             return;
@@ -107,7 +124,7 @@ export function createEditableSurface(deps) {
         const el = deps.getEl();
         if (!el)
             return;
-        el.focus();
+        el.focus({ preventScroll: true });
         const ambientLength = deps.getAmbientLength();
         // minOffset = the walk position of raw 0 keeps the scan out of the marker region.
         const minOffset = toDomTextOffset(asRawOffset(0), ambientLength);
@@ -283,6 +300,8 @@ export function createClipboardHandlers(deps) {
     async function insertPastedText(text, e) {
         const fold = deps.foldReveal?.() ?? null;
         await fold?.settled;
+        if (text && deps.pastePreHook && (await deps.pastePreHook(text)))
+            return;
         if (await deps.crossBlock.handlePaste(e, text))
             return;
         deps.stickyColumn.reset();

package/dist/components/blocks/list/ListItemBlock.svelte

@@ -260,6 +260,7 @@
 <div
 	class="list-item-block"
 	class:reorder-host={dragHandles}
+	class:handle-host={dragHandles}
 	data-task-checked={taskCheckedAttr}
 	data-list-marker={presentationMarkerKind}
 	bind:this={boxEl}
@@ -289,7 +290,7 @@
 		align-items: flex-start;
 	}
 
-	/* Hover reveal is the shared global `.reorder-host` rule in BlockHost; it reveals
+	/* Hover reveal is the shared global `.handle-host` rule in BlockHost; it reveals
 	   only the innermost hovered unit, so a sub-item's hover never lights the parent. */
 
 	.list-item-content {
@@ -318,7 +319,6 @@
 		> :global(.block-list)
 		> :global(.block-host:first-child)
 		> :global(:not(.list-block)) {
-		text-decoration: line-through;
-		color: var(--syntax-task-done, rgba(128, 128, 128, 0.7));
+		color: var(--syntax-task-done, var(--color-text-muted, rgba(128, 128, 128, 0.7)));
 	}
 </style>

package/dist/components/blocks/list/task-checkbox.d.ts

@@ -1,3 +1,5 @@
 import type { AmbientPrefix } from '../../../block-component';
 import type { ListItemMetadata } from '../../../core/nodes';
+/** Matches the `.task-checkbox` slot and gap in editor.css; the two move together. */
+export declare const TASK_HANGING_INDENT = "2.1em";
 export declare function buildTaskItemAmbient(metadata: ListItemMetadata | undefined, onToggle: () => void): AmbientPrefix;

package/dist/components/blocks/list/task-checkbox.js

@@ -1,4 +1,6 @@
 import { devWarn } from '../../../dev-warn';
+/** Matches the `.task-checkbox` slot and gap in editor.css; the two move together. */
+export const TASK_HANGING_INDENT = '2.1em';
 function isTaskMarkerChecked(taskMarker) {
     const c = taskMarker[1];
     return c === 'x' || c === 'X';
@@ -26,8 +28,15 @@ export function buildTaskItemAmbient(metadata, onToggle) {
                 role: 'checkbox',
                 // single source of truth: derive from the keyed marker (in the render memo key), not parallel taskChecked
                 ariaChecked: isTaskMarkerChecked(metadata.taskMarker),
+                // The painted box is taller than the text beside it; the grip centres on the box.
+                dragAnchor: true,
                 onClick: onToggle
-            }
-        ]
+            },
+            // The list marker gets a span of its own so the rendered modes can collapse its width:
+            // GitHub draws the box at the margin, not indented under a bullet that is not there.
+            { start: 0, end: boxStart, className: 'task-list-marker', onClick: () => { } }
+        ],
+        // The painted box (editor.css): slot + gap + the marker's trailing space.
+        indent: TASK_HANGING_INDENT
     };
 }

package/dist/components/blocks/surface-wiring.svelte.d.ts

@@ -5,6 +5,8 @@
  * `createEditableSurface` itself stays context-free (the jsdom harness constructs it bare).
  */
 import { type KindCommandTarget } from '../../schema/block-commands';
+import type { AnyBlockKind } from '../../core/nodes';
+import type { AnyCommandId } from '../../schema/command-id';
 import type { EditableSurfaceDeps } from './editable-surface';
 /** The context-threaded half of `EditableSurfaceDeps` — the fields every surface passes verbatim. */
 export type SharedSurfaceDeps = Pick<EditableSurfaceDeps, 'selection' | 'getDoc' | 'getBlockElByPath' | 'focusActions' | 'getEditorRoot' | 'getScrollHost' | 'getEditorLifetime' | 'stickyColumn' | 'edgeAffinity' | 'blockEdit' | 'controller' | 'history' | 'pluginEditor' | 'getKeybindingOverrides' | 'pasteCoordinator' | 'grammar' | 'activePlugins' | 'events' | 'linkRef' | 'onCommandError' | 'crossBlockCommands'>;
@@ -13,6 +15,8 @@ export interface SurfaceWiring {
     deps: SharedSurfaceDeps;
     /** Resolve a chord at `target` through the shared gates; consumes the event when spent. */
     dispatchChord(e: KeyboardEvent, target: KindCommandTarget): boolean;
+    /** The command a press names at `kind`, overrides included, without running it. */
+    resolveChord(e: KeyboardEvent, kind: AnyBlockKind): AnyCommandId | null;
 }
 export declare function wireSurfaceContexts(): SurfaceWiring;
 export declare function useParkFocusOnUnmount(getEl: () => HTMLElement | null, getEditorRoot: () => HTMLElement | null): void;

package/dist/components/blocks/surface-wiring.svelte.js

@@ -9,6 +9,7 @@ import { BLOCK_EDIT_KEY, EDITOR_DOC_KEY, EDITOR_POLICIES_KEY, EDITOR_SERVICES_KE
 import { emitCommandError } from '../../editor-events';
 import { eventToChord } from '../../schema/keybindings';
 import { dispatchKeyCommand } from '../../schema/block-commands';
+import { resolveBinding } from '../../schema/commands';
 import { parkFocusOnEditorRoot } from '../../selection/native-bridge';
 export function wireSurfaceContexts() {
     const blockEdit = getContext(BLOCK_EDIT_KEY);
@@ -56,7 +57,13 @@ export function wireSurfaceContexts() {
         e.preventDefault();
         return true;
     };
-    return { deps, dispatchChord };
+    const resolveChord = (e, kind) => {
+        const chord = eventToChord(e);
+        if (!chord)
+            return null;
+        return resolveBinding(chord, kind, keybindingOverrides(), activePlugins)?.command ?? null;
+    };
+    return { deps, dispatchChord, resolveChord };
 }
 // Windowed out while focused: hand focus to the editor root so the next keystroke
 // routes through its document-level listener instead of falling to `<body>`.