@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/schema/commands.js

@@ -1,8 +1,11 @@
 import { devWarn } from '../dev-warn';
-import { deletePluginEntries, registerOnce, devReplacesRegistration } from './register-once';
+import { devReplacesRegistration } from './register-once';
+import { enrollTestReset } from './registry-reset';
+import { createPluginRegistry } from './plugin-registry';
 import { tryGetBlockKindDescriptor } from './block-kind-descriptor';
-import { normalizeChord, isChordWellFormed } from './keybindings';
+import { eventToChord, registeredChord } from './keybindings';
 import { lookupOverride, overrideDecision } from './keybinding-overrides';
+import { isReadingMode } from '../presentation-mode';
 export const GLOBAL_COMMAND_IDS = ['history.undo', 'history.redo'];
 export const BLOCK_COMMAND_IDS = [
     'block.split',
@@ -25,11 +28,12 @@ export const BLOCK_COMMAND_IDS = [
     'code.delete',
     'list.indent',
     'list.unindent',
+    'list.toggleTask',
     'cell.enter',
     'cell.tab',
     'cell.shiftTab',
-    // Bound on `tableCell` (the focused surface) but named for their subject: each takes the
-    // focused cell's row or column as its index, supplied from the cell's own props.
+    // Bound on `tableCell` (the block that holds the caret) but named for their subject: each takes
+    // the focused cell's row or column as its index, supplied from the cell's own props.
     'table.insertRowBelow',
     'table.insertRowAbove',
     'table.insertColumnRight',
@@ -44,20 +48,23 @@ export const BLOCK_COMMAND_IDS = [
     'chrome.descendToBody'
 ];
 /**
- * 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.
+ * Commands that rewrite one block and have no cross-block form, declined while a selection spans
+ * blocks. Membership follows what the handler does (the link card, a heading level), not the id.
  */
 export const RANGE_DECLINED_COMMAND_IDS = new Set([
     'link.openCard',
     'heading.cycle'
 ]);
+/** Built-in commands that move the block or row holding the caret rather than the caret. */
+export const BLOCK_MOVE_COMMAND_IDS = new Set([
+    'block.moveUp',
+    'block.moveDown',
+    'table.moveRowUp',
+    'table.moveRowDown'
+]);
 /**
- * The same one-block arms, but with a cross-block one behind them
- * (`selection/cross-block/format-toggle.ts`), which the seam routes to through an injected
- * router. Declined wherever no router is threaded, so a dispatch site that skips it cannot
- * fall through to the focused block's own offsets.
+ * Single-block commands with a cross-block form (`selection/cross-block/format-toggle.ts`),
+ * declined wherever no router was injected so they never fall through to the focused block.
  */
 export const CROSS_BLOCK_RANGE_COMMAND_IDS = new Set([
     'format.toggleStrong',
@@ -66,10 +73,8 @@ export const CROSS_BLOCK_RANGE_COMMAND_IDS = new Set([
     'format.toggleCode'
 ]);
 /**
- * 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. 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.
+ * The ids a host's selection toolbar invokes through `EditorInstance.runCommand`. Each is in one of
+ * the two sets above, so `canRunCommand` can tell a toolbar which buttons a range leaves idle.
  */
 export const TOOLBAR_COMMANDS = {
     toggleStrong: 'format.toggleStrong',
@@ -78,33 +83,48 @@ export const TOOLBAR_COMMANDS = {
     toggleCode: 'format.toggleCode',
     /** The link editor Mod+K opens: over a selection it creates, inside a link it edits. */
     editLink: 'link.openCard',
-    /** The heading picker's arm, taking the level as its argument; 0 is normal text. */
+    /** The heading picker's command, taking the level as its argument; 0 is normal text. */
     setHeading: 'heading.cycle'
 };
-const globalCommands = new Map();
-export function registerCommand(id, run) {
-    registerOnce(globalCommands.has(id), () => globalCommands.set(id, run), `registerCommand: "${id}" is already registered. Commands are register-once.`);
-}
-export function getCommand(id) {
-    return globalCommands.get(id);
-}
 const BUILTIN_COMMAND_IDS = new Set([...GLOBAL_COMMAND_IDS, ...BLOCK_COMMAND_IDS]);
 /** True when the id is in the closed built-in vocabulary. Takes a plain, unbranded name. */
 export function isBuiltinCommandId(id) {
     return BUILTIN_COMMAND_IDS.has(id);
 }
-/**
- * Test-only. Removes every command outside the closed built-in vocabulary; the plugin-global
- * chord keymap resets separately (`__resetPluginGlobalKeymapForTests`).
- */
-export function __removePluginCommandsForTests() {
-    deletePluginEntries(globalCommands, (id) => BUILTIN_COMMAND_IDS.has(id));
+const globalCommands = createPluginRegistry({
+    label: 'registerCommand',
+    isBuiltin: isBuiltinCommandId
+});
+export function registerCommand(id, run) {
+    globalCommands.register(id, run, `registerCommand: "${id}" is already registered. Commands are register-once.`);
+}
+/** The command's handler where `activation` resolves the plugin that registered it. */
+export function getCommand(id, activation) {
+    return globalCommands.get(id, activation);
+}
+/** Whether any plugin or built-in registered the id, whatever the activation. */
+export function isCommandRegistered(id) {
+    return globalCommands.has(id);
+}
+/** The plugin whose setup registered a global command, read at dispatch like a block command's. */
+export function globalCommandOwner(id) {
+    return globalCommands.ownerOf(id);
+}
+/** Runs a plugin's command handler, global or block, and reports a throw as the plugin's that
+ *  registered it; a contained throw still counts as handled, so the key goes no further. */
+export function runPluginCommand(owner, failure, onCommandError, run) {
+    try {
+        return run();
+    }
+    catch (error) {
+        onCommandError({ ...failure, plugin: owner ?? undefined, error });
+        return true;
+    }
 }
 const warnedDeadKeys = new Set();
 /**
- * Dev-warn once per (id, path) that a command reached no runnable handler at `path` — a dead
- * key. Unreachable, not unregistered: a minted command resolves only where the dispatch target
- * supplies a command context.
+ * Dev-warn once per (id, path) that a command reached no runnable handler: a key that does nothing.
+ * Unreachable rather than unregistered: a plugin command needs the target's command context.
  */
 export function warnDeadKeyCommand(id, path) {
     const key = `${path} ${id}`;
@@ -114,9 +134,10 @@ export function warnDeadKeyCommand(id, path) {
     devWarn('commands', `command "${id}" reached no handler on the ${path} path; key is dead`);
 }
 /** Test-only. Clears the dead-key warn memo so each test sees a first-time warn. */
-export function __resetCommandWarningsForTests() {
+function __resetCommandWarningsForTests() {
     warnedDeadKeys.clear();
 }
+enrollTestReset(__resetCommandWarningsForTests);
 registerCommand('history.undo', (ctx) => {
     void ctx.history.requestUndo();
     return true;
@@ -130,87 +151,91 @@ export const GLOBAL_KEYMAP = [
     { chord: 'Mod+Y', command: 'history.redo' },
     { chord: 'Mod+Shift+Z', command: 'history.redo' }
 ];
-const pluginGlobalKeymap = [];
+// ── Plugin-global chords ─────────────────────────────────────────────────
+// A plugin's global command may bind a chord here. It resolves last, after every override and
+// built-in table, and built-in chords cannot be taken (register-once, throw on collision).
+// Keyed by the normalized chord, so a chord binds at most one command.
+const pluginGlobalKeymap = createPluginRegistry({
+    label: 'registerPluginGlobalBinding',
+    isBuiltin: () => false
+});
 // Chords the editor UI intercepts outside the command resolvers (the search bar's
-// document-level listener) — a plugin binding one would double-fire on a single keypress.
+// document-level listener): a plugin binding one would fire twice on a single keypress.
 const RESERVED_UI_CHORDS = new Set(['Mod+F', 'Mod+H']);
 /**
- * True when the editor UI intercepts a chord outside the command resolvers. The single source
- * both the plugin-global registration guard and the editor-root keydown handler read.
+ * True when the editor UI intercepts a normalized chord outside the command resolvers. The single
+ * source both the plugin-global registration guard and the editor-root keydown handler read.
  */
 export function isReservedUiChord(chord) {
-    return RESERVED_UI_CHORDS.has(normalizeChord(chord));
+    return RESERVED_UI_CHORDS.has(chord);
 }
 /** The same pair, for the callers that must enumerate it rather than test one chord. */
 export function reservedUiChords() {
     return [...RESERVED_UI_CHORDS];
 }
-/**
- * `candidateCommand` is the id the incoming registration will bind (the mint is deterministic:
- * name IS the id). A dev-server re-eval re-binding its OWN command to its OWN chord is an
- * idempotent replace, not a collision; reserved chords and cross-command collisions still throw.
- */
+/** The chord's normal form, or a throw when it can't be bound. A dev-server re-evaluation binding
+ *  `candidateCommand` to its own chord again replaces the binding rather than colliding. */
 export function assertPluginGlobalChordAvailable(rawChord, candidateCommand) {
-    // Fails loudly, not warn-and-drop: a malformed chord (the `'Ctrl+B'` → bare `'B'` trap) would
-    // bind a handler that fires on every plain keypress. Thrown before the mint (see
-    // global-commands.ts), so a rejected registration leaves no orphaned command.
-    if (!isChordWellFormed(rawChord)) {
-        throw new Error(`plugin global chord "${rawChord}" is malformed — modifiers must be Mod/Alt/Shift and the key non-empty`);
-    }
-    const chord = normalizeChord(rawChord);
-    if (RESERVED_UI_CHORDS.has(chord)) {
-        throw new Error(`plugin global chord "${rawChord}" is reserved by the editor UI (search) — pick another chord`);
+    // Thrown before the id is created (`global-commands.ts`), so a rejected registration leaves
+    // no orphaned command.
+    const chord = registeredChord(rawChord, 'registerGlobalCommand');
+    if (isReservedUiChord(chord)) {
+        throw new Error(`plugin global chord "${rawChord}" is reserved by the editor UI (search): pick another chord`);
     }
     // Activation-blind: registration is process-global register-once, so a chord no editor
-    // has activated yet still collides.
-    const collision = builtinGlobalBinding(chord, undefined);
+    // has activated yet, or a failed plugin's, still collides.
+    const collision = findByChord(GLOBAL_KEYMAP, chord) ?? pluginGlobalKeymap.getIgnoringActivation(chord);
     if (collision) {
         if (devReplacesRegistration() && collision.command === candidateCommand)
-            return;
-        throw new Error(`plugin global chord "${rawChord}" is already bound to "${collision.command}" — global chords are register-once`);
+            return chord;
+        throw new Error(`plugin global chord "${rawChord}" is already bound to "${collision.command}": global chords are register-once`);
     }
+    return chord;
 }
-export function registerPluginGlobalBinding(binding, plugin) {
-    assertPluginGlobalChordAvailable(binding.chord, binding.command);
-    // A dev re-eval passed the same-command exemption above: replace in place instead of stacking
-    // a duplicate. A fresh registration never finds an existing entry.
-    const chord = normalizeChord(binding.chord);
-    const entry = { ...binding, plugin };
-    const existing = pluginGlobalKeymap.findIndex((b) => normalizeChord(b.chord) === chord);
-    if (existing >= 0)
-        pluginGlobalKeymap[existing] = entry;
-    else
-        pluginGlobalKeymap.push(entry);
-}
-/** The tier's one activation gate: every read of a plugin-global chord passes through it,
- *  and an absent activation means every installed plugin. */
-function claimedHere(entry, activation) {
-    return entry.plugin === null || activation === undefined || activation.isActive(entry.plugin);
+export function registerPluginGlobalBinding(binding) {
+    const chord = assertPluginGlobalChordAvailable(binding.chord, binding.command);
+    // The check above already let a dev re-evaluation of the same command through, so the
+    // registry's own duplicate rule only ever replaces here.
+    pluginGlobalKeymap.register(chord, { ...binding, chord });
 }
 export function pluginGlobalBinding(chord, activation) {
-    const entry = findByChord(pluginGlobalKeymap, chord);
-    return entry && claimedHere(entry, activation) ? entry : null;
+    return pluginGlobalKeymap.get(chord, activation) ?? null;
 }
-/** Every chord the plugin-global tier binds for `activation`. Registration is process-global,
- *  so an absent activation reflects plugins any mounted editor installed. */
-export function pluginGlobalChords(activation) {
+/** Every plugin-global binding `activation` resolves, each with the plugin that installed it. */
+export function pluginGlobalBindings(activation) {
     return pluginGlobalKeymap
-        .filter((entry) => claimedHere(entry, activation))
-        .map((b) => normalizeChord(b.chord));
+        .entries(activation)
+        .map(([chord, binding]) => ({ ...binding, plugin: pluginGlobalKeymap.ownerOf(chord) }));
 }
-export function __resetPluginGlobalKeymapForTests() {
-    pluginGlobalKeymap.length = 0;
+/** The chords of {@link pluginGlobalBindings}, normalized. */
+export function pluginGlobalChords(activation) {
+    return pluginGlobalKeymap.entries(activation).map(([chord]) => chord);
 }
-/** First binding in `bindings` whose chord normalizes to the already-normalized `chord`. */
+/** First binding in `bindings` for `chord`; every stored chord is normalized already. */
 function findByChord(bindings, chord) {
-    return bindings?.find((b) => normalizeChord(b.chord) === chord) ?? null;
+    return bindings.find((b) => b.chord === chord) ?? null;
+}
+// A block focused as a whole has no text keymap to hold the reorder chords, so it gets them here
+// unless its kind binds the chord; added on read, so a changed `blockFocus` leaves none stale.
+const WHOLE_BLOCK_KEYMAP = [
+    { chord: 'Alt+ArrowUp', command: 'block.moveUp' },
+    { chord: 'Alt+ArrowDown', command: 'block.moveDown' }
+];
+/** The bindings a kind resolves: its declared keymap, plus the whole-block defaults above. */
+export function kindKeymap(kind) {
+    const descriptor = tryGetBlockKindDescriptor(kind);
+    const declared = descriptor?.keymap ?? [];
+    if (descriptor?.blockFocus !== 'whole-block')
+        return declared;
+    const bound = new Set(declared.map((binding) => binding.chord));
+    return [...declared, ...WHOLE_BLOCK_KEYMAP.filter((binding) => !bound.has(binding.chord))];
 }
 function builtinKindBinding(chord, kind) {
-    return findByChord(tryGetBlockKindDescriptor(kind)?.keymap, chord);
+    return findByChord(kindKeymap(kind), chord);
 }
 /**
- * The consumer-override tier shared by leaf and bubble resolution: kind override, then global.
- * `null` is a disable decision; `undefined` means neither tier decided.
+ * The consumer-override level shared by leaf and container resolution: kind override, then global.
+ * `null` is a disable; `undefined` means neither scope had an entry.
  */
 function overrideTier(overrides, kind, chord) {
     const kindDecision = overrideDecision(lookupOverride(overrides, kind, chord));
@@ -218,16 +243,14 @@ function overrideTier(overrides, kind, chord) {
         return kindDecision;
     return overrideDecision(lookupOverride(overrides, 'global', chord));
 }
-/** The built-in global keymap tier, then the plugin-global tier — the shared tail of
- *  leaf resolution and both global-only resolvers. */
+/** The built-in global keymap, then the plugin-global chords: the shared tail of leaf
+ *  resolution and both global-only resolvers. */
 function builtinGlobalBinding(chord, activation) {
     return findByChord(GLOBAL_KEYMAP, chord) ?? pluginGlobalBinding(chord, activation);
 }
 /**
- * Container-bubble resolution: override(kind) → override(global) → built-in kind keymap. No
- * built-in GLOBAL fallthrough — undo/redo belong to the focused leaf, and a bubble re-firing
- * them would double-fire. Consumer overrides ARE honored at both scopes, so a global disable
- * unbinds a chord a kind defines, and a global bind shadows the built-in kind binding.
+ * A chord bubbled to a container: override(kind), override(global), then the built-in kind keymap.
+ * No built-in global fallthrough, since undo/redo belong to the focused leaf and would double-fire.
  */
 export function resolveKindBinding(chord, kind, overrides) {
     const override = overrideTier(overrides, kind, chord);
@@ -246,18 +269,29 @@ export function resolveBinding(chord, kind, overrides, activation) {
     return builtinKindBinding(chord, kind) ?? builtinGlobalBinding(chord, activation);
 }
 /**
- * True when the built-in keymap, or a plugin-global chord `activation` claims, binds this exact
- * chord BEFORE any consumer override — never a modified variant like `Mod+Alt+Y`. Override-BLIND
- * by design: it answers which chords carry a native browser default to suppress, not which
- * command runs. A dispatch question reads `runGlobalChord`/`runGlobalChordOnKind`, which consult
- * the override tier.
+ * The command a keypress names at `kind`, overrides included, without running it; a keypress
+ * with no block under it (a null kind) resolves at global scope.
+ */
+export function commandForKey(e, kind, ctx) {
+    const chord = eventToChord(e);
+    if (!chord)
+        return null;
+    const overrides = ctx.keybindingOverrides();
+    const binding = kind === null
+        ? resolveGlobalBinding(chord, overrides, ctx.activation)
+        : resolveBinding(chord, kind, overrides, ctx.activation);
+    return binding?.command ?? null;
+}
+/**
+ * Whether the built-in keymap or an active plugin-global chord binds this exact chord, ignoring
+ * overrides: the question is which chords have a browser default to suppress, not what runs.
  */
 export function isDefaultGlobalChord(chord, activation) {
     return builtinGlobalBinding(chord, activation) !== null;
 }
 /**
- * Resolve a chord at GLOBAL scope only, for input-layer sites with no focused block for a kind
- * tier to apply to: a consumer global override, else the editor-global keymap.
+ * Resolve a chord at global scope only, for the input sites with no focused block whose kind
+ * keymap could apply: a consumer global override, else the editor-global keymap.
  */
 export function resolveGlobalBinding(chord, overrides, activation) {
     const decision = overrideDecision(lookupOverride(overrides, 'global', chord));
@@ -266,34 +300,35 @@ export function resolveGlobalBinding(chord, overrides, activation) {
     return builtinGlobalBinding(chord, activation);
 }
 /**
- * Run whatever `chord` claims at global scope, for the surfaces with no focused block for a kind
- * tier to apply to — the editor root's windowed-out caret, the gap caret's proxy. True means the
- * press was CONSUMED, which a disabled chord is without running anything.
+ * Run what `chord` binds at global scope where no focused block's keymap applies (a caret in an
+ * unmounted block, the gap caret). True means consumed, which a disabled chord is too.
  */
-export function runGlobalChord(chord, overrides, context) {
-    return runClaimedGlobalChord(resolveGlobalBinding(chord, overrides, context.activation), chord, context, false);
+export function runGlobalChord(chord, context) {
+    const binding = resolveGlobalBinding(chord, context.keybindingOverrides(), context.activation);
+    return runClaimedGlobalChord(binding, chord, context, false);
 }
 /**
- * The same, for a block that IS its own focus target: no inner leaf carries the global tier for
- * it, so resolution takes the leaf precedence and a consumer's KIND-scoped rebind reaches here.
+ * The same for a block that is its own focus target: no inner leaf resolves global chords for it,
+ * so resolution takes the leaf precedence and a consumer's kind-scoped rebind reaches here.
  */
-export function runGlobalChordOnKind(chord, kind, overrides, context) {
-    return runClaimedGlobalChord(resolveBinding(chord, kind, overrides, context.activation), chord, context, true);
+export function runGlobalChordOnKind(chord, kind, context) {
+    const overrides = context.keybindingOverrides();
+    const binding = resolveBinding(chord, kind, overrides, context.activation);
+    return runClaimedGlobalChord(binding, chord, context, true);
 }
-/** A chord the built-in tables bind is consumed whatever an override left it resolving to: the
- *  fall-through is the browser's own history, which bypasses the CST undo stack. */
+/** A chord the built-in tables bind is consumed whatever an override resolves it to, since the
+ *  browser's own undo would bypass the CST undo stack; reading mode consumes it, runs nothing. */
 function runClaimedGlobalChord(binding, chord, context, kindDispatchBelow) {
-    const run = binding ? getCommand(binding.command) : undefined;
+    const run = binding ? getCommand(binding.command, context.activation) : undefined;
     const consumed = !!run || isDefaultGlobalChord(chord, context.activation);
-    // A resolved binding no global command backs is dead only where nothing else can answer it:
-    // consumed here and inert, or declined at a surface with no kind dispatch under it. A kind
-    // keymap chord declining INTO that dispatch is the normal handoff.
+    // A binding no global command backs is dead only where nothing else can answer it; a kind
+    // keymap chord declining into the block's own dispatch is the normal handoff.
     if (binding && !run && (consumed || !kindDispatchBelow)) {
         warnDeadKeyCommand(binding.command, 'global-chord');
     }
     if (!consumed)
         return false;
-    if (!context.isReading)
-        run?.(context);
+    if (!isReadingMode(context.getPresentationMode))
+        run?.({ ...context, arg: binding?.arg });
     return true;
 }

package/dist/schema/container-raw.d.ts

@@ -1,21 +1,61 @@
 /**
- * Ancestry dispatch for container raw rebuilds — looks up
- * `descriptor.rebuildRaw`, so plugin containers participate by declaring one.
+ * Rebuilds container `raw` up a node's ancestors, looking up `descriptor.rebuildRaw`, so a
+ * plugin container joins in by declaring one. A container's metadata follows its rebuilt bytes
+ * (`docs/design/editor.md` § The container `raw` contract).
  */
-import type { CstNode } from '../core/nodes';
+import type { AnyBlockKind, CstNode } from '../core/nodes';
+import { type GrammarView } from './block-openers';
 import type { ChildRawChange } from './child-spans';
 /**
- * Rebuild `raw` for every container along `path`, innermost first. The leaf at the tail of
- * `path` is NOT rebuilt — callers mutate its raw before calling. Empty path rebuilds `root`.
+ * Rebuild `raw` for every container along `path`, innermost first. The leaf at the end of `path`
+ * is not rebuilt: callers change its raw before calling. An empty path rebuilds `root`.
  */
-export declare function rebuildAncestryRaw(root: CstNode, path: number[]): void;
+export declare function rebuildAncestryRaw(root: CstNode, path: number[], grammar: GrammarView): void;
 /**
- * Dispatch via the kind's descriptor `rebuildRaw`; throws on a leaf. Callers walking ancestry
- * chains use {@link rebuildContainerRawIfContainer} instead.
+ * Calls the `rebuildRaw` on the kind's descriptor, then re-reads the metadata a moved outer line
+ * may carry; throws on a leaf.
  */
-export declare function rebuildContainerRaw(node: CstNode): void;
+export declare function rebuildContainerRaw(node: CstNode, grammar: GrammarView): void;
 /**
- * Rebuild `raw` when `node` has a rebuildRaw on its descriptor; no-op otherwise. `changed` is
- * the one-child hint (`child-spans.ts`); a rebuilder ignoring it re-derives the whole raw.
+ * The chain rebuild's step, which re-derives kind and metadata itself once it knows whether an
+ * outer line moved; a rebuild outside the chain uses {@link rebuildContainerRaw}.
  */
 export declare function rebuildContainerRawIfContainer(node: CstNode, changed?: ChildRawChange): void;
+/** What a container's position holds once its rewritten bytes are read as a reload reads them. */
+export type BytesReading = {
+    outcome: 'kept';
+}
+/** The bytes read as one node of the kind over other children: that node takes the position. */
+ | {
+    outcome: 'reread';
+    node: CstNode;
+}
+/** The bytes read as something other than one node of the kind: `blocks` is that reading. */
+ | {
+    outcome: 'diverged';
+    blocks: CstNode[];
+};
+export interface FollowOptions {
+    /** Only the title row changed, which no metadata comes from (`ReservedChrome`). */
+    titleRowOnly?: boolean;
+    /** A child's bytes stopped reading as one node where they stand, so the whole node is read. */
+    whole?: boolean;
+}
+/** Reads `node`'s bytes as a reload would after a rewrite from `rawBefore`, taking in place the
+ *  metadata they give it: the one place that knows which lines a kind's metadata comes from. */
+export declare function followBytes(node: CstNode, rawBefore: string, grammar: GrammarView, options?: FollowOptions): BytesReading;
+/**
+ * What the grammar opens `line` as, read in isolation: asked of the opener registry and never
+ * a kind list, so a kind registered later is covered the day it registers.
+ */
+export declare function lineOpensAs(line: string, grammar: GrammarView): AnyBlockKind;
+/**
+ * Takes the metadata a parse of `node`'s own bytes derived, so the next rebuild reads what a
+ * reload would. False when the parse isn't one block of the node's kind, and nothing is taken.
+ */
+export declare function adoptParsedMetadata(node: CstNode, parsed: readonly CstNode[]): boolean;
+/** One parse of a container's own bytes, the cost the kind and metadata re-derive pay. */
+export declare function parseContainerRaw(raw: string, grammar: GrammarView): CstNode[];
+export declare function firstLine(raw: string): string;
+/** The container's closing line: its last line carrying bytes, without the ending. */
+export declare function lastLine(raw: string): string;