@voithos-labs/aragonite 0.10.1

package/dist/schema/commands.js

@@ -0,0 +1,294 @@
+import { devWarn } from '../dev-warn';
+import { deletePluginEntries, registerOnce, devReplacesRegistration } from './register-once';
+import { tryGetBlockKindDescriptor } from './block-kind-descriptor';
+import { normalizeChord, isChordWellFormed } from './keybindings';
+import { lookupOverride, overrideDecision } from './keybinding-overrides';
+export const GLOBAL_COMMAND_IDS = ['history.undo', 'history.redo'];
+export const BLOCK_COMMAND_IDS = [
+    'block.split',
+    'block.hardBreak',
+    'block.insertTab',
+    'block.mergePrev',
+    'block.mergeNext',
+    'block.moveUp',
+    'block.moveDown',
+    'format.toggleStrong',
+    'format.toggleEmphasis',
+    'format.toggleStrikethrough',
+    'format.toggleCode',
+    'link.openCard',
+    'heading.cycle',
+    'code.newline',
+    'code.indent',
+    'code.dedent',
+    'code.backspace',
+    'code.delete',
+    'list.indent',
+    'list.unindent',
+    '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.
+    'table.insertRowBelow',
+    'table.insertRowAbove',
+    'table.insertColumnRight',
+    'table.insertColumnLeft',
+    'table.deleteRow',
+    'table.deleteColumn',
+    'table.moveRowUp',
+    'table.moveRowDown',
+    'table.moveColumnLeft',
+    'table.moveColumnRight',
+    'table.cycleAlignment',
+    '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.
+ */
+export const RANGE_DECLINED_COMMAND_IDS = new Set([
+    'link.openCard'
+]);
+/**
+ * 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.
+ */
+export const CROSS_BLOCK_RANGE_COMMAND_IDS = new Set([
+    'format.toggleStrong',
+    'format.toggleEmphasis',
+    'format.toggleStrikethrough',
+    '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.
+ */
+export const TOOLBAR_COMMANDS = {
+    toggleStrong: 'format.toggleStrong',
+    toggleEmphasis: 'format.toggleEmphasis',
+    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'
+};
+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 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.
+ */
+export function warnDeadKeyCommand(id, path) {
+    const key = `${path} ${id}`;
+    if (warnedDeadKeys.has(key))
+        return;
+    warnedDeadKeys.add(key);
+    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() {
+    warnedDeadKeys.clear();
+}
+registerCommand('history.undo', (ctx) => {
+    void ctx.history.requestUndo();
+    return true;
+});
+registerCommand('history.redo', (ctx) => {
+    void ctx.history.requestRedo();
+    return true;
+});
+export const GLOBAL_KEYMAP = [
+    { chord: 'Mod+Z', command: 'history.undo' },
+    { chord: 'Mod+Y', command: 'history.redo' },
+    { chord: 'Mod+Shift+Z', command: 'history.redo' }
+];
+const pluginGlobalKeymap = [];
+// 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.
+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.
+ */
+export function isReservedUiChord(chord) {
+    return RESERVED_UI_CHORDS.has(normalizeChord(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.
+ */
+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`);
+    }
+    // Activation-blind: registration is process-global register-once, so a chord no editor
+    // has activated yet still collides.
+    const collision = builtinGlobalBinding(chord, undefined);
+    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`);
+    }
+}
+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 pluginGlobalBinding(chord, activation) {
+    const entry = findByChord(pluginGlobalKeymap, chord);
+    return entry && claimedHere(entry, activation) ? entry : 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) {
+    return pluginGlobalKeymap
+        .filter((entry) => claimedHere(entry, activation))
+        .map((b) => normalizeChord(b.chord));
+}
+export function __resetPluginGlobalKeymapForTests() {
+    pluginGlobalKeymap.length = 0;
+}
+/** First binding in `bindings` whose chord normalizes to the already-normalized `chord`. */
+function findByChord(bindings, chord) {
+    return bindings?.find((b) => normalizeChord(b.chord) === chord) ?? null;
+}
+function builtinKindBinding(chord, kind) {
+    return findByChord(tryGetBlockKindDescriptor(kind)?.keymap, 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.
+ */
+function overrideTier(overrides, kind, chord) {
+    const kindDecision = overrideDecision(lookupOverride(overrides, kind, chord));
+    if (kindDecision !== undefined)
+        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. */
+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.
+ */
+export function resolveKindBinding(chord, kind, overrides) {
+    const override = overrideTier(overrides, kind, chord);
+    if (override !== undefined)
+        return override;
+    return builtinKindBinding(chord, kind);
+}
+/**
+ * Leaf precedence: override(kind) → override(global) → built-in kind → built-in global. Override
+ * source dominates specificity, so a global disable suppresses a chord a kind defines.
+ */
+export function resolveBinding(chord, kind, overrides, activation) {
+    const override = overrideTier(overrides, kind, chord);
+    if (override !== undefined)
+        return override;
+    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.
+ */
+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.
+ */
+export function resolveGlobalBinding(chord, overrides, activation) {
+    const decision = overrideDecision(lookupOverride(overrides, 'global', chord));
+    if (decision !== undefined)
+        return decision;
+    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.
+ */
+export function runGlobalChord(chord, overrides, context) {
+    return runClaimedGlobalChord(resolveGlobalBinding(chord, overrides, context.activation), 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.
+ */
+export function runGlobalChordOnKind(chord, kind, overrides, context) {
+    return runClaimedGlobalChord(resolveBinding(chord, kind, overrides, context.activation), 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. */
+function runClaimedGlobalChord(binding, chord, context, kindDispatchBelow) {
+    const run = binding ? getCommand(binding.command) : 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.
+    if (binding && !run && (consumed || !kindDispatchBelow)) {
+        warnDeadKeyCommand(binding.command, 'global-chord');
+    }
+    if (!consumed)
+        return false;
+    if (!context.isReading)
+        run?.(context);
+    return true;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Ancestry dispatch for container raw rebuilds — looks up
+ * `descriptor.rebuildRaw`, so plugin containers participate by declaring one.
+ */
+import type { CstNode } from '../core/nodes';
+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`.
+ */
+export declare function rebuildAncestryRaw(root: CstNode, path: number[]): void;
+/**
+ * Dispatch via the kind's descriptor `rebuildRaw`; throws on a leaf. Callers walking ancestry
+ * chains use {@link rebuildContainerRawIfContainer} instead.
+ */
+export declare function rebuildContainerRaw(node: CstNode): 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.
+ */
+export declare function rebuildContainerRawIfContainer(node: CstNode, changed?: ChildRawChange): void;

package/dist/schema/container-raw.js

@@ -0,0 +1,43 @@
+/**
+ * Ancestry dispatch for container raw rebuilds — looks up
+ * `descriptor.rebuildRaw`, so plugin containers participate by declaring one.
+ */
+import { tryGetBlockKindDescriptor } from './block-kind-descriptor';
+/**
+ * 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`.
+ */
+export function rebuildAncestryRaw(root, path) {
+    if (path.length === 0) {
+        rebuildContainerRaw(root);
+        return;
+    }
+    const containers = [];
+    let current = root;
+    for (let i = 0; i < path.length - 1; i++) {
+        current = current.children[path[i]];
+        containers.push(current);
+    }
+    for (let i = containers.length - 1; i >= 0; i--) {
+        rebuildContainerRaw(containers[i]);
+    }
+    rebuildContainerRaw(root);
+}
+/**
+ * Dispatch via the kind's descriptor `rebuildRaw`; throws on a leaf. Callers walking ancestry
+ * chains use {@link rebuildContainerRawIfContainer} instead.
+ */
+export function rebuildContainerRaw(node) {
+    const rebuild = tryGetBlockKindDescriptor(node.kind)?.rebuildRaw;
+    if (!rebuild) {
+        throw new Error(`rebuildContainerRaw: kind "${node.kind}" has no rebuildRaw — only container kinds are valid`);
+    }
+    rebuild(node);
+}
+/**
+ * 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.
+ */
+export function rebuildContainerRawIfContainer(node, changed) {
+    tryGetBlockKindDescriptor(node.kind)?.rebuildRaw?.(node, changed);
+}

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

@@ -0,0 +1,32 @@
+/**
+ * Per-container-kind raw rebuilders. Separate from container-raw.ts (the ancestry dispatch) so
+ * the built-in registrations can declare rebuildRaw directly: this file reaches no registry,
+ * while the dispatch must import one, and same-file would cycle. The strip and concat shapes
+ * live in child-spans.ts; each kind here contributes only its own per-line syntax.
+ */
+import type { CstNode } from '../core/nodes';
+import { type ChildRawChange } from './child-spans';
+/** Rebuild a blockquote's `raw`: `> ` on content lines, `>` on blank lines. */
+export declare function rebuildBlockquoteRaw(node: CstNode, changed?: ChildRawChange): void;
+/**
+ * Rebuild a list item's `raw`: marker on the first line, indentation on continuations. Blank
+ * lines stay unindented — GFM loose-list form.
+ */
+export declare function rebuildListItemRaw(node: CstNode, changed?: ChildRawChange): void;
+export declare function rebuildListRaw(node: CstNode, changed?: ChildRawChange): void;
+/** `| c0 | c1 | ... |` plus the row's own ending (single-space padding). */
+export declare function rebuildTableRowRaw(node: CstNode): void;
+/**
+ * The same bytes under an ending the row does not own: a row minted by a structural op has no
+ * authored one, so the TABLE dictates it. Split from the descriptor-shaped rebuilder above
+ * because `rebuildRaw`'s second parameter is the changed-child hint.
+ */
+export declare function writeTableRow(node: CstNode, lineEnding: string): void;
+/**
+ * Header + synthesized canonical delimiter + body rows. Every row is rebuilt before assembly, so
+ * the whole table normalizes to canonical padding on first structural mutation rather than
+ * landing half-padded. The table's own ending drives every emitted line (G4.20): a row minted by
+ * a structural op has no authored ending, so per-row detection would strand it on LF in a CRLF
+ * table.
+ */
+export declare function rebuildTableRaw(node: CstNode): void;

package/dist/schema/container-rebuilders.js

@@ -0,0 +1,95 @@
+/**
+ * Per-container-kind raw rebuilders. Separate from container-raw.ts (the ancestry dispatch) so
+ * the built-in registrations can declare rebuildRaw directly: this file reaches no registry,
+ * while the dispatch must import one, and same-file would cycle. The strip and concat shapes
+ * live in child-spans.ts; each kind here contributes only its own per-line syntax.
+ */
+import { metadataOf } from '../core/nodes';
+import { trailingLineEnding } from '../core/lines';
+import { rebuildConcatRaw, rebuildStripRaw } from './child-spans';
+// ── Blockquote ───────────────────────────────────────────────────────────────
+/** Rebuild a blockquote's `raw`: `> ` on content lines, `>` on blank lines. */
+export function rebuildBlockquoteRaw(node, changed) {
+    if (!node.children)
+        return;
+    rebuildStripRaw(node, quoteLine, changed);
+}
+const quoteLine = (text) => (text === '' ? '>' : '> ' + text);
+// ── List ─────────────────────────────────────────────────────────────────────
+/**
+ * Rebuild a list item's `raw`: marker on the first line, indentation on continuations. Blank
+ * lines stay unindented — GFM loose-list form.
+ */
+export function rebuildListItemRaw(node, changed) {
+    if (!node.children || !node.metadata)
+        return;
+    const meta = metadataOf(node, 'listItem');
+    const marker = meta.marker ?? '- ';
+    const taskMarker = meta.taskMarker ?? '';
+    const indent = ' '.repeat(marker.length);
+    rebuildStripRaw(node, (text, first) => {
+        if (first)
+            return marker + taskMarker + text;
+        return text === '' ? '' : indent + text;
+    }, changed);
+}
+export function rebuildListRaw(node, changed) {
+    if (!node.children)
+        return;
+    rebuildConcatRaw(node, changed);
+}
+// ── Table ────────────────────────────────────────────────────────────────────
+/** `| c0 | c1 | ... |` plus the row's own ending (single-space padding). */
+export function rebuildTableRowRaw(node) {
+    writeTableRow(node, trailingLineEnding(node.raw));
+}
+/**
+ * The same bytes under an ending the row does not own: a row minted by a structural op has no
+ * authored one, so the TABLE dictates it. Split from the descriptor-shaped rebuilder above
+ * because `rebuildRaw`'s second parameter is the changed-child hint.
+ */
+export function writeTableRow(node, lineEnding) {
+    if (!node.children)
+        return;
+    const cells = node.children.map((c) => c.raw);
+    node.raw = '| ' + cells.join(' | ') + ' |' + lineEnding;
+}
+/**
+ * Header + synthesized canonical delimiter + body rows. Every row is rebuilt before assembly, so
+ * the whole table normalizes to canonical padding on first structural mutation rather than
+ * landing half-padded. The table's own ending drives every emitted line (G4.20): a row minted by
+ * a structural op has no authored ending, so per-row detection would strand it on LF in a CRLF
+ * table.
+ */
+export function rebuildTableRaw(node) {
+    if (!node.children)
+        return;
+    const meta = metadataOf(node, 'table');
+    const lineEnding = trailingLineEnding(node.raw);
+    for (const row of node.children)
+        writeTableRow(row, lineEnding);
+    const headerRow = node.children[0];
+    const bodyRows = node.children.slice(1);
+    const delimiterCells = meta.alignments.map(formatAlignmentCell).join(' | ');
+    const delimiterLine = '| ' + delimiterCells + ' |' + lineEnding;
+    let raw = (headerRow?.raw ?? '') + delimiterLine;
+    for (const r of bodyRows)
+        raw += r.raw;
+    node.raw = raw;
+}
+function formatAlignmentCell(a) {
+    switch (a) {
+        case 'left':
+            return ':---';
+        case 'center':
+            return ':---:';
+        case 'right':
+            return '---:';
+        case 'none':
+            return '---';
+        default: {
+            const _exhaustive = a;
+            throw new Error(`Unknown alignment: ${_exhaustive}`);
+        }
+    }
+}

package/dist/schema/define-plugin-block.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The single-block plugin unit: declare-and-describe a kind, then bind its component, sparing a
+ * one-kind plugin the register/define double-wrap and its setup ordering. A multi-kind plugin
+ * stays on `definePlugin` directly. `kind` is the plain declared-kind NAME, branded lazily after
+ * `register` runs — `declaredPluginKind` throws for a not-yet-declared name.
+ */
+import type { Component } from 'svelte';
+import { type EditorPlugin } from './plugin-install';
+import type { BlockComponentExports, BlockComponentProps } from '../block-component';
+export declare function definePluginBlock<P extends Partial<BlockComponentProps> & Record<string, unknown>>(config: {
+    name: string;
+    kind: string;
+    component: Component<P, BlockComponentExports>;
+    register: () => void;
+}): EditorPlugin;

package/dist/schema/define-plugin-block.js

@@ -0,0 +1,18 @@
+/**
+ * The single-block plugin unit: declare-and-describe a kind, then bind its component, sparing a
+ * one-kind plugin the register/define double-wrap and its setup ordering. A multi-kind plugin
+ * stays on `definePlugin` directly. `kind` is the plain declared-kind NAME, branded lazily after
+ * `register` runs — `declaredPluginKind` throws for a not-yet-declared name.
+ */
+import { definePlugin } from './plugin-install';
+import { declaredPluginKind } from './plugin-kind';
+import { registerBlockComponent, defineBlockComponent } from './block-component-registry';
+export function definePluginBlock(config) {
+    return definePlugin({
+        name: config.name,
+        setup() {
+            config.register();
+            registerBlockComponent(declaredPluginKind(config.kind), defineBlockComponent(config.component));
+        }
+    });
+}

package/dist/schema/fenced-code-raw.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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.
+ */
+import type { NodeView } from '../core/node-views';
+export interface FenceShape {
+    marker: '`' | '~';
+    /** The block's own run length, from its metadata — not re-scanned from the write. */
+    length: number;
+    closed: boolean;
+}
+/** Whether the written bytes are the user authoring the block's syntax, or content. */
+export type FenceWriteMode = 'authored' | 'literal';
+export interface FenceWriteInput {
+    /** Display text about to be committed — raw without its trailing line ending. */
+    display: string;
+    /** Caret offset in `display`, mapped onto the reconciled bytes on the way out. */
+    caret: number;
+    fence: FenceShape;
+    mode: FenceWriteMode;
+}
+export interface FenceWriteResult {
+    display: string;
+    caret: number;
+}
+export declare function fenceShapeOf(node: NodeView): FenceShape;
+export declare function reconcileFenceWrite(input: FenceWriteInput): FenceWriteResult;
+/**
+ * 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.
+ */
+export declare function normalizeFencedRaw(raw: string, node: NodeView): string;
+/**
+ * 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.
+ */
+export declare function writeFenceInfo(display: string, info: string, fence: FenceShape): string | null;