@voithos-labs/aragonite 0.10.4 → 0.10.7

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

@@ -1,85 +1,82 @@
 <script lang="ts">
 	import { getContext, setContext } from 'svelte';
-	import type {
-		BlockEditActions,
-		ContainerEditActions,
-		FocusActions,
-		ListContext
-	} from '../../../action-contracts';
+	import type { ListContext } from '../../../action-contracts';
 	import type { BlockComponent } from '../../../block-component';
 	import type { NodeView } from '../../../core/node-views';
 	import {
-		BLOCK_EDIT_KEY,
-		CONTAINER_EDIT_KEY,
-		EDITOR_DOC_KEY,
 		EDITOR_POLICIES_KEY,
 		EDITOR_SERVICES_KEY,
-		FOCUS_KEY,
 		LIST_CONTEXT_KEY,
-		type EditorDoc,
 		type EditorPolicies,
 		type EditorServices
 	} from '../../../editor-keys';
 	import { metadataOf } from '../../../core/nodes';
 	import { hidesMarkers } from '../../../presentation-mode';
-	import { displayLength } from '../../../core/lines';
-	import { createBlockListState } from '../../../reactivity/block-list-state.svelte';
 	import { useContainerWindowing } from '../../../reactivity/use-container-windowing.svelte';
+	import { useMeasuredChild } from '../../../reactivity/use-measured-child.svelte';
 	import { useMountGauge } from '../../../perf/use-mount-gauge.svelte';
+	import { createContainerActions } from '../../../editor-actions/nested/container-actions';
+	import { createListItemOverrides } from '../../../editor-actions/list-overrides';
 	import {
-		createStandardNestedActions,
-		setNestedActionsContexts,
-		type NodeScope
-	} from '../../../editor-actions/nested/nested-actions';
-	import { createContainerBlockComponent } from '../../../editor-actions/container-block-component';
+		createContainerBlockComponent,
+		dispatchContainerChord
+	} from '../../../editor-actions/container-block-component';
 	import { buildTaskItemAmbient } from './task-checkbox';
 	import BlockList from '../../BlockList.svelte';
 	import { publishRefSlot, type RefSlots } from '../../../reactivity/publish-ref.svelte';
-	import { eventToChord } from '../../../schema/keybindings';
-	import { dispatchKindCommand } from '../../../schema/block-commands';
+	import type { ChildList } from '../../../reactivity/child-list';
 	import type { AnyCommandId } from '../../../schema/command-id';
 	import BlockDragHandle from '../../BlockDragHandle.svelte';
+	import SelectionOverlay from '../../SelectionOverlay.svelte';
 	import { showsListItemDragHandle } from '../../drag-handle';
+	import { useBlockDecorations } from '../../../decorations/use-block-decorations.svelte';
 
 	let {
 		node,
 		index,
+		id,
 		myPath = [],
 		itemCount,
 		slots
 	}: {
 		node: NodeView;
 		index: number;
+		id: string;
 		myPath?: number[];
 		/** How many items the enclosing list holds; a lone item has no sibling to reorder past. */
 		itemCount: number;
 		slots?: RefSlots<BlockComponent>;
 	} = $props();
 
-	const parentBlockEdit = getContext<BlockEditActions>(BLOCK_EDIT_KEY);
-	const parentFocus = getContext<FocusActions>(FOCUS_KEY);
-	const parentContainerEdit = getContext<ContainerEditActions>(CONTAINER_EDIT_KEY);
-	const { stickyColumn, selection, registryView } = getContext<EditorServices>(EDITOR_SERVICES_KEY);
-	const {
-		keybindingOverrides,
-		blockDragHandles: getDragHandles,
-		presentationMode: getPresentationMode
-	} = getContext<EditorPolicies>(EDITOR_POLICIES_KEY);
-	const linkRef = getContext<EditorDoc | undefined>(EDITOR_DOC_KEY)?.linkRef;
+	const { selection, decorations, events, commands } =
+		getContext<EditorServices>(EDITOR_SERVICES_KEY);
+	const { blockDragHandles: getDragHandles } = getContext<EditorPolicies>(EDITOR_POLICIES_KEY);
 
 	const listContext = getContext<ListContext>(LIST_CONTEXT_KEY);
+	const {
+		state: listState,
+		parent: { blockEdit: parentBlockEdit },
+		reading
+	} = createContainerActions({
+		getNode: () => node,
+		getIndex: () => index,
+		getPath: () => myPath,
+		// The enclosing list's context, not the wrapped one this item provides.
+		overrides: ({ scope }) => createListItemOverrides({ scope, listContext }),
+		childList: () => childList
+	});
+
 	// $derived, not a mount-time snapshot: a runtime prop toggle must reach blocks
 	// that window in and out after the change, not just those mounted at mount.
-	const dragHandles = $derived(getDragHandles?.() ?? false);
-	// The grip is the only pointer road into a reorder, and a reorder needs a sibling: a lone
-	// item stays a reorder host (a dragged sibling never arrives, but the class costs nothing)
-	// and simply shows nothing to grab.
+	const dragHandles = $derived(getDragHandles());
+	// A reorder needs a sibling, so a lone item shows no handle; it stays a reorder host, which
+	// costs nothing, since a dragged sibling never arrives.
 	const showsHandle = $derived(showsListItemDragHandle(itemCount, dragHandles));
-	const presentationMode = $derived(getPresentationMode?.() ?? 'source');
+	const presentationMode = $derived(reading.mode());
 	const readOnly = $derived(presentationMode === 'reading');
 
-	// The marker-hiding CSS tells bullet/ordered/task apart through this hook and the ambient
-	// span carries no such class. Absent in source, so that DOM stays byte-identical.
+	// The marker-hiding CSS tells a bullet from a number from a checkbox through this attribute,
+	// since the marker span carries no such class. Absent in source, so that DOM is unchanged.
 	const presentationMarkerKind = $derived.by(() => {
 		if (!hidesMarkers(presentationMode)) return undefined;
 		const meta = metadataOf(node, 'listItem');
@@ -87,27 +84,34 @@
 		return /^\d/.test(meta?.marker ?? '-') ? 'ordered' : 'bullet';
 	});
 
-	// Wrap getContainingItemIndex so a nested ListBlock inside this item sees
-	// this item's index in the outer list — the coordinate promoteNestedItem needs.
+	// Wrap `getContainingItemIndex` so a nested ListBlock inside this item sees this
+	// item's index in the outer list, which is what `promoteNestedItem` needs.
 	const wrappedListContext: ListContext = {
 		...listContext,
 		getContainingItemIndex: () => index
 	};
 	setContext(LIST_CONTEXT_KEY, wrappedListContext);
 
-	const listState = createBlockListState(() => node);
-
 	let boxEl: HTMLElement | undefined = $state();
 	let contentEl: HTMLElement | undefined = $state();
 
 	useMountGauge();
 
-	function toggleTask(): void {
+	// The item renders no block host, so its own box carries the decorations addressed to it.
+	const blockDecorations = useBlockDecorations({
+		getPath: () => myPath,
+		getEl: () => boxEl ?? null,
+		engine: decorations,
+		onRenderError: (error) => events.emit('error', error)
+	});
+
+	// False on a plain item, so the chord that asked falls through.
+	function toggleTask(): boolean {
 		// Reading mode keeps checkboxes visible but inert: a toggle rewrites the
 		// document, and reading mode writes no bytes.
-		if (readOnly) return;
+		if (readOnly) return false;
 		const meta = metadataOf(node, 'listItem');
-		if (!meta?.taskItem) return;
+		if (!meta?.taskItem) return false;
 
 		if (selection?.isCrossBlock) {
 			selection.clear();
@@ -119,6 +123,7 @@
 			taskChecked: nextChecked,
 			taskMarker: nextMarker
 		});
+		return true;
 	}
 
 	const taskCheckedAttr = $derived.by(() => {
@@ -127,95 +132,43 @@
 		return meta.taskChecked ? 'true' : 'false';
 	});
 
-	const scope: NodeScope = {
-		get index() {
-			return index;
-		},
-		get node() {
-			return node;
-		},
-		get path() {
-			return myPath;
-		}
-	};
-
-	const bundle = createStandardNestedActions(
-		listState,
-		{
-			scope,
-			stickyColumn,
-			grammar: registryView.grammar,
-			getPresentationMode,
-			linkRef,
-			parent: {
-				blockEdit: parentBlockEdit,
-				focus: parentFocus,
-				containerEdit: parentContainerEdit
-			}
-		},
-		() => ({
-			blockEdit: {
-				splitBlock: async (innerIndex: number, offset: number): Promise<void> => {
-					if (!node.children) return;
-
-					// Enter-empty. Deliberately shallower than isItemUserEmpty — trailing
-					// structural children stay until exitListAtItem relocates them.
-					const firstChild = node.children[0];
-					const isEmptyItem = firstChild?.kind === 'paragraph' && firstChild.raw.trim() === '';
-					if (isEmptyItem) {
-						await listContext.exitListAtItem(index);
-						return;
-					}
-
-					const lastChild = node.children[node.children.length - 1];
-					const isAtEnd =
-						innerIndex === node.children.length - 1 && offset >= displayLength(lastChild.raw);
-
-					if (isAtEnd) {
-						await listContext.insertItemAfter(index);
-						return;
-					}
-
-					await listContext.splitItemAtOffset(index, innerIndex, offset);
-				}
-				// mergeWithPrevious at innerIndex <= 0 is the factory default — no override needed.
-			}
-		})
-	);
-
-	setNestedActionsContexts(bundle);
-
 	// ── Virtual rendering (nested windowing) ────────────────────────────
 
+	// An item renders no block host, so its own box is what the list measures. Before this item
+	// provides its own list below, whose channel would otherwise answer.
+	useMeasuredChild({
+		getId: () => id,
+		getPath: () => myPath,
+		getEl: () => boxEl ?? null,
+		getRaw: () => node.raw
+	});
+
 	const windowing = useContainerWindowing({
-		getIndex: () => index,
 		getParentPath: () => myPath,
 		getChildren: () => node.children ?? [],
 		getChildIds: () => listState.innerBlockIds,
-		// .block-list is a direct child of .list-item-content, reached through contentEl.
-		getListEl: () => contentEl?.querySelector(':scope > .block-list') ?? null,
-		// An item is NOT wrapped in a BlockHost; its own .list-item-block box is what the
-		// parent ListBlock's item-indexed sink expects (no competing leaf channel).
-		getOwnEl: () => boxEl ?? null,
-		provideLeafChannel: true
+		// .block-list is a direct child of .list-item-content, reached through `contentEl`.
+		getListEl: () => contentEl?.querySelector(':scope > .block-list') ?? null
 	});
 
+	const childList: ChildList = {
+		count: () => node.children?.length ?? 0,
+		refs: listState.refSlots,
+		windowing
+	};
+
 	// ── BlockComponent interface ────────────────────────────────────────
 
 	export const containerApi = createContainerBlockComponent({
 		selection,
+		reading,
 		get innerBlockRefs() {
 			return listState.innerBlockRefs;
 		},
-		refSlots: listState.refSlots,
-		get nodeChildrenLength() {
-			return node.children?.length ?? 0;
-		},
+		childList,
 		get node() {
 			return node;
-		},
-		revealChild: windowing.revealChild,
-		isInWindow: windowing.isInWindow
+		}
 	});
 
 	$effect(() => {
@@ -225,8 +178,8 @@
 
 	// ── Commands ────────────────────────────────────────────────────────
 
-	// Not on the BlockComponent surface (the published ref is containerApi, not
-	// this instance); the bubble handler below closes over it directly.
+	// Not part of the BlockComponent interface, since the registered reference is
+	// `containerApi` rather than this instance; the handler below closes over it.
 	function runCommand(id: AnyCommandId): boolean {
 		switch (id) {
 			case 'list.indent':
@@ -235,40 +188,31 @@
 			case 'list.unindent':
 				listContext.unindentItem(index);
 				return true;
+			case 'list.toggleTask':
+				return toggleTask();
 			default:
 				return false;
 		}
 	}
 
-	// Tab/Shift+Tab bubble here from the inner paragraph, whose block.insertTab declines
-	// without preventDefault. Dispatch is kind-only: the contenteditable's async handler
-	// preventDefaults only after an await, so a global tier here would re-fire undo/redo.
+	// Tab, Shift+Tab and Mod+Enter bubble up from the inner paragraph. Only kind commands run here:
+	// the paragraph has already dispatched the global ones, so undo would otherwise fire twice.
 	function handleKeydown(e: KeyboardEvent): void {
-		if (e.defaultPrevented) return;
-		const chord = eventToChord(e);
-		if (!chord) return;
-		if (
-			dispatchKindCommand(
-				chord,
-				{ kind: node.kind, runCommand },
-				{
-					getPresentationMode,
-					isCrossBlockRange: () => selection?.isCrossBlock ?? false,
-					// A container bubble carries no range command: the leaf below it owns the format ids.
-					crossBlockCommands: undefined
-				},
-				keybindingOverrides()
-			)
-		) {
-			e.preventDefault();
-		}
+		// A key a nested item declined is still that item's: the task toggle must not reach the
+		// task it sits in.
+		if (!(e.target instanceof Element) || e.target.closest('.list-item-block') !== boxEl) return;
+		dispatchContainerChord(e, { kind: node.kind, runCommand }, commands);
 	}
 </script>
 
+<!-- No `data-block-path` on the item box: a lookup by that attribute treats the match as a
+	 block host, and the item renders none. -->
 <div
-	class="list-item-block"
-	class:reorder-host={dragHandles}
-	class:handle-host={showsHandle}
+	class={[
+		'list-item-block',
+		{ 'reorder-host': dragHandles, 'handle-host': showsHandle },
+		...blockDecorations.classes
+	]}
 	data-task-checked={taskCheckedAttr}
 	data-list-marker={presentationMarkerKind}
 	bind:this={boxEl}
@@ -284,9 +228,11 @@
 			ambientPrefixForFirst={buildTaskItemAmbient(metadataOf(node, 'listItem'), toggleTask)}
 		/>
 	</div>
-	<!-- A list item IS a reorder unit; its inner content BlockList passes the
-		 default reorderable={false}, so the paragraph inside gets no handle. A lone item
-		 renders none either: its drag is list-scoped and there is no sibling to pass. -->
+	<!-- The item paints its own selection box: it renders no BlockHost, so a range that
+		 holds it whole has nothing else to draw one over its marker and its content. -->
+	<SelectionOverlay path={myPath} delegatesPainting />
+	<!-- A list item is the reorder unit, so its inner BlockList keeps `reorderable={false}` and
+		 the paragraph inside gets no handle; a lone item shows none either. -->
 	{#if showsHandle}
 		<BlockDragHandle />
 	{/if}
@@ -299,7 +245,7 @@
 		align-items: flex-start;
 	}
 
-	/* Hover reveal is the shared global `.handle-host` rule in BlockHost; it reveals
+	/* Showing it on hover is the shared `.handle-host` rule in BlockHost; it shows
 	   only the innermost hovered unit, so a sub-item's hover never lights the parent. */
 
 	.list-item-content {
@@ -328,6 +274,6 @@
 		> :global(.block-list)
 		> :global(.block-host:first-child)
 		> :global(:not(.list-block)) {
-		color: var(--syntax-task-done, var(--color-text-muted, rgba(128, 128, 128, 0.7)));
+		color: var(--syntax-task-done, #8f8f89);
 	}
 </style>

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

@@ -4,6 +4,7 @@ import { type RefSlots } from '../../../reactivity/publish-ref.svelte';
 type $$ComponentProps = {
     node: NodeView;
     index: number;
+    id: string;
     myPath?: number[];
     /** How many items the enclosing list holds; a lone item has no sibling to reorder past. */
     itemCount: number;

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

@@ -1,5 +1,8 @@
 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";
+/** Matches the `.task-checkbox` width and gap in editor.css, which sets `--md-task-indent` to
+ *  follow the drawn marker in each mode; the fallback is the width source mode draws. */
+export declare const TASK_HANGING_INDENT = "var(--md-task-indent, 2.1em)";
+/** Whether a block's container marker prefix draws a task box, making the block the to-do's text. */
+export declare function ambientHoldsTaskBox(prefix: AmbientPrefix): boolean;
 export declare function buildTaskItemAmbient(metadata: ListItemMetadata | undefined, onToggle: () => void): AmbientPrefix;

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

@@ -1,15 +1,20 @@
 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';
+/** Matches the `.task-checkbox` width and gap in editor.css, which sets `--md-task-indent` to
+ *  follow the drawn marker in each mode; the fallback is the width source mode draws. */
+export const TASK_HANGING_INDENT = 'var(--md-task-indent, 2.1em)';
 function isTaskMarkerChecked(taskMarker) {
     const c = taskMarker[1];
     return c === 'x' || c === 'X';
 }
+/** Whether a block's container marker prefix draws a task box, making the block the to-do's text. */
+export function ambientHoldsTaskBox(prefix) {
+    return typeof prefix !== 'string' && !!prefix.interactive?.some((r) => r.role === 'checkbox');
+}
 export function buildTaskItemAmbient(metadata, onToggle) {
     const listMarker = metadata?.marker ?? '- ';
     const taskMarkerPresent = metadata?.taskMarker != null;
     if (metadata && metadata.taskItem !== taskMarkerPresent) {
-        devWarn('ListItemBlock', 'taskItem / taskMarker inconsistent — rendering as plain list item', {
+        devWarn('ListItemBlock', 'taskItem / taskMarker inconsistent, rendering as plain list item', {
             taskItem: metadata.taskItem,
             taskMarker: metadata.taskMarker
         });
@@ -26,17 +31,17 @@ export function buildTaskItemAmbient(metadata, onToggle) {
                 end: boxStart + 3,
                 className: 'task-checkbox',
                 role: 'checkbox',
-                // single source of truth: derive from the keyed marker (in the render memo key), not parallel taskChecked
+                // Read from the marker already in the render key, not a second checked field.
                 ariaChecked: isTaskMarkerChecked(metadata.taskMarker),
-                // The painted box is taller than the text beside it; the grip centres on the box.
+                // The drawn box is taller than the text beside it, so it 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:
+            // The list marker gets a span of its own so the rendered modes can collapse it:
             // 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.
+        // The drawn box (editor.css): its width, the gap, and the marker's trailing space.
         indent: TASK_HANGING_INDENT
     };
 }

package/dist/components/blocks/plain-text-backend.d.ts

@@ -1,21 +1,5 @@
-/**
- * The zero-ambient, widget-free surface backend shared by CodeBlock and the
- * `editable-leaf` seam: with no ambient marker and no inline widgets, DOM-text space
- * IS raw space, so the brand mint happens once here rather than at each surface.
- * Surfaces with an ambient marker (TextEditableBlock) use the ambient IO instead.
- */
-import type { CursorBackend } from './editable-surface';
-import { type RawOffset } from '../../cursor/coordinate-spaces';
-export interface ContentOffsetBackend {
-    backend: CursorBackend;
-    getFocusOffset: () => RawOffset | null;
-    getTextLen: () => number;
-    readText: () => string;
-}
-export declare function createContentOffsetBackend(getEl: () => HTMLElement | null): ContentOffsetBackend;
-/**
- * Chromium with `white-space: pre` won't paint a caret on the line after a trailing
- * `\n` unless something follows it. A `<br>` anchors it without touching `textContent`
- * (BR has empty textContent, so `textContent === trimTrailingLineEnding(raw)` holds).
- */
+/** Chromium with `white-space: pre` paints no caret on the line after a trailing `\n` unless
+ *  something follows; a `<br>` anchors it without touching `textContent`. */
 export declare function anchorTrailingNewline(el: HTMLElement): void;
+/** The DOM text of a block whose text is its raw. */
+export declare function plainTextOf(el: HTMLElement | null | undefined): string;

package/dist/components/blocks/plain-text-backend.js

@@ -1,47 +1,13 @@
-/**
- * The zero-ambient, widget-free surface backend shared by CodeBlock and the
- * `editable-leaf` seam: with no ambient marker and no inline widgets, DOM-text space
- * IS raw space, so the brand mint happens once here rather than at each surface.
- * Surfaces with an ambient marker (TextEditableBlock) use the ambient IO instead.
- */
-import { asDomTextOffset, asRawOffset } from '../../cursor/coordinate-spaces';
-import { createRangeFromOffsets, setCursorOffset, getCursorOffset, getSelectionFocusOffset } from '../../cursor/content-offsets';
-export function createContentOffsetBackend(getEl) {
-    return {
-        backend: {
-            getRaw: () => {
-                const el = getEl();
-                const offset = el ? getCursorOffset(el) : null;
-                return offset === null ? null : asRawOffset(offset);
-            },
-            setRaw: (offset) => {
-                const el = getEl();
-                if (el)
-                    setCursorOffset(el, asDomTextOffset(offset));
-            },
-            buildRange: (start, end) => {
-                const el = getEl();
-                return el ? createRangeFromOffsets(el, asDomTextOffset(start), asDomTextOffset(end)) : null;
-            }
-        },
-        getFocusOffset: () => {
-            const el = getEl();
-            const offset = el ? getSelectionFocusOffset(el) : null;
-            return offset === null ? null : asRawOffset(offset);
-        },
-        getTextLen: () => (getEl()?.textContent ?? '').length,
-        readText: () => getEl()?.textContent ?? ''
-    };
-}
-/**
- * Chromium with `white-space: pre` won't paint a caret on the line after a trailing
- * `\n` unless something follows it. A `<br>` anchors it without touching `textContent`
- * (BR has empty textContent, so `textContent === trimTrailingLineEnding(raw)` holds).
- */
+// Helpers for the blocks whose DOM text is their raw: a code block and a plugin leaf.
+import { createCaretAnchor } from '../../cursor/widget-offset';
+/** Chromium with `white-space: pre` paints no caret on the line after a trailing `\n` unless
+ *  something follows; a `<br>` anchors it without touching `textContent`. */
 export function anchorTrailingNewline(el) {
     if (!el.textContent?.endsWith('\n'))
         return;
-    const anchor = document.createElement('br');
-    anchor.dataset.caretAnchor = '';
-    el.appendChild(anchor);
+    el.appendChild(createCaretAnchor());
+}
+/** The DOM text of a block whose text is its raw. */
+export function plainTextOf(el) {
+    return el?.textContent ?? '';
 }

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

@@ -1,21 +1,20 @@
 /**
- * The context wiring every editable-block component threads identically: one init-time bundle
- * of the shared `EditableSurfaceDeps` fields, plus chord dispatch built over the same gates and
- * the shared focus-park teardown. Call during component init — `getContext` requires it, and
- * `createEditableSurface` itself stays context-free (the jsdom harness constructs it bare).
+ * The context wiring every editable-block component shares: the common `EditableSurfaceDeps`
+ * fields, chord dispatch through the editor's command context, and the focus-away teardown.
+ * Call it during component init, since it reads `getContext`.
  */
 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'>;
+/** The context half of `EditableSurfaceDeps`: the fields every block passes through unchanged. */
+export type SharedSurfaceDeps = Pick<EditableSurfaceDeps, 'selection' | 'getDoc' | 'getBlockElByPath' | 'focusActions' | 'caretLanding' | 'getEditorRoot' | 'getScrollHost' | 'scrollOwner' | 'getEditorLifetime' | 'caretMemory' | 'blockEdit' | 'controller' | 'history' | 'pasteCoordinator' | 'activePlugins' | 'events' | 'selectedWidget' | 'reading' | 'commands'>;
 export interface SurfaceWiring {
-    /** Spread first into `createEditableSurface`; per-surface fields follow and may override. */
+    /** Spread first into `createEditableSurface`; per-block fields follow and may override. */
     deps: SharedSurfaceDeps;
-    /** Resolve a chord at `target` through the shared gates; consumes the event when spent. */
+    /** Resolve a chord at `target` through the editor's command context; consumes a handled event. */
     dispatchChord(e: KeyboardEvent, target: KindCommandTarget): boolean;
-    /** The command a press names at `kind`, overrides included, without running it. */
+    /** The command a keypress names at `kind`, overrides included, without running it. */
     resolveChord(e: KeyboardEvent, kind: AnyBlockKind): AnyCommandId | null;
 }
 export declare function wireSurfaceContexts(): SurfaceWiring;

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

@@ -1,68 +1,49 @@
 /**
- * The context wiring every editable-block component threads identically: one init-time bundle
- * of the shared `EditableSurfaceDeps` fields, plus chord dispatch built over the same gates and
- * the shared focus-park teardown. Call during component init — `getContext` requires it, and
- * `createEditableSurface` itself stays context-free (the jsdom harness constructs it bare).
+ * The context wiring every editable-block component shares: the common `EditableSurfaceDeps`
+ * fields, chord dispatch through the editor's command context, and the focus-away teardown.
+ * Call it during component init, since it reads `getContext`.
  */
 import { getContext } from 'svelte';
-import { BLOCK_EDIT_KEY, EDITOR_DOC_KEY, EDITOR_POLICIES_KEY, EDITOR_SERVICES_KEY, FOCUS_KEY, HISTORY_KEY } from '../../editor-keys';
-import { emitCommandError } from '../../editor-events';
+import { BLOCK_EDIT_KEY, EDITOR_DOC_KEY, EDITOR_SERVICES_KEY, FOCUS_KEY, HISTORY_KEY } from '../../editor-keys';
 import { eventToChord } from '../../schema/keybindings';
 import { dispatchKeyCommand } from '../../schema/block-commands';
-import { resolveBinding } from '../../schema/commands';
+import { commandForKey } from '../../schema/commands';
 import { parkFocusOnEditorRoot } from '../../selection/native-bridge';
 export function wireSurfaceContexts() {
     const blockEdit = getContext(BLOCK_EDIT_KEY);
     const focusActions = getContext(FOCUS_KEY);
     const history = getContext(HISTORY_KEY);
-    const { controller, pasteCoordinator, stickyColumn, edgeAffinity, selection, registryView, activePlugins, events, crossBlockCommands } = getContext(EDITOR_SERVICES_KEY);
-    const { keybindingOverrides, presentationMode: getPresentationMode } = getContext(EDITOR_POLICIES_KEY);
-    const { blockElLookup: getBlockElByPath, doc: getDoc, editorRoot: getEditorRoot, scrollHost: getScrollHost, lifetime: editorLifetime, pluginEditor, linkRef } = getContext(EDITOR_DOC_KEY);
+    const { controller, caretLanding, pasteCoordinator, caretMemory, selection, activePlugins, events, commands, selectedWidget, scrollOwner } = getContext(EDITOR_SERVICES_KEY);
+    const { blockElLookup: getBlockElByPath, doc: getDoc, editorRoot: getEditorRoot, scrollHost: getScrollHost, lifetime: editorLifetime, reading } = getContext(EDITOR_DOC_KEY);
     const deps = {
         selection,
         getDoc,
         getBlockElByPath,
         focusActions,
+        caretLanding,
         getEditorRoot,
         getScrollHost,
+        scrollOwner,
         getEditorLifetime: () => editorLifetime ?? null,
-        stickyColumn,
-        edgeAffinity,
+        caretMemory,
         blockEdit,
         controller,
         history,
-        pluginEditor,
-        getKeybindingOverrides: keybindingOverrides,
         pasteCoordinator,
-        grammar: registryView.grammar,
         activePlugins,
         events,
-        linkRef,
-        crossBlockCommands,
-        onCommandError: (report) => emitCommandError(events, report)
+        selectedWidget,
+        reading,
+        commands
     };
     const dispatchChord = (e, target) => {
         const chord = eventToChord(e);
-        if (!chord ||
-            !dispatchKeyCommand(chord, target, {
-                history,
-                pluginEditor,
-                activation: activePlugins,
-                getPresentationMode,
-                isCrossBlockRange: () => selection.isCrossBlock,
-                crossBlockCommands: crossBlockCommands
-            }, keybindingOverrides(), deps.onCommandError)) {
+        if (!chord || !dispatchKeyCommand(chord, target, commands))
             return false;
-        }
         e.preventDefault();
         return true;
     };
-    const resolveChord = (e, kind) => {
-        const chord = eventToChord(e);
-        if (!chord)
-            return null;
-        return resolveBinding(chord, kind, keybindingOverrides(), activePlugins)?.command ?? null;
-    };
+    const resolveChord = (e, kind) => commandForKey(e, kind, commands);
     return { deps, dispatchChord, resolveChord };
 }
 // Windowed out while focused: hand focus to the editor root so the next keystroke