@voithos-labs/aragonite 0.10.2 → 0.10.4

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/plugins/mermaid/MermaidBlock.svelte

@@ -32,6 +32,7 @@
 		updateOwnMetadata,
 		handleKeydown,
 		moveFocusOut,
+		captureScrollPosition,
 		getPresentationMode,
 		getTheme
 	} = createContainerBlock({
@@ -142,22 +143,20 @@
 	const view = createPanZoom();
 	const overlayView = createPanZoom();
 
-	// Focus-gated so the in-document diagram never hijacks the page: unfocused, a bare
-	// wheel scrolls and a stray drag cannot pan. Any descendant focus counts.
-	const isFocused = () => !!boxEl?.contains(document.activeElement);
+	// Armed by focus, so an unfocused diagram hijacks neither the page nor the editor's own drag.
+	// Tracked rather than probed: the editor reads the same fact as markup, so there is one value.
+	let gestureArmed = $state(false);
 
 	function onViewportWheel(e: WheelEvent): void {
-		if (!isFocused() || !(e.ctrlKey || e.metaKey)) return;
+		if (!gestureArmed || !(e.ctrlKey || e.metaKey)) return;
 		e.preventDefault();
 		e.stopPropagation();
 		view.zoomBy(e.deltaY);
 	}
 
 	function onViewportPointerDown(e: PointerEvent): void {
-		// Never preventDefault, so the browser's focus-on-mousedown still lands: the
-		// first click focuses, and only a drag on the now-focused block pans.
 		e.stopPropagation();
-		if (isFocused()) view.beginPan(e);
+		if (gestureArmed) view.beginPan(e);
 	}
 
 	function onOverlayWheel(e: WheelEvent): void {
@@ -219,8 +218,11 @@
 		// there too, so this closes the command path.
 		if (isReading) return;
 		if (!editing) seedDraft();
+		// Captured BEFORE the flip: the card reaches its fitted height only after mounting, and
+		// a scrollport at the document's end clamps against the short layout in between.
+		const restoreScroll = captureScrollPosition();
 		editRequested = true;
-		void tick().then(() => textareaEl?.focus());
+		void restoreScroll().then(() => textareaEl?.focus());
 	}
 
 	function cancelEdit(): void {
@@ -306,7 +308,13 @@
 </script>
 
 <!-- svelte-ignore a11y_no_static_element_interactions -->
-<div class="mermaid-block" bind:this={boxEl} onkeydown={handleKeydown}>
+<div
+	class="mermaid-block"
+	bind:this={boxEl}
+	onkeydown={handleKeydown}
+	onfocusin={() => (gestureArmed = true)}
+	onfocusout={(e) => (gestureArmed = boxEl?.contains(e.relatedTarget as Node | null) ?? false)}
+>
 	{#if editing}
 		<textarea
 			bind:this={textareaEl}
@@ -330,6 +338,7 @@
 			<!-- svelte-ignore a11y_no_noninteractive_tabindex -->
 			<div
 				class="mermaid-viewport"
+				data-pointer-gesture={gestureArmed ? '' : undefined}
 				tabindex="0"
 				role="img"
 				aria-label="Mermaid diagram"
@@ -392,6 +401,7 @@
 			</div>
 			<div
 				class="mermaid-overlay-viewport"
+				data-pointer-gesture
 				onwheel={onOverlayWheel}
 				onpointerdown={(e) => {
 					e.stopPropagation();

package/dist/plugins/parrot/ParrotBlock.svelte

@@ -273,7 +273,9 @@ cNd.........................................;lOc
 		font-size: 1.1em;
 		line-height: 1.1;
 		letter-spacing: 0.05em;
-		/* one frame tall, in the reel's own rows so a step lands on the next frame exactly */
+		/* one frame tall, in the reel's own rows so a step lands on the next frame exactly; the
+		   em line is the same height for engines without lh (Safari before 16.4) */
+		height: calc(var(--parrot-rows) * 1.1em);
 		height: calc(var(--parrot-rows) * 1lh);
 		/* wider than a phone column, and the editor root pans if it isn't contained; the bar
 		   would sit across the bird, which is decoration rather than a pane to scroll */

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)
@@ -43,7 +43,23 @@ export function createListWindowing(deps) {
     // structural rebuild needs the OLD ordering to remap the anchor by id, and by then
     // `getChildIds()` already reflects the new children. Copied — it is spliced in place.
     let modelChildIds = [];
-    function buildModel() {
+    /** What the CURRENT model holds, keyed by id, for a rebuild to carry across. The two lengths
+     *  diverge for one tick after a child change, and a slot past the model's end reads 0. */
+    function heightsById() {
+        const carried = new Map();
+        const known = Math.min(modelChildIds.length, model.size);
+        for (let i = 0; i < known; i++)
+            carried.set(modelChildIds[i], model.heightOf(i));
+        return carried;
+    }
+    /**
+     * A surviving block keeps the height the model measured (VR-15); `carried` is null only
+     * where a width or type-scale change has earned a reseed from the oracle. The cache behind
+     * those heights can be gone (a mode flip drops it, and a block whose box never moved reports
+     * no resize to put it back), so reseeding a structural rebuild would trade a whole document
+     * of measurements for estimates and scroll the reader by the difference.
+     */
+    function buildModel(carried) {
         const width = estimateWidth(deps.getListEl(), deps.getPort()?.contentWidth() ?? 0);
         const children = deps.getChildren();
         // Indexed, and off the snapshot: `map` pays a `has` trap beside every `get`, once per child.
@@ -51,15 +67,17 @@ export function createListWindowing(deps) {
         const count = children.length;
         const heights = new Array(count);
         for (let i = 0; i < count; i++) {
-            heights[i] = deps.oracle.height(modelChildIds[i], children[i], width);
+            const id = modelChildIds[i];
+            heights[i] =
+                deps.oracle.measured(id) ?? carried?.get(id) ?? deps.oracle.estimate(children[i], width);
         }
         return new HeightModel(heights);
     }
-    let model = $state(buildModel());
+    let model = $state(buildModel(null));
     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 +141,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,12 +166,12 @@ 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;
         if (delta !== 0 && port)
-            port.setScrollTop(port.scrollTop() + delta);
+            port.scrollBy(delta);
     }
     // The structural-rebuild variant of correctAnchor. A count change shifts every index
     // above it, so the numeric form would measure a DIFFERENT block at index N and mis-correct
@@ -168,7 +200,7 @@ export function createListWindowing(deps) {
             return;
         const delta = model.offsetOf(newIndex) - before;
         if (delta !== 0 && port)
-            port.setScrollTop(port.scrollTop() + delta);
+            port.scrollBy(delta);
     }
     let lastWidthVersion = deps.getWidthVersion();
     // Rebuild on any structural child change or an editor WIDTH change, never per keystroke.
@@ -188,8 +220,10 @@ export function createListWindowing(deps) {
             // the re-measure compares measured-before against all-estimate-after, and lands the
             // anchor a block off wherever the poisoned model names a different top child (#188).
             // Width only — re-measuring on a structural edit costs a reflow per split.
+            // Read off the OLD model, so the carry is taken before the rebuild replaces it.
+            const carried = widthChanged ? null : heightsById();
             correctAnchorByStableId(() => {
-                model = buildModel();
+                model = buildModel(carried);
                 heightVersion++;
                 if (widthChanged)
                     remeasureMounted();
@@ -258,22 +292,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 +383,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 +407,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/commands.d.ts

@@ -19,10 +19,10 @@ export type GlobalCommandId = (typeof GLOBAL_COMMAND_IDS)[number];
 export type BlockCommandId = (typeof BLOCK_COMMAND_IDS)[number];
 export type CommandId = GlobalCommandId | BlockCommandId;
 /**
- * Commands whose arms rewrite one block's bytes around that block's own selection and have no
- * cross-block reading: the dispatch seam declines them outright while a range is painted.
- * Membership is the arm's shape, not the id's prefix — the link card mints its link over one
- * block's offsets, and a range gives it no one block to mint into.
+ * Commands whose arms rewrite one block and have no cross-block reading: the dispatch seam
+ * declines them outright while a range is painted. Membership is the arm's shape, not the id's
+ * prefix: the link card mints over one block's offsets and a heading level belongs to one block,
+ * so a range spanning blocks leaves neither of them a subject to act on.
  */
 export declare const RANGE_DECLINED_COMMAND_IDS: ReadonlySet<string>;
 /**
@@ -34,7 +34,9 @@ export declare const RANGE_DECLINED_COMMAND_IDS: ReadonlySet<string>;
 export declare const CROSS_BLOCK_RANGE_COMMAND_IDS: ReadonlySet<string>;
 /**
  * The command ids a host's selection toolbar invokes through `EditorInstance.runCommand`. The
- * rest of the vocabulary stays internal until the command registry unifies it.
+ * rest of the vocabulary stays internal until the command registry unifies it. Every id here
+ * answers the range question in one of the two sets above, so `canRunCommand` tells a bar which
+ * of its buttons a cross-block selection leaves nothing to act on.
  */
 export declare const TOOLBAR_COMMANDS: {
     readonly toggleStrong: "format.toggleStrong";
@@ -43,6 +45,8 @@ export declare const TOOLBAR_COMMANDS: {
     readonly toggleCode: "format.toggleCode";
     /** The link editor Mod+K opens: over a selection it creates, inside a link it edits. */
     readonly editLink: "link.openCard";
+    /** The heading picker's arm, taking the level as its argument; 0 is normal text. */
+    readonly setHeading: "heading.cycle";
 };
 /** Minimal context a global command needs; HistoryActions is structurally compatible. */
 export interface GlobalCommandContext {

package/dist/schema/commands.js

@@ -44,13 +44,14 @@ export const BLOCK_COMMAND_IDS = [
     'chrome.descendToBody'
 ];
 /**
- * Commands whose arms rewrite one block's bytes around that block's own selection and have no
- * cross-block reading: the dispatch seam declines them outright while a range is painted.
- * Membership is the arm's shape, not the id's prefix — the link card mints its link over one
- * block's offsets, and a range gives it no one block to mint into.
+ * Commands whose arms rewrite one block and have no cross-block reading: the dispatch seam
+ * declines them outright while a range is painted. Membership is the arm's shape, not the id's
+ * prefix: the link card mints over one block's offsets and a heading level belongs to one block,
+ * so a range spanning blocks leaves neither of them a subject to act on.
  */
 export const RANGE_DECLINED_COMMAND_IDS = new Set([
-    'link.openCard'
+    'link.openCard',
+    'heading.cycle'
 ]);
 /**
  * The same one-block arms, but with a cross-block one behind them
@@ -66,7 +67,9 @@ export const CROSS_BLOCK_RANGE_COMMAND_IDS = new Set([
 ]);
 /**
  * The command ids a host's selection toolbar invokes through `EditorInstance.runCommand`. The
- * rest of the vocabulary stays internal until the command registry unifies it.
+ * rest of the vocabulary stays internal until the command registry unifies it. Every id here
+ * answers the range question in one of the two sets above, so `canRunCommand` tells a bar which
+ * of its buttons a cross-block selection leaves nothing to act on.
  */
 export const TOOLBAR_COMMANDS = {
     toggleStrong: 'format.toggleStrong',
@@ -74,7 +77,9 @@ export const TOOLBAR_COMMANDS = {
     toggleStrikethrough: 'format.toggleStrikethrough',
     toggleCode: 'format.toggleCode',
     /** The link editor Mod+K opens: over a selection it creates, inside a link it edits. */
-    editLink: 'link.openCard'
+    editLink: 'link.openCard',
+    /** The heading picker's arm, taking the level as its argument; 0 is normal text. */
+    setHeading: 'heading.cycle'
 };
 const globalCommands = new Map();
 export function registerCommand(id, run) {

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');