@glw907/cairn-cms 0.60.1 → 0.62.2

package/dist/render/component-grammar.js

@@ -28,6 +28,9 @@ function slotByName(def, name) {
 function nestedSlots(def) {
     return (def.slots ?? []).filter((s) => s.name !== 'title' && s.name !== 'body');
 }
+/**
+ *
+ */
 export function serializeComponent(def, values) {
     const fence = COLON.repeat(nestedSlots(def).length > 0 ? 4 : 3);
     const title = slotByName(def, 'title') ? values.slots.title ?? '' : '';
@@ -109,18 +112,23 @@ function valuesFromRoot(root, def) {
 function rawKeysFromRoot(root) {
     return Object.keys(root?.attributes ?? {});
 }
-/** Parse a serialized component directive back into guided-form values, the inverse of
+/**
+ * Parse a serialized component directive back into guided-form values, the inverse of
  *  {@link serializeComponent}. The grammar is reversible, so the editor can round-trip a
- *  saved directive through the form. */
+ *  saved directive through the form.
+ */
 export async function parseComponent(markdown, def) {
     return valuesFromRoot(findComponentRoot(markdown, def), def);
 }
-/** The raw attribute keys present on the component's opening directive, read from the parsed tree
- *  (quote-aware, unlike a regex over the source). Used by validation to flag unknown keys. */
+/**
+ * The raw attribute keys present on the component's opening directive, read from the parsed tree
+ *  (quote-aware, unlike a regex over the source). Used by validation to flag unknown keys.
+ */
 export function parseRawAttributeKeys(markdown, def) {
     return rawKeysFromRoot(findComponentRoot(markdown, def));
 }
-/** Decide whether guided edit of this placed block is provably lossless. A block a person typed by
+/**
+ * Decide whether guided edit of this placed block is provably lossless. A block a person typed by
  *  hand can carry more than the schema models (an attribute the def does not list, a child container
  *  the def does not declare, slot content the form cannot represent stably), and parsing such a block
  *  into the form then re-serializing would silently drop it. The edit affordance is offered only when
@@ -130,7 +138,8 @@ export function parseRawAttributeKeys(markdown, def) {
  *  2. `unknown-attribute`: the block carries an attribute key the def does not declare.
  *  3. `undeclared-child`: the root has a direct child container directive that is not a declared
  *     nested slot. Such a child would otherwise fold into the body slot and move on re-serialize.
- *  4. `not-idempotent`: `parse -> serialize -> parse` does not recover the same values. */
+ *  4. `not-idempotent`: `parse -> serialize -> parse` does not recover the same values.
+ */
 export async function componentRoundTripSafety(markdown, def) {
     const root = findComponentRoot(markdown, def);
     if (!root)
@@ -154,9 +163,11 @@ export async function componentRoundTripSafety(markdown, def) {
         return { safe: false, reason: 'not-idempotent' };
     return { safe: true };
 }
-/** Parse the component once and derive both the guided-form values and the raw attribute keys.
+/**
+ * Parse the component once and derive both the guided-form values and the raw attribute keys.
  *  Validation needs both, so this seam spares it the double parse that calling
- *  {@link parseComponent} and {@link parseRawAttributeKeys} separately would cost. */
+ *  {@link parseComponent} and {@link parseRawAttributeKeys} separately would cost.
+ */
 export async function parseComponentWithRawKeys(markdown, def) {
     const root = findComponentRoot(markdown, def);
     return { values: valuesFromRoot(root, def), rawKeys: rawKeysFromRoot(root) };

package/dist/render/component-insert.d.ts

@@ -1,6 +1,8 @@
 import type { ComponentDef, ComponentValues } from './registry.js';
-/** The outcome of preparing a guided-form component for insertion: the markdown to insert, or the
- *  field-keyed errors to show on the form. */
+/**
+ * The outcome of preparing a guided-form component for insertion: the markdown to insert, or the
+ *  field-keyed errors to show on the form.
+ */
 export type ComponentInsert = {
     ok: true;
     markdown: string;
@@ -8,6 +10,8 @@ export type ComponentInsert = {
     ok: false;
     errors: Record<string, string>;
 };
-/** Serialize a component's form values, then validate the result against its schema. Returns the
- *  markdown to insert at the cursor, or the field errors keyed by attribute key or slot name. */
+/**
+ * Serialize a component's form values, then validate the result against its schema. Returns the
+ *  markdown to insert at the cursor, or the field errors keyed by attribute key or slot name.
+ */
 export declare function buildComponentInsert(def: ComponentDef, values: ComponentValues): Promise<ComponentInsert>;

package/dist/render/component-insert.js

@@ -1,7 +1,9 @@
 import { serializeComponent } from './component-grammar.js';
 import { validateComponent } from './component-validate.js';
-/** Serialize a component's form values, then validate the result against its schema. Returns the
- *  markdown to insert at the cursor, or the field errors keyed by attribute key or slot name. */
+/**
+ * Serialize a component's form values, then validate the result against its schema. Returns the
+ *  markdown to insert at the cursor, or the field errors keyed by attribute key or slot name.
+ */
 export async function buildComponentInsert(def, values) {
     const markdown = serializeComponent(def, values);
     const verdict = await validateComponent(markdown, def);

package/dist/render/component-reference.d.ts

@@ -5,6 +5,8 @@ export interface ReferenceOptions {
     /** The one-line blockquote summary under the title. */
     summary: string;
 }
-/** Build a self-contained markdown reference (the llms-full.txt shape) for a component registry, for
- *  authors and for pointing an LLM at one curated file. */
+/**
+ * Build a self-contained markdown reference (the llms-full.txt shape) for a component registry, for
+ *  authors and for pointing an LLM at one curated file.
+ */
 export declare function generateComponentReference(registry: ComponentRegistry, opts: ReferenceOptions): string;

package/dist/render/component-reference.js

@@ -1,7 +1,9 @@
 import { serializeComponent } from './component-grammar.js';
 import { emptyValues } from './registry.js';
-/** Build a self-contained markdown reference (the llms-full.txt shape) for a component registry, for
- *  authors and for pointing an LLM at one curated file. */
+/**
+ * Build a self-contained markdown reference (the llms-full.txt shape) for a component registry, for
+ *  authors and for pointing an LLM at one curated file.
+ */
 export function generateComponentReference(registry, opts) {
     const sections = registry.defs.map((def) => componentSection(def));
     return `# ${opts.title}\n\n> ${opts.summary}\n\n${sections.join('\n\n')}\n`;

package/dist/render/component-validate.d.ts

@@ -6,4 +6,7 @@ export type ComponentValidation = {
     ok: false;
     errors: Record<string, string>;
 };
+/**
+ *
+ */
 export declare function validateComponent(markdown: string, def: ComponentDef): Promise<ComponentValidation>;

package/dist/render/component-validate.js

@@ -1,4 +1,7 @@
 import { parseComponentWithRawKeys } from './component-grammar.js';
+/**
+ *
+ */
 export async function validateComponent(markdown, def) {
     const { values, rawKeys } = await parseComponentWithRawKeys(markdown, def);
     const errors = {};

package/dist/render/glyph.d.ts

@@ -1,8 +1,10 @@
 import type { Element } from 'hast';
 /** A glyph name to SVG path-data map (the site owns the icon set). */
 export type IconSet = Record<string, string>;
-/** Inline SVG glyph as a real hast node: class ec-glyph, 256 viewBox, currentColor fill.
+/**
+ * Inline SVG glyph as a real hast node: class ec-glyph, 256 viewBox, currentColor fill.
  *  An unknown icon name yields the bare svg shell with no path child, so it never serializes
  *  a stray empty (or undefined) path. Callers always wrap the returned element, so the shell
- *  keeps them safe. */
+ *  keeps them safe.
+ */
 export declare function glyph(name: string, icons: IconSet): Element;

package/dist/render/glyph.js

@@ -1,8 +1,10 @@
 import { s } from 'hastscript';
-/** Inline SVG glyph as a real hast node: class ec-glyph, 256 viewBox, currentColor fill.
+/**
+ * Inline SVG glyph as a real hast node: class ec-glyph, 256 viewBox, currentColor fill.
  *  An unknown icon name yields the bare svg shell with no path child, so it never serializes
  *  a stray empty (or undefined) path. Callers always wrap the returned element, so the shell
- *  keeps them safe. */
+ *  keeps them safe.
+ */
 export function glyph(name, icons) {
     const d = icons[name];
     return s('svg', { className: ['ec-glyph'], viewBox: '0 0 256 256', fill: 'currentColor', ariaHidden: 'true' }, d == null ? [] : [s('path', { d })]);

package/dist/render/pipeline.d.ts

@@ -4,27 +4,37 @@ import { type MediaResolve } from './resolve-media.js';
 import { type ComponentRegistry } from './registry.js';
 import type { LinkResolve } from '../content/links.js';
 export interface RendererOptions {
-    /** Stamp a `data-rise` ordinal (0, 1, 2, …) on each top-level component so a site's
+    /**
+     * Stamp a `data-rise` ordinal (0, 1, 2, …) on each top-level component so a site's
      *  CSS can drive an entrance-cascade delay off it. Omit for no stagger. The ordinal
-     *  is inert, so a consumer's sanitize floor can keep `data-rise` and drop `style`. */
+     *  is inert, so a consumer's sanitize floor can keep `data-rise` and drop `style`.
+     */
     stagger?: boolean;
-    /** Extend the sanitize allowlist. Receives cairn's default schema (defaultSchema plus the
+    /**
+     * Extend the sanitize allowlist. Receives cairn's default schema (defaultSchema plus the
      *  directive markers and the common benign tags) and returns the schema to use. Add to the
      *  allowlist for the benign HTML a site's content needs; start from the argument so the
-     *  dangerous strip is preserved. */
+     *  dangerous strip is preserved.
+     */
     sanitizeSchema?: (defaults: Schema) => Schema;
-    /** Developer-only escape hatch: disable the sanitize floor entirely. This reintroduces the XSS
+    /**
+     * Developer-only escape hatch: disable the sanitize floor entirely. This reintroduces the XSS
      *  vector the floor closes, so it is only for a site whose content is fully developer-controlled.
-     *  It is a code-level adapter decision, never an editor-facing setting. */
+     *  It is a code-level adapter decision, never an editor-facing setting.
+     */
     unsafeDisableSanitize?: boolean;
-    /** The `rel` value forced on every `target="_blank"` anchor, applied last so it also covers
+    /**
+     * The `rel` value forced on every `target="_blank"` anchor, applied last so it also covers
      *  component-built anchors. Defaults to `'noopener noreferrer'`. Set a different string to change
-     *  it, or `false` to disable the injection (a site that owns its own anchor hardening). */
+     *  it, or `false` to disable the injection (a site that owns its own anchor hardening).
+     */
     anchorRel?: string | false;
 }
-/** Compose a site's render pipeline from its component registry: directive syntax to
+/**
+ * Compose a site's render pipeline from its component registry: directive syntax to
  *  stamped markers to registry-built hast. Returns `renderMarkdown` plus the remark/
- *  rehype plugin arrays (so the admin editor preview can reuse the exact same set). */
+ *  rehype plugin arrays (so the admin editor preview can reuse the exact same set).
+ */
 export declare function createRenderer(registry?: ComponentRegistry, options?: RendererOptions): {
     remarkPlugins: PluggableList;
     rehypePlugins: PluggableList;

package/dist/render/pipeline.js

@@ -15,9 +15,11 @@ import { remarkResolveCairnLinks, CAIRN_RESOLVE } from './resolve-links.js';
 import { remarkResolveMedia, MEDIA_RESOLVE } from './resolve-media.js';
 import { rehypeDispatch } from './rehype-dispatch.js';
 import { defineRegistry } from './registry.js';
-/** Compose a site's render pipeline from its component registry: directive syntax to
+/**
+ * Compose a site's render pipeline from its component registry: directive syntax to
  *  stamped markers to registry-built hast. Returns `renderMarkdown` plus the remark/
- *  rehype plugin arrays (so the admin editor preview can reuse the exact same set). */
+ *  rehype plugin arrays (so the admin editor preview can reuse the exact same set).
+ */
 export function createRenderer(registry = defineRegistry({ components: [] }), options = {}) {
     const remarkPlugins = [
         remarkDirective,

package/dist/render/registry.d.ts

@@ -20,14 +20,18 @@ export interface AttributeField {
         source: string;
         message: string;
     };
-    /** A pure, browser-safe cross-field validator. Returns an error string, or null when valid.
+    /**
+     * A pure, browser-safe cross-field validator. Returns an error string, or null when valid.
      *  Receives the field's value and the full {@link ComponentValues} so a rule can read sibling
-     *  fields. The picker wraps the call in try/catch so an author's throw never crashes the form. */
+     *  fields. The picker wraps the call in try/catch so an author's throw never crashes the form.
+     */
     validate?: (value: string | boolean, all: ComponentValues) => string | null;
 }
 export type SlotKind = 'markdown' | 'inline' | 'repeatable';
-/** One named content region of a component. The slots named `title` and `body` are special: `title`
- *  serializes to the directive `[label]` and `body` to the unmarked content (see the canonical grammar). */
+/**
+ * One named content region of a component. The slots named `title` and `body` are special: `title`
+ *  serializes to the directive `[label]` and `body` to the unmarked content (see the canonical grammar).
+ */
 export interface SlotDef {
     name: string;
     label: string;
@@ -36,14 +40,18 @@ export interface SlotDef {
     help?: string;
     /** For `kind: 'repeatable'`: the fields composing each list item (v1 uses the first field). */
     itemFields?: AttributeField[];
-    /** For `kind: 'repeatable'`: derives a row's label from its item values and zero-based index.
-     *  When it returns nothing, the picker falls back to `${label} ${index + 1}`. */
+    /**
+     * For `kind: 'repeatable'`: derives a row's label from its item values and zero-based index.
+     *  When it returns nothing, the picker falls back to `${label} ${index + 1}`.
+     */
     itemLabel?: (item: Record<string, string | boolean>, index: number) => string;
 }
-/** The structured input a component's `build` receives. The engine stamps the component's
+/**
+ * The structured input a component's `build` receives. The engine stamps the component's
  *  attributes and partitions its slots from the rendered hast, so `build` arranges hast and
  *  never walks the tree. `slot(name)` returns a slot's rendered children (title, body, or any
- *  named slot); `items(name)` returns a repeatable slot's items, one child list per item. */
+ *  named slot); `items(name)` returns a repeatable slot's items, one child list per item.
+ */
 export interface ComponentContext {
     /** Declared attribute values, keyed by attribute key. Booleans are real booleans. */
     attributes: Record<string, string | boolean>;
@@ -64,9 +72,11 @@ export interface ComponentDef {
     description: string;
     /** Markdown scaffold inserted at the cursor by the editor palette. */
     insertTemplate?: string;
-    /** Build the final hast element from the component context (attributes plus partitioned
+    /**
+     * Build the final hast element from the component context (attributes plus partitioned
      *  slots). The engine stamps the entrance-stagger ordinal (`data-rise`) on the top-level
-     *  result, so a build fn stays free of any motion concern. */
+     *  result, so a build fn stays free of any motion concern.
+     */
     build: (ctx: ComponentContext) => Element;
     /** Optional role-to-default-icon, e.g. `{ caution: 'warning' }`. */
     defaultIconByRole?: Record<string, string>;
@@ -82,8 +92,10 @@ export interface ComponentDef {
     group?: string;
     /** Omit from the top-level picker (for a nested or round-trip-only component). */
     hidden?: boolean;
-    /** A structured sample the picker seeds the form with and renders through the same path a real
-     *  insert takes. Declaring `preview` is what opts the component into the two-pane configure layout. */
+    /**
+     * A structured sample the picker seeds the form with and renders through the same path a real
+     *  insert takes. Declaring `preview` is what opts the component into the two-pane configure layout.
+     */
     preview?: {
         attributes?: Record<string, string | boolean>;
         slots?: Record<string, string | string[]>;
@@ -97,9 +109,11 @@ export interface ComponentRegistry {
     /** The component's first `type:'icon'` attribute, or undefined when it declares none. */
     iconField(name: string): AttributeField | undefined;
 }
-/** The hast property name carrying one declared attribute from stamp to dispatch, e.g. `tone`
+/**
+ * The hast property name carrying one declared attribute from stamp to dispatch, e.g. `tone`
  *  becomes `dataAttrTone`. The directive stamp writes it and the rehype dispatch reads it, so both
- *  sides derive the name from this one helper rather than spelling the capitalize twice. */
+ *  sides derive the name from this one helper rather than spelling the capitalize twice.
+ */
 export declare function dataAttrProp(key: string): string;
 /**
  * Build a registry from a site's component definitions. The single source the render
@@ -108,16 +122,22 @@ export declare function dataAttrProp(key: string): string;
 export declare function defineRegistry({ components }: {
     components: ComponentDef[];
 }): ComponentRegistry;
-/** Guided-form values for one component: attribute values keyed by attribute key, slot values keyed
- *  by slot name (a string, or a string list for a repeatable slot). */
+/**
+ * Guided-form values for one component: attribute values keyed by attribute key, slot values keyed
+ *  by slot name (a string, or a string list for a repeatable slot).
+ */
 export interface ComponentValues {
     attributes: Record<string, string | boolean>;
     slots: Record<string, string | string[]>;
 }
-/** Seed an empty {@link ComponentValues} from a component's schema: attribute defaults (or '' / false)
- *  and empty slot values ([] for repeatable, '' otherwise). */
+/**
+ * Seed an empty {@link ComponentValues} from a component's schema: attribute defaults (or '' / false)
+ *  and empty slot values ([] for repeatable, '' otherwise).
+ */
 export declare function emptyValues(def: ComponentDef): ComponentValues;
-/** Seed {@link ComponentValues} from a component's `preview` sample: the {@link emptyValues} base
+/**
+ * Seed {@link ComponentValues} from a component's `preview` sample: the {@link emptyValues} base
  *  with `def.preview.attributes` and `def.preview.slots` overlaid (a shallow merge per side). When
- *  the def declares no `preview`, returns exactly the {@link emptyValues} output. */
+ *  the def declares no `preview`, returns exactly the {@link emptyValues} output.
+ */
 export declare function previewValues(def: ComponentDef): ComponentValues;

package/dist/render/registry.js

@@ -1,12 +1,16 @@
-/** The hast property name carrying one declared attribute from stamp to dispatch, e.g. `tone`
+/**
+ * The hast property name carrying one declared attribute from stamp to dispatch, e.g. `tone`
  *  becomes `dataAttrTone`. The directive stamp writes it and the rehype dispatch reads it, so both
- *  sides derive the name from this one helper rather than spelling the capitalize twice. */
+ *  sides derive the name from this one helper rather than spelling the capitalize twice.
+ */
 export function dataAttrProp(key) {
     return `dataAttr${key.charAt(0).toUpperCase()}${key.slice(1)}`;
 }
-/** A component's first `type:'icon'` attribute, or undefined when it declares none. Both the
+/**
+ * A component's first `type:'icon'` attribute, or undefined when it declares none. Both the
  *  construction-time guard and the registry's `iconField` derive the icon field from this one
- *  predicate rather than spelling the `type === 'icon'` find twice. */
+ *  predicate rather than spelling the `type === 'icon'` find twice.
+ */
 function findIconField(def) {
     return def.attributes?.find((field) => field.type === 'icon');
 }
@@ -35,8 +39,10 @@ export function defineRegistry({ components }) {
         },
     };
 }
-/** Seed an empty {@link ComponentValues} from a component's schema: attribute defaults (or '' / false)
- *  and empty slot values ([] for repeatable, '' otherwise). */
+/**
+ * Seed an empty {@link ComponentValues} from a component's schema: attribute defaults (or '' / false)
+ *  and empty slot values ([] for repeatable, '' otherwise).
+ */
 export function emptyValues(def) {
     const attributes = {};
     for (const field of def.attributes ?? []) {
@@ -48,9 +54,11 @@ export function emptyValues(def) {
     }
     return { attributes, slots };
 }
-/** Seed {@link ComponentValues} from a component's `preview` sample: the {@link emptyValues} base
+/**
+ * Seed {@link ComponentValues} from a component's `preview` sample: the {@link emptyValues} base
  *  with `def.preview.attributes` and `def.preview.slots` overlaid (a shallow merge per side). When
- *  the def declares no `preview`, returns exactly the {@link emptyValues} output. */
+ *  the def declares no `preview`, returns exactly the {@link emptyValues} output.
+ */
 export function previewValues(def) {
     const base = emptyValues(def);
     if (!def.preview)

package/dist/render/rehype-dispatch.d.ts

@@ -1,9 +1,17 @@
 import type { Root, Element, ElementContent } from 'hast';
 import { type ComponentContext, type ComponentRegistry } from './registry.js';
+/**
+ *
+ */
 export declare function isElement(node: ElementContent | undefined): node is Element;
-/** Read a declared string attribute off the component context, returning undefined for a boolean or
- *  absent value. Replaces the `typeof ctx.attributes[key] === 'string'` narrowing a build repeats. */
+/**
+ * Read a declared string attribute off the component context, returning undefined for a boolean or
+ *  absent value. Replaces the `typeof ctx.attributes[key] === 'string'` narrowing a build repeats.
+ */
 export declare function strAttr(ctx: ComponentContext, key: string): string | undefined;
+/**
+ *
+ */
 export declare function strProp(node: Element, name: string): string | undefined;
 /** Wrap a pre-built glyph in an ec-icon span; secondary role adds the modifier. */
 export declare function iconSpan(glyphEl: Element, role?: string): Element;
@@ -11,18 +19,24 @@ export declare function iconSpan(glyphEl: Element, role?: string): Element;
 export type MakeIcon = (name: string, role?: string) => Element;
 /** Section wrapper: `<section class=…><div class="card-body">…</div></section>`. */
 export declare function cardShell(classes: string[], body: ElementContent[]): Element;
-/** Card head row: `<div class="ec-head">[icon]<hN class="card-title">{title}</hN></div>`.
+/**
+ * Card head row: `<div class="ec-head">[icon]<hN class="card-title">{title}</hN></div>`.
  *  Pass the title's inline children, an optional pre-built icon element, and an optional heading
  *  level (default 2). This factors the icon-plus-heading head that a titled component build would
- *  otherwise rebuild by hand (the shape the removed `splitHead` produced). */
+ *  otherwise rebuild by hand (the shape the removed `splitHead` produced).
+ */
 export declare function headRow(title: ElementContent[], icon?: Element, level?: number): Element;
-/** Tag the first <ul> among children with `ec-grid` and strip its whitespace-only
- *  text nodes so the bare list serializes without newlines. Returns that <ul>. */
+/**
+ * Tag the first <ul> among children with `ec-grid` and strip its whitespace-only
+ *  text nodes so the bare list serializes without newlines. Returns that <ul>.
+ */
 export declare function markFirstList(children: ElementContent[]): Element | undefined;
-/** Rehype transformer: dispatch each stamped element through its registry `build`
+/**
+ * Rehype transformer: dispatch each stamped element through its registry `build`
  *  fn. When `stagger` is on, each top-level primitive gets a `data-rise` attribute
  *  carrying its document-order index (0, 1, 2, …); the site's CSS maps that ordinal
  *  to an entrance delay. The index is inert, so a consumer's sanitize floor can keep
  *  `data-rise` while dropping `style`. Nested primitives never get it. Non-primitive
- *  content (lede, intro paragraphs, the page-toc nav) passes through untouched. */
+ *  content (lede, intro paragraphs, the page-toc nav) passes through untouched.
+ */
 export declare function rehypeDispatch(registry: ComponentRegistry, stagger?: boolean): (tree: Root) => void;

package/dist/render/rehype-dispatch.js

@@ -1,10 +1,15 @@
 import { h } from 'hastscript';
 import { dataAttrProp } from './registry.js';
+/**
+ *
+ */
 export function isElement(node) {
     return !!node && node.type === 'element';
 }
-/** Read a declared string attribute off the component context, returning undefined for a boolean or
- *  absent value. Replaces the `typeof ctx.attributes[key] === 'string'` narrowing a build repeats. */
+/**
+ * Read a declared string attribute off the component context, returning undefined for a boolean or
+ *  absent value. Replaces the `typeof ctx.attributes[key] === 'string'` narrowing a build repeats.
+ */
 export function strAttr(ctx, key) {
     const value = ctx.attributes[key];
     return typeof value === 'string' ? value : undefined;
@@ -12,6 +17,9 @@ export function strAttr(ctx, key) {
 // hast Properties values are PropertyValue (string | number | boolean | array | null).
 // Directive markers (dataPrimitive/dataRole/dataAttr<Key>) are always stamped as strings;
 // this reads them back with that guarantee instead of casting at each call site.
+/**
+ *
+ */
 export function strProp(node, name) {
     const value = node.properties?.[name];
     return typeof value === 'string' ? value : undefined;
@@ -25,10 +33,12 @@ export function iconSpan(glyphEl, role) {
 export function cardShell(classes, body) {
     return h('section', { className: classes }, [h('div', { className: ['card-body'] }, body)]);
 }
-/** Card head row: `<div class="ec-head">[icon]<hN class="card-title">{title}</hN></div>`.
+/**
+ * Card head row: `<div class="ec-head">[icon]<hN class="card-title">{title}</hN></div>`.
  *  Pass the title's inline children, an optional pre-built icon element, and an optional heading
  *  level (default 2). This factors the icon-plus-heading head that a titled component build would
- *  otherwise rebuild by hand (the shape the removed `splitHead` produced). */
+ *  otherwise rebuild by hand (the shape the removed `splitHead` produced).
+ */
 export function headRow(title, icon, level = 2) {
     const children = [];
     if (icon)
@@ -36,8 +46,10 @@ export function headRow(title, icon, level = 2) {
     children.push(h(`h${level}`, { className: ['card-title'] }, title));
     return h('div', { className: ['ec-head'] }, children);
 }
-/** Tag the first <ul> among children with `ec-grid` and strip its whitespace-only
- *  text nodes so the bare list serializes without newlines. Returns that <ul>. */
+/**
+ * Tag the first <ul> among children with `ec-grid` and strip its whitespace-only
+ *  text nodes so the bare list serializes without newlines. Returns that <ul>.
+ */
 export function markFirstList(children) {
     const ul = children.find((c) => isElement(c) && c.tagName === 'ul');
     if (ul) {
@@ -133,12 +145,14 @@ function transformNode(node, registry) {
     };
     return def.build(ctx);
 }
-/** Rehype transformer: dispatch each stamped element through its registry `build`
+/**
+ * Rehype transformer: dispatch each stamped element through its registry `build`
  *  fn. When `stagger` is on, each top-level primitive gets a `data-rise` attribute
  *  carrying its document-order index (0, 1, 2, …); the site's CSS maps that ordinal
  *  to an entrance delay. The index is inert, so a consumer's sanitize floor can keep
  *  `data-rise` while dropping `style`. Nested primitives never get it. Non-primitive
- *  content (lede, intro paragraphs, the page-toc nav) passes through untouched. */
+ *  content (lede, intro paragraphs, the page-toc nav) passes through untouched.
+ */
 export function rehypeDispatch(registry, stagger) {
     return (tree) => {
         let idx = 0;

package/dist/render/remark-directives.d.ts

@@ -1,3 +1,6 @@
 import type { Root } from 'mdast';
 import { type ComponentRegistry } from './registry.js';
+/**
+ *
+ */
 export declare function remarkDirectiveStamp(registry: ComponentRegistry): (tree: Root) => void;

package/dist/render/remark-directives.js

@@ -51,6 +51,9 @@ function restoreLiteral(node) {
 // component name, icon, and role. No structure is built here; the rehype
 // dispatcher rewrites the marked elements once their children are hast.
 // Text and leaf directives are restored to literal text (accidental prose colons).
+/**
+ *
+ */
 export function remarkDirectiveStamp(registry) {
     const known = new Set(registry.names);
     return (tree) => {

package/dist/render/remark-figure.d.ts

@@ -1,4 +1,6 @@
 import type { Root } from 'mdast';
-/** Rewrite the reserved `figure` container directive into a placed <figure>. Every other directive
- *  is left to remarkDirectiveStamp, which already skips unregistered names. */
+/**
+ * Rewrite the reserved `figure` container directive into a placed <figure>. Every other directive
+ *  is left to remarkDirectiveStamp, which already skips unregistered names.
+ */
 export declare function remarkFigure(): (tree: Root) => void;

package/dist/render/remark-figure.js

@@ -42,8 +42,10 @@ function trimLeadingNewline(children) {
     }
     return children;
 }
-/** Rewrite the reserved `figure` container directive into a placed <figure>. Every other directive
- *  is left to remarkDirectiveStamp, which already skips unregistered names. */
+/**
+ * Rewrite the reserved `figure` container directive into a placed <figure>. Every other directive
+ *  is left to remarkDirectiveStamp, which already skips unregistered names.
+ */
 export function remarkFigure() {
     return (tree) => {
         visit(tree, 'containerDirective', (node) => {

package/dist/render/resolve-links.d.ts

@@ -1,7 +1,9 @@
 import type { VFile } from 'vfile';
 /** The VFile data key the renderer sets the per-call resolver under. */
 export declare const CAIRN_RESOLVE = "cairnResolve";
-/** Resolve cairn: link nodes against the VFile's resolver. A non-cairn href and a malformed token
+/**
+ * Resolve cairn: link nodes against the VFile's resolver. A non-cairn href and a malformed token
  *  pass through. A missing target is marked with the cairn-broken-link class (the resolver returns
- *  undefined) or, when the resolver throws, the error propagates and fails the build. */
+ *  undefined) or, when the resolver throws, the error propagates and fails the build.
+ */
 export declare function remarkResolveCairnLinks(): (tree: unknown, file: VFile) => void;

package/dist/render/resolve-links.js

@@ -7,9 +7,11 @@ import { visit } from 'unist-util-visit';
 import { parseCairnToken } from '../content/links.js';
 /** The VFile data key the renderer sets the per-call resolver under. */
 export const CAIRN_RESOLVE = 'cairnResolve';
-/** Resolve cairn: link nodes against the VFile's resolver. A non-cairn href and a malformed token
+/**
+ * Resolve cairn: link nodes against the VFile's resolver. A non-cairn href and a malformed token
  *  pass through. A missing target is marked with the cairn-broken-link class (the resolver returns
- *  undefined) or, when the resolver throws, the error propagates and fails the build. */
+ *  undefined) or, when the resolver throws, the error propagates and fails the build.
+ */
 export function remarkResolveCairnLinks() {
     return (tree, file) => {
         const resolve = file.data[CAIRN_RESOLVE];