@signal9/era-ui 1.1.2

package/dist/dev/audit/audits/_helpers.d.ts

@@ -0,0 +1,5 @@
+/** Sub-pixel tolerance. Below this, treat values as equal. */
+export declare const TOL = 0.5;
+export declare function flexChildren(el: HTMLElement): HTMLElement[];
+export declare function isFlex(style: CSSStyleDeclaration): boolean;
+export declare function isHorizontalFlex(style: CSSStyleDeclaration): boolean;

package/dist/dev/audit/audits/_helpers.js

@@ -0,0 +1,11 @@
+/** Sub-pixel tolerance. Below this, treat values as equal. */
+export const TOL = 0.5;
+export function flexChildren(el) {
+    return [...el.children].filter((c) => c instanceof HTMLElement);
+}
+export function isFlex(style) {
+    return style.display === 'flex' || style.display === 'inline-flex';
+}
+export function isHorizontalFlex(style) {
+    return isFlex(style) && !style.flexDirection.startsWith('column');
+}

package/dist/dev/audit/audits/concentric-inset.d.ts

@@ -0,0 +1,2 @@
+import type { Audit } from '../types.js';
+export declare const concentricInset: Audit;

package/dist/dev/audit/audits/concentric-inset.js

@@ -0,0 +1,33 @@
+import { TOL, flexChildren, isFlex } from './_helpers.js';
+export const concentricInset = {
+    id: 'layout/concentric-inset',
+    name: 'Concentric vertical inset',
+    description: 'In a vertically-centered flex container, each child should sit with equal space above and below. Flags asymmetry greater than 0.5px.',
+    category: 'layout',
+    severity: 'warn',
+    selector: '*',
+    check(el) {
+        const s = getComputedStyle(el);
+        if (!isFlex(s) || !s.alignItems.includes('center'))
+            return null;
+        const kids = flexChildren(el);
+        if (kids.length === 0)
+            return null;
+        const pR = el.getBoundingClientRect();
+        const issues = [];
+        for (const k of kids) {
+            const kR = k.getBoundingClientRect();
+            const top = kR.top - pR.top;
+            const bot = pR.bottom - kR.bottom;
+            if (Math.abs(top - bot) > TOL) {
+                issues.push({
+                    auditId: 'layout/concentric-inset',
+                    element: k,
+                    message: `asymmetric vertical inset: T${top.toFixed(1)} vs B${bot.toFixed(1)}`,
+                    details: { top, bottom: bot, delta: top - bot }
+                });
+            }
+        }
+        return issues.length > 0 ? issues : null;
+    }
+};

package/dist/dev/audit/audits/index.d.ts

@@ -0,0 +1,4 @@
+import { concentricInset } from './concentric-inset.js';
+import { uniformSiblingGaps } from './uniform-sibling-gaps.js';
+import { wallMatchesGap } from './wall-matches-gap.js';
+export { concentricInset, uniformSiblingGaps, wallMatchesGap };

package/dist/dev/audit/audits/index.js

@@ -0,0 +1,9 @@
+import { registry } from '../registry.js';
+import { concentricInset } from './concentric-inset.js';
+import { uniformSiblingGaps } from './uniform-sibling-gaps.js';
+import { wallMatchesGap } from './wall-matches-gap.js';
+export { concentricInset, uniformSiblingGaps, wallMatchesGap };
+// Auto-register built-ins. Consumers can still unregister or add their own.
+registry.register(concentricInset);
+registry.register(uniformSiblingGaps);
+registry.register(wallMatchesGap);

package/dist/dev/audit/audits/uniform-sibling-gaps.d.ts

@@ -0,0 +1,2 @@
+import type { Audit } from '../types.js';
+export declare const uniformSiblingGaps: Audit;

package/dist/dev/audit/audits/uniform-sibling-gaps.js

@@ -0,0 +1,29 @@
+import { TOL, flexChildren, isHorizontalFlex } from './_helpers.js';
+export const uniformSiblingGaps = {
+    id: 'layout/uniform-sibling-gaps',
+    name: 'Uniform sibling gaps',
+    description: 'Horizontal flex siblings should have equal gaps between each adjacent pair. Flags variance greater than 0.5px.',
+    category: 'layout',
+    severity: 'warn',
+    selector: '*',
+    check(el) {
+        const s = getComputedStyle(el);
+        if (!isHorizontalFlex(s))
+            return null;
+        const kids = flexChildren(el);
+        if (kids.length < 3)
+            return null;
+        const rects = kids.map((k) => k.getBoundingClientRect());
+        const gaps = rects.slice(1).map((r, i) => r.left - rects[i].right);
+        const min = Math.min(...gaps);
+        const max = Math.max(...gaps);
+        if (max - min <= TOL)
+            return null;
+        return {
+            auditId: 'layout/uniform-sibling-gaps',
+            element: el,
+            message: `sibling gaps vary: ${min.toFixed(1)}…${max.toFixed(1)} (Δ ${(max - min).toFixed(1)})`,
+            details: { gaps, min, max }
+        };
+    }
+};

package/dist/dev/audit/audits/wall-matches-gap.d.ts

@@ -0,0 +1,2 @@
+import type { Audit } from '../types.js';
+export declare const wallMatchesGap: Audit;

package/dist/dev/audit/audits/wall-matches-gap.js

@@ -0,0 +1,30 @@
+import { TOL, flexChildren, isHorizontalFlex } from './_helpers.js';
+export const wallMatchesGap = {
+    id: 'layout/wall-matches-gap',
+    name: 'Wall padding matches sibling gap',
+    description: 'In a horizontal flex container, the left padding (wall to first child) should equal the gap between siblings — the rhythm rule that would have caught the bar/button-group mismatch. Flags delta greater than 0.5px.',
+    category: 'layout',
+    severity: 'info',
+    selector: '*',
+    check(el) {
+        const s = getComputedStyle(el);
+        if (!isHorizontalFlex(s))
+            return null;
+        const kids = flexChildren(el);
+        if (kids.length < 2)
+            return null;
+        const pR = el.getBoundingClientRect();
+        const first = kids[0].getBoundingClientRect();
+        const second = kids[1].getBoundingClientRect();
+        const wall = first.left - pR.left;
+        const gap = second.left - first.right;
+        if (Math.abs(wall - gap) <= TOL)
+            return null;
+        return {
+            auditId: 'layout/wall-matches-gap',
+            element: el,
+            message: `wall ≠ gap: wall=${wall.toFixed(1)} gap=${gap.toFixed(1)}`,
+            details: { wall, gap, delta: wall - gap }
+        };
+    }
+};

package/dist/dev/audit/index.d.ts

@@ -0,0 +1,4 @@
+export type { Audit, AuditCategory, AuditResult, AuditSeverity, Issue } from './types.js';
+export { AuditRegistry, registry } from './registry.js';
+export { runAudits } from './runner.js';
+export * from './audits/index.js';

package/dist/dev/audit/index.js

@@ -0,0 +1,3 @@
+export { AuditRegistry, registry } from './registry.js';
+export { runAudits } from './runner.js';
+export * from './audits/index.js';

package/dist/dev/audit/registry.d.ts

@@ -0,0 +1,13 @@
+import type { Audit } from './types.js';
+export declare class AuditRegistry {
+    #private;
+    constructor();
+    register(audit: Audit): void;
+    unregister(id: string): void;
+    all(): Audit[];
+    get(id: string): Audit | undefined;
+    isEnabled(id: string): boolean;
+    setEnabled(id: string, enabled: boolean): void;
+}
+/** Shared singleton. Import built-in audits via ./audits to auto-register. */
+export declare const registry: AuditRegistry;

package/dist/dev/audit/registry.js

@@ -0,0 +1,50 @@
+const STORAGE_KEY = 'era-audit-disabled';
+export class AuditRegistry {
+    #audits = new Map();
+    #disabled;
+    constructor() {
+        this.#disabled = new Set(loadDisabled());
+    }
+    register(audit) {
+        if (this.#audits.has(audit.id)) {
+            console.warn(`[audit] duplicate id: ${audit.id}`);
+        }
+        this.#audits.set(audit.id, audit);
+    }
+    unregister(id) {
+        this.#audits.delete(id);
+    }
+    all() {
+        return [...this.#audits.values()];
+    }
+    get(id) {
+        return this.#audits.get(id);
+    }
+    isEnabled(id) {
+        return !this.#disabled.has(id);
+    }
+    setEnabled(id, enabled) {
+        if (enabled)
+            this.#disabled.delete(id);
+        else
+            this.#disabled.add(id);
+        saveDisabled(this.#disabled);
+    }
+}
+function loadDisabled() {
+    if (typeof localStorage === 'undefined')
+        return [];
+    try {
+        return JSON.parse(localStorage.getItem(STORAGE_KEY) ?? '[]');
+    }
+    catch {
+        return [];
+    }
+}
+function saveDisabled(disabled) {
+    if (typeof localStorage === 'undefined')
+        return;
+    localStorage.setItem(STORAGE_KEY, JSON.stringify([...disabled]));
+}
+/** Shared singleton. Import built-in audits via ./audits to auto-register. */
+export const registry = new AuditRegistry();

package/dist/dev/audit/runner.d.ts

@@ -0,0 +1,3 @@
+import type { AuditResult } from './types.js';
+import type { AuditRegistry } from './registry.js';
+export declare function runAudits(root: HTMLElement, reg: AuditRegistry): AuditResult[];

package/dist/dev/audit/runner.js

@@ -0,0 +1,27 @@
+export function runAudits(root, reg) {
+    return reg
+        .all()
+        .filter((a) => reg.isEnabled(a.id))
+        .map((audit) => {
+        const t0 = performance.now();
+        const issues = runOne(audit, root);
+        return { audit, issues, durationMs: performance.now() - t0 };
+    });
+}
+function runOne(audit, root) {
+    if (audit.runAll)
+        return audit.runAll(root);
+    if (!audit.selector || !audit.check)
+        return [];
+    const issues = [];
+    for (const el of root.querySelectorAll(audit.selector)) {
+        const r = audit.check(el);
+        if (!r)
+            continue;
+        if (Array.isArray(r))
+            issues.push(...r);
+        else
+            issues.push(r);
+    }
+    return issues;
+}

package/dist/dev/audit/types.d.ts

@@ -0,0 +1,28 @@
+export type AuditSeverity = 'info' | 'warn' | 'error';
+export type AuditCategory = 'layout' | 'tokens' | 'a11y' | 'semantics';
+export interface Issue {
+    readonly auditId: string;
+    readonly element: HTMLElement;
+    readonly message: string;
+    readonly details?: Record<string, unknown>;
+}
+type CheckResult = Issue | Issue[] | null;
+export interface Audit {
+    readonly id: string;
+    readonly name: string;
+    readonly description: string;
+    readonly category: AuditCategory;
+    readonly severity: AuditSeverity;
+    /** CSS selector for elements the runner iterates. Paired with check(). */
+    readonly selector?: string;
+    /** Per-element check. Return null to pass, Issue(s) to report. */
+    readonly check?: (el: HTMLElement) => CheckResult;
+    /** Escape hatch for audits that don't fit selector iteration. */
+    readonly runAll?: (root: HTMLElement) => Issue[];
+}
+export interface AuditResult {
+    readonly audit: Audit;
+    readonly issues: Issue[];
+    readonly durationMs: number;
+}
+export {};

package/dist/dev/audit/types.js

@@ -0,0 +1,7 @@
+/*
+ * Audit framework types.
+ *
+ * Design informed by axe-core (rules + metadata + selectors), ESLint (rule
+ * meta + severity), and Lighthouse (categorized results, impact levels).
+ */
+export {};

package/dist/dev/audit-overlay.svelte

@@ -0,0 +1,125 @@
+<script lang="ts">
+	import { onMount } from 'svelte';
+	import { dev } from '$app/environment';
+	import { registry, runAudits, type AuditResult } from './audit/index.js';
+
+	interface Props {
+		/** Scope audits to a subtree. Defaults to document.body. */
+		root?: HTMLElement;
+		/** Shortcut letter (cmd/ctrl + shift + key). Default: "a". */
+		key?: string;
+	}
+
+	let { root, key = 'a' }: Props = $props();
+
+	let open = $state(false);
+	let results = $state<AuditResult[]>([]);
+
+	// Highlight tracking — restore previous outline when a new element is selected.
+	let highlightedEl: HTMLElement | undefined;
+	let prevOutline = '';
+
+	function run() {
+		results = runAudits(root ?? document.body, registry);
+	}
+
+	function toggle(id: string, enabled: boolean) {
+		registry.setEnabled(id, enabled);
+		run();
+	}
+
+	function highlight(el: HTMLElement) {
+		if (highlightedEl) highlightedEl.style.outline = prevOutline;
+		prevOutline = el.style.outline;
+		el.style.outline = '2px solid oklch(0.7 0.3 330)';
+		el.scrollIntoView({ behavior: 'smooth', block: 'center' });
+		highlightedEl = el;
+	}
+
+	function onKey(e: KeyboardEvent) {
+		if ((e.metaKey || e.ctrlKey) && e.shiftKey && e.key.toLowerCase() === key) {
+			e.preventDefault();
+			open = !open;
+			if (open) run();
+		}
+	}
+
+	onMount(() => {
+		window.addEventListener('keydown', onKey);
+		return () => {
+			window.removeEventListener('keydown', onKey);
+			if (highlightedEl) highlightedEl.style.outline = prevOutline;
+		};
+	});
+
+	let totalIssues = $derived(results.reduce((n, r) => n + r.issues.length, 0));
+
+	const isMac = typeof navigator !== 'undefined' && navigator.platform.includes('Mac');
+</script>
+
+{#if dev && open}
+	<div
+		class="fixed right-4 bottom-4 z-50 flex max-h-[70vh] w-96 flex-col overflow-hidden rounded-(--era-rd-md) bg-surface font-mono text-body shadow-[inset_0_0_0_0.5px_var(--color-border),var(--era-shadow)]"
+	>
+		<header
+			class="flex items-center gap-(--era-xs-inset-sm) px-(--era-inset-sm) py-(--era-gap) shadow-[inset_0_-0.5px_0_0_var(--color-border)]"
+		>
+			<strong class="text-bright">audits</strong>
+			<span class="text-muted">
+				{totalIssues} issue{totalIssues === 1 ? '' : 's'}
+			</span>
+			<button class="ml-auto text-muted hover:text-bright" onclick={run} aria-label="Re-run audits"
+				>↻</button
+			>
+			<button class="text-muted hover:text-bright" onclick={() => (open = false)} aria-label="Close"
+				>×</button
+			>
+		</header>
+
+		<div class="overflow-auto">
+			{#each results as r (r.audit.id)}
+				{@const enabled = registry.isEnabled(r.audit.id)}
+				<details open={r.issues.length > 0}>
+					<summary
+						class="flex cursor-pointer items-center gap-(--era-xs-inset-sm) px-(--era-inset-sm) py-(--era-gap) hover:bg-(--era-highlight)"
+					>
+						<input
+							type="checkbox"
+							checked={enabled}
+							onclick={(e) => e.stopPropagation()}
+							onchange={(e) => toggle(r.audit.id, e.currentTarget.checked)}
+						/>
+						<span class="flex-1 text-fg">{r.audit.name}</span>
+						<span class={r.issues.length > 0 ? 'text-destructive' : 'text-muted'}>
+							{r.issues.length}
+						</span>
+					</summary>
+					{#if r.issues.length === 0}
+						<p class="px-(--era-inset-sm) py-(--era-gap) text-muted">
+							{r.audit.description}
+						</p>
+					{:else}
+						{#each r.issues as issue, i (i)}
+							<button
+								class="flex w-full items-start gap-(--era-xs-inset-sm) px-(--era-inset-sm) py-(--era-gap) text-left hover:bg-(--era-highlight)"
+								onclick={() => highlight(issue.element)}
+							>
+								<span class="text-destructive">●</span>
+								<span class="text-fg">{issue.message}</span>
+							</button>
+						{/each}
+					{/if}
+				</details>
+			{/each}
+		</div>
+
+		<footer
+			class="flex items-center gap-(--era-gap) px-(--era-inset-sm) py-(--era-gap) text-muted shadow-[inset_0_0.5px_0_0_var(--color-border)]"
+		>
+			<kbd class="rounded-(--era-rd-xs) bg-hover px-(--era-inset-sm) text-fg">
+				{isMac ? '⌘' : 'ctrl'}⇧{key.toUpperCase()}
+			</kbd>
+			<span>toggle</span>
+		</footer>
+	</div>
+{/if}

package/dist/dev/audit-overlay.svelte.d.ts

@@ -0,0 +1,9 @@
+interface Props {
+    /** Scope audits to a subtree. Defaults to document.body. */
+    root?: HTMLElement;
+    /** Shortcut letter (cmd/ctrl + shift + key). Default: "a". */
+    key?: string;
+}
+declare const AuditOverlay: import("svelte").Component<Props, {}, "">;
+type AuditOverlay = ReturnType<typeof AuditOverlay>;
+export default AuditOverlay;

package/dist/dev/index.d.ts

@@ -0,0 +1,2 @@
+export * from './audit/index.js';
+export { default as AuditOverlay } from './audit-overlay.svelte';

package/dist/dev/index.js

@@ -0,0 +1,2 @@
+export * from './audit/index.js';
+export { default as AuditOverlay } from './audit-overlay.svelte';

package/dist/docs/badge.md

@@ -0,0 +1,18 @@
+## Usage
+
+```svelte
+<script>
+	import { Badge } from '$lib/ui/badge';
+</script>
+
+<Badge>draft</Badge>
+<Badge tone="accent">new</Badge>
+<Badge tone="success">passing</Badge>
+<Badge tone="destructive">failing</Badge>
+```
+
+## Notes
+
+- Non-interactive. For dismissible tokens use `Chip`. For labelled pairs use `KV`.
+- Uses the `xxs` tier tokens (height, radius, inset).
+- Inter-icon gap tightens to `--era-inset-xxs` when an SVG is present.

package/dist/docs/bits-ui-audit.md

@@ -0,0 +1,58 @@
+# Bits UI leverage audit
+
+_Date: 2026-04-22_
+
+## High-level status
+
+Era UI already wraps most of the major Bits UI primitives (accordion, dialog, menus, date/time fields, calendar/date pickers, command, select/combobox, etc.).
+
+## Components that are **custom-only** today
+
+These directories currently do not import `bits-ui` and are intentionally custom presentation components:
+
+- `badge`
+- `bar`
+- `button-group`
+- `card`
+- `chip`
+- `code-block`
+- `file-upload`
+- `input`
+- `kv`
+- `mode`
+- `skeleton`
+- `table`
+
+### Which of these are likely fine as custom components
+
+No direct Bits UI primitive exists for these semantic/presentational pieces:
+
+- `badge`, `bar`, `button-group`, `card`, `chip`, `code-block`, `kv`, `mode`, `skeleton`, `table`
+
+### One likely improvement area
+
+- `input` can stay native for simple text input, but if you want richer semantics and stronger consistency with the rest of the library, consider introducing wrappers around Bits UI field-family components (`DateField`, `TimeField`, etc.) as your recommended form surface. This is more of a product/design-system choice than a correctness gap.
+
+- `file-upload` has no first-class Bits UI file-upload primitive, so your custom drag/drop implementation is expected.
+
+## Bits UI primitives available but not wrapped yet
+
+Bits UI currently exposes additional primitives that are not represented in `src/lib/ui` yet:
+
+- `avatar`
+- `collapsible`
+- `link-preview`
+- `menu`
+- `navigation-menu`
+- `range-calendar`
+- `rating-group`
+- `toggle-group`
+- `toolbar`
+
+If your design system roadmap includes any of those UX patterns, adding wrappers would be the main way to “take fuller advantage” of Bits UI from where the repo is today.
+
+## Practical recommendations
+
+1. **Prioritize wrappers with immediate UX value**: `avatar`, `collapsible`, `toggle-group`, `toolbar`.
+2. **Document intentional non-Bits components** (`card`, `badge`, `table`, `skeleton`) so contributors know these are design primitives, not missing migrations.
+3. **Keep custom `file-upload`** unless Bits UI adds a dedicated primitive later.

package/dist/docs/button.md

@@ -0,0 +1,18 @@
+## Usage
+
+```svelte
+<script>
+	import { Button } from '$lib/ui/button';
+</script>
+
+<Button onclick={() => console.log('clicked')}>Save</Button>
+<Button tone="accent" size="sm">Confirm</Button>
+<Button tone="destructive" variant="link">Delete</Button>
+<Button icon size="icon" aria-label="Close"><X /></Button>
+```
+
+## Notes
+
+- Heights, radii, paddings, and gaps come from density tokens — never hard-code px.
+- `link` variant intentionally does not change color on hover (underline only) so it reads as static prose until confirmed interactive.
+- For a segmented row of buttons, use `ButtonGroup`.

package/dist/docs/chip.md

@@ -0,0 +1,20 @@
+## Usage
+
+```svelte
+<script>
+	import { Chip } from '$lib/ui/chip';
+
+	let tags = $state(['alpha', 'beta', 'gamma']);
+</script>
+
+{#each tags as tag}
+	<Chip ondismiss={() => (tags = tags.filter((t) => t !== tag))}>
+		{tag}
+	</Chip>
+{/each}
+```
+
+## Notes
+
+- Internal pointerdown/up events on the dismiss button are stopped from bubbling — this prevents accidental toggling when a Chip is nested inside a Select/Popover trigger.
+- Uses the `xxs` tier tokens (height, radius, inset). Part of the Badge/Chip/KV "tag" family.

package/dist/docs/component-docs-core.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentEntry } from '../../routes/registry.js';
+import type { RootExport, SubExport } from './component-source-scanners.js';
+export interface ComponentDocSources {
+    rootExports: Record<string, RootExport>;
+    subExportsBySlug: Record<string, SubExport[]>;
+    svelteBySlug: Record<string, Record<string, string>>;
+}
+export declare function buildComponentDocFromSources(entry: ComponentEntry, sources: ComponentDocSources, appendix?: string): string;

package/dist/docs/component-docs-core.js

@@ -0,0 +1,72 @@
+import { extractProps } from './extract-props.js';
+export function buildComponentDocFromSources(entry, sources, appendix) {
+    const { slug, name, description } = entry;
+    const root = sources.rootExports[slug];
+    const lines = [`# ${name}`, '', description, ''];
+    if (!root) {
+        if (appendix) {
+            const trimmed = stripRedundantHeader(appendix).trim();
+            if (trimmed)
+                lines.push(trimmed, '');
+        }
+        return lines.join('\n');
+    }
+    lines.push('## Import', '', '```ts', `import { ${root.alias} } from "$lib/ui/${slug}";`, '```', '');
+    const subs = sources.subExportsBySlug[slug] ?? [];
+    const files = sources.svelteBySlug[slug] ?? {};
+    if (root.kind === 'namespace') {
+        lines.push('Composed from sub-components — compose explicitly at the call site:', '', ...subs.map((s) => `- \`${root.alias}.${s.name}\``), '');
+        for (const sub of subs) {
+            lines.push(`## ${root.alias}.${sub.name}`, '');
+            if (sub.source.kind === 'passthrough') {
+                lines.push(`Re-exports \`${sub.source.ref}\` directly — see [bits-ui docs](https://bits-ui.com) for its full API.`, '');
+                continue;
+            }
+            const spec = extractProps(files[sub.source.file] ?? '');
+            lines.push(...renderPropsSection(spec));
+        }
+    }
+    else {
+        const sub = subs.find((s) => s.source.kind === 'file');
+        const file = sub && sub.source.kind === 'file' ? sub.source.file : `${slug}.svelte`;
+        const spec = extractProps(files[file] ?? '');
+        lines.push('## Props', '');
+        lines.push(...renderPropsSection(spec));
+    }
+    if (appendix) {
+        const trimmed = stripRedundantHeader(appendix).trim();
+        if (trimmed)
+            lines.push(trimmed, '');
+    }
+    return lines.join('\n');
+}
+function renderPropsSection(spec) {
+    if (!spec)
+        return ['_Props could not be parsed from source._', ''];
+    const out = [];
+    for (const inh of spec.inherits) {
+        out.push(`Inherits all props from \`${inh}\`.`);
+    }
+    if (spec.inherits.length)
+        out.push('');
+    if (!spec.props.length) {
+        if (!spec.inherits.length)
+            out.push('_No wrapper-specific props._', '');
+        return out;
+    }
+    out.push('| Prop | Type | Default | Notes |');
+    out.push('|------|------|---------|-------|');
+    for (const p of spec.props) {
+        const notes = [p.bindable ? 'bindable' : '', p.description ?? ''].filter(Boolean).join(' — ');
+        out.push(`| \`${p.name}${p.optional ? '?' : ''}\` | ${fmtCode(p.type)} | ${p.default !== undefined ? fmtCode(p.default) : '—'} | ${notes || '—'} |`);
+    }
+    out.push('');
+    return out;
+}
+function fmtCode(s) {
+    const normalized = s.replace(/\s+/g, ' ').trim().replace(/\|/g, '\\|');
+    return `\`${normalized}\``;
+}
+function stripRedundantHeader(md) {
+    return md.replace(/^#\s+[^\n]+\n+/, '');
+}

package/dist/docs/component-docs.d.ts

@@ -0,0 +1,2 @@
+import type { ComponentEntry } from '../../routes/registry.js';
+export declare function buildComponentDoc(entry: ComponentEntry, appendix?: string): string;