@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/components/blocks/code/code-context-actions.js

@@ -2,22 +2,23 @@
  * The code block's context menu: dissolve the fence into plain text. Delete is every block's
  * default row. Registered once from the code bootstrap.
  */
-import { registerBlockContextActions } from '../../../schema/context-actions';
+import { registerBuiltinBlockContextActions } from '../../../schema/context-actions';
+import { trailingLineEnding, trimTrailingLineEnding } from '../../../core/lines';
 import { sliceFencedCode } from './code-renderer';
 let registered = false;
 export function registerCodeContextActions() {
     if (registered)
         return;
     registered = true;
-    registerBlockContextActions('fencedCode', (node) => [
+    registerBuiltinBlockContextActions('fencedCode', 'code', (node) => [
         {
             id: 'code.dissolve',
             label: 'Dissolve into text',
             icon: 'type',
             run: (ctx) => {
                 // The body's lines as prose; the fence lines go. An empty body leaves an empty line.
-                const body = sliceFencedCode(node).body.replace(/\r?\n$/, '');
-                return ctx.replaceRaw(body + '\n');
+                const body = trimTrailingLineEnding(sliceFencedCode(node).body);
+                return ctx.replaceRaw(body + trailingLineEnding(node.raw, ctx.lineEnding));
             }
         }
     ]);

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

@@ -8,8 +8,8 @@ import { getLineLeadingWhitespace } from './code-editing';
 export function computeCodeEnter(input) {
     const { display, selection, mode, ending } = input;
     const { start, end } = selection;
-    // Indent reads from the SELECTION START's line — Enter on a non-collapsed
-    // range deletes the range first, so the surviving line is that one.
+    // The indent is read from the line the selection starts on: Enter over a range
+    // deletes the range first, so that is the line left behind.
     const indent = mode === 'normal' ? getLineLeadingWhitespace(display, start) : '';
     const inserted = ending + indent;
     return {

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.
+ * 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 grammar name, plus every alias, sorted — what the language picker
- * offers. Aliases are listed as their own entries: a user typing `js` should find it
- * rather than having to know it resolves to `javascript`.
- */
-export declare function listLanguages(): 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[];