@voithos-labs/aragonite 0.10.2 → 0.10.3

package/dist/plugins/latex/math-source.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Where the body sits inside the block's source. The fence lines carry no glyph of their own, so
+ * a point measured against the rendered equation names a place in this span and nowhere else.
+ */
+export declare function mathBodySpan(text: string): {
+    start: number;
+    end: number;
+};
+/**
+ * A `$$` block with no body LINE — `$$$$`, `$$\n$$`, a whitespace-only one-liner — has nowhere
+ * for a caret to sit once the fence lines hide, and Backspace has no byte it could mean. The
+ * completion every such block takes as its source is revealed: opener, one empty body line,
+ * closer, caret on that line. A block that already has a body line, blank or not, is left alone.
+ */
+export declare function completeBareMathSource(text: string): {
+    text: string;
+    caret: number;
+} | null;
+export declare function renderMathSource(text: string): DocumentFragment;

package/dist/plugins/latex/math-source.js

@@ -0,0 +1,97 @@
+/**
+ * The `$$` block's source as DOM, shaped like a code block's: each fence line in a
+ * `.md-fence-line` wrapper the marker-hiding modes collapse, the body as LaTeX highlight
+ * tokens. Text-preserving by construction — opener + body + closer is the input — so the
+ * offset walk and G1.28 hold. Anything not shaped like a fence paints as plain tokens.
+ */
+import { highlightCode } from '../../plugin';
+const FENCE = '$$';
+function sliceMathSource(text) {
+    if (!text.startsWith(FENCE))
+        return { opener: '', body: text, closer: '' };
+    const firstNewline = text.indexOf('\n');
+    // One-line form: `$$x^2$$`.
+    if (firstNewline === -1) {
+        if (text.length >= 4 && text.endsWith(FENCE)) {
+            return { opener: FENCE, body: text.slice(2, -2), closer: FENCE };
+        }
+        return { opener: '', body: text, closer: '' };
+    }
+    if (text.slice(0, firstNewline) !== FENCE)
+        return { opener: '', body: text, closer: '' };
+    const opener = text.slice(0, firstNewline + 1);
+    const rest = text.slice(opener.length);
+    const lastNewline = rest.lastIndexOf('\n');
+    const lastLine = lastNewline === -1 ? rest : rest.slice(lastNewline + 1);
+    if (lastLine !== FENCE)
+        return { opener, body: rest, closer: '' };
+    if (lastNewline === -1)
+        return { opener, body: '', closer: FENCE };
+    // The newline before the closer belongs to the closer's line (the code block's rule), so
+    // collapsing that line leaves no blank line at the box's edge — unless the body is blank,
+    // where that newline IS the one line the caret can sit on.
+    const bodyWithEnding = rest.slice(0, lastNewline + 1);
+    if (!/\S/.test(bodyWithEnding))
+        return { opener, body: bodyWithEnding, closer: FENCE };
+    return { opener, body: rest.slice(0, lastNewline), closer: rest.slice(lastNewline) };
+}
+function fenceLine(text) {
+    const line = document.createElement('span');
+    line.className = 'md-fence-line';
+    const marker = document.createElement('span');
+    marker.className = 'md-marker md-fence';
+    marker.textContent = text.replace(/\n$/, '').replace(/^\n/, '');
+    if (text.startsWith('\n'))
+        line.appendChild(document.createTextNode('\n'));
+    line.appendChild(marker);
+    if (text.endsWith('\n'))
+        line.appendChild(document.createTextNode('\n'));
+    return line;
+}
+/**
+ * Where the body sits inside the block's source. The fence lines carry no glyph of their own, so
+ * a point measured against the rendered equation names a place in this span and nowhere else.
+ */
+export function mathBodySpan(text) {
+    if (/^[ \t]*(?:`{3,}|~{3,})/.test(text)) {
+        const firstBreak = text.indexOf('\n');
+        if (firstBreak === -1)
+            return { start: text.length, end: text.length };
+        const closer = /(?:\r?\n)?[ \t]*(?:`{3,}|~{3,})[ \t]*\r?\n?$/.exec(text);
+        return { start: firstBreak + 1, end: closer ? closer.index : text.length };
+    }
+    const { opener, body } = sliceMathSource(text);
+    return { start: opener.length, end: opener.length + body.length };
+}
+/**
+ * A `$$` block with no body LINE — `$$$$`, `$$\n$$`, a whitespace-only one-liner — has nowhere
+ * for a caret to sit once the fence lines hide, and Backspace has no byte it could mean. The
+ * completion every such block takes as its source is revealed: opener, one empty body line,
+ * closer, caret on that line. A block that already has a body line, blank or not, is left alone.
+ */
+export function completeBareMathSource(text) {
+    const { opener, body, closer } = sliceMathSource(text);
+    if (!opener || !closer)
+        return null;
+    if (body.includes('\n') || body.trim() !== '')
+        return null;
+    const completed = `${FENCE}\n\n${FENCE}`;
+    return { text: completed, caret: FENCE.length + 1 };
+}
+export function renderMathSource(text) {
+    const { opener, body, closer } = sliceMathSource(text);
+    const frag = document.createDocumentFragment();
+    if (opener)
+        frag.appendChild(fenceLine(opener));
+    frag.appendChild(highlightCode(body, 'latex'));
+    // An empty last body line has only the hidden closer after it; the anchor gives the caret
+    // that line (see `code-renderer.ts`).
+    if (closer.startsWith('\n') && body.endsWith('\n')) {
+        const anchor = document.createElement('br');
+        anchor.dataset.caretAnchor = 'closer';
+        frag.appendChild(anchor);
+    }
+    if (closer)
+        frag.appendChild(fenceLine(closer));
+    return frag;
+}

package/dist/plugins/latex/register.d.ts

@@ -5,6 +5,15 @@
  */
 import { type EditorPlugin } from '../../plugin';
 import { type MathRenderer } from './math-renderer';
-export declare function latexPlugin(options: {
+import { type MathBlockLayout } from './math-layout';
+export interface LatexPluginOptions {
     renderer: MathRenderer;
-}): EditorPlugin;
+    /**
+     * How a `$$` block opens for editing: `split` (source beside the preview, the default),
+     * `stacked` (preview below), or `source` (no preview). Definition-time, so it is the
+     * bare-install default; an editor's `{ plugin, options: { blockLayout } }` entry overrides it
+     * per instance. The block's own toggle cycles from whichever applies.
+     */
+    blockLayout?: MathBlockLayout;
+}
+export declare function latexPlugin(options: LatexPluginOptions): EditorPlugin;

package/dist/plugins/latex/register.js

@@ -6,8 +6,10 @@
 import { definePlugin, registerBlockComponent, defineBlockComponent, declaredPluginKind } from '../../plugin';
 import { registerMathInline, registerMathBlock, MATH_BLOCK, MATH_FENCE } from './latex-kind';
 import { setMathRenderer } from './math-renderer';
+import { isMathBlockLayout } from './math-layout';
 import BlockMath from './BlockMath.svelte';
 export function latexPlugin(options) {
+    const blockLayout = isMathBlockLayout(options.blockLayout) ? options.blockLayout : 'split';
     return definePlugin({
         name: 'latex',
         setup() {
@@ -15,7 +17,7 @@ export function latexPlugin(options) {
             registerMathInline();
             // registerMathBlock co-registers the ```math fence kind; both render through BlockMath.
             registerMathBlock();
-            const blockMath = defineBlockComponent(BlockMath);
+            const blockMath = defineBlockComponent(BlockMath, () => ({ blockLayout }));
             registerBlockComponent(declaredPluginKind(MATH_BLOCK), blockMath);
             registerBlockComponent(declaredPluginKind(MATH_FENCE), blockMath);
         }

package/dist/plugins/latex/renderer.d.ts

@@ -6,8 +6,8 @@
 import 'katex/dist/katex.min.css';
 import type { MathRenderer } from './math-renderer';
 /**
- * `throwOnError: false` keeps a malformed formula from crashing the editor, but its fallback
- * renders the source verbatim, a bare raw-source strip A5 forbids: hence the `.katex-error`
- * detection and the legible message swapped in for it.
+ * `throwOnError: false` keeps a malformed formula from crashing the editor; its fallback is
+ * swapped for the source painted as an error — red, in the code face, the parser's message on
+ * hover — so a broken formula reads as what the author typed, not as a sentence about it.
  */
 export declare const katexRenderer: MathRenderer;

package/dist/plugins/latex/renderer.js

@@ -8,9 +8,9 @@ import katex from 'katex';
 // a `.katex-mathml` a11y tree this CSS clips to 1px, and unloaded every equation paints twice.
 import 'katex/dist/katex.min.css';
 /**
- * `throwOnError: false` keeps a malformed formula from crashing the editor, but its fallback
- * renders the source verbatim, a bare raw-source strip A5 forbids: hence the `.katex-error`
- * detection and the legible message swapped in for it.
+ * `throwOnError: false` keeps a malformed formula from crashing the editor; its fallback is
+ * swapped for the source painted as an error — red, in the code face, the parser's message on
+ * hover — so a broken formula reads as what the author typed, not as a sentence about it.
  */
 export const katexRenderer = (source, { display }) => {
     const container = document.createElement('span');
@@ -22,13 +22,20 @@ export const katexRenderer = (source, { display }) => {
     const errorSpan = container.querySelector('.katex-error');
     if (errorSpan) {
         const message = (errorSpan.getAttribute('title') ?? 'invalid LaTeX').replace(/^ParseError:\s*/, '');
-        return { dom: buildErrorNode(message), error: message };
+        return { dom: buildErrorNode(source, message), error: message };
     }
     return { dom: container };
 };
-function buildErrorNode(message) {
+function buildErrorNode(source, message) {
     const span = document.createElement('span');
     span.className = 'math-error';
-    span.textContent = `Math error: ${message}`;
+    span.textContent = source;
+    span.title = message;
+    // Inline style rather than a stylesheet: the span lands inside any prose block, where no
+    // plugin sheet is guaranteed to be mounted.
+    span.style.color = 'var(--color-error, #d03025)';
+    span.style.fontFamily = 'var(--font-code, ui-monospace, monospace)';
+    span.style.fontSize = '0.9em';
+    span.style.cursor = 'help';
     return span;
 }

package/dist/reactivity/list-windowing.svelte.d.ts

@@ -63,15 +63,15 @@ export interface ListWindowing {
     recordMeasuredChild(index: number, id: string, height: number): void;
     /** A PROPAGATED child-container subtotal: oracle + model slot, addressed by index. No anchor correction. */
     setChildSubtotal(index: number, total: number): void;
-    /** Enroll a child in this scope's batched measure pass; returns an unregister fn to call on
-     *  the child's unmount. The scope reads ALL pending children before applying ANY write, so a
-     *  fling that mounts many costs one reflow. */
+    /** Enroll a child in this scope's batched measure pass, read after the flush that registered
+     *  it; returns an unregister fn to call on the child's unmount. The scope reads ALL pending
+     *  children before applying ANY write, so a fling that mounts many costs one reflow. */
     registerChild(id: string, child: MeasureEntry): () => void;
     /** Re-measure ONE registered child immediately (its content height changed on edit). */
     measureChildNow(id: string): void;
-    /** ResizeObserver path: O(1)-gate `observedHeight` against the recorded height and
-     *  re-measure only on a genuine post-mount change, so the no-op mount resize on a fling
-     *  costs no DOM read. */
+    /** ResizeObserver path: O(1)-gate `observedHeight` against the height this scope last
+     *  applied and re-measure only on a genuine post-mount change, so the no-op mount resize
+     *  on a fling costs no DOM read. */
     measureChildOnResize(id: string, observedHeight: number): void;
     /**
      * True when the scroll position IS the reveal target's requested placement. Asked by
@@ -93,8 +93,8 @@ export interface ListWindowing {
  * Resize-gate decision (pure, unit-tested). Keyed on the height DIFFERING from what is
  * recorded, never on which callback delivered it: a cached remount can report the grown
  * size in the very first callback, so a callback-order heuristic would drop it.
- * `recorded === undefined` means the batched mount pass hasn't measured this block yet —
- * defer to it rather than racing a lone read in on a fling-dirtied layout.
+ * `recorded === undefined` means the scope has applied no height for this block yet —
+ * defer to the batched pass rather than racing a lone read in on a fling-dirtied layout.
  */
 export declare function shouldRemeasureOnResize(recorded: number | undefined, observed: number): boolean;
 export declare function createListWindowing(deps: ListWindowingDeps): ListWindowing;

package/dist/reactivity/list-windowing.svelte.js

@@ -14,8 +14,8 @@ import { runMeasureBatch } from './measure-batch';
  * Resize-gate decision (pure, unit-tested). Keyed on the height DIFFERING from what is
  * recorded, never on which callback delivered it: a cached remount can report the grown
  * size in the very first callback, so a callback-order heuristic would drop it.
- * `recorded === undefined` means the batched mount pass hasn't measured this block yet —
- * defer to it rather than racing a lone read in on a fling-dirtied layout.
+ * `recorded === undefined` means the scope has applied no height for this block yet —
+ * defer to the batched pass rather than racing a lone read in on a fling-dirtied layout.
  */
 export function shouldRemeasureOnResize(recorded, observed) {
     if (observed <= 0 || recorded === undefined)
@@ -59,7 +59,7 @@ export function createListWindowing(deps) {
     let heightVersion = $state(0);
     // One scope-owned batched pass rather than a per-child effect, which would interleave a
     // layout read with the prior child's write → one forced reflow per mounted block on a
-    // fling. `pending` holds ids awaiting their first measure; the batch effect drains it.
+    // fling. `pending` holds ids awaiting their first measure; registration drains it.
     const registry = new Map();
     const pending = new Set();
     /**
@@ -123,6 +123,20 @@ export function createListWindowing(deps) {
         placeRevealTarget();
         return true;
     }
+    /**
+     * Which block this correction holds still: the top-of-viewport one by default, the FOCUSED
+     * one when it sits at or below the fold. Clicking a construct that reveals its source (a
+     * math block, a paragraph holding inline math) resizes that block and folds whichever was
+     * revealed before it; anchored on the viewport top, both slide the clicked block out from
+     * under the pointer. Anchoring on the focused block holds its start offset instead, so it
+     * stays put and only the content after it reflows.
+     */
+    function anchorIndexFor(topIndex) {
+        const pinned = pinnedIndex();
+        if (pinned === null || pinned < topIndex || pinned >= model.size)
+            return topIndex;
+        return pinned;
+    }
     // Hold the anchor block's screen position across a height mutation that would otherwise
     // slide the visible content (VR-2) — native `overflow-anchor` is off wherever this runs, so
     // nothing else holds the line. The delta comes from the Fenwick model, not
@@ -134,7 +148,7 @@ export function createListWindowing(deps) {
         if (reassertRevealAnchor(mutate))
             return;
         const port = deps.getPort();
-        const anchorIndex = model.indexAtOffset(localScrollTop());
+        const anchorIndex = anchorIndexFor(model.indexAtOffset(localScrollTop()));
         const before = model.offsetOf(anchorIndex);
         mutate();
         const delta = model.offsetOf(anchorIndex) - before;
@@ -258,22 +272,23 @@ export function createListWindowing(deps) {
     $effect(() => {
         void heightVersion;
         const el = deps.getOwnEl?.();
-        if (!el || !deps.reportSelfHeight)
+        const report = deps.reportSelfHeight;
+        if (!el || !report)
             return;
-        const h = el.getBoundingClientRect().height;
-        if (h > 0 && Math.abs(h - reportedSelfHeight) >= 1) {
-            reportedSelfHeight = h;
-            deps.reportSelfHeight(h);
-        }
-    });
-    // The batched measure pass for NEWLY-MOUNTED children, keyed on the EFFECTIVE window: the
-    // raw result can be identical across a collapse expand, stranding remounted children in
-    // `pending` until the next scroll. Registration deliberately does NOT bump reactive
-    // state — the mount that registers a child already moved the window, so a per-child
-    // trigger would re-enter this effect O(children) times and trip the update-depth guard.
-    $effect(() => {
-        void effectiveWindow;
-        untrack(() => flushMeasurements());
+        // After the flush, like the batch: at this effect's first run the children are unrendered.
+        let live = true;
+        void tick().then(() => {
+            if (!live)
+                return;
+            const h = el.getBoundingClientRect().height;
+            if (h > 0 && Math.abs(h - reportedSelfHeight) >= 1) {
+                reportedSelfHeight = h;
+                report(h);
+            }
+        });
+        return () => {
+            live = false;
+        };
     });
     // The UNCORRECTED batch: the caller owns the anchor correction, because nesting a second
     // one inside an outer `mutate` double-counts the delta.
@@ -348,11 +363,21 @@ export function createListWindowing(deps) {
             if (!skipWhileHostAnchors(write) && !reassertRevealAnchor(write))
                 write();
         },
-        // Enroll without touching reactive state: the mount that registers this child already
-        // moved the window, which re-runs the batch effect to drain `pending`.
+        // Read after the flush that mounted the child, not inside it: content can land later in
+        // that flush (an inline widget's root flushes after this one), and an empty-host read is
+        // a scroll correction the observer undoes a frame later. Still ahead of paint.
         registerChild(id, child) {
-            registry.set(id, child);
+            const entry = {
+                readHeight: child.readHeight,
+                applyHeight: (h) => {
+                    entry.applied = h;
+                    child.applyHeight(h);
+                },
+                applied: undefined
+            };
+            registry.set(id, entry);
             pending.add(id);
+            void tick().then(flushMeasurements);
             return () => {
                 registry.delete(id);
                 pending.delete(id);
@@ -362,11 +387,11 @@ export function createListWindowing(deps) {
         measureChildNow(id) {
             measureOne(id);
         },
-        // ResizeObserver path for async growth. The gate reads the oracle's recorded height
+        // ResizeObserver path for async growth. The gate reads what this scope last applied
         // (O(1), no DOM), so the no-op mount resize a fling fires for every newly-mounted
         // block returns without a rect read on the spacer-dirtied layout (VR-4).
         measureChildOnResize(id, observedHeight) {
-            if (shouldRemeasureOnResize(deps.oracle.measured(id), observedHeight))
+            if (shouldRemeasureOnResize(registry.get(id)?.applied, observedHeight))
                 measureOne(id);
         },
         revealHoldsScroll() {

package/dist/schema/block-completions.d.ts

@@ -22,10 +22,18 @@ export interface CompletionResult {
 export interface BlockCompleter {
     /** Attempt to complete `line`; null declines, as does a claim whose lines would paint nothing. */
     tryComplete(line: string): CompletionResult | null;
+    /**
+     * Also consulted as the line is TYPED, not only at Enter — for a claim that can only ever mean
+     * one thing the moment it is complete (a lone `$$`), so the block forms as a ` ``` ` fence does.
+     * Off by default: a table's header row is a prefix of a longer row the user may still be typing.
+     */
+    onType?: boolean;
 }
 export declare function registerBlockCompleter(kind: AnyBlockKind, completer: BlockCompleter): void;
 /** The first claim on `line`, or null when no registered completer takes it. */
 export declare function completeTypedLine(line: string): CompletionResult | null;
+/** The first claim on `line` among the completers that answer as the line is typed. */
+export declare function completeLineOnType(line: string): CompletionResult | null;
 /** Whether `kind` already owns a completer — the probe a registrar re-run reads before it
  *  registers, so a re-installed plugin never trips the register-once throw. */
 export declare function isBlockCompleterRegistered(kind: string): boolean;

package/dist/schema/block-completions.js

@@ -33,6 +33,17 @@ export function completeTypedLine(line) {
     }
     return null;
 }
+/** The first claim on `line` among the completers that answer as the line is typed. */
+export function completeLineOnType(line) {
+    for (const completer of ordered()) {
+        if (!completer.onType)
+            continue;
+        const claim = completer.tryComplete(line);
+        if (claim)
+            return claim;
+    }
+    return null;
+}
 /** Whether `kind` already owns a completer — the probe a registrar re-run reads before it
  *  registers, so a re-installed plugin never trips the register-once throw. */
 export function isBlockCompleterRegistered(kind) {

package/dist/schema/context-actions.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The block context menu's vocabulary: what a right-click on a block of a given kind offers.
+ * A kind's own providers come first, then the ones registered for every kind (`'*'`: the
+ * editor's copy, replace and remove rows). Providers are consulted on every open, so they read
+ * the block as it is. The defaults register at bootstrap; a plugin registers through the barrel.
+ */
+export declare const EVERY_KIND = "*";
+import type { NodeView } from '../core/node-views';
+export interface BlockActionContext {
+    node: NodeView;
+    /** The block's path from the document root. Top-level blocks only, for now. */
+    path: number[];
+    /** Remove the block. */
+    deleteBlock(): Promise<void>;
+    /** Replace the block's bytes wholesale; the result reparses to whatever those bytes are. */
+    replaceRaw(raw: string): Promise<void>;
+}
+export interface BlockContextAction {
+    id: string;
+    label: string;
+    /** A glyph name the menu knows (`components/menu/MenuIcon.svelte`); absent draws none. */
+    icon?: string;
+    danger?: boolean;
+    run(ctx: BlockActionContext): void | Promise<void>;
+}
+export type BlockContextActionProvider = (node: NodeView, path: number[]) => BlockContextAction[];
+/** Add a provider for `kind`, or for every kind with `EVERY_KIND`. Several may stack. */
+export declare function registerBlockContextActions(kind: string, provider: BlockContextActionProvider): void;
+export declare function blockContextActionsFor(node: NodeView, path: number[]): BlockContextAction[];
+/** Test-only. */
+export declare function __resetBlockContextActionsForTests(): void;

package/dist/schema/context-actions.js

@@ -0,0 +1,23 @@
+/**
+ * The block context menu's vocabulary: what a right-click on a block of a given kind offers.
+ * A kind's own providers come first, then the ones registered for every kind (`'*'`: the
+ * editor's copy, replace and remove rows). Providers are consulted on every open, so they read
+ * the block as it is. The defaults register at bootstrap; a plugin registers through the barrel.
+ */
+export const EVERY_KIND = '*';
+const providers = new Map();
+/** Add a provider for `kind`, or for every kind with `EVERY_KIND`. Several may stack. */
+export function registerBlockContextActions(kind, provider) {
+    const list = providers.get(kind) ?? [];
+    list.push(provider);
+    providers.set(kind, list);
+}
+export function blockContextActionsFor(node, path) {
+    const own = providers.get(node.kind) ?? [];
+    const every = providers.get(EVERY_KIND) ?? [];
+    return [...own, ...every].flatMap((provider) => provider(node, path));
+}
+/** Test-only. */
+export function __resetBlockContextActionsForTests() {
+    providers.clear();
+}

package/dist/schema/fenced-code-raw.js

@@ -17,7 +17,8 @@ export function reconcileFenceWrite(input) {
     const { fence, mode } = input;
     if (!fence.closed && mode === 'authored')
         return { display: input.display, caret: input.caret };
-    return escalateFenceRuns({ ...input, ...sanitizeInfoString(input) });
+    const unglued = separateGluedCloser(input);
+    return escalateFenceRuns({ ...input, ...sanitizeInfoString({ ...input, ...unglued }) });
 }
 /**
  * A whole fencedCode `raw` made legal — the kind's `normalizeRawWrite`. Literal by
@@ -166,6 +167,35 @@ function countDroppedBefore(info, infoStart, caret) {
     }
     return dropped;
 }
+/**
+ * Un-glue a closer the write landed on top of. A fence with NO body line — ```` ```\n``` ```` —
+ * has nothing between its two runs, so the body's only caret seat IS the closer's line start,
+ * and the first character typed there arrives ahead of the closer run: ```` ```\nAB``` ````,
+ * which no longer reads as closed and shows the run as body text. The fence says it is closed
+ * and the display no longer carries a closer line, so the write broke it; the missing line
+ * ending is what puts it back.
+ */
+function separateGluedCloser(input) {
+    const { display, caret, fence } = input;
+    if (!fence.closed)
+        return { display, caret };
+    const lines = display.split('\n');
+    // A closer still on its own line needs nothing; so does a display too short to hold one.
+    if (lines.length < 2 || lastCloserIndex(lines, fence) >= 1)
+        return { display, caret };
+    const run = new RegExp(`[${fence.marker}]{${fence.length},}[ \t]*$`).exec(lines[lines.length - 1]);
+    // `index === 0` is a bare run that some other rule owns, not a glued one.
+    if (!run || run.index === 0)
+        return { display, caret };
+    const at = display.length - run[0].length;
+    const ending = display.includes('\r\n') ? '\r\n' : '\n';
+    return {
+        display: display.slice(0, at) + ending + display.slice(at),
+        // The caret sits at the typed text's end, which is where the ending is inserted: it
+        // stays put, and only a caret already inside the closer run rides the shift.
+        caret: caret > at ? caret + ending.length : caret
+    };
+}
 function escalateFenceRuns(input) {
     const { display, caret, fence } = input;
     const lines = display.split('\n');

package/dist/schema/operations.d.ts

@@ -39,7 +39,7 @@ export interface OperationDetailMap {
         parentItemIdx?: number;
         nestedItemIdx?: number;
     } | {
-        source: 'paste-dispatch' | 'paste-dispatch-table-cell' | 'cross-block-paste-whole-table';
+        source: 'paste-dispatch' | 'paste-dispatch-table-cell' | 'cross-block-covered-block';
     };
     paste: {
         count: number;
@@ -70,6 +70,13 @@ export interface OperationDetailMap {
         colIdx: number;
         side: 'left' | 'right';
     };
+    /** A grid pasted from `rowIdx`/`colIdx`, the table grown to hold it. */
+    tablePasteGrid: {
+        rowIdx: number;
+        colIdx: number;
+        rows: number;
+        cols: number;
+    };
     tableDeleteColumn: {
         colIdx: number;
         crossBlock?: true;

package/dist/schema/reserved-chords.js

@@ -15,6 +15,12 @@ export const HARDCODED_CHORD_SITES = [
         keys: [],
         note: 'Mod-click link activation — no keystroke is consumed.'
     },
+    {
+        file: 'components/editor-root-keydown.ts',
+        chords: [],
+        keys: ['Escape'],
+        note: 'Escape closes the find bar (a reserved UI chord, enumerated). The modifier read is a REFUSAL: an unchorded character over a live range goes to the range’s text door, a chorded one to the arms below it.'
+    },
     {
         file: 'components/editor-root-listeners.ts',
         chords: [],
@@ -45,8 +51,8 @@ export const HARDCODED_CHORD_SITES = [
     {
         file: 'components/blocks/editable-leaf.ts',
         chords: [],
-        keys: ['Enter'],
-        note: 'Shift-click gate on the rendered surface — a pointer read.'
+        keys: ['Backspace', 'Enter'],
+        note: "Shift-click gate on the rendered surface — a pointer read; plain Backspace (no modifier) at the top of an empty painted source deletes the block, as the code block does. The reveal's own undo resolves its chord through the keymap, so it claims none here."
     },
     {
         file: 'components/link-card/LinkCard.svelte',
@@ -54,6 +60,12 @@ export const HARDCODED_CHORD_SITES = [
         keys: ['Enter', 'K', 'Tab', 'k'],
         note: "Backwards step of the open card's focus trap, plus the entry chord swallowed as a no-op where the focus already is — the kind keymaps claim it everywhere else. Escape lives on the host, which must also close a card the document still holds the caret for."
     },
+    {
+        file: 'components/menu/BlockMenu.svelte',
+        chords: [],
+        keys: ['ArrowDown', 'ArrowLeft', 'ArrowRight', 'ArrowUp', 'Enter', 'Escape'],
+        note: 'The open block menu steps and picks; the modifier read is the guard that leaves every chord to the editor.'
+    },
     {
         file: 'components/blocks/table/TableActionMenu.svelte',
         chords: ['Shift+Tab'],
@@ -115,8 +127,17 @@ export const HARDCODED_CHORD_SITES = [
     {
         file: 'components/blocks/text/widget-interaction.ts',
         chords: ['Shift+ArrowLeft', 'Shift+ArrowRight'],
-        keys: ['Arrow*', 'ArrowLeft', 'ArrowRight', 'Backspace', 'Delete', 'Escape'],
-        note: 'Extends a selection into a widget. A modified arrow is also swallowed while a widget is selected, but that is a caret-coherence guard in a transient state, not a binding.'
+        keys: [
+            'Arrow*',
+            'ArrowDown',
+            'ArrowLeft',
+            'ArrowRight',
+            'ArrowUp',
+            'Backspace',
+            'Delete',
+            'Escape'
+        ],
+        note: 'Extends a selection into a widget. A modified arrow is also swallowed while a widget is selected, but that is a caret-coherence guard in a transient state, not a binding; a plain vertical arrow seats a caret and declines.'
     },
     {
         file: 'components/image/ImageResizeHandles.svelte',

package/dist/schema/table-cell-raw.d.ts

@@ -1,6 +1,6 @@
 /**
  * The tableCell raw-write rule, declared on the kind as `normalizeRawWrite` and applied at the
- * write sink (`tree-operations/node-ops.updateNodeContent`). A cell's bytes are joined verbatim
+ * write sink (`tree-operations/content-write.updateNodeContent`). A cell's bytes are joined verbatim
  * into its row, and the parser truncates a row reparsing wider than the delimiter's column
  * count, so a bare `|` or line break reaching a cell raw deletes the last column's content.
  * Both passes are prefix-composable, which is what makes `escapedCellOffset` an exact caret image.

package/dist/schema/table-cell-raw.js

@@ -1,6 +1,6 @@
 /**
  * The tableCell raw-write rule, declared on the kind as `normalizeRawWrite` and applied at the
- * write sink (`tree-operations/node-ops.updateNodeContent`). A cell's bytes are joined verbatim
+ * write sink (`tree-operations/content-write.updateNodeContent`). A cell's bytes are joined verbatim
  * into its row, and the parser truncates a row reparsing wider than the delimiter's column
  * count, so a bare `|` or line break reaching a cell raw deletes the last column's content.
  * Both passes are prefix-composable, which is what makes `escapedCellOffset` an exact caret image.

package/dist/selection/block-hit-test.js

@@ -26,10 +26,11 @@ export function blockAtPoint(editorRoot, clientX, clientY) {
                 path,
                 // A cell-addressed kind's first contenteditable is one of its CELLS, so declaring
                 // the drag hook withdraws the block-level surface rather than offering that. The
-                // whole-block editing host is chrome, not characters, so it is excluded too.
+                // whole-block editing host is chrome, not characters, so it is excluded too, as is
+                // the selection overlay (`contenteditable="false"`, mounted while a range is live).
                 charSurface: dragHitTest
                     ? null
-                    : wrapper.querySelector(`[contenteditable]:not([${WHOLE_BLOCK_INPUT_ATTR}])`),
+                    : wrapper.querySelector(`[contenteditable]:not([${WHOLE_BLOCK_INPUT_ATTR}]):not(.selection-overlay)`),
                 foreignDragHitTest: dragHitTest && ((cx, cy) => dragHitTest(wrapper, cx, cy)),
                 caretTargetAtPoint: caretTarget && ((cx, cy) => caretTarget(wrapper, cx, cy))
             };

package/dist/selection/char-endpoint-snap.js

@@ -6,7 +6,7 @@
  * order against the other endpoint, never the anchor/focus role, which `normalize` reorders later.
  */
 import { displayLength, snapToScalarBoundary } from '../core/lines';
-import { isBlockNode, nodeAt } from '../tree-operations/node-ops';
+import { isBlockNode, nodeAt } from '../tree-operations/node-primitives';
 import { isWholeBlockUnit } from '../schema/whole-block-unit';
 import { comparePaths } from './path-math';
 import { isWholeBlockEndpoint } from './primitives';