@glw907/cairn-cms 0.60.0 → 0.62.1

package/dist/media/sniff.d.ts

@@ -5,8 +5,10 @@
  * advisory. Recognizes JPEG, PNG, GIF, WebP, and the AVIF/HEIC ISO-BMFF brands.
  */
 export declare function sniffMediaType(bytes: Uint8Array): string | null;
-/** The storage extension for a sniffed media type, or null for a type the upload path does not store
- *  (HEIC, an unknown type). Driven by the sniffed type, so the key's ext is server-owned. */
+/**
+ * The storage extension for a sniffed media type, or null for a type the upload path does not store
+ *  (HEIC, an unknown type). Driven by the sniffed type, so the key's ext is server-owned.
+ */
 export declare function extForMediaType(type: string): string | null;
 /**
  * The engine-level upload deny predicate. Returns true (reject) when the upload is markup a site can

package/dist/media/sniff.js

@@ -7,21 +7,29 @@
 // and this byte check sees only the magic. The delivery route's response headers (X-Content-Type-Options:
 // nosniff, Content-Disposition: inline, a restrictive Content-Security-Policy) are the real XSS control
 // for the served bytes; sniffing here is the ingest gate, not the served-bytes defense.
-/** The leading ASCII whitespace bytes skipped before the deny-list's first-byte-is-`<` check:
- *  tab (0x09), newline (0x0A), carriage return (0x0D), and space (0x20). */
+/**
+ * The leading ASCII whitespace bytes skipped before the deny-list's first-byte-is-`<` check:
+ *  tab (0x09), newline (0x0A), carriage return (0x0D), and space (0x20).
+ */
 const WHITESPACE = new Set([0x09, 0x0a, 0x0d, 0x20]);
-/** The single byte `<` (0x3C). A payload whose first non-whitespace byte is `<` is markup (SVG, HTML,
- *  XML) and is denied regardless of its declared type or any site `allowedTypes`. */
+/**
+ * The single byte `<` (0x3C). A payload whose first non-whitespace byte is `<` is markup (SVG, HTML,
+ *  XML) and is denied regardless of its declared type or any site `allowedTypes`.
+ */
 const LT = 0x3c;
-/** Declared content types denied at the engine level, independent of any site `allowedTypes`. SVG and
- *  the markup types carry active content (script, foreignObject), so they never ingest as media. */
+/**
+ * Declared content types denied at the engine level, independent of any site `allowedTypes`. SVG and
+ *  the markup types carry active content (script, foreignObject), so they never ingest as media.
+ */
 const DENIED_TYPES = new Set(['image/svg+xml', 'image/svg', 'text/html', 'application/xml']);
 /** The ISO-BMFF major-brand codes (at bytes 8..11 of an `ftyp` box) that mean an AVIF image. */
 const AVIF_BRANDS = new Set(['avif', 'avis']);
 /** The ISO-BMFF major-brand codes that mean a HEIF/HEIC image. */
 const HEIC_BRANDS = new Set(['heic', 'heix', 'heif', 'hevc', 'hevx', 'mif1', 'msf1']);
-/** True when every byte of `magic` matches `bytes` starting at `offset`. False if `bytes` is too
- *  short to hold the whole magic. */
+/**
+ * True when every byte of `magic` matches `bytes` starting at `offset`. False if `bytes` is too
+ *  short to hold the whole magic.
+ */
 function matches(bytes, offset, magic) {
     if (bytes.length < offset + magic.length)
         return false;
@@ -31,8 +39,10 @@ function matches(bytes, offset, magic) {
     }
     return true;
 }
-/** The four ASCII characters at bytes `offset..offset+3`, or null when the input is too short. Used to
- *  read an ISO-BMFF brand code as a string. */
+/**
+ * The four ASCII characters at bytes `offset..offset+3`, or null when the input is too short. Used to
+ *  read an ISO-BMFF brand code as a string.
+ */
 function ascii4(bytes, offset) {
     if (bytes.length < offset + 4)
         return null;
@@ -71,9 +81,11 @@ export function sniffMediaType(bytes) {
     }
     return null;
 }
-/** The bare file extension (no dot) for each sniffed media type the upload path stores. The ext is
+/**
+ * The bare file extension (no dot) for each sniffed media type the upload path stores. The ext is
  *  derived from the server-sniffed type, never the client filename, so the stored key and the
- *  delivery extension allow-list always agree. An unmappable type returns null (the upload 415s). */
+ *  delivery extension allow-list always agree. An unmappable type returns null (the upload 415s).
+ */
 const EXT_BY_TYPE = {
     'image/jpeg': 'jpg',
     'image/png': 'png',
@@ -81,8 +93,10 @@ const EXT_BY_TYPE = {
     'image/webp': 'webp',
     'image/avif': 'avif',
 };
-/** The storage extension for a sniffed media type, or null for a type the upload path does not store
- *  (HEIC, an unknown type). Driven by the sniffed type, so the key's ext is server-owned. */
+/**
+ * The storage extension for a sniffed media type, or null for a type the upload path does not store
+ *  (HEIC, an unknown type). Driven by the sniffed type, so the key's ext is server-owned.
+ */
 export function extForMediaType(type) {
     return EXT_BY_TYPE[type] ?? null;
 }

package/dist/media/store.d.ts

@@ -1,17 +1,23 @@
 import type { R2Bucket, R2Conditional, R2HTTPMetadata, R2Object, R2ObjectBody, R2Range } from '@cloudflare/workers-types';
-/** The narrow R2 surface the media pipeline uses. The engine depends on this, not on R2Bucket, so the
- *  multipart, list, and conditional-read surface R2 also carries never leaks into the media code. */
+/**
+ * The narrow R2 surface the media pipeline uses. The engine depends on this, not on R2Bucket, so the
+ *  multipart, list, and conditional-read surface R2 also carries never leaks into the media code.
+ */
 export interface MediaStore {
-    /** Store bytes under a content-addressed key, with the response HTTP metadata (the content type)
+    /**
+     * Store bytes under a content-addressed key, with the response HTTP metadata (the content type)
      *  and optional custom metadata (the upload stores the full sha256 here, so a short-hash collision
-     *  is detectable on a later dedup probe). */
+     *  is detectable on a later dedup probe).
+     */
     put(key: string, bytes: ArrayBuffer | Uint8Array, httpMetadata?: R2HTTPMetadata, customMetadata?: Record<string, string>): Promise<void>;
     /** The object's metadata, or null when no object lives at the key (the dedup probe). */
     head(key: string): Promise<R2Object | null>;
-    /** The object body for streaming to a delivery response, or null when the key is absent. The
+    /**
+     * The object body for streaming to a delivery response, or null when the key is absent. The
      *  delivery route passes `onlyIf` and `range` through for conditional and partial reads: an
      *  `onlyIf` etag match returns a body-less R2Object (the 304 shape), so the return widens to
-     *  `R2Object` alongside `R2ObjectBody`. */
+     *  `R2Object` alongside `R2ObjectBody`.
+     */
     get(key: string, opts?: {
         range?: R2Range;
         onlyIf?: R2Conditional;
@@ -19,7 +25,9 @@ export interface MediaStore {
     /** Remove the object at the key. A delete of an absent key is a no-op, the R2 contract. */
     delete(key: string): Promise<void>;
 }
-/** Wrap an R2 bucket binding as a MediaStore. Each method delegates to the binding; put folds the
+/**
+ * Wrap an R2 bucket binding as a MediaStore. Each method delegates to the binding; put folds the
  *  HTTP and custom metadata into R2's options shape and drops the returned R2Object the pipeline does
- *  not read. */
+ *  not read.
+ */
 export declare function r2Store(bucket: R2Bucket): MediaStore;

package/dist/media/store.js

@@ -1,6 +1,8 @@
-/** Wrap an R2 bucket binding as a MediaStore. Each method delegates to the binding; put folds the
+/**
+ * Wrap an R2 bucket binding as a MediaStore. Each method delegates to the binding; put folds the
  *  HTTP and custom metadata into R2's options shape and drops the returned R2Object the pipeline does
- *  not read. */
+ *  not read.
+ */
 export function r2Store(bucket) {
     return {
         async put(key, bytes, httpMetadata, customMetadata) {

package/dist/media/transform-url.d.ts

@@ -1,6 +1,8 @@
-/** A single image variant: the resize and format directives Cloudflare Images applies to the
+/**
+ * A single image variant: the resize and format directives Cloudflare Images applies to the
  *  original bytes. Every field is optional. width, height, quality, and fit are emitted only when
- *  set; format and gravity always appear, defaulting to auto. */
+ *  set; format and gravity always appear, defaulting to auto.
+ */
 export interface VariantSpec {
     /** Target width in pixels. */
     width?: number;
@@ -15,12 +17,16 @@ export interface VariantSpec {
     /** Output format, `auto` to let Cloudflare negotiate, or a forced codec. */
     format?: 'auto' | 'webp' | 'avif' | string;
 }
-/** Build the on-demand Cloudflare Images transform URL for a delivery path. The options are
+/**
+ * Build the on-demand Cloudflare Images transform URL for a delivery path. The options are
  *  comma-joined in the stable order width, height, quality, fit, format, gravity, with width through
  *  fit emitted only when the spec sets them and format and gravity always present (defaulting to
- *  auto). The publicPath is appended unaltered, so the result is `/cdn-cgi/image/<options><publicPath>`. */
+ *  auto). The publicPath is appended unaltered, so the result is `/cdn-cgi/image/<options><publicPath>`.
+ */
 export declare function variantUrl(publicPath: string, spec: VariantSpec): string;
-/** Build a variant URL from a named preset. Looks up presetName in variants and builds its spec with
+/**
+ * Build a variant URL from a named preset. Looks up presetName in variants and builds its spec with
  *  variantUrl. Throws a cairn:-prefixed error naming the unknown preset when the name is absent, so a
- *  typo in a preset name fails loudly rather than silently rendering an unsized image. */
+ *  typo in a preset name fails loudly rather than silently rendering an unsized image.
+ */
 export declare function presetUrl(publicPath: string, presetName: string, variants: Record<string, VariantSpec>): string;

package/dist/media/transform-url.js

@@ -4,10 +4,12 @@
 // the option encoding and the stable option order, so the same spec always builds the same URL and
 // a CDN cache keys on it cleanly. The delivery path is appended unaltered, since it already carries
 // its own leading slash.
-/** Build the on-demand Cloudflare Images transform URL for a delivery path. The options are
+/**
+ * Build the on-demand Cloudflare Images transform URL for a delivery path. The options are
  *  comma-joined in the stable order width, height, quality, fit, format, gravity, with width through
  *  fit emitted only when the spec sets them and format and gravity always present (defaulting to
- *  auto). The publicPath is appended unaltered, so the result is `/cdn-cgi/image/<options><publicPath>`. */
+ *  auto). The publicPath is appended unaltered, so the result is `/cdn-cgi/image/<options><publicPath>`.
+ */
 export function variantUrl(publicPath, spec) {
     const options = [];
     if (spec.width !== undefined)
@@ -26,9 +28,11 @@ export function variantUrl(publicPath, spec) {
     const source = publicPath.startsWith('/') ? publicPath : `/${publicPath}`;
     return `/cdn-cgi/image/${options.join(',')}${source}`;
 }
-/** Build a variant URL from a named preset. Looks up presetName in variants and builds its spec with
+/**
+ * Build a variant URL from a named preset. Looks up presetName in variants and builds its spec with
  *  variantUrl. Throws a cairn:-prefixed error naming the unknown preset when the name is absent, so a
- *  typo in a preset name fails loudly rather than silently rendering an unsized image. */
+ *  typo in a preset name fails loudly rather than silently rendering an unsized image.
+ */
 export function presetUrl(publicPath, presetName, variants) {
     const spec = variants[presetName];
     if (spec === undefined) {

package/dist/media/usage.d.ts

@@ -21,13 +21,17 @@ export interface UsageEntry {
     /** Published vs the cairn/* branch the edit lives on. */
     origin: UsageOrigin;
 }
-/** Content hash to the distinct entries that reference it. A hash with no row is "no references
- *  found" (see the raw-HTML caveat above), never a proven orphan. */
+/**
+ * Content hash to the distinct entries that reference it. A hash with no row is "no references
+ *  found" (see the raw-HTML caveat above), never a proven orphan.
+ */
 export type UsageIndex = Map<string, UsageEntry[]>;
-/** Build options. `branches` lets a caller that already listed the open cairn/* branches pass them
+/**
+ * Build options. `branches` lets a caller that already listed the open cairn/* branches pass them
  *  in so the index does not list them a second time (the load path lists once for the media-union).
  *  `strict` flips the per-branch read from degrade-and-skip to fail-closed: a delete gate must not
- *  treat a transient branch-read failure as an absent reference, so it rethrows instead. */
+ *  treat a transient branch-read failure as an absent reference, so it rethrows instead.
+ */
 export interface BuildUsageOptions {
     /** The open cairn/* branch names, already listed. When present the index skips its own listing. */
     branches?: string[];

package/dist/nav/site-config.d.ts

@@ -34,16 +34,20 @@ export interface SiteConfig {
     menus?: Record<string, unknown>;
     /** Per-concept URL policy: the permalink pattern and date-prefix granularity, keyed by concept id. */
     content?: Record<string, ConceptUrlPolicy>;
-    /** The editor spellcheck settings. The dialect is declared once per site (spec 1.2), so a British
+    /**
+     * The editor spellcheck settings. The dialect is declared once per site (spec 1.2), so a British
      *  site loads the British word list and "colour" reads as correct. Today only US English ships, so an
-     *  unset or unknown dialect resolves to it. */
+     *  unset or unknown dialect resolves to it.
+     */
     spellcheck?: {
         dialect?: string;
     };
-    /** The editor tidy (LLM copy-edit) settings. Opt-in at the site level (spec 2.8): tidy is a remote,
+    /**
+     * The editor tidy (LLM copy-edit) settings. Opt-in at the site level (spec 2.8): tidy is a remote,
      *  costly model call, so the whole block is optional and `enabled` defaults false. The model is a
      *  developer-tier fact; the `conventions` block is the editor-tier per-convention config that builds
-     *  the prompt's CONVENTIONS section. The Anthropic API key is a Worker secret, never config. */
+     *  the prompt's CONVENTIONS section. The Anthropic API key is a Worker secret, never config.
+     */
     tidy?: TidyConfig;
     [key: string]: unknown;
 }
@@ -69,14 +73,18 @@ export declare const DEFAULT_TIDY_MODEL = "claude-sonnet-4-6";
  * Sentence spacing is dropped on purpose and regional spelling is `spellcheck.dialect`, not a toggle.
  */
 export interface TidyConventions {
-    /** The objective Fixes group (spelling, grammar, doubled words, whitespace, capitals, terminal
+    /**
+     * The objective Fixes group (spelling, grammar, doubled words, whitespace, capitals, terminal
      *  punctuation). Default on. The always-on core governs it; this toggle lets the screen turn the
-     *  group off. */
+     *  group off.
+     */
     fixes: boolean;
     /** Oxford comma position. Off when undefined; `always` | `complex-only` (AP) | `never`. */
     oxfordComma?: 'always' | 'complex-only' | 'never';
-    /** Number style threshold. Off when undefined; the always-numeral exception sets (ages, dates,
-     *  measurements, percentages) apply at any threshold. */
+    /**
+     * Number style threshold. Off when undefined; the always-numeral exception sets (ages, dates,
+     *  measurements, percentages) apply at any threshold.
+     */
     numberStyle?: 'under-ten' | 'under-hundred' | 'always-numerals';
     /** Measurement notation only (never the system, never the number). Off when undefined. */
     measurements?: 'abbreviate' | 'spell-out';

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

@@ -1,21 +1,31 @@
 import type { ComponentDef, ComponentValues } from './registry.js';
+/**
+ *
+ */
 export declare function serializeComponent(def: ComponentDef, values: ComponentValues): string;
-/** 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 declare function parseComponent(markdown: string, def: ComponentDef): Promise<ComponentValues>;
-/** 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 declare function parseRawAttributeKeys(markdown: string, def: ComponentDef): string[];
-/** The result of {@link componentRoundTripSafety}: whether re-opening a placed block into the
- *  guided form and re-serializing it is provably lossless. */
+/**
+ * The result of {@link componentRoundTripSafety}: whether re-opening a placed block into the
+ *  guided form and re-serializing it is provably lossless.
+ */
 export type RoundTripSafety = {
     safe: true;
 } | {
     safe: false;
     reason: 'unknown-attribute' | 'undeclared-child' | 'not-idempotent' | 'not-a-component';
 };
-/** 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
@@ -25,11 +35,14 @@ export type RoundTripSafety = {
  *  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 declare function componentRoundTripSafety(markdown: string, def: ComponentDef): Promise<RoundTripSafety>;
-/** 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 declare function parseComponentWithRawKeys(markdown: string, def: ComponentDef): Promise<{
     values: ComponentValues;
     rawKeys: string[];

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,