@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/components/Editor.svelte.d.ts

@@ -1,13 +1,15 @@
 import '../styles/editor.css';
-import type { BlockComponent } from '../block-component';
-import type { AnyBlockKind, Document } from '../core/nodes';
-import type { EditorProps, EditorDiagnostics } from '../editor-props';
+import type { AnyBlockKind } from '../core/nodes';
+import type { EditorProps, EditorDiagnostics, InsertMarkdownOptions } from '../editor-props';
 import type { EditorEvents } from '../editor-events';
 import type { EditorSelection } from '../selection/primitives';
 import { type SearchState } from '../search/search-state.svelte';
 import type { DecorationRegistry } from '../decorations/types';
 import { type EditorRects } from '../editor-rects';
+import type { EditorTestSurface } from './editor-root-test-surface';
+import { type InsertEntry } from '../schema/insert-catalogue';
 import { type KindEnablement } from '../schema/registry-view';
+import type { InlineMenuRegistry } from '../inline-menu/types';
 type $$ComponentProps = EditorProps & {
     __registryEnablement?: KindEnablement;
 };
@@ -17,33 +19,20 @@ declare const Editor: import("svelte").Component<$$ComponentProps, {
     getSelection: () => EditorSelection | null;
     setSelection: (selection: EditorSelection) => Promise<boolean>;
     placeCaretAtPoint: (x: number, y: number) => boolean;
-    insertMarkdown: (md: string) => boolean;
+    insertMarkdown: (md: string, options?: InsertMarkdownOptions) => Promise<boolean>;
     runCommand: (commandId: string, arg?: unknown) => boolean;
     canRunCommand: (commandId: string) => boolean;
     isCommandActive: (commandId: string) => boolean;
     getEvents: () => EditorEvents;
     getSearch: () => SearchState;
     getDecorations: () => DecorationRegistry;
+    getInlineMenus: () => InlineMenuRegistry;
+    getInsertCatalogue: () => readonly InsertEntry[];
     getRects: () => EditorRects;
     reservedChords: () => ReadonlySet<string>;
     claimsChord: (event: KeyboardEvent) => boolean;
     getDiagnostics: () => EditorDiagnostics;
-    __test: {
-        getDocument: () => Document;
-        getContentVersion: () => number;
-        getBlockComponent: (path: number[]) => BlockComponent | null;
-        getUndoStack: () => {
-            undo: import("../undo/types").UndoEntry[];
-            redo: import("../undo/types").UndoEntry[];
-        };
-        getOperationsLog: () => import("../debug/operations-log").OperationsLog;
-        isCrossBlockActive: () => boolean;
-        getGapCaret: () => import("../selection/gap-caret").GapCaretPosition | null;
-        getDecorationEngine: () => import("../decorations/decoration-state.svelte").DecorationEngine;
-        getHeightOracle: () => import("../cursor/height-oracle").HeightOracle;
-        getWidthVersion: () => number;
-        setBlockRefSlot: (index: number, ref: BlockComponent | undefined) => void;
-    };
+    __test: EditorTestSurface;
 }, "">;
 type Editor = ReturnType<typeof Editor>;
 export default Editor;

package/dist/components/GapCaret.svelte

@@ -1,23 +1,21 @@
 <script lang="ts">
 	/**
-	 * The between-blocks caret's own surface: a zero-height proxy that takes DOM focus while the
-	 * gap is live. It lives in the BlockList, outside every block's surface, so it contributes
-	 * nothing to any block's textContent walk. Text and Enter mint a paragraph at the boundary;
-	 * every other input is refused at `beforeinput`.
+	 * The between-blocks caret: a zero-height stand-in element that takes DOM focus while the
+	 * gap is live. It lives in the BlockList, outside every block, so it adds nothing to any
+	 * block's text content. Text and Enter create a paragraph at the boundary; every other
+	 * input is refused at `beforeinput`.
 	 */
 	import { getContext } from 'svelte';
-	import type { BlockEditActions, FocusActions, HistoryActions } from '../action-contracts';
+	import type { BlockEditActions, FocusActions } from '../action-contracts';
 	import { GAP_CARET_LABEL } from '../a11y-strings';
 	import {
 		EDITOR_DOC_KEY,
 		EDITOR_POLICIES_KEY,
 		EDITOR_SERVICES_KEY,
-		HISTORY_KEY,
 		type EditorDoc,
 		type EditorPolicies,
 		type EditorServices
 	} from '../editor-keys';
-	import { emitCommandError } from '../editor-events';
 	import { runGlobalChord } from '../schema/commands';
 	import { eventToChord } from '../schema/keybindings';
 	import { isReadingMode } from '../presentation-mode';
@@ -32,21 +30,20 @@
 		blockEdit: BlockEditActions | undefined;
 	} = $props();
 
-	// Root-provided facets, read here rather than threaded through BlockList: only the
-	// scope-local action bundles depend on where this list sits.
+	// Provided by the root and read here rather than passed through BlockList: only the
+	// two action bundles above depend on where this list sits.
 	const services = getContext<EditorServices | undefined>(EDITOR_SERVICES_KEY);
 	const selection = services?.selection;
-	const policies = getContext<EditorPolicies | undefined>(EDITOR_POLICIES_KEY);
+	const policies = getContext<EditorPolicies>(EDITOR_POLICIES_KEY);
 	const editorDoc = getContext<EditorDoc | undefined>(EDITOR_DOC_KEY);
-	const history = getContext<HistoryActions | undefined>(HISTORY_KEY);
 
 	let proxyEl: HTMLElement | undefined = $state();
 	let composing = false;
 
-	const isReading = $derived(isReadingMode(policies?.presentationMode));
+	const isReading = $derived(isReadingMode(policies.presentationMode));
 
-	// Rendering, not sequencing: the component exists only while it IS the live gap.
-	// Focusing the contenteditable seats a caret in it (Chromium); no manual range needed.
+	// Mounted only while the gap is live; focusing the contenteditable gives it a caret, so no
+	// range is set by hand.
 	$effect(() => {
 		if (!proxyEl) return;
 		proxyEl.focus();
@@ -63,48 +60,22 @@
 		void focusActions?.moveFocus(index - 1, 'end', EXIT);
 	}
 
-	/** The mint's own `afterTick` focuses the new block, and that door ends the gap. */
+	/** `insertParagraph`'s own landing focuses the new block, and that focus ends the gap. */
 	function mint(text: string): void {
 		void blockEdit?.insertParagraph(index, text);
 	}
 
-	/**
-	 * Undo/redo and plugin globals resolve HERE, at the target: no block holds focus, and the
-	 * root's own arm answers only a caret with no focused element at all. Reading mode still
-	 * consumes the chord, or the browser's native history runs on the proxy.
-	 */
-	function handleGlobalChord(
-		event: KeyboardEvent,
-		deps: {
-			history: HistoryActions;
-			doc: EditorDoc;
-			events: EditorServices['events'];
-			activation: EditorServices['activePlugins'];
-		}
-	): boolean {
+	/** Undo, redo and plugin-global chords run here, since no block has focus and the root answers
+	 *  only an unfocused caret; reading mode takes them too, so the browser's undo never runs. */
+	function handleGlobalChord(event: KeyboardEvent): boolean {
 		const chord = eventToChord(event);
-		if (!chord) return false;
-		const consumed = runGlobalChord(chord, policies?.keybindingOverrides(), {
-			isReading,
-			history: deps.history,
-			pluginEditor: deps.doc.pluginEditor,
-			activation: deps.activation,
-			onCommandError: (report) => emitCommandError(deps.events, report)
-		});
-		if (consumed) event.preventDefault();
-		return consumed;
+		if (!chord || !services || !runGlobalChord(chord, services.commands)) return false;
+		event.preventDefault();
+		return true;
 	}
 
 	function onKeyDown(event: KeyboardEvent): void {
-		if (history && editorDoc && services) {
-			const deps = {
-				history,
-				doc: editorDoc,
-				events: services.events,
-				activation: services.activePlugins
-			};
-			if (handleGlobalChord(event, deps)) return;
-		}
+		if (handleGlobalChord(event)) return;
 		// Any other modified chord belongs to whatever the root or the host does with it.
 		if (event.ctrlKey || event.metaKey || event.altKey) return;
 		switch (event.key) {
@@ -130,8 +101,8 @@
 	}
 
 	function onBeforeInput(event: InputEvent): void {
-		// The browser owns the proxy between compositionstart and compositionend (the editor's
-		// standing IME stance) — refusing here swallows the composition.
+		// The browser owns this element between compositionstart and compositionend, as it does
+		// everywhere in the editor: refusing here would swallow the composition.
 		if (composing) return;
 		event.preventDefault();
 		if (event.inputType === 'insertText' && event.data) mint(event.data);
@@ -140,8 +111,8 @@
 	function onCompositionEnd(): void {
 		composing = false;
 		const composed = proxyEl?.textContent ?? '';
-		// The proxy is a caret host, never a surface a serializer reads: whatever the IME left
-		// belongs to the minted paragraph, and the proxy goes back to empty either way.
+		// This element only holds a caret; nothing serializes it. Whatever the IME left belongs
+		// to the new paragraph, and the element goes back to empty either way.
 		if (proxyEl) proxyEl.textContent = '';
 		if (composed) mint(composed);
 	}
@@ -149,7 +120,7 @@
 	function onFocusOut(event: FocusEvent): void {
 		const next = event.relatedTarget;
 		// A null relatedTarget is the window losing focus, which a native caret survives too.
-		// Anything landing inside the editor claimed the caret through a door of its own.
+		// Anything focused inside the editor took the caret by its own route.
 		if (next === null) return;
 		if (next instanceof Node && editorDoc?.editorRoot()?.contains(next)) return;
 		selection?.clearGapCaret();
@@ -194,12 +165,8 @@
 		pointer-events: none;
 		animation: gap-caret-blink 1s step-end infinite;
 	}
-	/**
-	 * Absolutely positioned, so the zero-height wrapper keeps the boundary's layout, and a
-	 * REAL box: Chromium fires no `beforeinput` on a zero-height editing host, which silently
-	 * costs the proxy every keystroke. Click-through, or the band would steal edge clicks
-	 * from both neighbours; the painted line is the caret, so this one never shows.
-	 */
+	/* A real box, since Chromium fires no `beforeinput` on a zero-height editing host;
+	   click-through, so it steals no edge clicks from either neighbour. */
 	.gap-caret-proxy {
 		position: absolute;
 		top: -0.6em;

package/dist/components/SelectionOverlay.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
 	import { getContext } from 'svelte';
-	import { SELECTION_END, type BlockComponent } from '../block-component';
+	import type { BlockComponent } from '../block-component';
 	import {
 		EDITOR_DOC_KEY,
 		EDITOR_SERVICES_KEY,
@@ -8,14 +8,10 @@
 		type EditorServices
 	} from '../editor-keys';
 	import {
-		normalize,
+		blockPaintsWholeBox,
 		classifyBlockForSelection,
-		charOffsetOf,
-		cellIndexOf,
-		type BlockSelectionClass
+		endpointMeasureSpan
 	} from '../selection/primitives';
-	import { snapCrossBlockTableEndpoints } from '../selection/table-endpoint-snap';
-	import { pathsEqual } from '../selection/path-math';
 	import { wireOverlayRemeasure } from '../cursor/overlay-remeasure';
 
 	let {
@@ -26,48 +22,40 @@
 		containerPaintsRects = false
 	}: {
 		path: number[];
-		blockRef: BlockComponent | undefined;
-		blockEl: HTMLElement | null | undefined;
-		/** This container's children paint their own overlays, so it paints none. */
+		/** How the endpoint rects are measured, and where: a delegating container passes neither,
+		 *  since it never measures. */
+		blockRef?: BlockComponent;
+		blockEl?: HTMLElement | null;
+		/** This container's children paint the range's endpoint rects, so it measures none. */
 		delegatesPainting?: boolean;
 		/** This container measures its own rects instead of delegating. Both are decided
 		 *  at BlockHost, which hands the same pair to DecorationOverlay. */
 		containerPaintsRects?: boolean;
 	} = $props();
 
-	// Optional, like every context BlockHost reads: a bare mount provides no shell,
-	// and every use below is written for absence. Destructuring these threw first.
-	const selection = getContext<EditorServices | undefined>(EDITOR_SERVICES_KEY)?.selection;
-	const editorDoc = getContext<EditorDoc | undefined>(EDITOR_DOC_KEY);
-	const getEditorRoot = editorDoc?.editorRoot;
-	const getDoc = editorDoc?.doc;
-
-	const classification = $derived.by<BlockSelectionClass>(() => {
-		if (delegatesPainting) return 'outside';
-		if (!selection?.isCustomRendered || !selection.anchor || !selection.focus) {
-			return 'outside';
-		}
-		return classifyBlockForSelection(path, {
-			anchor: selection.anchor,
-			focus: selection.focus
-		});
-	});
+	// Optional, like every context BlockHost reads: a mount without the editor shell
+	// provides none, and every use below is written for absence.
+	const services = getContext<EditorServices | undefined>(EDITOR_SERVICES_KEY);
+	const selection = services?.selection;
+	const getEditorRoot = getContext<EditorDoc | undefined>(EDITOR_DOC_KEY)?.editorRoot;
 
-	// A whole unit (one surface-less block taken as the entire range) paints as a middle block
-	// does: its full box, no measuring.
-	const paintsWholeBox = $derived.by(() => {
-		if (classification === 'middle') return true;
-		if (classification !== 'single-block') return false;
-		const unit = selection?.wholeUnitPath ?? null;
-		return unit !== null && pathsEqual(unit, path);
-	});
+	const coverage = $derived(services?.rangeCoverage() ?? null);
+
+	const classification = $derived(coverage ? classifyBlockForSelection(path, coverage) : 'outside');
+
+	// Ignores who measures, on purpose: a block the range covers whole paints one box over
+	// everything it renders, markers included, and its children already paint nothing under it.
+	const paintsWholeBox = $derived(
+		coverage !== null && blockPaintsWholeBox(path, coverage, selection?.wholeUnitPath ?? null)
+	);
 
-	// The measuring effect and the template read this one predicate, so a rendered
-	// rect is always one the effect measured; two predicates render a stale box.
+	// The measuring effect and the markup read this one value, so a painted rectangle is
+	// always one the effect measured; two separate tests would paint a stale box.
 	const paintsEndpoints = $derived(
-		classification === 'start' ||
-			classification === 'end' ||
-			(classification === 'single-block' && containerPaintsRects)
+		!delegatesPainting &&
+			(classification === 'start' ||
+				classification === 'end' ||
+				(classification === 'single-block' && containerPaintsRects))
 	);
 
 	interface LocalRect {
@@ -77,9 +65,8 @@
 		height: number;
 	}
 
-	/** Merge rects on the same visual line into a single rect to prevent double-highlight. Same
-	 *  line means vertically overlapping, not equal tops: an inline widget (a KaTeX box) stands
-	 *  taller than the text beside it, and two rects painted over one span read twice as dark. */
+	/** Merges vertically overlapping rects, not just equal tops, so a tall inline widget beside
+	 *  text is not highlighted twice. */
 	function mergeRectsPerLine(rects: LocalRect[]): LocalRect[] {
 		if (rects.length <= 1) return rects;
 		const sorted = [...rects].sort((a, b) => a.top - b.top);
@@ -112,38 +99,20 @@
 			endpointRects = [];
 			return;
 		}
-		if (!blockRef?.measurePartialRects || !blockEl || !selection?.anchor || !selection?.focus) {
+		if (!blockRef?.measurePartialRects || !blockEl || !services || !coverage) {
 			endpointRects = [];
 			return;
 		}
 
 		const ref = blockRef;
 		const el = blockEl;
-		const sel = selection;
+		const covered = services.rangeCoverage;
 
 		function measure(): void {
-			if (!sel.anchor || !sel.focus || !ref.measurePartialRects) return;
-			const normalized = normalize({ anchor: sel.anchor, focus: sel.focus });
-			const doc = getDoc?.();
-			const { start, end } = doc
-				? snapCrossBlockTableEndpoints(doc, normalized.start, normalized.end)
-				: normalized;
-			const startOffset =
-				classification === 'end'
-					? 0
-					: start.cellCoordinate
-						? cellIndexOf(start, 'SelectionOverlay:start')
-						: charOffsetOf(start, 'SelectionOverlay:start');
-			// measurePartialRects paints [start, end) exclusive, so the +1 turning a
-			// snapped table end (inclusive last cell) into an exclusive whole-row bound
-			// belongs to the cell branch only.
-			const endOffset =
-				classification === 'start'
-					? SELECTION_END
-					: end.cellCoordinate
-						? cellIndexOf(end, 'SelectionOverlay:end') + 1
-						: charOffsetOf(end, 'SelectionOverlay:end');
-			const viewportRects: DOMRect[] = ref.measurePartialRects(startOffset, endOffset);
+			const live = covered();
+			if (!live || !ref.measurePartialRects) return;
+			const { from, to } = endpointMeasureSpan(classification, live);
+			const viewportRects: DOMRect[] = ref.measurePartialRects(from, to);
 			const blockRect = el.getBoundingClientRect();
 			endpointRects = mergeRectsPerLine(
 				viewportRects.map((r) => ({

package/dist/components/SelectionOverlay.svelte.d.ts

@@ -1,9 +1,11 @@
-import { type BlockComponent } from '../block-component';
+import type { BlockComponent } from '../block-component';
 type $$ComponentProps = {
     path: number[];
-    blockRef: BlockComponent | undefined;
-    blockEl: HTMLElement | null | undefined;
-    /** This container's children paint their own overlays, so it paints none. */
+    /** How the endpoint rects are measured, and where: a delegating container passes neither,
+     *  since it never measures. */
+    blockRef?: BlockComponent;
+    blockEl?: HTMLElement | null;
+    /** This container's children paint the range's endpoint rects, so it measures none. */
     delegatesPainting?: boolean;
     /** This container measures its own rects instead of delegating. Both are decided
      *  at BlockHost, which hands the same pair to DecorationOverlay. */

package/dist/components/TailInsert.svelte

@@ -1,44 +1,32 @@
 <script lang="ts">
 	/**
-	 * The row below the last block: a full-width strip that adds an empty paragraph at the end
-	 * of the document and lands the caret in it, with a `+` in the left gutter that does the
-	 * same — so there is always a way to write below whatever the last block is (a table, a
-	 * fence, an equation), and a place to add the next block from.
+	 * The row below the last block: a full-width, invisible strip that adds an empty paragraph at
+	 * the end of the document and puts the caret in it, so there is always a way to write below
+	 * whatever the last block is (a table, a fence, an equation). A drag that starts on it is the
+	 * editor's own drag-select, like one from any margin (`editor-root-gestures.ts`).
 	 */
 	import type { BlockEditActions } from '../action-contracts';
-	import { TAIL_ADD_BLOCK, TAIL_ADD_ROW } from '../a11y-strings';
-	import MenuIcon from './menu/MenuIcon.svelte';
+	import { TAIL_ADD_ROW } from '../a11y-strings';
 
 	let {
 		blockEdit,
 		childCount,
-		readOnly,
-		onPlus
+		readOnly
 	}: {
 		blockEdit: BlockEditActions | undefined;
 		childCount: number;
 		readOnly: boolean;
-		/** The `+`: the editor appends the paragraph and opens the block menu over it. */
-		onPlus: (button: HTMLElement) => void;
 	} = $props();
 
-	// The mint's own focus lands the caret; the mousedown is swallowed so nothing else seats one.
+	// `insertParagraph` focuses the new block, which places the caret; the mousedown is
+	// swallowed so nothing else places one.
 	function append(): void {
-		if (readOnly) return;
 		void blockEdit?.insertParagraph(childCount, '');
 	}
 </script>
 
 {#if !readOnly}
 	<div class="editor-tail">
-		<button
-			type="button"
-			class="editor-tail-plus"
-			aria-label={TAIL_ADD_BLOCK}
-			title={TAIL_ADD_BLOCK}
-			onmousedown={(e) => e.preventDefault()}
-			onclick={(e) => onPlus(e.currentTarget)}><MenuIcon name="plus" size={14} /></button
-		>
 		<button
 			type="button"
 			class="editor-tail-row"
@@ -51,7 +39,6 @@
 
 <style>
 	.editor-tail {
-		position: relative;
 		display: flex;
 		align-items: center;
 		height: 34px;
@@ -70,38 +57,4 @@
 		outline-offset: -1px;
 		border-radius: 4px;
 	}
-	/* In the editor's gutter, exactly where a block's drag handle sits (`BlockDragHandle`): the
-	   root's 1rem padding holds a 0.85rem slot, and this is the handle of the imaginary last line. */
-	.editor-tail-plus {
-		position: absolute;
-		left: -1rem;
-		top: 50%;
-		transform: translateY(-50%);
-		display: flex;
-		align-items: center;
-		justify-content: center;
-		width: 1rem;
-		height: 1rem;
-		padding: 0;
-		border: 0;
-		border-radius: 3px;
-		background: transparent;
-		color: var(--color-ui-muted, #8f8f89);
-		cursor: pointer;
-		opacity: 0;
-		transition: opacity 120ms ease-out;
-	}
-	.editor-tail:hover .editor-tail-plus,
-	.editor-tail-plus:focus-visible {
-		opacity: 1;
-	}
-	.editor-tail-plus:hover {
-		background: var(--color-ui-faint, rgba(255, 255, 255, 0.07));
-		color: var(--color-text-primary, #e8e8e5);
-	}
-	@media (prefers-reduced-motion: reduce) {
-		.editor-tail-plus {
-			transition: none;
-		}
-	}
 </style>

package/dist/components/TailInsert.svelte.d.ts

@@ -1,16 +1,14 @@
 /**
-     * The row below the last block: a full-width strip that adds an empty paragraph at the end
-     * of the document and lands the caret in it, with a `+` in the left gutter that does the
-     * same — so there is always a way to write below whatever the last block is (a table, a
-     * fence, an equation), and a place to add the next block from.
+     * The row below the last block: a full-width, invisible strip that adds an empty paragraph at
+     * the end of the document and puts the caret in it, so there is always a way to write below
+     * whatever the last block is (a table, a fence, an equation). A drag that starts on it is the
+     * editor's own drag-select, like one from any margin (`editor-root-gestures.ts`).
      */
 import type { BlockEditActions } from '../action-contracts';
 type $$ComponentProps = {
     blockEdit: BlockEditActions | undefined;
     childCount: number;
     readOnly: boolean;
-    /** The `+`: the editor appends the paragraph and opens the block menu over it. */
-    onPlus: (button: HTMLElement) => void;
 };
 declare const TailInsert: import("svelte").Component<$$ComponentProps, {}, "">;
 type TailInsert = ReturnType<typeof TailInsert>;

package/dist/components/block-content-selector.d.ts

@@ -1,16 +1,16 @@
 /**
- * A block's content element is the first child of its `data-block-path` wrapper that is not chrome
- * wrapped around it (child order: badges, content, the code block's rail, selection
- * overlay, decoration overlays, drag handle). One definition, shared by the runtime and the e2e
- * page-object.
+ * Selectors for a block's content element: the first child of its `data-block-path` wrapper
+ * that is not an overlay, badge, gutter or handle. Shared by the runtime and the e2e page object.
  */
-/** For `querySelector`, which returns the FIRST match only, so what must be excluded
- *  is the chrome that can precede the block content. */
+/** For `querySelector`, which returns the first match only, so what must be excluded is
+ *  whatever can come before the block content. */
 export declare const BLOCK_CONTENT_SELECTOR = ":scope > :not(.selection-overlay):not(.decoration-badge)";
-/** For a Playwright `locator`, which enumerates ALL matches, so every chrome child
- *  must be named — the decoration overlay is one per painted mark, not per block. */
+/** For a Playwright `locator`, which returns every match, so each extra child has to be
+ *  named; the decoration overlay is one per painted mark, not one per block. */
 export declare const BLOCK_CONTENT_LOCATOR_SELECTOR = ":scope > *:not(.selection-overlay):not(.decoration-overlay):not(.block-drag-handle):not(.decoration-badge):not(.code-rail)";
-/** Marks the element a block's drag grip centres on (`drag-handle.ts`); absent, the block's
- *  first line of text is it. Here rather than beside the handle so the ambient-prefix DOM
- *  builder can set it without reaching into the components layer. */
+/** Marks the element a block's drag handle centres on instead of its first line of text; here
+ *  so the container marker-prefix code can set it without importing `components/`. */
 export declare const DRAG_ANCHOR_ATTR = "data-drag-anchor";
+/** A table cell, header row included: row 0's cells are column headers to assistive tech. Used
+ *  under `:scope >` from a row, and with `closest` from inside a cell. */
+export declare const TABLE_CELL_SELECTOR = ":is([role=\"cell\"], [role=\"columnheader\"])";

package/dist/components/block-content-selector.js

@@ -1,16 +1,16 @@
 /**
- * A block's content element is the first child of its `data-block-path` wrapper that is not chrome
- * wrapped around it (child order: badges, content, the code block's rail, selection
- * overlay, decoration overlays, drag handle). One definition, shared by the runtime and the e2e
- * page-object.
+ * Selectors for a block's content element: the first child of its `data-block-path` wrapper
+ * that is not an overlay, badge, gutter or handle. Shared by the runtime and the e2e page object.
  */
-/** For `querySelector`, which returns the FIRST match only, so what must be excluded
- *  is the chrome that can precede the block content. */
+/** For `querySelector`, which returns the first match only, so what must be excluded is
+ *  whatever can come before the block content. */
 export const BLOCK_CONTENT_SELECTOR = ':scope > :not(.selection-overlay):not(.decoration-badge)';
-/** For a Playwright `locator`, which enumerates ALL matches, so every chrome child
- *  must be named — the decoration overlay is one per painted mark, not per block. */
+/** For a Playwright `locator`, which returns every match, so each extra child has to be
+ *  named; the decoration overlay is one per painted mark, not one per block. */
 export const BLOCK_CONTENT_LOCATOR_SELECTOR = ':scope > *:not(.selection-overlay):not(.decoration-overlay):not(.block-drag-handle):not(.decoration-badge):not(.code-rail)';
-/** Marks the element a block's drag grip centres on (`drag-handle.ts`); absent, the block's
- *  first line of text is it. Here rather than beside the handle so the ambient-prefix DOM
- *  builder can set it without reaching into the components layer. */
+/** Marks the element a block's drag handle centres on instead of its first line of text; here
+ *  so the container marker-prefix code can set it without importing `components/`. */
 export const DRAG_ANCHOR_ATTR = 'data-drag-anchor';
+/** A table cell, header row included: row 0's cells are column headers to assistive tech. Used
+ *  under `:scope >` from a row, and with `closest` from inside a cell. */
+export const TABLE_CELL_SELECTOR = ':is([role="cell"], [role="columnheader"])';

package/dist/components/block-el-lookup.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The block content element at a path: what cross-block caret arithmetic measures against.
+ * Table cells carry no `data-block-path` (they render without BlockHost), so a deep cell path
+ * resolves the table wrapper and descends into the cell DOM.
+ */
+export declare function blockContentElAt(root: HTMLElement, path: number[]): HTMLElement | null;

package/dist/components/block-el-lookup.js

@@ -0,0 +1,27 @@
+/**
+ * The block content element at a path: what cross-block caret arithmetic measures against.
+ * Table cells carry no `data-block-path` (they render without BlockHost), so a deep cell path
+ * resolves the table wrapper and descends into the cell DOM.
+ */
+import { BLOCK_CONTENT_SELECTOR, TABLE_CELL_SELECTOR } from './block-content-selector';
+export function blockContentElAt(root, path) {
+    const wrapper = root.querySelector(`[data-block-path='${JSON.stringify(path)}']`);
+    if (wrapper)
+        return wrapper.querySelector(BLOCK_CONTENT_SELECTOR);
+    if (path.length < 3)
+        return null;
+    const tablePath = path.slice(0, -2);
+    const rowIdx = path[path.length - 2];
+    const colIdx = path[path.length - 1];
+    const tableWrapper = root.querySelector(`[data-block-path='${JSON.stringify(tablePath)}']`);
+    if (!tableWrapper)
+        return null;
+    const tableEl = tableWrapper.querySelector(':scope > [role="table"]');
+    if (!tableEl)
+        return null;
+    const rowEl = tableEl.querySelector(`:scope > [data-table-row-idx='${rowIdx}']`);
+    if (!rowEl)
+        return null;
+    const cells = rowEl.querySelectorAll(`:scope > ${TABLE_CELL_SELECTOR}`);
+    return cells[colIdx] ?? null;
+}

package/dist/components/blocks/BlockquoteBlock.svelte

@@ -7,8 +7,8 @@
 
 	let boxEl: HTMLElement | undefined = $state();
 
-	// A plain strip container: the seam wires it end to end. `handleKeydown` stays
-	// unwired on purpose — a blockquote never bubbled kind commands.
+	// A plain container with a left border: `createContainerBlock` wires it end to end.
+	// `handleKeydown` is deliberately left unwired, since a blockquote takes no chords.
 	const { blockListProps, containerApi } = createContainerBlock({
 		getNode: () => node,
 		getIndex: () => index,
@@ -20,7 +20,7 @@
 </script>
 
 <div class="blockquote-block" bind:this={boxEl}>
-	<BlockList {...blockListProps} reorderable={true} />
+	<BlockList {...blockListProps} />
 </div>
 
 <style>