@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/components/blocks/code/code-fence-boundary.d.ts

@@ -1,20 +1,17 @@
 /**
- * Pure decisions that keep an edit off the fence lines of a fenced code block: rewriting either
- * fence leaves an unclosed one that absorbs the rest of the document at the next parse. Editable
- * content is the body plus the opener's info string. Display-text coordinates throughout.
+ * Pure decisions that keep a caret and an edit off a fenced code block's fence lines where the
+ * mode hides them; there, editable content is the body plus the opener's info string. Where the
+ * mode paints them, edits land and the fence write rule keeps one opener and one closer.
+ * Display-text coordinates throughout.
  */
 import type { NodeView } from '../../../core/node-views';
+import type { RawRange } from '../../../cursor/widget-offset';
 export interface FenceBoundaryInput {
     node: NodeView;
     offset: number;
     /** True when the user pressed Delete (forward) rather than Backspace. */
     forward: boolean;
 }
-/** Display-text offset range, as the code gestures pass it around. */
-export interface CodeRange {
-    start: number;
-    end: number;
-}
 export type FenceBoundaryResult = {
     kind: 'allow';
 } | {
@@ -22,56 +19,42 @@ export type FenceBoundaryResult = {
 } | {
     kind: 'exitNext';
 };
-/**
- * Classify a Backspace/Delete against the two body boundaries: Backspace at bodyStart
- * would delete the opener's terminating `\n`, Delete at bodyEnd the body's — either
- * re-parses the block in a different shape, so both become a focus-move out instead.
- * What else a keystroke may rewrite is `crossesFenceBoundary`'s question.
- */
+/** Backspace at the body start would delete the opener's `\n`, and Delete at the body end the
+ *  body's; either reshapes the block, so both move focus out instead. */
 export declare function classifyFenceBoundary(input: FenceBoundaryInput): FenceBoundaryResult;
-/**
- * Clamp an Enter-splice out of both fence lines onto the nearest body edge — a `\n`
- * inside the opener re-shapes the fence, one inside the closer breaks it apart. Each
- * fence line's inner edge is left alone: splicing after the info string, or at the
- * start of the closer line, is already safe.
- */
+/** A `\n` inside either fence line breaks the fence, so an Enter there moves to the nearest body
+ *  edge; each fence line's inner edge is already safe and stays put. */
 export declare function clampEnterOffsetToBody(node: NodeView, offset: number): number;
-/**
- * Clamp a whole range onto the body, unconditionally — for gestures that rewrite entire LINES (Tab
- * indent, Shift+Tab dedent), where a tab on the closer pushes it past GFM's 3-space limit and one
- * on the opener demotes the block. Arbitrary RANGE gestures use `fenceEditSpan` instead.
- */
-export declare function clampRangeToBody(node: NodeView, range: CodeRange): CodeRange;
-/**
- * Does a pending edit reach out of the editable content — the body, plus the opener's info string?
- * Every other offset on the fence lines is one keystroke from swallowing the following blocks into
- * the code node. An UNCLOSED fence is the exception: with no closer to orphan, its run is content
- * too, so demoting the block is how a just-typed ` ``` ` gets undone.
- */
-export declare function crossesFenceBoundary(node: NodeView, range: CodeRange): boolean;
+/** For gestures that rewrite whole lines (indent, dedent): a tab on the closer pushes it past
+ *  GFM's three-space limit, and one on the opener demotes the block. */
+export declare function clampRangeToBody(node: NodeView, range: RawRange): RawRange;
+/** Whether an edit reaches past the body and the opener's info string. An unclosed fence's run
+ *  counts as content, so deleting it is how a just-typed ` ``` ` is undone. */
+export declare function crossesFenceBoundary(node: NodeView, range: RawRange): boolean;
 /**
  * The span a ranged edit actually rewrites: the range itself while it stays inside
  * one content region, its intersection with the body once it reaches structure.
  */
-export declare function fenceEditSpan(node: NodeView, range: CodeRange): CodeRange;
+export declare function fenceEditSpan(node: NodeView, range: RawRange): RawRange;
 /**
- * Where a caret LANDING may sit — every door that seats a caret on this surface goes
- * through here. A caret parked on a fence line takes keystrokes the guard refuses:
- * the landing looks successful and the next character disappears.
+ * Where a caret arriving from outside the block lands, in every mode: on the body. On a hidden
+ * fence line it would take keystrokes the fence check refuses, so the next character disappears.
  */
 export declare function clampCaretToBody(node: NodeView, offset: number): number;
+/** A range that reached the fence lines and keeps no body after the clamp is declined, rather
+ *  than moved to a body edge the user never pointed at. */
+export declare function isStructureOnlyRange(node: NodeView, range: RawRange): boolean;
 /**
- * The refusal rule shared by every mutating gesture here: a range that reached structure and kept
- * no body after the clamp is declined, not re-sited to a body edge the user never pointed at.
- * Paste consults it directly, since it splices through the paste tree-op.
- */
-export declare function isStructureOnlyRange(node: NodeView, range: CodeRange): boolean;
-/**
- * The one in-place range splice — native delete/type-over (via the beforeinput guard)
- * and cut. Null when there is nothing to rewrite, so no undo entry is spent.
+ * The one splice over a range in place where the fence lines are hidden: the browser's delete
+ * and type-over, through the beforeinput check, and cut. Null when there is nothing to rewrite.
  */
-export declare function computeFenceRangedEdit(node: NodeView, range: CodeRange, insert: string): FenceRangedEdit | null;
+export declare function computeFenceRangedEdit(node: NodeView, range: RawRange, insert: string): FenceRangedEdit | null;
+/** `insert` spliced over `range` of `display`; null when it changes nothing, so no undo entry is used. */
+export declare function computeRangedEdit(display: string, range: RawRange, insert: string): FenceRangedEdit | null;
 export interface FenceRangedEdit {
     newText: string;
     newCursor: number;
 }
+/** The body's own span, the only lines a vertical arrival may land a caret on. */
+export declare function bodyWindow(node: NodeView): RawRange;
+export declare function orderedRange(range: RawRange): RawRange;

package/dist/components/blocks/code/code-fence-boundary.js

@@ -1,17 +1,15 @@
 /**
- * Pure decisions that keep an edit off the fence lines of a fenced code block: rewriting either
- * fence leaves an unclosed one that absorbs the rest of the document at the next parse. Editable
- * content is the body plus the opener's info string. Display-text coordinates throughout.
+ * Pure decisions that keep a caret and an edit off a fenced code block's fence lines where the
+ * mode hides them; there, editable content is the body plus the opener's info string. Where the
+ * mode paints them, edits land and the fence write rule keeps one opener and one closer.
+ * Display-text coordinates throughout.
  */
 import { metadataOf } from '../../../core/nodes';
 import { displayLength, trimTrailingLineEnding } from '../../../core/lines';
+import { fenceAnatomy } from '../../../core/parsers/fence-syntax';
 import { sliceFencedCode } from './code-renderer';
-/**
- * Classify a Backspace/Delete against the two body boundaries: Backspace at bodyStart
- * would delete the opener's terminating `\n`, Delete at bodyEnd the body's — either
- * re-parses the block in a different shape, so both become a focus-move out instead.
- * What else a keystroke may rewrite is `crossesFenceBoundary`'s question.
- */
+/** Backspace at the body start would delete the opener's `\n`, and Delete at the body end the
+ *  body's; either reshapes the block, so both move focus out instead. */
 export function classifyFenceBoundary(input) {
     const { node, offset, forward } = input;
     const slice = sliceFencedCode(node);
@@ -25,12 +23,8 @@ export function classifyFenceBoundary(input) {
         return { kind: 'exitNext' };
     return { kind: 'allow' };
 }
-/**
- * Clamp an Enter-splice out of both fence lines onto the nearest body edge — a `\n`
- * inside the opener re-shapes the fence, one inside the closer breaks it apart. Each
- * fence line's inner edge is left alone: splicing after the info string, or at the
- * start of the closer line, is already safe.
- */
+/** A `\n` inside either fence line breaks the fence, so an Enter there moves to the nearest body
+ *  edge; each fence line's inner edge is already safe and stays put. */
 export function clampEnterOffsetToBody(node, offset) {
     const { openerTextEnd, body, closerTextStart } = fenceRegions(node);
     if (offset < openerTextEnd)
@@ -39,22 +33,15 @@ export function clampEnterOffsetToBody(node, offset) {
         return body.end;
     return offset;
 }
-/**
- * Clamp a whole range onto the body, unconditionally — for gestures that rewrite entire LINES (Tab
- * indent, Shift+Tab dedent), where a tab on the closer pushes it past GFM's 3-space limit and one
- * on the opener demotes the block. Arbitrary RANGE gestures use `fenceEditSpan` instead.
- */
+/** For gestures that rewrite whole lines (indent, dedent): a tab on the closer pushes it past
+ *  GFM's three-space limit, and one on the opener demotes the block. */
 export function clampRangeToBody(node, range) {
     const { start: lo, end: hi } = bodyWindow(node);
     const clamp = (offset) => Math.min(Math.max(offset, lo), hi);
     return { start: clamp(range.start), end: clamp(range.end) };
 }
-/**
- * Does a pending edit reach out of the editable content — the body, plus the opener's info string?
- * Every other offset on the fence lines is one keystroke from swallowing the following blocks into
- * the code node. An UNCLOSED fence is the exception: with no closer to orphan, its run is content
- * too, so demoting the block is how a just-typed ` ``` ` gets undone.
- */
+/** Whether an edit reaches past the body and the opener's info string. An unclosed fence's run
+ *  counts as content, so deleting it is how a just-typed ` ``` ` is undone. */
 export function crossesFenceBoundary(node, range) {
     const { openerContent, body } = fenceRegions(node);
     const lo = Math.min(range.start, range.end);
@@ -72,9 +59,8 @@ export function fenceEditSpan(node, range) {
     return crossesFenceBoundary(node, span) ? clampRangeToBody(node, span) : span;
 }
 /**
- * Where a caret LANDING may sit — every door that seats a caret on this surface goes
- * through here. A caret parked on a fence line takes keystrokes the guard refuses:
- * the landing looks successful and the next character disappears.
+ * Where a caret arriving from outside the block lands, in every mode: on the body. On a hidden
+ * fence line it would take keystrokes the fence check refuses, so the next character disappears.
  */
 export function clampCaretToBody(node, offset) {
     const caret = { start: offset, end: offset };
@@ -82,11 +68,8 @@ export function clampCaretToBody(node, offset) {
         return offset;
     return clampRangeToBody(node, caret).start;
 }
-/**
- * The refusal rule shared by every mutating gesture here: a range that reached structure and kept
- * no body after the clamp is declined, not re-sited to a body edge the user never pointed at.
- * Paste consults it directly, since it splices through the paste tree-op.
- */
+/** A range that reached the fence lines and keeps no body after the clamp is declined, rather
+ *  than moved to a body edge the user never pointed at. */
 export function isStructureOnlyRange(node, range) {
     const ordered = orderedRange(range);
     if (!crossesFenceBoundary(node, ordered))
@@ -95,28 +78,41 @@ export function isStructureOnlyRange(node, range) {
     return span.start === span.end;
 }
 /**
- * The one in-place range splice — native delete/type-over (via the beforeinput guard)
- * and cut. Null when there is nothing to rewrite, so no undo entry is spent.
+ * The one splice over a range in place where the fence lines are hidden: the browser's delete
+ * and type-over, through the beforeinput check, and cut. Null when there is nothing to rewrite.
  */
 export function computeFenceRangedEdit(node, range, insert) {
     if (isStructureOnlyRange(node, range))
         return null;
-    const display = trimTrailingLineEnding(node.raw);
-    const span = fenceEditSpan(node, range);
+    return computeRangedEdit(trimTrailingLineEnding(node.raw), fenceEditSpan(node, range), insert);
+}
+/** `insert` spliced over `range` of `display`; null when it changes nothing, so no undo entry is used. */
+export function computeRangedEdit(display, range, insert) {
+    const span = orderedRange(range);
     const newText = display.slice(0, span.start) + insert + display.slice(span.end);
     if (newText === display)
         return null;
     return { newText, newCursor: span.start + insert.length };
 }
+/** The body's own span, the only lines a vertical arrival may land a caret on. */
+export function bodyWindow(node) {
+    return bodyWindowOf(sliceFencedCode(node), displayLength(node.raw));
+}
 function fenceRegions(node) {
     const slice = sliceFencedCode(node);
     const displayEnd = displayLength(node.raw);
     const body = bodyWindowOf(slice, displayEnd);
     const openerTextEnd = Math.min(displayLength(slice.openerLine), displayEnd);
+    // The run is measured, so an opener a paste grew to four markers measures as four; a line past
+    // the three-space indent limit opens no fence and has no info string at all.
+    const marker = metadataOf(node, 'fencedCode').fenceMarker;
+    const opener = fenceAnatomy(slice.openerLine, { marker, length: 3 });
     const hasCloser = slice.closerLine.length > 0;
-    const contentStart = hasCloser
-        ? Math.min(markerRunEnd(slice.openerLine, metadataOf(node, 'fencedCode').fenceMarker), openerTextEnd)
-        : 0;
+    let contentStart = 0;
+    if (!opener)
+        contentStart = openerTextEnd;
+    else if (hasCloser)
+        contentStart = Math.min(opener.runEnd, openerTextEnd);
     return {
         openerTextEnd,
         openerContent: { start: contentStart, end: openerTextEnd },
@@ -126,31 +122,12 @@ function fenceRegions(node) {
         closerTextStart: Math.min(body.start + slice.body.length, displayEnd)
     };
 }
-/**
- * Past the opener's indentation and marker run — where the info string starts. The run's LENGTH is
- * measured rather than read from `fenceLength`, so an opener a paste bumped to four markers
- * measures as four. Past GFM's 3-space indent limit there is no info string at all.
- */
-function markerRunEnd(openerLine, marker) {
-    const MAX_INDENT = 3;
-    let index = 0;
-    while (index < MAX_INDENT && openerLine[index] === ' ')
-        index++;
-    if (openerLine[index] !== marker)
-        return openerLine.length;
-    while (openerLine[index] === marker)
-        index++;
-    return index;
-}
-function orderedRange(range) {
+export function orderedRange(range) {
     return {
         start: Math.min(range.start, range.end),
         end: Math.max(range.start, range.end)
     };
 }
-function bodyWindow(node) {
-    return bodyWindowOf(sliceFencedCode(node), displayLength(node.raw));
-}
 function bodyWindowOf(slice, displayEnd) {
     const bounds = fenceBodyBounds(slice);
     // A fence with no body line yet (` ``` ` plus its ending) has a body start past
@@ -158,11 +135,8 @@ function bodyWindowOf(slice, displayEnd) {
     const start = Math.min(bounds.start, displayEnd);
     return { start, end: Math.min(Math.max(bounds.end, start), displayEnd) };
 }
-/**
- * The body's display-text bounds, excluding both fence lines. `end` reads the body's
- * own trailing ending through `displayLength`, so a CRLF document's boundary does not
- * land between the `\r` and the `\n`.
- */
+/** `end` reads the body's trailing ending through `displayLength`, so a CRLF boundary never
+ *  lands between the `\r` and the `\n`. */
 function fenceBodyBounds(slice) {
     const start = slice.openerLine.length;
     return { start, end: start + displayLength(slice.body) };

package/dist/components/blocks/code/code-fence-exit.d.ts

@@ -1,8 +1,7 @@
 /**
- * Pure decision for "does pressing Enter exit a fenced code block?". An unclosed
- * fence exits by MINTING its own closer: the gesture authors a block below, and
- * without a closer a reload's lazy continuation absorbs that block back in.
- * `none` means Enter falls through to in-block edit handling.
+ * Whether pressing Enter leaves a fenced code block. An unclosed fence leaves by writing its own
+ * closer: the gesture creates a block below, and without a closer a reload would absorb that
+ * block back into the fence. `none` means Enter falls through to editing inside the block.
  */
 import type { FencedCodeMetadata } from '../../../core/nodes';
 export interface FenceExitInput {
@@ -25,15 +24,11 @@ export interface TypedFenceExitInput extends FenceExitInput {
     /** The one character the pending `insertText` would write. */
     typed: string;
 }
-/** A typed closer either leaves (taking its own line with it) or is just a byte. */
+/** A typed closer either leaves the block, taking its own line with it, or is just a byte. */
 export type TypedFenceExitResult = Extract<FenceExitResult, {
     kind: 'exitWithEdit' | 'none';
 }>;
 export declare function computeFenceExit(input: FenceExitInput): FenceExitResult;
-/**
- * The block's other exit gesture: a closer typed on the body's empty last line. Every other
- * editor reads that run as "done here", and the bytes never land — written, they would be a body
- * line reading as the closer, which the write seam can only answer by growing the fence. A run
- * anywhere else is content, and that escalation keeps its CommonMark meaning.
- */
+/** A closer run typed on the body's empty last line leaves the block unwritten, since written
+ *  it would grow the fence; a run anywhere else is content. */
 export declare function computeTypedFenceExit(input: TypedFenceExitInput): TypedFenceExitResult;

package/dist/components/blocks/code/code-fence-exit.js

@@ -1,10 +1,9 @@
 /**
- * Pure decision for "does pressing Enter exit a fenced code block?". An unclosed
- * fence exits by MINTING its own closer: the gesture authors a block below, and
- * without a closer a reload's lazy continuation absorbs that block back in.
- * `none` means Enter falls through to in-block edit handling.
+ * Whether pressing Enter leaves a fenced code block. An unclosed fence leaves by writing its own
+ * closer: the gesture creates a block below, and without a closer a reload would absorb that
+ * block back into the fence. `none` means Enter falls through to editing inside the block.
  */
-import { trailingLineEnding } from '../../../core/lines';
+import { firstDisplayLine, lineEndingAt, ownTrailingLineEnding } from '../../../core/lines';
 import { matchFenceClose } from '../../../core/parsers/fence-syntax';
 // ── Public API ──────────────────────────────────────────────────────────────
 export function computeFenceExit(input) {
@@ -12,51 +11,51 @@ export function computeFenceExit(input) {
     if (meta.closed) {
         if (offset === text.length)
             return { kind: 'exit' };
+        // The caret starts an empty line: a break before it, and its own break right at it.
+        const ending = lineEndingAt(text, offset);
         const onEmptyLineBeforeCloser = offset >= 1 &&
             text[offset - 1] === '\n' &&
-            text[offset] === '\n' &&
-            matchFenceClose(lineAt(text, offset + 1), meta.fenceMarker, meta.fenceLength);
+            ending !== '' &&
+            startsCloserLine(text, offset + ending.length, meta);
         if (onEmptyLineBeforeCloser) {
-            return { kind: 'exitWithEdit', newText: text.slice(0, offset) + text.slice(offset + 1) };
+            return {
+                kind: 'exitWithEdit',
+                newText: text.slice(0, offset) + text.slice(offset + ending.length)
+            };
         }
         return { kind: 'none' };
     }
-    if (offset === text.length && text.endsWith('\n')) {
-        const ending = trailingLineEnding(text);
+    const ending = ownTrailingLineEnding(text);
+    if (offset === text.length && ending !== '') {
         const body = text.slice(0, text.length - ending.length);
         const closer = meta.fenceMarker.repeat(meta.fenceLength);
         return { kind: 'closeAndExit', newText: body + ending + closer };
     }
     return { kind: 'none' };
 }
-/**
- * The block's other exit gesture: a closer typed on the body's empty last line. Every other
- * editor reads that run as "done here", and the bytes never land — written, they would be a body
- * line reading as the closer, which the write seam can only answer by growing the fence. A run
- * anywhere else is content, and that escalation keeps its CommonMark meaning.
- */
+/** A closer run typed on the body's empty last line leaves the block unwritten, since written
+ *  it would grow the fence; a run anywhere else is content. */
 export function computeTypedFenceExit(input) {
     const { text, offset, meta, typed } = input;
     const none = { kind: 'none' };
     if (!meta.closed || typed !== meta.fenceMarker)
         return none;
     // The caret must sit at the end of a line that has one below it: the closer's.
-    const ending = /^\r?\n/.exec(text.slice(offset));
-    if (!ending)
+    const ending = lineEndingAt(text, offset);
+    if (ending === '')
         return none;
     const lineStart = text.lastIndexOf('\n', offset - 1) + 1;
     const run = text.slice(lineStart, offset);
     if (run !== meta.fenceMarker.repeat(run.length) || run.length + 1 < meta.fenceLength)
         return none;
-    const below = offset + ending[0].length;
-    if (!matchFenceClose(lineAt(text, below), meta.fenceMarker, meta.fenceLength))
+    const below = offset + ending.length;
+    if (!startsCloserLine(text, below, meta))
         return none;
-    // The run's line goes with the exit, as Enter's own empty-line exit takes the blank one.
+    // The run's line goes with the exit, as Enter's own exit takes the blank line.
     return { kind: 'exitWithEdit', newText: text.slice(0, lineStart) + text.slice(below) };
 }
 // ── Internal ────────────────────────────────────────────────────────────────
-// The one physical line beginning at `start`, without its trailing newline.
-function lineAt(text, start) {
-    const end = text.indexOf('\n', start);
-    return end === -1 ? text.slice(start) : text.slice(start, end);
+/** Whether the line starting at `offset` closes the block's fence. */
+function startsCloserLine(text, offset, meta) {
+    return matchFenceClose(firstDisplayLine(text.slice(offset)).text, meta.fenceMarker, meta.fenceLength);
 }

package/dist/components/blocks/code/code-indent.d.ts

@@ -1,6 +1,6 @@
 /**
- * Pure tab-indent / tab-dedent for code-block text. Dedent removes one tab OR up to
- * four leading spaces per line, preferring tab.
+ * Tab indent and Shift+Tab dedent for code-block text. Dedent removes one tab, or up to
+ * four leading spaces per line, preferring a tab.
  */
 export interface Selection {
     start: number;

package/dist/components/blocks/code/code-indent.js

@@ -1,6 +1,6 @@
 /**
- * Pure tab-indent / tab-dedent for code-block text. Dedent removes one tab OR up to
- * four leading spaces per line, preferring tab.
+ * Tab indent and Shift+Tab dedent for code-block text. Dedent removes one tab, or up to
+ * four leading spaces per line, preferring a tab.
  */
 // ── Public API ──────────────────────────────────────────────────────────────
 export function indentLines(text, selection) {
@@ -59,11 +59,8 @@ export function dedentLines(text, selection) {
     };
 }
 // ── Internal ────────────────────────────────────────────────────────────────
-/**
- * Line-start offsets for every line the selection touches. A selection ending
- * at or before a line's terminating newline stays on that line; one ending at
- * the next line's start pulls that line in.
- */
+/** Line starts for every line the selection touches; a selection ending at the next line's
+ *  start pulls that line in. */
 function collectLineStarts(text, selection) {
     const first = text.lastIndexOf('\n', selection.start - 1) + 1;
     const starts = [first];

package/dist/components/blocks/code/code-languages.d.ts

@@ -1,21 +1,25 @@
 /**
- * Language registry for code-block tokenization. Nothing outside this directory
- * imports highlight.js directly; static vs. dynamic loading is a policy on top.
- * Aliases fold to their canonical name here, so no caller carries its own table.
+ * The registry of languages code blocks are highlighted with. Nothing outside this directory
+ * imports highlight.js directly; whether a language loads eagerly is decided above this.
+ * Alternate spellings resolve to their canonical name here, so no caller keeps its own table.
+ * Every read takes an editor's activation, so a plugin's language shows only where it is listed.
  */
 import type { LanguageFn } from 'highlight.js';
+import type { PluginActivation } from '../../../schema/plugin-activation';
 export interface LanguageGrammar {
     readonly name: string;
     readonly definition: LanguageFn;
 }
-/** Idempotent — repeat calls with the same name are no-ops. */
+/** Register-once: a name already taken throws (a dev server replaces). */
 export declare function registerLanguage(name: string, definition: LanguageFn, aliasList?: readonly string[]): void;
+/** The code bootstrap's entry: a language the test reset keeps, owned by no plugin. */
+export declare function registerBuiltinLanguage(name: string, definition: LanguageFn, aliasList?: readonly string[]): void;
+/** Whether the name is taken, whatever the activation: the check before a guarded register. */
+export declare function isLanguageRegistered(name: string): boolean;
 /** Info strings with trailing attributes (`js {1-3}`) resolve on the first token. */
-export declare function getLanguageGrammar(infoString: string): LanguageGrammar | null;
-/** Every registered language once, under its canonical name, sorted — the picker's rows. */
-export declare function listLanguages(): string[];
-/** The alternate spellings a language answers to, from any spelling of it — a picker's filter
- *  matches `rs` to `rust` without a table of its own. */
-export declare function getLanguageAliases(name: string): readonly string[];
-/** Test-only: clear all registered languages. */
-export declare function __resetRegistryForTests(): void;
+export declare function getLanguageGrammar(infoString: string, activation: PluginActivation): LanguageGrammar | null;
+/** Every registered language once, under its canonical name, sorted: the picker's rows. */
+export declare function listLanguages(activation: PluginActivation): string[];
+/** The alternate spellings a language answers to, from any spelling of it, so a picker's
+ *  filter matches `rs` to `rust` without a table of its own. */
+export declare function getLanguageAliases(name: string, activation: PluginActivation): readonly string[];

package/dist/components/blocks/code/code-languages.js

@@ -1,49 +1,67 @@
 /**
- * Language registry for code-block tokenization. Nothing outside this directory
- * imports highlight.js directly; static vs. dynamic loading is a policy on top.
- * Aliases fold to their canonical name here, so no caller carries its own table.
+ * The registry of languages code blocks are highlighted with. Nothing outside this directory
+ * imports highlight.js directly; whether a language loads eagerly is decided above this.
+ * Alternate spellings resolve to their canonical name here, so no caller keeps its own table.
+ * Every read takes an editor's activation, so a plugin's language shows only where it is listed.
  */
-const grammars = new Map();
-const aliases = new Map();
-/** Idempotent — repeat calls with the same name are no-ops. */
+import { createPluginRegistry } from '../../../schema/plugin-registry';
+import { fenceLanguage } from '../../../core/parsers/fence-syntax';
+const grammars = createPluginRegistry({
+    label: 'registerLanguage',
+    isBuiltin: () => false
+});
+/** Register-once: a name already taken throws (a dev server replaces). */
 export function registerLanguage(name, definition, aliasList = []) {
+    const { key, language, conflict } = languageEntry(name, definition, aliasList);
+    grammars.register(key, language, conflict);
+}
+/** The code bootstrap's entry: a language the test reset keeps, owned by no plugin. */
+export function registerBuiltinLanguage(name, definition, aliasList = []) {
+    const { key, language, conflict } = languageEntry(name, definition, aliasList);
+    grammars.registerCore(key, language, conflict);
+}
+function languageEntry(name, definition, aliasList) {
     const key = name.toLowerCase();
-    if (grammars.has(key))
-        return;
-    grammars.set(key, { name: key, definition });
-    for (const alias of aliasList) {
-        aliases.set(alias.toLowerCase(), key);
-    }
-}
-/** The fold: any spelling of a language to the one name it is registered under. A name of its
- *  own beats another language's alias, so no grammar is shadowed by somebody's nickname. */
-function canonicalName(spelling) {
+    const aliases = [...new Set(aliasList.map((alias) => alias.toLowerCase()))];
+    return {
+        key,
+        language: { name: key, definition, aliases },
+        conflict: `registerLanguage: "${key}" is already registered. Languages are register-once.`
+    };
+}
+/** Whether the name is taken, whatever the activation: the check before a guarded register. */
+export function isLanguageRegistered(name) {
+    return grammars.has(name.toLowerCase());
+}
+/** Any spelling of a language to the one name it is registered under. A name of its own beats
+ *  another language's alternate spelling, so no grammar is hidden behind somebody's nickname. */
+function canonicalName(spelling, activation) {
     const key = spelling.toLowerCase();
-    if (grammars.has(key))
+    const languages = grammars.entries(activation);
+    if (languages.some(([name]) => name === key))
         return key;
-    return aliases.get(key) ?? key;
+    let canonical = key;
+    for (const [name, language] of languages)
+        if (language.aliases.includes(key))
+            canonical = name;
+    return canonical;
 }
 /** Info strings with trailing attributes (`js {1-3}`) resolve on the first token. */
-export function getLanguageGrammar(infoString) {
-    const trimmed = infoString.trim();
-    if (trimmed.length === 0)
+export function getLanguageGrammar(infoString, activation) {
+    const language = fenceLanguage(infoString);
+    if (language === '')
         return null;
-    return grammars.get(canonicalName(trimmed.split(/\s+/)[0])) ?? null;
-}
-/** Every registered language once, under its canonical name, sorted — the picker's rows. */
-export function listLanguages() {
-    return [...grammars.keys()].sort();
-}
-/** The alternate spellings a language answers to, from any spelling of it — a picker's filter
- *  matches `rs` to `rust` without a table of its own. */
-export function getLanguageAliases(name) {
-    const key = canonicalName(name);
-    if (!grammars.has(key))
-        return [];
-    return [...aliases].filter(([, target]) => target === key).map(([alias]) => alias);
-}
-/** Test-only: clear all registered languages. */
-export function __resetRegistryForTests() {
-    grammars.clear();
-    aliases.clear();
+    return grammars.get(canonicalName(language, activation), activation) ?? null;
+}
+/** Every registered language once, under its canonical name, sorted: the picker's rows. */
+export function listLanguages(activation) {
+    return grammars
+        .entries(activation)
+        .map(([name]) => name)
+        .sort();
+}
+/** The alternate spellings a language answers to, from any spelling of it, so a picker's
+ *  filter matches `rs` to `rust` without a table of its own. */
+export function getLanguageAliases(name, activation) {
+    return grammars.get(canonicalName(name, activation), activation)?.aliases ?? [];
 }

package/dist/components/blocks/code/code-paste-surface.d.ts

@@ -1,6 +1,7 @@
 /**
- * PasteSurface for fenced code blocks. Paste is always literal text, so the structural
- * hook is omitted and pasteDispatch falls through to the inline path.
+ * PasteSurface for fenced code blocks. Paste is always literal text, so the structural hook is
+ * omitted and pasteDispatch falls through to the inline path; the write that stores the splice
+ * runs the fence rule, which grows the fence past a run the paste lands.
  */
 import type { PasteSurface } from '../../../tree-operations/paste-surfaces';
 export declare const codePasteSurface: PasteSurface;