@voithos-labs/aragonite 0.10.3 → 0.10.7

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

@@ -1,75 +1,124 @@
 /**
- * The fencedCode raw-write rule, declared on the kind as `normalizeRawWrite` and applied at every
- * write sink. RESTORE re-appends a closer a truncating write dropped and DROP removes one it
- * stranded, ESCALATE grows both runs past a body line that would read as the closer, SANITIZE
- * drops backticks from a backtick fence's info string (CommonMark §4.5) — all off the block's OWN
- * fence shape, which is why the pass takes a node. An authored open fence is exempt.
+ * The rule for writing a fenced block's bytes, declared on the kind as `rawWrite`: it restores or
+ * drops fence lines a write broke, grows the marker runs past a body line that would close them,
+ * and keeps backticks out of a backtick fence's info string, moving the caret with every byte. A
+ * fence the user is still typing (open, `authored`) is left alone.
  */
 import { metadataOf } from '../core/nodes';
-import { trailingLineEnding, trimTrailingLineEnding } from '../core/lines';
-import { escalatedFenceLength, matchFenceClose, matchFenceOpen } from '../core/parsers/fence-syntax';
+import { displayLines, firstDisplayLine, firstLineEnding, joinDisplayLines, ownTrailingLineEnding, trailingLineEnding, trimTrailingLineEnding } from '../core/lines';
+import { escalatedFenceLength, fenceAnatomy, fenceRunLength, matchFenceClose, matchFenceOpen } from '../core/parsers/fence-syntax';
 // ── Public API ──────────────────────────────────────────────────────────────
 export function fenceShapeOf(node) {
     const meta = metadataOf(node, 'fencedCode');
     return { marker: meta.fenceMarker, length: meta.fenceLength, closed: meta.closed };
 }
-export function reconcileFenceWrite(input) {
-    const { fence, mode } = input;
-    if (!fence.closed && mode === 'authored')
-        return { display: input.display, caret: input.caret };
-    const unglued = separateGluedCloser(input);
-    return escalateFenceRuns({ ...input, ...sanitizeInfoString({ ...input, ...unglued }) });
+/** The fence write rule for a kind whose fence shape `shapeOf` reads off the block. */
+export function fenceRawWrite(shapeOf) {
+    return {
+        normalize: (raw, ctx) => reconcileFenceRaw(raw, 0, shapeOf(ctx.node), ctx).raw,
+        mapOffset: (raw, offset, ctx) => reconcileFenceRaw(raw, offset, shapeOf(ctx.node), ctx).offset
+    };
+}
+/** The built-in code block's rule, sized by its parsed metadata. */
+export const fencedCodeWrite = fenceRawWrite(fenceShapeOf);
+/**
+ * The shape of a fenced block that keeps no fence metadata, read off its own opener line. A
+ * plugin kind declares its rule as `fenceRawWrite(fenceShapeOfRaw)`.
+ */
+export function fenceShapeOfRaw(node) {
+    const anatomy = fenceAnatomy(node.raw);
+    return anatomy
+        ? { marker: anatomy.marker, length: anatomy.length, closed: anatomy.closed }
+        : { marker: '`', length: 3, closed: false };
 }
 /**
- * A whole fencedCode `raw` made legal — the kind's `normalizeRawWrite`. Literal by
- * construction: a sink reaching a node's bytes without its surface is never the author
- * typing the block's own syntax. The fence lines reconcile first, so ESCALATE measures a
- * body that ends where the closer does.
+ * The display text of a fenced block made legal, the caret carried along. The fence lines are
+ * fixed before the runs grow, so growing measures a body that ends where the closer does.
  */
-export function normalizeFencedRaw(raw, node) {
-    const fence = fenceShapeOf(node);
-    const written = reconcileFenceWrite({
-        display: reconcileFenceLines(trimTrailingLineEnding(raw), fence, trailingLineEnding(node.raw)),
-        caret: 0,
-        fence,
-        mode: 'literal'
-    });
-    return written.display + trailingLineEnding(raw);
+export function reconcileFenceWrite(input) {
+    const { mode, ending } = input;
+    if (!input.fence.closed && mode === 'authored') {
+        return { display: input.display, caret: input.caret };
+    }
+    const widened = widenedCloser(input);
+    const fence = widened?.fence ?? writtenFence(input.display, input.fence, mode);
+    const unglued = separateGluedCloser({ ...input, ...widened?.written, fence });
+    const lines = reconcileFenceLines(unglued, fence, ending);
+    const sanitized = sanitizeInfoString({ ...input, ...lines, fence });
+    return escalateFenceRuns({ ...input, ...sanitized, fence });
 }
 /**
- * The bytes with `info` written onto the opening fence line. Only that span moves, so the
- * indent, both marker runs, the body and the closer come through byte-identical. Null when
- * line 0 does not read as this block's opener at all.
+ * The bytes with `info` written onto the opener line, everything else byte-identical. Null when
+ * line 0 does not read as this block's opener.
  */
 export function writeFenceInfo(display, info, fence) {
-    const lineEnd = firstLineEnd(display);
-    const line = display.slice(0, lineEnd);
-    const opener = splitOpener(line, fence);
+    const first = firstDisplayLine(display);
+    const opener = splitOpener(first.text, fence);
     if (!opener)
         return null;
-    // A CRLF separator's `\r` sits inside the line; the info span ends before it.
-    const infoEnd = lineEnd - (line.endsWith('\r') ? 1 : 0);
-    return display.slice(0, opener.runEnd) + legalInfo(info, fence) + display.slice(infoEnd);
+    return (display.slice(0, opener.runEnd) +
+        legalFenceInfo(info, fence.marker) +
+        display.slice(first.text.length));
 }
-// ── Internal ────────────────────────────────────────────────────────────────
 /**
- * What the info span may hold: one line, no backtick under a backtick fence (CommonMark §4.5),
- * and no leading run of the fence's own marker, which lengthens the fence instead — `~~~` + `~x`
- * reparses as a four-tilde run its own closer no longer closes. Dropped rather than declined,
- * the rule the typed and pasted routes already share.
+ * `info` less what an info string may not hold: a line break, a backtick under a backtick fence,
+ * and a leading run of the fence's own marker, which would lengthen the fence (`~~~` plus `~x`).
  */
-function legalInfo(info, fence) {
+export function legalFenceInfo(info, marker) {
     const oneLine = info.replace(/[\r\n]/g, '');
-    const kept = fence.marker === '`' ? oneLine.replaceAll('`', '') : oneLine;
+    const kept = marker === '`' ? oneLine.replaceAll('`', '') : oneLine;
     let start = 0;
-    while (kept[start] === fence.marker)
+    while (kept[start] === marker)
         start++;
     return kept.slice(start);
 }
+// ── Internal ────────────────────────────────────────────────────────────────
+/**
+ * A whole `raw` through the rule, with an offset into it carried along. The trailing line ending
+ * is the written one, else the block's own: an unterminated last block stays unterminated.
+ */
+function reconcileFenceRaw(raw, offset, fence, ctx) {
+    const ending = trailingLineEnding(ctx.node.raw, ctx.lineEnding);
+    const display = trimTrailingLineEnding(raw);
+    const tail = ownTrailingLineEnding(raw) || ownTrailingLineEnding(ctx.node.raw);
+    const caret = Math.min(offset, display.length);
+    const written = reconcileFenceWrite({ display, caret, fence, mode: ctx.mode, ending });
+    const intoTail = Math.min(Math.max(offset - display.length, 0), tail.length);
+    return { raw: written.display + tail, offset: written.caret + intoTail };
+}
+/**
+ * The fence the written bytes carry: a literal write is read as the grammar reads it, so a replace
+ * that resized the opener run resizes the fence; typing keeps the block's own run.
+ */
+function writtenFence(display, fence, mode) {
+    if (mode === 'authored')
+        return fence;
+    const anatomy = fenceAnatomy(firstDisplayLine(display).text, { marker: fence.marker, length: 3 });
+    return anatomy ? { ...fence, length: anatomy.length } : fence;
+}
 /**
- * Split by the block's OWN run length, not by re-scanning the written line: a backtick
- * typed at the head of the info string must read as info, not as a longer run.
+ * A marker typed or pasted onto the opener's run lengthens the fence, so the closer grows to match:
+ * a closer shorter than its opener closes nothing, and the fence would take every block below.
  */
+function widenedCloser(input) {
+    const { display, caret, fence } = input;
+    const lines = displayLines(display);
+    const opener = fenceAnatomy(lines[0].text, fence);
+    const closerIndex = lastCloserIndex(lines, fence);
+    if (!opener || opener.length === fence.length || closerIndex < 1)
+        return null;
+    const closer = lines[closerIndex].text;
+    const grow = Math.max(opener.length - fenceRunLength(closer, fence.marker), 0);
+    const at = lineStartOffset(display, closerIndex) + /^ */.exec(closer)[0].length;
+    return {
+        written: {
+            display: display.slice(0, at) + fence.marker.repeat(grow) + display.slice(at),
+            caret: caret > at ? caret + grow : caret
+        },
+        fence: { ...fence, length: opener.length }
+    };
+}
+/** Split at the fence's known run length, so a marker past it reads as info string. */
 function splitOpener(line, fence) {
     const indent = /^ {0,3}/.exec(line)[0];
     const runEnd = indent.length + fence.length;
@@ -78,83 +127,88 @@ function splitOpener(line, fence) {
     return { indent, info: line.slice(runEnd), runEnd };
 }
 /**
- * The block's fence lines against a write that took one of them — an unclosed fence absorbs every
- * block below it at the next parse, from either half. With the block's own opener still at line 0
- * a missing closer comes back; without it a surviving closer is machinery the write stranded and
- * goes. The arms split on {@link ownOpener}, so exactly one can fire.
+ * A fence left open swallows every block below it, so a write that removed one fence line gets its
+ * closer back (its own opener still on line 0) or loses the closer it stranded.
  */
-function reconcileFenceLines(display, fence, blockEnding) {
+function reconcileFenceLines(written, fence, blockEnding) {
     if (!fence.closed)
-        return display;
-    const lines = display.split('\n');
+        return written;
+    const lines = displayLines(written.display);
     const opener = ownOpener(lines, fence);
-    const reconciled = opener
-        ? restoredCloser(lines, fence, opener, blockEnding)
-        : droppedStrandedCloser(lines, fence);
-    return reconciled ?? display;
+    if (!opener)
+        return droppedStrandedCloser(lines, fence, written.caret) ?? written;
+    const restored = restoredCloser(lines, fence, opener, blockEnding);
+    // The closer goes in after every written byte, so no offset moves.
+    return restored === null ? written : { display: restored, caret: written.caret };
 }
 /**
- * Line 0 read as the block's OWN opener: its exact run, and info that is not a longer run. A
- * write's only line reading as this fence's CLOSER is not it — an opener never doubles as one,
- * and no metadata claims a block to size a fence to.
+ * Line 0 read as the block's own opener, at the run {@link writtenFence} sized. A write whose
+ * only line reads as this fence's closer is not one: an opener never doubles as a closer.
  */
 function ownOpener(lines, fence) {
-    const opener = splitOpener(lines[0], fence);
-    if (!opener || opener.info.startsWith(fence.marker))
+    const opener = splitOpener(lines[0].text, fence);
+    if (!opener)
         return null;
-    if (lines.length === 1 && matchFenceClose(lines[0], fence.marker, fence.length))
+    if (lines.length === 1 && matchFenceClose(lines[0].text, fence.marker, fence.length))
         return null;
     return opener;
 }
 /**
- * The closer a truncating write dropped, re-appended, or null when one is still there. The ending
- * is the BLOCK's, not the written slice's, which may be unterminated (G4.20).
+ * Puts back the closer a truncating write dropped, or null when one is still there. The line
+ * ending is the block's, not the written slice's, which may have none.
  */
 function restoredCloser(lines, fence, opener, blockEnding) {
     if (lastCloserIndex(lines, fence) !== -1)
         return null;
-    return lines.join('\n') + blockEnding + opener.indent + fence.marker.repeat(fence.length);
+    const closer = opener.indent + fence.marker.repeat(fence.length);
+    return joinDisplayLines(lines) + blockEnding + closer;
 }
 /**
- * The closer a write left behind after taking the block's own opener — machinery no metadata
- * claims, removed rather than kept, since as text it re-opens a fence over the live siblings
- * below. Null when there is none, or when an opener above could CLOSE on the run:
- * same marker, run no longer than the closer's — a foreign-marker or longer-run open line is
- * body text the run never terminated.
+ * Drops the closer a write stranded by removing the opener, since as text it would open a fence
+ * below. Null when there is none, or a line above opens a same-marker run it would close.
  */
-function droppedStrandedCloser(lines, fence) {
+function droppedStrandedCloser(lines, fence, caret) {
     const closer = lastCloserIndex(lines, fence, 0);
     if (closer === -1)
         return null;
-    const run = /^ {0,3}([`~]+)/.exec(lines[closer])[1].length;
+    const run = /^ {0,3}([`~]+)/.exec(lines[closer].text)[1].length;
     const claimed = (line) => {
-        const open = matchFenceOpen(line);
+        const open = matchFenceOpen(line.text);
         return open !== null && open.marker === fence.marker && open.length <= run;
     };
     if (lines.slice(0, closer).some(claimed))
         return null;
-    return withoutLine(lines, closer);
+    return withoutLine(lines, closer, caret);
 }
-/** Splitting on `\n` leaves a CRLF separator's `\r` above; dropping the last line orphans it. */
-function withoutLine(lines, index) {
+/**
+ * The lines with one removed; dropping the last line takes the ending above it too. A caret inside
+ * the removed span lands where the span was.
+ */
+function withoutLine(lines, index, caret) {
+    let from = lineStartOffset(joinDisplayLines(lines), index);
+    let to = from + lines[index].text.length + lines[index].ending.length;
     const kept = lines.slice(0, index).concat(lines.slice(index + 1));
     if (index === lines.length - 1 && kept.length > 0) {
-        kept[kept.length - 1] = kept[kept.length - 1].replace(/\r$/, '');
+        const above = kept[kept.length - 1];
+        from -= above.ending.length;
+        to = from + above.ending.length + lines[index].text.length;
+        kept[kept.length - 1] = { ...above, ending: '' };
     }
-    return kept.join('\n');
+    const moved = caret <= from ? caret : Math.max(from, caret - (to - from));
+    return { display: joinDisplayLines(kept), caret: moved };
 }
 function sanitizeInfoString(input) {
     const { display, caret, fence } = input;
     if (fence.marker !== '`')
         return { display, caret };
-    const lineEnd = firstLineEnd(display);
-    const opener = splitOpener(display.slice(0, lineEnd), fence);
+    const first = firstDisplayLine(display);
+    const opener = splitOpener(first.text, fence);
     if (!opener || !opener.info.includes('`'))
         return { display, caret };
     const kept = opener.info.replaceAll('`', '');
     const dropped = countDroppedBefore(opener.info, opener.runEnd, caret);
     return {
-        display: opener.indent + fence.marker.repeat(fence.length) + kept + display.slice(lineEnd),
+        display: opener.indent + fence.marker.repeat(fence.length) + kept + display.slice(first.text.length),
         caret: caret - dropped
     };
 }
@@ -168,38 +222,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.
+ * Separate a closer the write ran into: text typed at the start of an empty fence's closer line
+ * lands in front of the run (```` ```\nAB``` ````), so a line ending goes back before the run.
  */
 function separateGluedCloser(input) {
     const { display, caret, fence } = input;
     if (!fence.closed)
         return { display, caret };
-    const lines = display.split('\n');
+    const lines = displayLines(display);
     // 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.
+    const run = new RegExp(`[${fence.marker}]{${fence.length},}[ \t]*$`).exec(lines[lines.length - 1].text);
+    // `index === 0` is a bare run another rule handles, not one the write ran into.
     if (!run || run.index === 0)
         return { display, caret };
     const at = display.length - run[0].length;
-    const ending = display.includes('\r\n') ? '\r\n' : '\n';
+    // Two lines at least, so the display holds the ending the new line takes.
+    const ending = firstLineEnding(display) ?? '\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.
+        // The caret sits at the end of the typed text, exactly where the line ending goes in: it
+        // stays put, and only a caret already inside the closer run moves.
         caret: caret > at ? caret + ending.length : caret
     };
 }
 function escalateFenceRuns(input) {
     const { display, caret, fence } = input;
-    const lines = display.split('\n');
-    const opener = splitOpener(lines[0], fence);
+    const lines = displayLines(display);
+    const opener = splitOpener(lines[0].text, fence);
     if (!opener || lines.length < 2)
         return { display, caret };
     // An open fence has no closer line, so a literal write measures everything below
@@ -208,19 +259,20 @@ function escalateFenceRuns(input) {
     if (fence.closed && closerIndex < 1)
         return { display, caret };
     const bodyEnd = closerIndex === -1 ? lines.length : closerIndex;
-    const body = lines.slice(1, bodyEnd).join('\n');
+    const body = joinDisplayLines(lines.slice(1, bodyEnd));
     const grown = escalatedFenceLength(body, fence.marker, fence.length);
     const delta = grown - fence.length;
     if (delta === 0)
         return { display, caret };
     const run = fence.marker.repeat(grown);
-    lines[0] = opener.indent + run + opener.info;
+    lines[0] = { ...lines[0], text: opener.indent + run + opener.info };
     let closerRunStart = -1;
     if (closerIndex !== -1) {
-        const closerIndent = /^ {0,3}/.exec(lines[closerIndex])[0];
-        const tail = lines[closerIndex].slice(closerIndent.length).replace(/^[`~]+/, '');
+        const closerText = lines[closerIndex].text;
+        const closerIndent = /^ {0,3}/.exec(closerText)[0];
+        const tail = closerText.slice(closerIndent.length).replace(/^[`~]+/, '');
         closerRunStart = lineStartOffset(display, closerIndex) + closerIndent.length;
-        lines[closerIndex] = closerIndent + run + tail;
+        lines[closerIndex] = { ...lines[closerIndex], text: closerIndent + run + tail };
     }
     // The run grows in place, so a caret past an insertion point moves with it.
     let moved = caret;
@@ -228,20 +280,16 @@ function escalateFenceRuns(input) {
         moved += delta;
     if (closerRunStart !== -1 && caret > closerRunStart)
         moved += delta;
-    return { display: lines.join('\n'), caret: moved };
+    return { display: joinDisplayLines(lines), caret: moved };
 }
-/** Last line reading as this fence's closer at or after `from`; line 0 is the opener's slot. */
+/** Last line reading as this fence's closer at or after `from`; line 0 is the opener's line. */
 function lastCloserIndex(lines, fence, from = 1) {
     for (let i = lines.length - 1; i >= from; i--) {
-        if (matchFenceClose(lines[i], fence.marker, fence.length))
+        if (matchFenceClose(lines[i].text, fence.marker, fence.length))
             return i;
     }
     return -1;
 }
-function firstLineEnd(display) {
-    const index = display.indexOf('\n');
-    return index === -1 ? display.length : index;
-}
 function lineStartOffset(display, lineIndex) {
     let offset = 0;
     for (let i = 0; i < lineIndex; i++)

package/dist/schema/global-commands.d.ts

@@ -1,11 +1,11 @@
 /**
- * Plugin-facing global commands: mint a process-wide command id, register a handler receiving
- * the dispatching instance's EditorContext, optionally bind a chord in the plugin-global tier
- * (last in precedence). Beside block-commands, not in commands.ts, for the same cycle reason —
- * commands ← command-id must stay one-directional.
+ * Plugin-facing global commands: create a process-wide command id, register a handler that
+ * receives the dispatching editor's `EditorContext` and the dispatch's argument, and optionally
+ * bind a chord among the plugin-global chords (last in precedence). Beside `block-commands`, not
+ * in `commands.ts`, so `commands → command-id` stays one-directional.
  */
 import { type PluginCommandId } from './command-id';
-import type { EditorContext } from './plugin-install';
-export declare function registerGlobalCommand(name: string, handler: (editor: EditorContext) => boolean, opts?: {
+import { type EditorContext } from './plugin-install';
+export declare function registerGlobalCommand(name: string, handler: (editor: EditorContext, arg?: unknown) => boolean, opts?: {
     chord?: string;
 }): PluginCommandId;

package/dist/schema/global-commands.js

@@ -1,40 +1,32 @@
 /**
- * Plugin-facing global commands: mint a process-wide command id, register a handler receiving
- * the dispatching instance's EditorContext, optionally bind a chord in the plugin-global tier
- * (last in precedence). Beside block-commands, not in commands.ts, for the same cycle reason —
- * commands ← command-id must stay one-directional.
+ * Plugin-facing global commands: create a process-wide command id, register a handler that
+ * receives the dispatching editor's `EditorContext` and the dispatch's argument, and optionally
+ * bind a chord among the plugin-global chords (last in precedence). Beside `block-commands`, not
+ * in `commands.ts`, so `commands → command-id` stays one-directional.
  */
 import { mintCommandId } from './command-id';
-import { registerCommand, registerPluginGlobalBinding, assertPluginGlobalChordAvailable, warnDeadKeyCommand } from './commands';
-import { currentInstallingPlugin } from './plugin-install';
+import { registerCommand, registerPluginGlobalBinding, assertPluginGlobalChordAvailable, globalCommandOwner, runPluginCommand, warnDeadKeyCommand } from './commands';
+import { pluginEditorFor } from './plugin-install';
 export function registerGlobalCommand(name, handler, opts) {
-    // Validate the chord BEFORE the mint: a collision must not leave a minted name and a
+    // Validate the chord before creating the id: a collision must not leave a created name and a
     // registered handler behind a failed registration.
     if (opts?.chord)
         assertPluginGlobalChordAvailable(opts.chord, name);
-    const owner = currentInstallingPlugin();
-    // Owner-attributed: it is what lets a plugin re-mint its own name, and what names the prior
-    // owner in a cross-plugin collision.
-    const id = mintCommandId(name, owner);
+    const id = mintCommandId(name);
     registerCommand(id, (ctx) => {
         if (!ctx.pluginEditor) {
             warnDeadKeyCommand(id, 'plugin-global');
             return false;
         }
-        // Installed process-wide but absent from this editor's `plugins` prop: inert here, not
-        // dead, so it must not spend the dead-key diagnostic a truly unreachable id owes.
-        const editor = ctx.pluginEditor(owner ?? '');
+        const owner = globalCommandOwner(id);
+        // A global handler takes a context it can't run without, so a missing one declines, and
+        // that is inert rather than dead; a block handler runs with `ctx.editor` undefined instead.
+        const editor = pluginEditorFor(ctx.pluginEditor, owner);
         if (!editor)
             return false;
-        try {
-            return handler(editor);
-        }
-        catch (error) {
-            ctx.onCommandError?.({ command: id, plugin: owner ?? undefined, error });
-            return true;
-        }
+        return runPluginCommand(owner, { command: id }, ctx.onCommandError, () => handler(editor, ctx.arg));
     });
     if (opts?.chord)
-        registerPluginGlobalBinding({ chord: opts.chord, command: id }, owner);
+        registerPluginGlobalBinding({ chord: opts.chord, command: id });
     return id;
 }

package/dist/schema/height-estimates.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The height guesses windowing uses before a block has been measured, one per shape of block, for
+ * the descriptors' `estimateHeight`. Each returns the content height; the estimator adds the
+ * block's frame. All are O(1) in the tree: they read `raw` and a child count, never a subtree.
+ */
+import type { NodeView } from '../core/node-views';
+/** What an estimate reads besides the block: the editor's width and its type metrics, in px. */
+export interface HeightEstimateEnv {
+    width: number;
+    /** One wrapped line of prose. */
+    lineHeight: number;
+    /** One source line of code. */
+    codeLineHeight: number;
+    /** An average character, for how many fit on a line. */
+    avgCharWidth: number;
+    /** A block's margin and padding, which the estimator adds once per block. */
+    blockChrome: number;
+    /** The floor for an image whose alt carries no height. */
+    imageBlockMinHeight: number;
+}
+/** Wrapped text, or the images it holds when they stand taller than it. */
+export declare function proseEstimate(node: NodeView, env: HeightEstimateEnv): number;
+/** One line, whatever the bytes: a divider. */
+export declare function singleLineEstimate(_node: NodeView, env: HeightEstimateEnv): number;
+/** One code line per source line: code does not wrap. */
+export declare function sourceLinesEstimate(node: NodeView, env: HeightEstimateEnv): number;
+/**
+ * A grid takes the larger of its rows and its source wrapped; any other container the larger of a
+ * line per child and its text wrapped, since the first ignores wrapping and the second margins.
+ */
+export declare function containerEstimate(node: NodeView, env: HeightEstimateEnv): number;

package/dist/schema/height-estimates.js

@@ -0,0 +1,64 @@
+/**
+ * The height guesses windowing uses before a block has been measured, one per shape of block, for
+ * the descriptors' `estimateHeight`. Each returns the content height; the estimator adds the
+ * block's frame. All are O(1) in the tree: they read `raw` and a child count, never a subtree.
+ */
+import { parseImageDimensions } from '../core/inline/image-dimensions';
+import { isGridKind } from './block-kind-descriptor';
+const NEWLINE = 10;
+// Any image form, capturing the alt, whose `|WxH` hint sizes the rendered image.
+const IMAGE_ALT = /!\[([^\]]*)\]/g;
+function wrappedLines(length, env) {
+    const perLine = Math.max(1, Math.floor(env.width / env.avgCharWidth));
+    return Math.max(1, Math.ceil(length / perLine));
+}
+function sourceLines(raw) {
+    let n = 1;
+    // Code units, not `raw[i]`: the indexed read creates a one-character string per byte.
+    for (let i = 0; i < raw.length; i++)
+        if (raw.charCodeAt(i) === NEWLINE)
+            n++;
+    if (raw.endsWith('\n'))
+        n--;
+    return Math.max(1, n);
+}
+// An image's hinted height, else the floor: an unsized image is not knowable until it decodes.
+function imageHeights(raw, env) {
+    let total = 0;
+    IMAGE_ALT.lastIndex = 0;
+    let m;
+    while ((m = IMAGE_ALT.exec(raw)) !== null) {
+        total += parseImageDimensions(m[1]).height ?? env.imageBlockMinHeight;
+    }
+    return total;
+}
+// ── Estimates ───────────────────────────────────────────────────────────────
+/** Wrapped text, or the images it holds when they stand taller than it. */
+export function proseEstimate(node, env) {
+    const text = wrappedLines(node.raw.length, env) * env.lineHeight;
+    // The substring test first: most prose holds no image, and the alt scan is the costly part.
+    if (!node.raw.includes('!['))
+        return text;
+    // The image heights, the floor included, size the whole block, frame and all.
+    return Math.max(text, imageHeights(node.raw, env) - env.blockChrome);
+}
+/** One line, whatever the bytes: a divider. */
+export function singleLineEstimate(_node, env) {
+    return env.lineHeight;
+}
+/** One code line per source line: code does not wrap. */
+export function sourceLinesEstimate(node, env) {
+    return sourceLines(node.raw) * env.codeLineHeight;
+}
+/**
+ * A grid takes the larger of its rows and its source wrapped; any other container the larger of a
+ * line per child and its text wrapped, since the first ignores wrapping and the second margins.
+ */
+export function containerEstimate(node, env) {
+    const wrapped = wrappedLines(node.raw.length, env) * env.lineHeight;
+    if (isGridKind(node.kind)) {
+        return Math.max(sourceLines(node.raw) * env.lineHeight, wrapped);
+    }
+    const children = Math.max(1, node.children?.length ?? 1);
+    return Math.max(children * (env.lineHeight + env.blockChrome) - env.blockChrome, wrapped);
+}