@voithos-labs/aragonite 0.10.2 → 0.10.3

package/dist/cursor/overlay-remeasure.js

@@ -27,5 +27,13 @@ export function wireOverlayRemeasure(opts) {
         editorRoot.addEventListener('scroll', measure, { passive: true });
         disposers.push(() => editorRoot.removeEventListener('scroll', measure));
     }
+    // The block's own box changing under a live range — a paragraph set to a heading, a font
+    // load, a resize — moves the text the rects were measured against. Layout-driven, so it
+    // fires after the change has painted; absent (jsdom) the scroll paths above still hold.
+    if (typeof ResizeObserver === 'function') {
+        const observer = new ResizeObserver(() => measure());
+        observer.observe(el);
+        disposers.push(() => observer.disconnect());
+    }
     return () => disposers.forEach((dispose) => dispose());
 }

package/dist/cursor/reveal-source.js

@@ -8,13 +8,18 @@
 import { tick } from 'svelte';
 import { asRawOffset, toDomTextOffset } from './coordinate-spaces';
 import { restoreCaretAtWalkOffset } from './focused-caret';
+import { clampToLandableRaw } from './widget-offset';
 import { assertInvariant } from '../assert';
 import { checkRevealSourceLength } from '../invariants/inline-transitions';
 export function createSourceReveal(deps) {
     /** Places the caret at a BLOCK-source offset, converting to ambient-included walk space. */
     function placeCaret(container, blockSourceOffset) {
-        const walkOffset = toDomTextOffset(asRawOffset(blockSourceOffset), deps.getAmbientLength());
-        restoreCaretAtWalkOffset(container, walkOffset);
+        // Offset 0 of a source that opens with hidden chrome (a leaf painting `$$` fence lines) is
+        // BEFORE that chrome: typing there would land outside the fence. The seat is the nearest
+        // landable position, which is a no-op wherever nothing hides.
+        const ambient = deps.getAmbientLength();
+        const seat = clampToLandableRaw(container, blockSourceOffset, ambient);
+        restoreCaretAtWalkOffset(container, toDomTextOffset(asRawOffset(seat), ambient));
     }
     async function reveal(atSourceOffset = 0) {
         assertInvariant('reveal-transition', () => checkRevealSourceLength(deps.source.length, deps.sourceStart, deps.sourceEnd));

package/dist/cursor/widget-offset.d.ts

@@ -101,6 +101,12 @@ export declare function landableDomTextBounds(container: ParentNode): {
  * questions: a reference label is chrome that stays hidden, so it is not content standing behind
  * the stamp, and it is not the paint the stamp promises either.
  */
+/**
+ * The container's bytes outside its marker chrome — what a painted source holds as CONTENT,
+ * whatever the mode paints. A fence with an empty body answers whitespace; the leaf reads that
+ * as "nothing here a Backspace could mean but the block".
+ */
+export declare function chromeFreeText(container: ParentNode): string;
 export declare function holdsOnlyMarkerChrome(container: ParentNode): boolean;
 /**
  * Whether the mode paints NOTHING landable here: every walk segment is a hidden marker run, so no

package/dist/cursor/widget-offset.js

@@ -85,8 +85,11 @@ export function findDomTextOffsetTarget(container, target) {
         const after = positionBeside(seg.last, 'after');
         if (!after)
             continue;
-        if (seg.start + seg.len >= target)
+        // Chromium canonicalizes the slot after a HIDDEN run upstream across it, so a byte typed
+        // there lands before the run; text starting at the target is the position that keeps it.
+        if (seg.start + seg.len > target || (seg.start + seg.len === target && !seg.hidden)) {
             return after;
+        }
         last = after;
     }
     return last;
@@ -239,7 +242,19 @@ export function revealsNoMarkers(container) {
  * An unmounted surface reads as source, where nothing hides and no rewrite has a run to move.
  */
 export function screenVisibilityOf(container) {
-    return screenVisibility(container === null ? 'source' : (markerHidingMode(container) ?? 'source'), { chromePaints: container instanceof Element && container.hasAttribute(CONTENT_EMPTY_ATTR) });
+    return screenVisibility(container === null ? 'source' : (markerHidingMode(container) ?? 'source'), { chromePaints: container instanceof Element && chromeStampPaints(container) });
+}
+/**
+ * The stamp's own condition, as `styles/editor.css` states it: the container carries
+ * `data-content-empty` AND holds focus. The seat is for a caret, so a stamped block nobody is in
+ * keeps its chrome hidden and reads as the empty construct it is. Focus containment rather than
+ * `:focus-within`, so a selector engine without that pseudo-class (jsdom's) reads the same answer.
+ */
+function chromeStampPaints(container) {
+    if (!container.hasAttribute(CONTENT_EMPTY_ATTR))
+        return false;
+    const active = container.ownerDocument.activeElement;
+    return active !== null && container.contains(active);
 }
 /**
  * The extreme walk offsets a caret can occupy in `container`: a hidden marker run or the leading
@@ -252,6 +267,7 @@ export function landableDomTextBounds(container) {
     let start = 0;
     let end = 0;
     let landed = false;
+    let lastText = null;
     for (const seg of landingSegments(container, markerHidingMode(container))) {
         if (seg.len === 0)
             continue;
@@ -265,9 +281,28 @@ export function landableDomTextBounds(container) {
         }
         landed = true;
         end = stop;
+        lastText = seg.kind === 'text' ? seg.node : null;
+    }
+    // The position after the last landable run's final `\n` is the start of a line nothing
+    // paints: the engine seats no caret there, so an end gate reading it never fires and the
+    // caret is stuck on the empty line. A caret anchor gives that line its paint and keeps it.
+    if (lastText?.textContent?.endsWith('\n') && !followedByCaretAnchor(lastText, container)) {
+        end -= 1;
     }
     return { start: asDomTextOffset(start), end: asDomTextOffset(Math.max(start, end)) };
 }
+/** Whether the next painted node after `text`, at any depth above it, is a caret anchor. */
+function followedByCaretAnchor(text, root) {
+    for (let node = text; node && node !== root; node = node.parentNode) {
+        let next = node.nextSibling;
+        while (next?.nodeType === Node.TEXT_NODE && (next.textContent?.length ?? 0) === 0) {
+            next = next.nextSibling;
+        }
+        if (next)
+            return next instanceof HTMLElement && next.tagName === 'BR' && 'caretAnchor' in next.dataset;
+    }
+    return false;
+}
 /**
  * Whether every byte `container` holds is marker chrome, at least one span of it a family the
  * empty-construct override paints. The stamp condition the render path writes as
@@ -276,6 +311,22 @@ export function landableDomTextBounds(container) {
  * questions: a reference label is chrome that stays hidden, so it is not content standing behind
  * the stamp, and it is not the paint the stamp promises either.
  */
+/**
+ * The container's bytes outside its marker chrome — what a painted source holds as CONTENT,
+ * whatever the mode paints. A fence with an empty body answers whitespace; the leaf reads that
+ * as "nothing here a Backspace could mean but the block".
+ */
+export function chromeFreeText(container) {
+    let text = '';
+    for (const seg of walkSegments(container, null)) {
+        if (seg.kind !== 'text' || seg.len === 0)
+            continue;
+        if (markerRootOf(seg.node, container) !== null)
+            continue;
+        text += seg.node.textContent ?? '';
+    }
+    return text;
+}
 export function holdsOnlyMarkerChrome(container) {
     let chrome = false;
     for (const seg of walkSegments(container, null)) {
@@ -383,8 +434,7 @@ function markerRootOf(node, root) {
 function chromeStandsAloneUnder(root, mode) {
     if (mode === null || !(root instanceof Element))
         return false;
-    return screenVisibility(mode, { chromePaints: root.hasAttribute(CONTENT_EMPTY_ATTR) })
-        .chromePaints;
+    return screenVisibility(mode, { chromePaints: chromeStampPaints(root) }).chromePaints;
 }
 /**
  * Whether `node` is inside the leading ambient marker island — a container's `- ` / `1. ` prefix,
@@ -442,8 +492,15 @@ function positionBeside(el, side) {
         return { node: sibling, offset: side === 'before' ? (sibling.textContent?.length ?? 0) : 0 };
     }
     const idx = Array.prototype.indexOf.call(parent.childNodes, el);
+    // A pending hard break's first anchor (`inline-render.ts`) ends the line the marker sat on;
+    // the seat past the marker is the start of the next one, which is after that anchor.
+    if (side === 'after' && isBreakAnchor(sibling))
+        return { node: parent, offset: idx + 2 };
     return { node: parent, offset: side === 'before' ? idx : idx + 1 };
 }
+function isBreakAnchor(node) {
+    return (node instanceof HTMLElement && node.tagName === 'BR' && node.dataset.caretAnchor === 'break');
+}
 /**
  * The classification every walk-space consumer shares: a text node contributes its textContent
  * length, an atomic widget its raw source length (never descended), any other element is

package/dist/debug/interaction-trace.d.ts

@@ -17,6 +17,7 @@ export declare function disableInteractionTrace(): void;
 export declare function isInteractionTraceEnabled(): boolean;
 /** Empty the buffer without touching the enabled flag — test isolation. */
 export declare function resetInteractionTrace(): void;
+export declare function interactionTraceKeydownCount(): number;
 export declare function interactionTraceSnapshot(): InteractionTraceEntry[];
 /** `changed` names the differing render-key segments, comma-joined. */
 export declare function traceRebuild(changed: string, force: boolean): void;
@@ -37,3 +38,6 @@ export declare function traceCompositionEnd(): void;
 export declare function traceIslandsApplied(count: number): void;
 export declare function traceStickyCapture(x: number): void;
 export declare function traceStickyReset(): void;
+/** `handled` is the event's own `defaultPrevented`: whether the editor claimed the press.
+ *  Recorded once per keydown, after the surface handler's await chain has settled. */
+export declare function traceKeydownVerdict(key: string, handled: boolean): void;

package/dist/debug/interaction-trace.js

@@ -8,6 +8,9 @@
 const CAPACITY = 200;
 let enabled = false;
 let buf = [];
+// Monotonic, so the harness poll costs one read and the ring buffer's eviction cannot
+// retract a verdict it already counted.
+let keydownVerdicts = 0;
 // ── Switch and readout ──────────────────────────────────────────────────────
 export function enableInteractionTrace() {
     enabled = true;
@@ -21,6 +24,10 @@ export function isInteractionTraceEnabled() {
 /** Empty the buffer without touching the enabled flag — test isolation. */
 export function resetInteractionTrace() {
     buf = [];
+    keydownVerdicts = 0;
+}
+export function interactionTraceKeydownCount() {
+    return keydownVerdicts;
 }
 export function interactionTraceSnapshot() {
     return buf.slice();
@@ -103,3 +110,11 @@ export function traceStickyReset() {
         return;
     record('sticky-column', 'reset');
 }
+/** `handled` is the event's own `defaultPrevented`: whether the editor claimed the press.
+ *  Recorded once per keydown, after the surface handler's await chain has settled. */
+export function traceKeydownVerdict(key, handled) {
+    if (!enabled)
+        return;
+    keydownVerdicts++;
+    record('keydown', 'verdict', { key, handled });
+}

package/dist/decorations/decoration-state.svelte.js

@@ -5,7 +5,7 @@ import { islandPosition } from './island-dom';
 import { assertInvariant } from '../assert';
 import { isCommitInProgress } from '../invariants/commit-scope';
 import { contentLengthOf, isProseKind } from '../core/inline';
-import { isBlockNode, nodeAt } from '../tree-operations/node-ops';
+import { isBlockNode, nodeAt } from '../tree-operations/node-primitives';
 import { devWarn } from '../dev-warn';
 import { recordDecorationRun } from '../perf/instruments';
 const EMPTY_MARKS = [];

package/dist/editor-actions/ancestry-folds.d.ts

@@ -1,10 +1,10 @@
 /**
- * Publishing side of the ancestry settle (`tree-operations/unshare.ts`): a fold at a container's
+ * Publishing side of the ancestry settle (`tree-operations/chain-rebuild.ts`): a fold at a container's
  * own slot splices its PARENT's children, a scope the commit's own change descriptor never
  * covers, so that scope's ids and refs are resynced here instead.
  */
 import type { CstNode } from '../core/nodes';
-import type { AncestrySeamFold } from '../tree-operations/unshare';
+import type { AncestrySeamFold } from '../tree-operations/chain-rebuild';
 import { type StructuralChange } from '../tree-operations/structural-change';
 import type { EditorActionsDeps } from './deps';
 /** Where the folded container's first byte ended up, as a document path. */

package/dist/editor-actions/ancestry-folds.js

@@ -1,5 +1,5 @@
 /**
- * Publishing side of the ancestry settle (`tree-operations/unshare.ts`): a fold at a container's
+ * Publishing side of the ancestry settle (`tree-operations/chain-rebuild.ts`): a fold at a container's
  * own slot splices its PARENT's children, a scope the commit's own change descriptor never
  * covers, so that scope's ids and refs are resynced here instead.
  */

package/dist/editor-actions/block-edit-scope.js

@@ -44,7 +44,7 @@ export function createTopLevelScope(deps, controller) {
 // ── Container adapter ────────────────────────────────────────────────────────
 export function createContainerScope(state, deps) {
     return {
-        // A fold at this container's own slot detaches it (`tree-operations/unshare.ts`), so a
+        // A fold at this container's own slot detaches it (`tree-operations/chain-rebuild.ts`), so a
         // post-commit read can find the scope gone rather than merely empty.
         children: () => deps.node?.children ?? [],
         refAt: (i) => state.innerBlockRefs[i],

package/dist/editor-actions/commit/text-batch.d.ts

@@ -6,8 +6,9 @@
 export interface TextBatchDeps {
     /** Capture the pre-edit snapshot for the first keystroke of a batch. */
     pushSnapshot(leafPath: number[], offset: number): void;
-    /** Emit the batched `input` edit event when a batch flushes. */
-    emitInput(leafPath: number[], byteLength: number): void;
+    /** Emit the batched `input` edit event when a batch flushes. Omitted by a batch with no edit
+     *  channel of its own: a revealed source's bytes reach it once, on the fold's commit. */
+    emitInput?(leafPath: number[], byteLength: number): void;
 }
 export interface TextBatch {
     /**

package/dist/editor-actions/commit/text-batch.js

@@ -17,7 +17,7 @@ export function createTextBatch(deps) {
      */
     function flushPendingInput() {
         if (batchByteLength > 0 && batchPath) {
-            deps.emitInput(batchPath, batchByteLength);
+            deps.emitInput?.(batchPath, batchByteLength);
         }
         batchPath = null;
         batchByteLength = 0;

package/dist/editor-actions/commit/undo-controller.js

@@ -12,8 +12,10 @@ import { assertInvariant } from '../../assert';
 import { beginCommit, endCommit } from '../../invariants/commit-scope';
 import { assignIds } from '../../block-id';
 import { replaceRefs } from '../../reactivity/publish-ref.svelte';
-import { nodeAt, settleSeparator } from '../../tree-operations/node-ops';
-import { attachedChainPrefix, ensureUnsharedPath, rebuildUnsharedChain } from '../../tree-operations/unshare';
+import { nodeAt } from '../../tree-operations/node-primitives';
+import { settleSeparator } from '../../tree-operations/settle';
+import { ensureUnsharedPath } from '../../tree-operations/unshare';
+import { attachedChainPrefix, rebuildUnsharedChain } from '../../tree-operations/chain-rebuild';
 import { foldLandingFor, publishAncestryFolds } from '../ancestry-folds';
 import { createTextBatch } from './text-batch';
 import { toEditEvent } from '../../editor-events';

package/dist/editor-actions/container-edit.js

@@ -2,7 +2,8 @@
  * ContainerEditActions factory: the debounced checkpoint pusher for raw typing
  * outside the commit primitive, the doc-root reactivity nudge, and `commitContainer`.
  */
-import { ensureUnsharedPath, rebuildUnsharedChain } from '../tree-operations/unshare';
+import { ensureUnsharedPath } from '../tree-operations/unshare';
+import { rebuildUnsharedChain } from '../tree-operations/chain-rebuild';
 import { publishAncestryFolds, publishScopeFold } from './ancestry-folds';
 export function createContainerEditActions(deps, controller) {
     return {

package/dist/editor-actions/enter-completion.d.ts

@@ -23,3 +23,5 @@ export interface EnterCompletion {
 export declare function withEnterCompletion(blockEdit: BlockEditActions, childAt: (index: number) => NodeView | undefined): BlockEditActions;
 /** The completion a press at `offset` earns, or null when the block or the caret disqualifies it. */
 export declare function planEnterCompletion(node: NodeView | undefined, offset: number): EnterCompletion | null;
+/** The completion a keystroke earns, consulting only the completers that answer on type. */
+export declare function planTypedCompletion(node: NodeView | undefined, offset: number): EnterCompletion | null;

package/dist/editor-actions/enter-completion.js

@@ -6,7 +6,7 @@
 import { parse } from '../core/parser';
 import { displayLength, splitLines, trailingLineEnding } from '../core/lines';
 import { getBlockKindDescriptor } from '../schema/block-kind-descriptor';
-import { completeTypedLine } from '../schema/block-completions';
+import { completeLineOnType, completeTypedLine } from '../schema/block-completions';
 /**
  * Wraps a COMPOSED `splitBlock` with the consult, at the two bundle composition sites only. Above
  * the container overrides rather than inside the split body, so a container that replaces
@@ -26,17 +26,38 @@ export function withEnterCompletion(blockEdit, childAt) {
             // `snapshotOffset` is where the caret WAS, so one undo restores the typed line with the
             // caret at its end rather than in front of it.
             await blockEdit.replaceBlock(index, completion.replacement, { replacementIndex: 0, ...completion.caret }, { snapshotOffset: offset });
+        },
+        // The typed arm: a keystroke that leaves the block as a line an on-type completer claims
+        // (see `BlockCompleter.onType`) forms the structure at once, the way a typed ` ``` ` is a
+        // fence the moment the parser sees it. The write lands first, so the typed line is its own
+        // undo step and the mint replaces the bytes the CST actually holds.
+        async updateBlockContent(index, text, preEditOffset, postEditFocusOffset) {
+            await blockEdit.updateBlockContent(index, text, preEditOffset, postEditFocusOffset);
+            const offset = postEditFocusOffset ?? preEditOffset;
+            if (offset === undefined)
+                return;
+            const completion = planTypedCompletion(childAt(index), offset);
+            if (!completion)
+                return;
+            await blockEdit.replaceBlock(index, completion.replacement, { replacementIndex: 0, ...completion.caret }, { snapshotOffset: offset });
         }
     };
 }
 /** The completion a press at `offset` earns, or null when the block or the caret disqualifies it. */
 export function planEnterCompletion(node, offset) {
+    return planCompletion(node, offset, completeTypedLine);
+}
+/** The completion a keystroke earns, consulting only the completers that answer on type. */
+export function planTypedCompletion(node, offset) {
+    return planCompletion(node, offset, completeLineOnType);
+}
+function planCompletion(node, offset, consult) {
     if (!node)
         return null;
     const line = wholeTypedLine(node);
     if (line === null || offset !== displayLength(node.raw))
         return null;
-    const claim = completeTypedLine(line);
+    const claim = consult(line);
     if (!claim)
         return null;
     // Through the parser rather than a hand-built node, so the mint is exactly what a reload of

package/dist/editor-actions/inline-range-commit.js

@@ -5,7 +5,7 @@
  */
 import { docPathFrom } from '../cursor/coordinate-spaces';
 import { expectStateForNode } from '../reactivity/state-registry';
-import { isBlockNode, nodeAt, normalizeOwnRaw, writeOwnRaw } from '../tree-operations/node-ops';
+import { isBlockNode, nodeAt, normalizeOwnRaw, writeOwnRaw } from '../tree-operations/node-primitives';
 import { ensureUnsharedChild, ensureUnsharedPath } from '../tree-operations/unshare';
 export function createInlineRangeCommit(deps) {
     async function commitInlineRange(path, start, end, bytes, caretAfter) {

package/dist/editor-actions/reorder-action.js

@@ -9,7 +9,7 @@
 import { CURSOR_START } from '../block-component';
 import { reorderChildrenWithTrivia } from '../tree-operations/reorder';
 import { resolveReorderUnit } from '../tree-operations/reorder-unit';
-import { blockNodeAt, nodeAt } from '../tree-operations/node-ops';
+import { blockNodeAt, nodeAt } from '../tree-operations/node-primitives';
 import { renumberOrderedList } from '../tree-operations/list/ordered-markers';
 import { expectStateForNode } from '../reactivity/state-registry';
 import { readCurrentSelection } from '../selection/native-bridge';
@@ -25,7 +25,7 @@ export function createReorderAction(deps, controller, onReorder) {
     function caretOffset() {
         return readCurrentSelection(deps.selectionState, deps.blockRefs)?.focus.offset ?? 0;
     }
-    async function commitReorder(unit, to, offset) {
+    async function commitReorder(unit, to, offset, focusAfter) {
         let landing = to;
         if (unit.scope === 'document') {
             await controller.commitStructural({
@@ -36,11 +36,14 @@ export function createReorderAction(deps, controller, onReorder) {
                     eventPath: docPathFrom([unit.index])
                 },
                 mutate: (children) => {
-                    const settled = reorderChildrenWithTrivia(children, unit.index, to, deps.sharing);
+                    const settled = reorderChildrenWithTrivia(children, unit.index, to, deps.sharing, true);
                     landing = settled.landing;
                     return settled.change;
                 },
-                afterTick: () => deps.blockRefs[landing]?.focus(CURSOR_START)
+                afterTick: () => {
+                    if (focusAfter)
+                        deps.blockRefs[landing]?.focus(CURSOR_START);
+                }
             });
             return { landing, total: deps.doc.children.length };
         }
@@ -69,7 +72,10 @@ export function createReorderAction(deps, controller, onReorder) {
                 }
                 return settled.change;
             },
-            afterTick: () => state.innerBlockRefs[landing]?.focus(CURSOR_START)
+            afterTick: () => {
+                if (focusAfter)
+                    state.innerBlockRefs[landing]?.focus(CURSOR_START);
+            }
         });
         // Re-resolved, not `parent`: the ceremony's copy-on-write replaced that node, so the one
         // this action resolved still holds the pre-move children.
@@ -86,19 +92,22 @@ export function createReorderAction(deps, controller, onReorder) {
             return null;
         return { unit, to };
     }
-    async function run(fromPath, computeTo) {
+    async function run(fromPath, computeTo, focusAfter) {
         const target = resolveAndClamp(fromPath, computeTo);
         if (!target)
             return;
         // Drop any cross-block selection so the overlay doesn't fight the move; the
-        // commit's afterTick re-places the caret.
+        // commit's afterTick re-places the caret when the caller wants it.
         deps.selectionState.collapse();
-        const outcome = await commitReorder(target.unit, target.to, caretOffset());
+        const outcome = await commitReorder(target.unit, target.to, caretOffset(), focusAfter);
         if (outcome)
             onReorder?.(outcome.landing, outcome.total);
     }
     return {
-        moveReorderUnit: (fromPath, toIndex) => run(fromPath, () => toIndex),
-        nudgeReorderUnit: (fromPath, dir) => run(fromPath, (index) => index + dir)
+        // A dropped block is not a block you asked to edit: focusing it opens whatever a caret
+        // opens there (an equation reveals its source), which is not what a drag asked for.
+        // The keyboard nudge is the opposite — the caret must ride the block it is moving.
+        moveReorderUnit: (fromPath, toIndex) => run(fromPath, () => toIndex, false),
+        nudgeReorderUnit: (fromPath, dir) => run(fromPath, (index) => index + dir, true)
     };
 }

package/dist/editor-actions/reorder-drag.js

@@ -144,9 +144,37 @@ function indexOf(host) {
         return readBlockPath(host)?.at(-1) ?? null;
     return readBlockPath(host.querySelector('[data-block-path]'))?.at(-2) ?? null;
 }
+/**
+ * What the block IS, for the kinds whose text does not read as a label: a table's cells run
+ * together into `IngredientAmountWater35 L`, an equation reads as its own source. Prose keeps
+ * its first words, which is the best label it could have.
+ */
+const KIND_LABELS = {
+    table: 'Table',
+    mathBlock: 'Equation',
+    fencedCode: 'Code',
+    mermaid: 'Diagram',
+    thematicBreak: 'Divider',
+    details: 'Details',
+    image: 'Image'
+};
 function ghostLabel(host) {
+    const kind = host.dataset.blockKind ?? '';
+    if (kind === 'table')
+        return tableLabel(host);
+    const named = KIND_LABELS[kind];
+    if (named)
+        return named;
     const text = (host.textContent ?? '').trim().replace(/\s+/g, ' ');
     if (!text)
-        return 'block';
+        return host.querySelector('[data-image-widget]') ? 'Image' : 'Block';
     return text.length > 40 ? text.slice(0, 40) + '…' : text;
 }
+/** Body rows × columns: the shape is what tells one table from another at a glance. */
+function tableLabel(host) {
+    const rows = host.querySelectorAll('.table-row').length;
+    const cols = host.querySelector('.table-row')?.childElementCount ?? 0;
+    if (rows === 0 || cols === 0)
+        return 'Table';
+    return `Table · ${rows} × ${cols}`;
+}

package/dist/editor-actions/replacement-focus.d.ts

@@ -3,7 +3,7 @@
  * probe that picks structural-vs-typing, and the post-commit caret restore.
  */
 import { updateNodeContent } from '../tree-operations';
-import { type SettledContent } from '../tree-operations/node-ops';
+import { type SettledContent } from '../tree-operations/content-write';
 import { type AnyBlockKind } from '../core/nodes';
 import type { NodeView } from '../core/node-views';
 import type { StructuralChange } from '../tree-operations/structural-change';

package/dist/editor-actions/replacement-focus.js

@@ -3,7 +3,7 @@
  * probe that picks structural-vs-typing, and the post-commit caret restore.
  */
 import { updateNodeContent } from '../tree-operations';
-import { settledCaretTarget } from '../tree-operations/node-ops';
+import { settledCaretTarget } from '../tree-operations/content-write';
 import { makeBlockNode } from '../core/nodes';
 import { readBlockPath } from '../selection/path-lookup';
 // ── Reparse probe ────────────────────────────────────────────────────────────

package/dist/editor-actions/search-replace.js

@@ -2,7 +2,7 @@ import { parse } from '../core/parser';
 import { cloneNode } from '../tree-operations/clone';
 import { spliceMany } from '../tree-operations/splice-many';
 import { getBlockKindDescriptor } from '../schema/block-kind-descriptor';
-import { normalizeBodyWrite, normalizeReplacementTrivia, writeOwnRaw } from '../tree-operations/node-ops';
+import { normalizeBodyWrite, normalizeReplacementTrivia, writeOwnRaw } from '../tree-operations/node-primitives';
 import { rebuildAncestryRaw } from '../schema/container-raw';
 import { replacePreservingFirst, stampStructuralChange } from '../tree-operations/structural-change';
 import { applyRangesToText } from '../search/replace';

package/dist/editor-actions/table-context.d.ts

@@ -4,6 +4,7 @@
  * live here.
  */
 import type { CellPosition, ContainerEditActions, TableContext } from '../action-contracts';
+import type { GrammarView } from '../schema/block-openers';
 import type { NodeView } from '../core/node-views';
 import type { UndoController } from './deps';
 import type { BlockListState } from '../reactivity/block-list-state.svelte';
@@ -29,6 +30,8 @@ export interface TableMutationsContextDeps {
     controller: UndoController;
     focusCell: (rowIdx: number, colIdx: number, position: CellPosition) => void;
     announceReorder: (message: string) => void;
+    /** The instance grammar the cell byte-write door threads (absent: the global one). */
+    grammar?: GrammarView;
 }
-export type TableMutationsContext = Pick<TableContext, 'insertRowAbove' | 'insertRowBelow' | 'insertColumnLeft' | 'insertColumnRight' | 'deleteRow' | 'deleteColumn' | 'reorderRowTo' | 'moveRowUp' | 'moveRowDown' | 'reorderColumnTo' | 'moveColumnLeft' | 'moveColumnRight' | 'cycleAlignment' | 'setColumnAlignment'>;
+export type TableMutationsContext = Pick<TableContext, 'insertRowAbove' | 'insertRowBelow' | 'insertColumnLeft' | 'insertColumnRight' | 'deleteRow' | 'deleteColumn' | 'reorderRowTo' | 'moveRowUp' | 'moveRowDown' | 'reorderColumnTo' | 'moveColumnLeft' | 'moveColumnRight' | 'cycleAlignment' | 'setColumnAlignment' | 'pasteGrid'>;
 export declare function createTableMutationsContext(deps: TableMutationsContextDeps): TableMutationsContext;

package/dist/editor-actions/table-context.js

@@ -8,8 +8,9 @@ import { extendDocPath, docPathFrom } from '../cursor/coordinate-spaces';
 import { getStateForNode } from '../reactivity/state-registry';
 import { assertInvariant } from '../assert';
 import { columnAligned, COLUMN_ALIGNMENT_CLEARED, DELETED_COLUMN, DELETED_ROW, INSERTED_COLUMN, INSERTED_ROW, movedColumnToPosition, movedRowToPosition } from '../a11y-strings';
-import { ensureUnsharedChildren } from '../tree-operations/unshare';
+import { ensureUnsharedChildren, ensureUnsharedSubtree } from '../tree-operations/unshare';
 import { rebuildTableRowRaw, rebuildTableRaw } from '../schema/container-rebuilders';
+import { writeOwnRaw } from '../tree-operations/node-primitives';
 import { reorderChildren } from '../tree-operations/reorder';
 import { insertEmptyRow, insertEmptyColumn, deleteRow as mutDeleteRow, deleteColumn as mutDeleteColumn, moveColumn as mutMoveColumn, cycleAlignment as mutCycleAlignment, setAlignment as mutSetAlignment, canDeleteRow, canDeleteColumn } from '../tree-operations/table-mutations';
 /**
@@ -105,6 +106,60 @@ export function createTableMutationsContext(deps) {
             afterTick: opts.afterTick
         });
     }
+    // Grown at the bottom and the right only, so each scope's change is one contiguous insert:
+    // rows for the table, cells for every mounted row. Cell texts go through the cell kind's own
+    // raw rule in place, and the table raw is rebuilt once, delimiter line included.
+    async function pasteGrid(origin, grid) {
+        const { myPath, controller, focusCell } = deps;
+        const rows = grid.length;
+        let cols = 0;
+        for (const line of grid)
+            cols = Math.max(cols, line.length);
+        if (rows === 0 || cols === 0)
+            return;
+        const { scopes, rowIndices } = mountedColumnScopes();
+        await controller.commitMultiScope({
+            scopes,
+            snapshot: { path: docPathFrom(myPath), offset: 0 },
+            mutate: ([tableScope, ...rowScopes]) => {
+                // Subtree, not children: the cell writes below land at depth two, and a row's
+                // cells stay shared with the undo snapshot when only the rows are unshared —
+                // the write would go through it and undo would restore the pasted bytes.
+                ensureUnsharedSubtree(tableScope.node, tableScope.sharing);
+                assertInvariant('column-scope-alignment', () => rowScopes.every((s, i) => s.node === tableScope.node.children?.[rowIndices[i]])
+                    ? null
+                    : {
+                        code: 'column-scope-alignment',
+                        message: 'pasteGrid: row scopes misaligned with owned table children'
+                    });
+                const table = tableScope.node;
+                const oldRows = table.children?.length ?? 0;
+                const oldCols = metadataOf(table, 'table').columnCount;
+                const needRows = origin.rowIdx + rows;
+                const needCols = origin.colIdx + cols;
+                for (let r = oldRows; r < needRows; r++)
+                    insertEmptyRow(table, r - 1, 'below');
+                for (let c = oldCols; c < needCols; c++)
+                    insertEmptyColumn(table, c - 1, 'right');
+                grid.forEach((line, r) => {
+                    const cells = table.children[origin.rowIdx + r].children;
+                    line.forEach((text, c) => writeOwnRaw(cells[origin.colIdx + c], text, deps.grammar));
+                });
+                rebuildTableRaw(table);
+                const addedRows = needRows - oldRows;
+                const addedCols = needCols - oldCols;
+                const tableChange = addedRows > 0 ? { op: 'insert', at: oldRows, count: addedRows } : { op: 'noop' };
+                const rowChange = addedCols > 0 ? { op: 'insert', at: oldCols, count: addedCols } : { op: 'noop' };
+                return [tableChange, ...rowScopes.map(() => rowChange)];
+            },
+            op: {
+                kind: 'tablePasteGrid',
+                detail: { rowIdx: origin.rowIdx, colIdx: origin.colIdx, rows, cols },
+                eventPath: docPathFrom(myPath)
+            },
+            afterTick: () => focusCell(origin.rowIdx + rows - 1, origin.colIdx + cols - 1, 'end')
+        });
+    }
     async function insertColumn(colIdx, side) {
         const { focusCell, focusedCell } = deps;
         const insertAt = side === 'left' ? colIdx : colIdx + 1;
@@ -187,6 +242,7 @@ export function createTableMutationsContext(deps) {
     return {
         insertRowAbove: (rowIdx) => insertRow(rowIdx, 'above'),
         insertRowBelow: (rowIdx) => insertRow(rowIdx, 'below'),
+        pasteGrid,
         insertColumnLeft: (colIdx) => insertColumn(colIdx, 'left'),
         insertColumnRight: (colIdx) => insertColumn(colIdx, 'right'),
         reorderRowTo,

package/dist/editor-events.d.ts

@@ -54,6 +54,9 @@ export interface EditorEventMap {
     /** The theme name after a `theme` prop change (never fired at mount), for a plugin
      *  that paints its own colors and so cannot pick the change up from CSS. */
     themeChange: string;
+    /** `true` when an editor-owned menu (right-click, insert `+`) opens, `false` when it closes,
+     *  so host chrome over the selection can step aside rather than stack on it. */
+    menuChange: boolean;
 }
 export interface EditorEvents {
     on<K extends keyof EditorEventMap>(event: K, handler: (payload: EditorEventMap[K]) => void): () => void;