@signal9/era-ui 1.1.2

package/dist/docs/component-docs.js

@@ -0,0 +1,25 @@
+import { buildComponentDocFromSources } from './component-docs-core.js';
+import { groupSvelteBySlug, parseAllSubExports, parseRootExports } from './component-source-scanners.js';
+const svelteSources = import.meta.glob('../ui/**/*.svelte', {
+    query: '?raw',
+    import: 'default',
+    eager: true
+});
+const componentIndexSources = import.meta.glob('../ui/*/index.ts', {
+    query: '?raw',
+    import: 'default',
+    eager: true
+});
+const rootIndexSources = import.meta.glob('../ui/index.ts', {
+    query: '?raw',
+    import: 'default',
+    eager: true
+});
+const sources = {
+    rootExports: parseRootExports(Object.values(rootIndexSources)[0] ?? ''),
+    subExportsBySlug: parseAllSubExports(componentIndexSources),
+    svelteBySlug: groupSvelteBySlug(svelteSources)
+};
+export function buildComponentDoc(entry, appendix) {
+    return buildComponentDocFromSources(entry, sources, appendix);
+}

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

@@ -0,0 +1,18 @@
+export interface RootExport {
+    kind: 'named' | 'namespace';
+    alias: string;
+}
+export interface SubExport {
+    name: string;
+    source: {
+        kind: 'file';
+        file: string;
+    } | {
+        kind: 'passthrough';
+        ref: string;
+    };
+}
+export declare function parseRootExports(src: string): Record<string, RootExport>;
+export declare function parseAllSubExports(sources: Record<string, string>): Record<string, SubExport[]>;
+export declare function parseSubExports(src: string): SubExport[];
+export declare function groupSvelteBySlug(sources: Record<string, string>): Record<string, Record<string, string>>;

package/dist/docs/component-source-scanners.js

@@ -0,0 +1,46 @@
+export function parseRootExports(src) {
+    const out = {};
+    for (const m of src.matchAll(/export\s*\{\s*([\w]+)(?:\s+as\s+[\w]+)?\s*(?:,[^}]*)?\}\s*from\s*["']\.\/([^/"']+)\/index\.js["']/g)) {
+        out[m[2]] = { kind: 'named', alias: m[1] };
+    }
+    for (const m of src.matchAll(/export\s*\*\s*as\s*([\w]+)\s*from\s*["']\.\/([^/"']+)\/index\.js["']/g)) {
+        out[m[2]] = { kind: 'namespace', alias: m[1] };
+    }
+    return out;
+}
+export function parseAllSubExports(sources) {
+    const out = {};
+    for (const [path, src] of Object.entries(sources)) {
+        const m = path.match(/\/ui\/([^/]+)\/index\.ts$/);
+        if (!m)
+            continue;
+        out[m[1]] = parseSubExports(src);
+    }
+    return out;
+}
+export function parseSubExports(src) {
+    const out = [];
+    for (const m of src.matchAll(/export\s*\{\s*default\s+as\s+([\w]+)\s*\}\s*from\s*["']\.\/([^"']+\.svelte)["']/g)) {
+        out.push({ name: m[1], source: { kind: 'file', file: m[2] } });
+    }
+    for (const m of src.matchAll(/export\s+const\s+([\w]+)\s*=\s*([\w.]+)\s*;/g)) {
+        out.push({ name: m[1], source: { kind: 'passthrough', ref: m[2] } });
+    }
+    for (const m of src.matchAll(/export\s*\{\s*([\w]+)\s*\}\s*from\s*["']\.\/([^"']+\.svelte)["']/g)) {
+        out.push({ name: m[1], source: { kind: 'file', file: m[2] } });
+    }
+    for (const m of src.matchAll(/export\s*\{\s*default\s*\}\s*from\s*["']\.\/([^"']+\.svelte)["']/g)) {
+        out.push({ name: 'default', source: { kind: 'file', file: m[1] } });
+    }
+    return out;
+}
+export function groupSvelteBySlug(sources) {
+    const out = {};
+    for (const [path, src] of Object.entries(sources)) {
+        const m = path.match(/\/ui\/([^/]+)\/([^/]+\.svelte)$/);
+        if (!m)
+            continue;
+        (out[m[1]] ??= {})[m[2]] = src;
+    }
+    return out;
+}

package/dist/docs/extract-props.d.ts

@@ -0,0 +1,13 @@
+export interface PropSpec {
+    name: string;
+    type: string;
+    optional: boolean;
+    default?: string;
+    bindable?: boolean;
+    description?: string;
+}
+export interface ComponentSpec {
+    inherits: string[];
+    props: PropSpec[];
+}
+export declare function extractProps(source: string): ComponentSpec | null;

package/dist/docs/extract-props.js

@@ -0,0 +1,324 @@
+export function extractProps(source) {
+    const script = extractScript(source);
+    if (!script)
+        return null;
+    const propsIdx = script.indexOf('$props(');
+    if (propsIdx === -1)
+        return null;
+    // Walk backwards through balanced brackets to locate `let { … }: … = $props()`.
+    // We find the `=` directly preceding `$props(`, then the matching `:`, then
+    // the destructure's closing `}`. Both the `=` and `:` must be at bracket
+    // depth 0 so we skip past any `=`/`:` buried inside the destructure or
+    // generic type arguments.
+    const eqIdx = findPrevTopLevel(script, propsIdx - 1, '=');
+    if (eqIdx === -1)
+        return null;
+    const typeEnd = eqIdx;
+    const typeStart = findPrevTopLevel(script, typeEnd - 1, ':');
+    if (typeStart === -1)
+        return null;
+    const typeExpr = script.slice(typeStart + 1, typeEnd).trim();
+    // Before `:` should be the destructure's closing `}`.
+    let braceEnd = typeStart - 1;
+    while (braceEnd >= 0 && /\s/.test(script[braceEnd]))
+        braceEnd--;
+    if (script[braceEnd] !== '}')
+        return null;
+    const braceStart = findMatchingOpen(script, braceEnd);
+    if (braceStart === -1)
+        return null;
+    const destructure = script.slice(braceStart + 1, braceEnd);
+    const defaults = parseDestructure(destructure);
+    const { inherits, literal } = parseTypeExpr(typeExpr);
+    // Merge defaults onto literal members; anything declared as bindable in the
+    // destructure is marked here too.
+    for (const prop of literal) {
+        const d = defaults[prop.name];
+        if (!d)
+            continue;
+        if (d.default !== undefined)
+            prop.default = d.default;
+        if (d.bindable)
+            prop.bindable = true;
+    }
+    // If the destructure introduces bindables not visible in the literal (a
+    // forwarded prop like `value` on Slider.Root), surface them anyway so the
+    // doc notes binding support.
+    for (const [name, d] of Object.entries(defaults)) {
+        if (literal.find((p) => p.name === name))
+            continue;
+        if (!d.bindable)
+            continue;
+        literal.push({
+            name,
+            type: '(forwarded)',
+            optional: true,
+            default: d.default,
+            bindable: true
+        });
+    }
+    return { inherits, props: literal };
+}
+function extractScript(source) {
+    // A component may have both a `<script module>` (tv() variants, etc.) and
+    // the instance `<script>`. $props() lives in the instance block, so scan
+    // all blocks and prefer the one that actually contains $props(); fall back
+    // to the last non-module block. Reading only the first block silently
+    // missed props on module-first components (badge/chip/card/skeleton).
+    const blocks = [...source.matchAll(/<script([^>]*)>([\s\S]*?)<\/script>/g)];
+    if (blocks.length === 0)
+        return null;
+    const withProps = blocks.find((b) => b[2].includes('$props('));
+    if (withProps)
+        return withProps[2];
+    const instance = blocks.filter((b) => !/\bmodule\b/.test(b[1])).at(-1);
+    return (instance ?? blocks[0])[2];
+}
+// If `src[i]` starts a string, template literal, or comment, skip past it and
+// return the next index. Otherwise returns `i` unchanged so callers can decide
+// what to do with the character.
+function skipNonCode(src, i) {
+    const c = src[i];
+    // Arrow `=>` is neither a bracket nor an operator we track. Skipping it as a
+    // unit keeps the lone `>` from being counted as a generic-bracket close
+    // (which corrupted depth on arrow-typed props like `(d: E) => void`) and
+    // keeps its `=` from being mistaken for the `= $props()` assignment.
+    if (c === '=' && src[i + 1] === '>')
+        return i + 2;
+    if (c === '"' || c === "'") {
+        const quote = c;
+        i++;
+        while (i < src.length && src[i] !== quote) {
+            if (src[i] === '\\')
+                i++;
+            i++;
+        }
+        return i + 1;
+    }
+    if (c === '`') {
+        i++;
+        while (i < src.length && src[i] !== '`') {
+            if (src[i] === '\\')
+                i++;
+            else if (src[i] === '$' && src[i + 1] === '{') {
+                i = findMatchingClose(src, i + 1) + 1;
+                continue;
+            }
+            i++;
+        }
+        return i + 1;
+    }
+    if (c === '/' && src[i + 1] === '/') {
+        while (i < src.length && src[i] !== '\n')
+            i++;
+        return i;
+    }
+    if (c === '/' && src[i + 1] === '*') {
+        i += 2;
+        while (i < src.length - 1 && !(src[i] === '*' && src[i + 1] === '/'))
+            i++;
+        return i + 2;
+    }
+    return i;
+}
+function findMatchingClose(src, openIdx) {
+    const open = src[openIdx];
+    const close = { '{': '}', '(': ')', '[': ']', '<': '>' }[open];
+    if (!close)
+        return -1;
+    let depth = 0;
+    let i = openIdx;
+    while (i < src.length) {
+        const next = skipNonCode(src, i);
+        if (next !== i) {
+            i = next;
+            continue;
+        }
+        const c = src[i];
+        if (c === open)
+            depth++;
+        else if (c === close) {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+        i++;
+    }
+    return -1;
+}
+function findMatchingOpen(src, closeIdx) {
+    const close = src[closeIdx];
+    const open = { '}': '{', ')': '(', ']': '[', '>': '<' }[close];
+    if (!open)
+        return -1;
+    // Rescan forward tracking balance rather than scanning backwards — handling
+    // string/comment boundaries in reverse is error-prone.
+    const stack = [];
+    let i = 0;
+    while (i <= closeIdx) {
+        const next = skipNonCode(src, i);
+        if (next !== i) {
+            i = next;
+            continue;
+        }
+        const c = src[i];
+        if (c === open)
+            stack.push(i);
+        else if (c === close) {
+            const o = stack.pop();
+            if (i === closeIdx)
+                return o ?? -1;
+        }
+        i++;
+    }
+    return -1;
+}
+function findPrevTopLevel(src, end, token) {
+    // Records only matches at bracket depth 0, skipping nested expressions.
+    let found = -1;
+    let depth = 0;
+    let i = 0;
+    while (i <= end) {
+        const next = skipNonCode(src, i);
+        if (next !== i) {
+            i = next;
+            continue;
+        }
+        const c = src[i];
+        if (c === '{' || c === '(' || c === '[' || c === '<')
+            depth++;
+        else if (c === '}' || c === ')' || c === ']' || c === '>')
+            depth--;
+        else if (depth === 0 && c === token)
+            found = i;
+        i++;
+    }
+    return found;
+}
+function splitTopLevel(s, delim) {
+    const out = [];
+    let start = 0;
+    let depth = 0;
+    let i = 0;
+    while (i < s.length) {
+        const next = skipNonCode(s, i);
+        if (next !== i) {
+            i = next;
+            continue;
+        }
+        const c = s[i];
+        if (c === '{' || c === '(' || c === '[' || c === '<')
+            depth++;
+        else if (c === '}' || c === ')' || c === ']' || c === '>')
+            depth--;
+        else if (depth === 0 && c === delim) {
+            out.push(s.slice(start, i));
+            start = i + 1;
+        }
+        i++;
+    }
+    out.push(s.slice(start));
+    return out;
+}
+function parseTypeExpr(typeExpr) {
+    const branches = splitTopLevel(typeExpr, '&')
+        .map((b) => b.trim())
+        .filter(Boolean);
+    const inherits = [];
+    const literal = [];
+    for (const branch of branches) {
+        if (branch.startsWith('{')) {
+            const close = findMatchingClose(branch, 0);
+            if (close === -1)
+                continue;
+            literal.push(...parseLiteralMembers(branch.slice(1, close)));
+        }
+        else {
+            inherits.push(branch);
+        }
+    }
+    return { inherits, literal };
+}
+function parseLiteralMembers(body) {
+    const entries = splitTopLevel(body, ';')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const props = [];
+    for (const entry of entries) {
+        let description;
+        let remainder = entry;
+        const jsdoc = remainder.match(/^\/\*\*([\s\S]*?)\*\/\s*/);
+        if (jsdoc) {
+            description = jsdoc[1].replace(/^\s*\*\s?/gm, '').trim();
+            remainder = remainder.slice(jsdoc[0].length);
+        }
+        // Strip any remaining leading line comments.
+        while (remainder.startsWith('//')) {
+            const nl = remainder.indexOf('\n');
+            remainder = nl === -1 ? '' : remainder.slice(nl + 1).trimStart();
+        }
+        const m = remainder.match(/^([A-Za-z_$][\w$]*)(\??)\s*:\s*([\s\S]+)$/);
+        if (!m)
+            continue;
+        props.push({
+            name: m[1],
+            optional: m[2] === '?',
+            type: m[3].trim(),
+            description
+        });
+    }
+    return props;
+}
+function parseDestructure(body) {
+    const entries = splitTopLevel(body, ',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const out = {};
+    for (const entry of entries) {
+        if (entry.startsWith('...'))
+            continue;
+        let left = entry;
+        let defaultVal;
+        const eq = findTopLevelChar(entry, '=');
+        if (eq !== -1) {
+            left = entry.slice(0, eq).trim();
+            defaultVal = entry.slice(eq + 1).trim();
+        }
+        // Strip alias: `class: className` → name is `class`.
+        const colon = findTopLevelChar(left, ':');
+        if (colon !== -1)
+            left = left.slice(0, colon).trim();
+        const bindable = /^\$bindable\b/.test(defaultVal ?? '');
+        let normalizedDefault = defaultVal;
+        if (bindable && defaultVal) {
+            // `$bindable(null)` → `null`; `$bindable<T>(x)` → `x`.
+            const paren = defaultVal.indexOf('(');
+            const close = paren === -1 ? -1 : findMatchingClose(defaultVal, paren);
+            if (paren !== -1 && close !== -1) {
+                normalizedDefault = defaultVal.slice(paren + 1, close).trim() || undefined;
+            }
+        }
+        out[left] = { default: normalizedDefault, bindable };
+    }
+    return out;
+}
+function findTopLevelChar(s, ch) {
+    let depth = 0;
+    let i = 0;
+    while (i < s.length) {
+        const next = skipNonCode(s, i);
+        if (next !== i) {
+            i = next;
+            continue;
+        }
+        const c = s[i];
+        if (c === '{' || c === '(' || c === '[' || c === '<')
+            depth++;
+        else if (c === '}' || c === ')' || c === ']' || c === '>')
+            depth--;
+        else if (depth === 0 && c === ch)
+            return i;
+        i++;
+    }
+    return -1;
+}

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

@@ -0,0 +1,4 @@
+export declare const docsBySlug: Record<string, string>;
+export declare const knownSlugs: Set<string>;
+export declare const llmsTxtTemplate: string;
+export declare const llmsFullTxt: string;

package/dist/docs/generated-docs.js

@@ -0,0 +1,23 @@
+const markdownFiles = import.meta.glob('../generated-docs/*.md', {
+    query: '?raw',
+    import: 'default',
+    eager: true
+});
+const textFiles = import.meta.glob('../generated-docs/*.txt', {
+    query: '?raw',
+    import: 'default',
+    eager: true
+});
+const manifestModules = import.meta.glob('../generated-docs/manifest.json', {
+    import: 'default',
+    eager: true
+});
+function stem(path) {
+    return path.replace(/^\.\.\/generated-docs\//, '').replace(/\.(md|txt)$/, '');
+}
+export const docsBySlug = Object.fromEntries(Object.entries(markdownFiles).map(([file, body]) => [stem(file), body]));
+const manifest = Object.values(manifestModules)[0];
+const manifestSlugs = manifest?.entries?.map((entry) => entry.slug) ?? [];
+export const knownSlugs = new Set(manifestSlugs.length ? manifestSlugs : Object.keys(docsBySlug));
+export const llmsTxtTemplate = textFiles['../generated-docs/llms.txt'] ?? '';
+export const llmsFullTxt = textFiles['../generated-docs/llms-full.txt'] ?? '';

package/dist/docs/index.d.ts

@@ -0,0 +1,5 @@
+import { type ComponentEntry } from '../../routes/registry.js';
+export declare const docs: Record<string, string>;
+export declare function getDoc(slug: string): string | undefined;
+export declare function hasDoc(slug: string): boolean;
+export declare function listEntries(): ComponentEntry[];

package/dist/docs/index.js

@@ -0,0 +1,62 @@
+import { components, guides } from '../../routes/registry.js';
+import { buildComponentDoc } from './component-docs.js';
+const rootUiIndexSources = import.meta.glob('../ui/index.ts', {
+    query: '?raw',
+    import: 'default',
+    eager: true
+});
+const markdownModules = import.meta.glob('./*.md', {
+    query: '?raw',
+    import: 'default',
+    eager: true
+});
+function slugFromPath(path) {
+    return path.replace(/^\.\//, '').replace(/\.md$/, '');
+}
+const appendices = Object.fromEntries(Object.entries(markdownModules).map(([path, body]) => [slugFromPath(path), body]));
+function titleFromSlug(slug) {
+    return slug
+        .split('-')
+        .map((part) => part[0]?.toUpperCase() + part.slice(1))
+        .join(' ');
+}
+function inferMissingEntriesFromRootUiIndex() {
+    const src = Object.values(rootUiIndexSources)[0] ?? '';
+    const mentioned = new Set();
+    for (const m of src.matchAll(/from\s+['"]\.\/([^/'"]+)\/index\.js['"]/g)) {
+        mentioned.add(m[1]);
+    }
+    // Provider exports theme tokens/types rather than a renderable component.
+    mentioned.delete('provider');
+    const existing = new Set([...guides, ...components].map((entry) => entry.slug));
+    const fallbackIcon = components[0]?.icon ?? guides[0].icon;
+    return [...mentioned]
+        .filter((slug) => !existing.has(slug))
+        .sort((a, b) => a.localeCompare(b))
+        .map((slug) => ({
+        name: titleFromSlug(slug),
+        slug,
+        description: `Component docs for ${titleFromSlug(slug)} (auto-discovered from src/lib/ui/index.ts exports).`,
+        icon: fallbackIcon
+    }));
+}
+const inferredEntries = inferMissingEntriesFromRootUiIndex();
+const allEntries = [...guides, ...components, ...inferredEntries];
+const entriesBySlug = Object.fromEntries(allEntries.map((e) => [e.slug, e]));
+// Synthesize every entry at module-init. Hand-authored markdown under
+// `src/lib/docs/<slug>.md` (if present) is appended verbatim as additional
+// notes — the header, import snippet, and props table always come from the
+// component source so the library stays in sync with itself.
+export const docs = Object.fromEntries(Object.values(entriesBySlug).map((entry) => [
+    entry.slug,
+    buildComponentDoc(entry, appendices[entry.slug])
+]));
+export function getDoc(slug) {
+    return docs[slug];
+}
+export function hasDoc(slug) {
+    return slug in docs;
+}
+export function listEntries() {
+    return allEntries;
+}

package/dist/docs/llms-txt.d.ts

@@ -0,0 +1,2 @@
+export declare function buildLlmsTxt(origin?: string): string;
+export declare function buildLlmsFullTxt(): string;

package/dist/docs/llms-txt.js

@@ -0,0 +1,84 @@
+import { docs, hasDoc, listEntries } from './index.js';
+import { modes, defaultMode, surfaces, defaultSurface, corners, defaultCorners, fonts, defaultFont, motions, defaultMotion } from '../ui/provider/index.js';
+const H1 = '# era-ui';
+const MISSION = '> A Svelte 5 + Bits UI component library. Every surface — heights, paddings, radii, gaps — derives from a single spacing atom, so density is a one-attribute override at any scope.';
+function orientation(origin) {
+    const axisList = (arr, dflt) => arr.map((v) => (v === dflt ? `**${v}** (default)` : v)).join(' · ');
+    return [
+        '## Using the library',
+        '',
+        '```ts',
+        'import { Button, Table, Select } from "@sig-nine/era-ui";',
+        'import "@sig-nine/era-ui/css";',
+        '```',
+        '',
+        'Named exports wrap a single primitive (`Button`, `Badge`, `Chip`, `Input`, …). Namespace exports compose primitives via sub-components (`Table.Root`, `Table.Row`, `Select.Trigger`, `Dialog.Content`, …). Every wrapper forwards unknown props to its underlying element or bits-ui primitive, so standard HTML attributes (`class`, `style`, event handlers, `aria-*`, `data-*`) work without ceremony.',
+        '',
+        '## Scoped overrides',
+        '',
+        'Five orthogonal axes are exposed as HTML attributes on any ancestor. The entire subtree re-tiers through CSS inheritance — no JS, no context provider.',
+        '',
+        `- \`data-mode\`: ${axisList(modes, defaultMode)} — adjusts the spacing atom (\`--era-sp\`).`,
+        `- \`data-surface\`: ${axisList(surfaces, defaultSurface)} — swaps the background treatment.`,
+        `- \`data-corners\`: ${axisList(corners, defaultCorners)} — scales all radii toward 0.`,
+        `- \`data-font\`: ${axisList(fonts, defaultFont)} — switches the font stack.`,
+        `- \`data-motion\`: ${axisList(motions, defaultMotion)} — sets animation speed (\`--era-duration\` / \`--era-ease\`), independent of density.`,
+        '',
+        'The `Mode` component is a thin wrapper that applies these attributes plus optional `primary` / `primaryFg` color overrides to a subtree.',
+        '',
+        '## Spacing system',
+        '',
+        'One atom, `--era-sp` (8px dense / 10px balanced / 12px spacious), drives everything. The tier ladder is:',
+        '',
+        '```',
+        'xs   = sp + 6       icons, tight affordances        14 / 16 / 18 px',
+        'xxs  = sp + 10      nested pill (badge, chip)       18 / 20 / 22 px',
+        'sm   = 2·sp + 6     standalone pill (kv)            22 / 26 / 30 px',
+        'md   = 3·sp         buttons, inputs, triggers       24 / 30 / 36 px',
+        'lg   = 4·sp         bars, top-level containers      32 / 40 / 48 px',
+        '```',
+        '',
+        'Heights (`--era-h-*`), insets (`--era-inset-*`), radii (`--era-rd-*`), and concentric gaps (`--era-xs-inset-sm`, `--era-xxs-inset-md`, …) are all `calc()` chains off `--era-sp`. Never hard-code pixel values — setting `data-mode` on any ancestor re-derives the whole subtree. Text size is static (14 px) across modes; only the spacing atom moves.',
+        '',
+        '## Per-component docs',
+        '',
+        `Every component has a passive markdown doc at \`${origin}/<slug>.md\`.`,
+        `Examples: \`${origin}/button.md\`, \`${origin}/select.md\`, \`${origin}/table.md\`.`,
+        `Full concatenated reference: \`${origin}/llms-full.txt\`.`,
+        '',
+        'Each page is generated from the component source, so props/variants/defaults stay in sync with the code automatically.'
+    ].join('\n');
+}
+export function buildLlmsTxt(origin = '') {
+    const entries = listEntries();
+    const lines = [H1, '', MISSION, '', orientation(origin), ''];
+    if (entries.length) {
+        lines.push('## Components', '');
+        lines.push(entries.map((e) => e.slug).join(', '), '');
+    }
+    return lines.join('\n');
+}
+// Module-init-cached: the concatenated reference has no request-dependent
+// inputs, so we pay its ~80 KB assembly cost once per worker instance instead
+// of on every request.
+let llmsFullTxtCache;
+export function buildLlmsFullTxt() {
+    if (llmsFullTxtCache !== undefined)
+        return llmsFullTxtCache;
+    const entries = listEntries().filter((e) => hasDoc(e.slug));
+    const parts = [
+        H1,
+        '',
+        MISSION,
+        '',
+        orientation(''),
+        '',
+        '<!-- Full component documentation, concatenated. -->',
+        ''
+    ];
+    for (const e of entries) {
+        parts.push(`<!-- begin: ${e.slug} -->`, '', docs[e.slug].trim(), '', `<!-- end: ${e.slug} -->`, '');
+    }
+    llmsFullTxtCache = parts.join('\n');
+    return llmsFullTxtCache;
+}

package/dist/docs/quickstart.md

@@ -0,0 +1,43 @@
+## Hero Template
+
+Use a single, pure component import from `$lib/ui` for a clean docs-friendly starter hero.
+
+```svelte
+<script lang="ts">
+	import { Badge, Bar, Button, ButtonGroup, Card, Separator } from '$lib/ui';
+</script>
+
+<section class="mx-auto flex w-full max-w-4xl flex-col gap-(--era-content-p) p-(--era-content-p)">
+	<Badge tone="accent">Now shipping v0.8</Badge>
+
+	<div class="space-y-(--era-gap)">
+		<h1 class="font-mono text-[length:calc(var(--era-text)*2)] font-semibold text-bright">
+			Era Hero
+		</h1>
+		<p class="max-w-prose text-muted">
+			Build once, then switch feel instantly with density and surface tokens.
+		</p>
+	</div>
+
+	<Bar class="border border-[color:var(--era-border-color)] bg-[var(--era-surface-bg)]">
+		<ButtonGroup>
+			<Button tone="accent">Get started</Button>
+			<Button variant="outline">Live preview</Button>
+		</ButtonGroup>
+	</Bar>
+
+	<Separator />
+
+	<div class="grid gap-(--era-gap) md:grid-cols-3">
+		<Card class="p-(--era-gap)">Dense-ready</Card>
+		<Card class="p-(--era-gap)">Balanced defaults</Card>
+		<Card class="p-(--era-gap)">Spacious polish</Card>
+	</div>
+</section>
+```
+
+### Why this template
+
+- Pure imports keep setup simple for first-time users.
+- Every spacing and size value comes from era tokens.
+- Works in all density modes without rewriting markup.

package/dist/docs/separator.md

@@ -0,0 +1,20 @@
+## Usage
+
+```svelte
+<script>
+	import { Separator } from '$lib/ui/separator';
+</script>
+
+<p>
+	era
+	<Separator variant="slant" decorative />
+	ui
+	<Separator variant="slant" decorative />
+	separator
+</p>
+```
+
+## Notes
+
+- `variant="slant"` is for inline text separators only, such as breadcrumbs, compact metadata, and split titles.
+- Mark slant separators `decorative` unless they communicate a meaningful boundary to assistive technology.