@voithos-labs/aragonite 0.10.1

package/dist/components/link-card/link-card-entry.js

@@ -0,0 +1,51 @@
+/**
+ * `link.openCard` — the keyboard entry to the link card and the pressed state a toolbar paints for
+ * it, off one resolution of the construct holding the caret or a range inside it. The chord ENTERS
+ * the card (focus in the URL field), unlike a click, which opens it beside a caret that stays the
+ * document's. Live mode only: every other mode paints the destination.
+ */
+import { canWrapRangeAsLink } from '../blocks/text/link-source-bytes';
+import { resolveLinkAtPoint } from '../blocks/text/link-at-point';
+/**
+ * The construct the chord would EDIT: the card-editable one under the caret, which a range must
+ * lie wholly inside since the card edits ONE link. Null where the chord creates instead or opens
+ * nothing, so a pressed paint and the press it promises resolve the same construct.
+ */
+export function linkCardTargetAt(query) {
+    if (query.mode !== 'live' || query.crossBlockRange)
+        return null;
+    const hit = resolveLinkAtPoint(query);
+    if (hit === null)
+        return null;
+    const range = query.selection;
+    if (range && (range.start < hit.link.start || range.end > hit.link.end))
+        return null;
+    return hit.target;
+}
+/**
+ * Enter the card for the chord: the construct the caret — or a range lying wholly inside it —
+ * sits in, EDIT mode; failing that, CREATE mode over the range, declined when it crosses another
+ * construct's bytes, since wrapping inside or across one is a policy question. The chord is
+ * consumed either way, by the keymap arm that calls this.
+ */
+export function enterLinkCardAtCaret(query) {
+    if (query.mode !== 'live')
+        return;
+    // The dispatch seam declines `link.openCard` over a cross-block range already
+    // (`RANGE_DECLINED_COMMAND_IDS`); the belt is here because the offsets this arm would
+    // otherwise trust are fabricated in exactly that state rather than absent.
+    if (query.crossBlockRange)
+        return;
+    // Edit before create, since create declines a range already inside a construct: taking the
+    // create fork there leaves the press inert under a button the pressed read paints ON.
+    const target = linkCardTargetAt(query);
+    if (target) {
+        query.card.enter(target);
+        return;
+    }
+    const range = query.selection;
+    if (range === null || range.start >= range.end)
+        return;
+    if (canWrapRangeAsLink(query.block.raw, range.start, range.end, query.linkRef?.current))
+        query.card.enterCreate({ path: query.path, start: range.start, end: range.end });
+}

package/dist/components/link-card/link-card-state.svelte.d.ts

@@ -0,0 +1,44 @@
+import type { LinkTarget } from '../blocks/text/link-at-point';
+/** The create gesture's target: the raw range a commit would wrap. A range, not a construct —
+ *  the document holds nothing until Enter mints it, which is what lets Escape owe no cleanup. */
+export interface CreateLinkTarget {
+    path: number[];
+    start: number;
+    end: number;
+}
+export interface LinkCardState {
+    getTarget(): LinkTarget | null;
+    /** Set and `getTarget()` are mutually exclusive: one card, one target. */
+    getCreateTarget(): CreateLinkTarget | null;
+    /**
+     * Zero for a click, a fresh positive number for each keyboard entry. The card focuses its field
+     * when this differs from the zero it starts at, which separates the two gestures without a mode
+     * flag AND survives the case with no remount to key on: `Mod+K` on an already-open card.
+     */
+    getFocusEpoch(): number;
+    /** Anchored beside a live caret; the document keeps focus. The click gesture.
+     *  False when `canOpen` declined and no card opened. */
+    open(target: LinkTarget): boolean;
+    /** Opened AND focused, so the trap and Escape's caret restore engage. The chord gesture.
+     *  False when `canEnter` declined. */
+    enter(target: LinkTarget): boolean;
+    /** Entered over the range a commit would wrap. False when `canOpenCreate` declined. */
+    enterCreate(target: CreateLinkTarget): boolean;
+    close(): void;
+}
+export interface LinkCardOptions {
+    /** Runs on every entry path before the card takes the screen — the caret snapshot lives here
+     *  rather than at each caller, so entry path N+1 cannot forget it. */
+    onOpen: () => void;
+    /** The CLICK door: a live selection — native or the editor's cross-block range — is a gesture
+     *  an unasked-for card must not interrupt or write over. */
+    canOpen: () => boolean;
+    /** The CHORD door, looser than the click's by exactly one case: the entry resolves the
+     *  construct from the selection itself, so a range it admits is the card's own bytes. */
+    canEnter: () => boolean;
+    /** The create door: gates on the very selection `canOpen` forbids, since the range IS the
+     *  gesture's target. Separate and required so each entry states which gesture it carries;
+     *  a cross-block range declines at all three. */
+    canOpenCreate: () => boolean;
+}
+export declare function createLinkCardState(options: LinkCardOptions): LinkCardState;

package/dist/components/link-card/link-card-state.svelte.js

@@ -0,0 +1,46 @@
+// The open link card's target. Identity only — path plus construct start — because every commit
+// rebuilds the inline tree, so a captured node would address bytes that moved.
+export function createLinkCardState(options) {
+    let target = $state(null);
+    let createTarget = $state(null);
+    let focusEpoch = $state(0);
+    let entries = 0;
+    function seat(next, admits) {
+        if (!admits())
+            return false;
+        createTarget = null;
+        target = { path: [...next.path], sourceStart: next.sourceStart };
+        options.onOpen();
+        return true;
+    }
+    return {
+        getTarget: () => target,
+        getCreateTarget: () => createTarget,
+        getFocusEpoch: () => focusEpoch,
+        open: (next) => {
+            if (!seat(next, options.canOpen))
+                return false;
+            focusEpoch = 0;
+            return true;
+        },
+        enter: (next) => {
+            if (!seat(next, options.canEnter))
+                return false;
+            focusEpoch = ++entries;
+            return true;
+        },
+        enterCreate: (next) => {
+            if (!options.canOpenCreate())
+                return false;
+            target = null;
+            createTarget = { path: [...next.path], start: next.start, end: next.end };
+            options.onOpen();
+            focusEpoch = ++entries;
+            return true;
+        },
+        close: () => {
+            target = null;
+            createTarget = null;
+        }
+    };
+}

package/dist/components/lrd-map-gate.d.ts

@@ -0,0 +1,18 @@
+import type { DocumentView } from '../core/node-views';
+import type { EditEvent } from '../editor-events';
+/**
+ * Whether a commit could change the LRD set, keeping the O(nodes) map rebuild off the keystroke
+ * hot path. Any op that is not a kind-stable `input`/`metadataUpdate` could add or remove a
+ * definition; a kind-stable one only can when its target is itself an LRD. `input` is kind-stable
+ * by construction, held by the input-op kind-stability lint under `test/invariants/lint/`.
+ */
+export declare function lrdMapCouldChange(doc: DocumentView, event: EditEvent): boolean;
+/**
+ * A monotonic stamp that changes **exactly** when the signature string does.
+ * Reference-bearing render memos key on the epoch instead of the whole (~MB)
+ * signature, so bumping on every rebuild would re-render every bracket-bearing block.
+ */
+export declare function advanceSignatureEpoch(prevSignature: string, prevEpoch: number, nextSignature: string): {
+    signature: string;
+    epoch: number;
+};

package/dist/components/lrd-map-gate.js

@@ -0,0 +1,22 @@
+import { nodeAt } from '../tree-operations/node-ops';
+/**
+ * Whether a commit could change the LRD set, keeping the O(nodes) map rebuild off the keystroke
+ * hot path. Any op that is not a kind-stable `input`/`metadataUpdate` could add or remove a
+ * definition; a kind-stable one only can when its target is itself an LRD. `input` is kind-stable
+ * by construction, held by the input-op kind-stability lint under `test/invariants/lint/`.
+ */
+export function lrdMapCouldChange(doc, event) {
+    if (event.op !== 'input' && event.op !== 'metadataUpdate')
+        return true;
+    return nodeAt(doc, event.path)?.kind === 'linkReferenceDefinition';
+}
+/**
+ * A monotonic stamp that changes **exactly** when the signature string does.
+ * Reference-bearing render memos key on the epoch instead of the whole (~MB)
+ * signature, so bumping on every rebuild would re-render every bracket-bearing block.
+ */
+export function advanceSignatureEpoch(prevSignature, prevEpoch, nextSignature) {
+    if (nextSignature === prevSignature)
+        return { signature: prevSignature, epoch: prevEpoch };
+    return { signature: nextSignature, epoch: prevEpoch + 1 };
+}

package/dist/components/paste-image-arm.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The host image-import arm of a paste, shared by the editable-surface clipboard skeleton and the
+ * editor-root fallback. It ends at "here is the markdown nobody claimed"; each caller owns what
+ * happens next. Two ordering rules: files are read before the first await (`clipboardData` is not
+ * dependably live afterwards), and a multi-block selection reaches the delete only after the hook
+ * answers, so a failed import destroys nothing.
+ */
+import type { PasteImageHook } from '../editor-keys';
+import { type EditorEvents } from '../editor-events';
+import type { CrossBlockHandlers } from '../selection/cross-block/dispatch';
+export interface ImagePasteArmDeps {
+    /** Undefined leaves an image-bearing paste on the text/plain path — `filesOf`
+     *  then reports none. */
+    onPasteImage: PasteImageHook | undefined;
+    /** A failed import reports here rather than vanishing. */
+    events: EditorEvents;
+    crossBlock: CrossBlockHandlers;
+}
+export interface ImagePasteArm {
+    /** Call before the handler's first await; empty when no hook is installed. */
+    filesOf(data: DataTransfer | null): File[];
+    /**
+     * Import `files` in clipboard order, then offer the markdown to the cross-block
+     * seam. Null means the arm is finished (nothing imported, or a multi-block
+     * selection took the insertion); markdown means no selection claimed it.
+     */
+    run(e: ClipboardEvent, files: File[]): Promise<string | null>;
+}
+export declare function createImagePasteArm(deps: ImagePasteArmDeps): ImagePasteArm;

package/dist/components/paste-image-arm.js

@@ -0,0 +1,61 @@
+/**
+ * The host image-import arm of a paste, shared by the editable-surface clipboard skeleton and the
+ * editor-root fallback. It ends at "here is the markdown nobody claimed"; each caller owns what
+ * happens next. Two ordering rules: files are read before the first await (`clipboardData` is not
+ * dependably live afterwards), and a multi-block selection reaches the delete only after the hook
+ * answers, so a failed import destroys nothing.
+ */
+import { emitClipboardError } from '../editor-events';
+export function createImagePasteArm(deps) {
+    return {
+        filesOf: (data) => (deps.onPasteImage ? imageFilesOf(data) : []),
+        async run(e, files) {
+            const importImage = deps.onPasteImage;
+            if (!importImage)
+                return null;
+            const markdown = await importAll(deps, importImage, files);
+            // Empty markdown ends the arm like no markdown, and keeps the seam's payload
+            // below non-empty.
+            if (!markdown)
+                return null;
+            // Inherit the ordinary paste route rather than placing anything here: the
+            // delete collapses start-wins and the receiving block may be merged away. The
+            // seam reads `isCrossBlock` LIVE, so a mid-import selection is the one replaced.
+            if (await deps.crossBlock.handlePaste(e, markdown))
+                return null;
+            return markdown;
+        }
+    };
+}
+// ── Internal ────────────────────────────────────────────────────────────────
+/** A paste can carry a plain attachment alongside its text; only images belong to
+ *  the host hook, the rest stays on the text/plain path. */
+function imageFilesOf(data) {
+    return Array.from(data?.files ?? []).filter((file) => file.type.startsWith('image/'));
+}
+/**
+ * One insertion, not one per image: a hook may return multi-line markdown, whose
+ * structural paste can split the block out from under a second insertion addressed at
+ * anchor + length — and one paste gesture owes the user one undo entry.
+ */
+async function importAll(deps, importImage, files) {
+    const markdown = [];
+    for (const image of files) {
+        try {
+            const inserted = await importImage({
+                blob: image,
+                mimeType: image.type,
+                suggestedName: image.name || undefined
+            });
+            if (inserted)
+                markdown.push(inserted);
+        }
+        catch (error) {
+            // One failed import skips its image; the rest of the paste still lands. Still
+            // a clipboard failure, not a command throw: the host needs to know an asset
+            // it started importing will not appear in the document.
+            emitClipboardError(deps.events, { error });
+        }
+    }
+    return markdown.join('');
+}

package/dist/components/portal.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Relocate a rendered element into a consumer-supplied host, without a second component
+ * instance: the node keeps its identity, its Svelte scope classes and its place in the
+ * reactive tree, so only its position in the DOM moves.
+ */
+/**
+ * Attachment factory: appends the node to `target`, and puts it back where it was when the
+ * target changes or the attachment tears down. A null target leaves the node home, which is
+ * how the seam stays absent by default.
+ */
+export declare function portalInto(target: HTMLElement | null | undefined): (node: HTMLElement) => (() => void) | void;

package/dist/components/portal.js

@@ -0,0 +1,29 @@
+/**
+ * Relocate a rendered element into a consumer-supplied host, without a second component
+ * instance: the node keeps its identity, its Svelte scope classes and its place in the
+ * reactive tree, so only its position in the DOM moves.
+ */
+/**
+ * Attachment factory: appends the node to `target`, and puts it back where it was when the
+ * target changes or the attachment tears down. A null target leaves the node home, which is
+ * how the seam stays absent by default.
+ */
+export function portalInto(target) {
+    return (node) => {
+        if (!target)
+            return;
+        // A marker holds the home position: the siblings around it can change while the node
+        // is away, so a captured `nextSibling` would insert against a stale reference.
+        const marker = node.ownerDocument.createComment('');
+        node.parentNode?.insertBefore(marker, node);
+        target.appendChild(node);
+        return () => {
+            // Only when the node is still ours: on unmount Svelte removes it first, and
+            // re-inserting it here would strand it in the document.
+            if (node.parentNode === target && marker.isConnected)
+                marker.replaceWith(node);
+            else
+                marker.remove();
+        };
+    };
+}

package/dist/core/directive/activate.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Grammar-side activation for the `:::name` directive primitive. No components: core must not
+ * reach the component tree, so the public `activateDirectives` layers render on top of this.
+ * Call-based, not a module-load side effect, so a consumer that never calls it leaves `:::` and
+ * `:` unclaimed. Must run before the editor parses, ahead of the grammar-consumed latch (G1.17).
+ * A second activation site is a no-op: every step guards on something the tier itself owns.
+ */
+export declare function activateDirectiveGrammar(): void;

package/dist/core/directive/activate.js

@@ -0,0 +1,25 @@
+/**
+ * Grammar-side activation for the `:::name` directive primitive. No components: core must not
+ * reach the component tree, so the public `activateDirectives` layers render on top of this.
+ * Call-based, not a module-load side effect, so a consumer that never calls it leaves `:::` and
+ * `:` unclaimed. Must run before the editor parses, ahead of the grammar-consumed latch (G1.17).
+ * A second activation site is a no-op: every step guards on something the tier itself owns.
+ */
+import { registerDirectiveKinds, registerDirectiveTextKind, DIRECTIVE_TEXT } from './kinds';
+import { registerDirectiveOpeners } from './container-opener';
+import { declaredPluginInlineKind, isInlineKindDeclared } from '../../schema/plugin-kind';
+import { registerInlineSyntax } from '../inline/scan/plugin-syntax';
+import { recognizeTextDirective } from './text-recognizer';
+export function activateDirectiveGrammar() {
+    // The inline rung has nothing of its own to probe, so it borrows the `directiveText` latch,
+    // read HERE before `registerDirectiveTextKind` sets it. It cannot ask whether `:` is taken:
+    // the trigger is SHARED (emoji rungs on it too), so that question answers for another plugin.
+    const alreadyActive = isInlineKindDeclared(DIRECTIVE_TEXT);
+    registerDirectiveKinds();
+    registerDirectiveOpeners();
+    registerDirectiveTextKind();
+    if (!alreadyActive) {
+        const kind = declaredPluginInlineKind(DIRECTIVE_TEXT);
+        registerInlineSyntax(':', (raw, pos, end) => recognizeTextDirective(raw, pos, end, kind));
+    }
+}

package/dist/core/directive/container-opener.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The one block opener owning `:::`/`::` directive syntax, dispatching by name through the
+ * registry: a registered name delegates to its `fromDirective` factory, an unregistered one
+ * falls back to the lossless generic kinds. Imports stay core-relative because the
+ * `$lib/plugin` barrel pulls in a Svelte component and would cycle.
+ */
+export declare function registerDirectiveOpeners(): void;

package/dist/core/directive/container-opener.js

@@ -0,0 +1,162 @@
+/**
+ * The one block opener owning `:::`/`::` directive syntax, dispatching by name through the
+ * registry: a registered name delegates to its `fromDirective` factory, an unregistered one
+ * falls back to the lossless generic kinds. Imports stay core-relative because the
+ * `$lib/plugin` barrel pulls in a Svelte component and would cycle.
+ */
+import { registerBlockOpener, isBlockOpenerRegistered } from '../../schema/block-openers';
+import { OPENER_PRIORITIES } from '../../schema/opener-priorities';
+import { declaredPluginKind } from '../../schema/plugin-kind';
+import { makeBlockNode, setPluginMetadata } from '../nodes';
+import { parseContainerBody, joinRaw } from '../parser';
+import { trailingLineEnding } from '../lines';
+import { matchDirectiveOpener, isDirectiveCloser } from './grammar';
+import { resolveBlockDirectiveFactory, resolveDirective } from './registry';
+import { DIRECTIVE_BODY_WRAP, DIRECTIVE_CONTAINER, DIRECTIVE_LEAF } from './kinds';
+export function registerDirectiveOpeners() {
+    if (isBlockOpenerRegistered(DIRECTIVE_CONTAINER))
+        return; // idempotent for HMR / re-import
+    const container = declaredPluginKind(DIRECTIVE_CONTAINER);
+    const leaf = declaredPluginKind(DIRECTIVE_LEAF);
+    registerBlockOpener(container, {
+        // Priced off the ladder, never as a bare integer, so renumbering a built-in moves this
+        // with it. A colon fence collides with no built-in matcher; it only needs the gap.
+        priority: OPENER_PRIORITIES.blockquote + 5,
+        interruptsParagraph: (line) => matchDirectiveOpener(line) !== null,
+        tryOpen(ctx) {
+            const fence = matchDirectiveOpener(ctx.line.text);
+            if (!fence)
+                return null;
+            const lineEnding = trailingLineEnding(ctx.line.raw);
+            if (fence.tier === 'leaf') {
+                const def = resolveDirective('leaf', fence.name);
+                const factory = resolveBlockDirectiveFactory('leaf', fence.name);
+                if (factory) {
+                    const parsed = {
+                        fence,
+                        body: undefined,
+                        leadingTrivia: ctx.leadingTrivia,
+                        raw: ctx.line.raw,
+                        closerColonCount: 0,
+                        closerNewline: false,
+                        lineEnding
+                    };
+                    return { node: factory(parsed), consumed: 1 };
+                }
+                // A leaf re-derives its content range from `node.raw`, so it needs no metadata.
+                const node = makeBlockNode({
+                    kind: (def?.kind ?? leaf),
+                    leadingTrivia: ctx.leadingTrivia,
+                    raw: ctx.line.raw
+                });
+                return { node, consumed: 1 };
+            }
+            // Colon-count-aware: a shorter nested closer (`:::` inside a `::::`) does not close here.
+            const closerIdx = findDirectiveCloser(ctx.lines, ctx.index, ctx.end, fence.colonCount);
+            if (closerIdx === -1)
+                return null; // unterminated declines to paragraph
+            const closerLine = ctx.lines[closerIdx];
+            const bodyText = joinRaw(ctx.lines, ctx.index + 1, closerIdx);
+            const raw = joinRaw(ctx.lines, ctx.index, closerIdx + 1);
+            // One nesting level deeper, so nested directives share the container-depth cap; the
+            // body stays inside this parse entry, so it inherits its scope.
+            const body = parseContainerBody(bodyText, DIRECTIVE_BODY_WRAP, {
+                scope: ctx.isDocumentParse ? 'document' : 'fragment',
+                depth: ctx.depth + 1
+            });
+            // isDirectiveCloser guarantees an all-colon line, so its length IS the colon count.
+            const closerColonCount = closerLine.text.length;
+            const closerNewline = closerLine.raw.endsWith('\n');
+            const factory = resolveBlockDirectiveFactory('container', fence.name);
+            if (factory) {
+                const parsed = {
+                    fence,
+                    body,
+                    leadingTrivia: ctx.leadingTrivia,
+                    raw,
+                    closerColonCount,
+                    closerNewline,
+                    lineEnding
+                };
+                return { node: factory(parsed), consumed: closerIdx + 1 - ctx.index };
+            }
+            const node = {
+                kind: container,
+                leadingTrivia: ctx.leadingTrivia,
+                raw,
+                innerPrefix: body.prefix,
+                children: body.children,
+                innerSuffix: body.suffix
+            };
+            setPluginMetadata(node, {
+                name: fence.name,
+                colonCount: fence.colonCount,
+                info: fence.info,
+                closerColonCount,
+                closerNewline,
+                lineEnding
+            });
+            return { node, consumed: closerIdx + 1 - ctx.index };
+        }
+    });
+}
+const closerIndexCache = new WeakMap();
+function closerIndex(lines) {
+    const cached = closerIndexCache.get(lines);
+    if (cached)
+        return cached;
+    const positions = [];
+    const counts = [];
+    for (let i = 0; i < lines.length; i++) {
+        const text = lines[i].text;
+        if (isDirectiveCloser(text, 1)) {
+            positions.push(i);
+            counts.push(text.length);
+        }
+    }
+    let leafBase = 1;
+    while (leafBase < counts.length)
+        leafBase *= 2;
+    const maxCounts = new Int32Array(2 * leafBase);
+    maxCounts.set(counts, leafBase);
+    for (let i = leafBase - 1; i >= 1; i--) {
+        maxCounts[i] = Math.max(maxCounts[2 * i], maxCounts[2 * i + 1]);
+    }
+    const index = { positions: Int32Array.from(positions), maxCounts, leafBase };
+    closerIndexCache.set(lines, index);
+    return index;
+}
+/**
+ * Smallest closer-index slot at or after `from` whose count is >= `min`, or -1. Padding leaves
+ * hold 0 and an opener runs at least two colons, so they never match.
+ */
+function firstCloserAtLeast(index, from, min) {
+    const descend = (node, lo, hi) => {
+        if (hi <= from || index.maxCounts[node] < min)
+            return -1;
+        if (hi - lo === 1)
+            return lo;
+        const mid = (lo + hi) >>> 1;
+        const left = descend(node * 2, lo, mid);
+        return left !== -1 ? left : descend(node * 2 + 1, mid, hi);
+    };
+    return descend(1, 0, index.leafBase);
+}
+/** Equivalent to scanning `isDirectiveCloser` forward from `afterIndex`, over the index. */
+function findDirectiveCloser(lines, afterIndex, end, colonCount) {
+    const index = closerIndex(lines);
+    const { positions } = index;
+    let lo = 0;
+    let hi = positions.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >>> 1;
+        if (positions[mid] <= afterIndex)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    const slot = firstCloserAtLeast(index, lo, colonCount);
+    if (slot === -1 || positions[slot] >= end)
+        return -1;
+    return positions[slot];
+}

package/dist/core/directive/grammar.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Pure fence grammar for the `:::name` directive primitive, framework-free and CST-free.
+ * Byte round-trip is the master invariant: `serializeDirective` reproduces the opener colons,
+ * the verbatim `info` (leading separator included), the body wrap, and a matched closer exactly.
+ */
+export type DirectiveTier = 'container' | 'leaf' | 'text';
+export interface DirectiveFence {
+    tier: Exclude<DirectiveTier, 'text'>;
+    /** 2 = leaf, ≥3 = container. */
+    colonCount: number;
+    /** Charset `[A-Za-z][A-Za-z0-9-]*`; no underscore. */
+    name: string;
+    /** Verbatim remainder of the line incl. its leading separator; no trailing newline. */
+    info: string;
+}
+export declare function matchDirectiveOpener(lineText: string): DirectiveFence | null;
+export declare function isDirectiveCloser(lineText: string, openColonCount: number): boolean;
+/**
+ * The colon count needed to wrap `body`: one past its longest whole-line colon run, never below
+ * `minimum`. Without it a body line reproducing the terminator reads as the container's own
+ * closer and ejects everything below it on reparse.
+ */
+export declare function escalatedColonCount(body: string, minimum: number): number;
+export declare function serializeDirective(parts: {
+    colonCount: number;
+    name: string;
+    info: string;
+    innerPrefix: string;
+    body: string;
+    innerSuffix: string;
+    /** Closer colon run; defaults to `colonCount`. A nested `::::` closer widens past its opener. */
+    closerColonCount?: number;
+    /** Defaults to true; false for a document-final directive. */
+    closerNewline?: boolean;
+    /** Opener line ending, default `\n`. Threaded so a CRLF-authored directive rebuilds CRLF-safe. */
+    lineEnding?: string;
+    /** Closer line ending, default `lineEnding`. A mixed-ending directive keeps each line's bytes. */
+    closerLineEnding?: string;
+}): string;
+export interface DirectiveAttributes {
+    label?: string;
+    id?: string;
+    classes: string[];
+    properties: Record<string, string>;
+}
+/**
+ * Opt-in `info -> structure` reader for a leading `[label]` and a `{#id .class key=val}` block.
+ * One-way: there is no inverse serializer, and the verbatim `info` stays the round-trip truth.
+ */
+export declare function parseDirectiveAttributes(info: string): DirectiveAttributes;