@santi020k/lumen 0.4.0 → 1.1.0

package/dist/integration-diagnostics.js

@@ -0,0 +1,311 @@
+import { createHash } from 'node:crypto';
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { extname, join, relative, resolve, sep } from 'node:path';
+import { lumenComponentBehavior, lumenGlobalBehaviors, lumenStylingContracts } from '@santi020k/lumen-core';
+const sourceExtensions = new Set(['.astro', '.css', '.js', '.jsx', '.mjs', '.ts', '.tsx']);
+const ignoredDirectories = new Set([
+    '.astro',
+    '.git',
+    '.next',
+    '.open-next',
+    '.output',
+    '.turbo',
+    '.vercel',
+    '.vite',
+    '.wrangler',
+    'build',
+    'coverage',
+    'dist',
+    'node_modules',
+    'out'
+]);
+const publicRootSlots = new Set(Object.values(lumenStylingContracts).flatMap(contract => [contract.rootSlot, ...contract.parts]));
+const discoverProject = async (root) => {
+    const packageRoots = [];
+    const sourceFiles = [];
+    const visit = async (directory) => {
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            if (ignoredDirectories.has(entry.name))
+                continue;
+            const path = join(directory, entry.name);
+            if (entry.isDirectory()) {
+                await visit(path);
+            }
+            else if (entry.name === 'package.json') {
+                packageRoots.push(directory);
+            }
+            else if (sourceExtensions.has(extname(entry.name))) {
+                sourceFiles.push(path);
+            }
+        }
+    };
+    await visit(root);
+    if (!packageRoots.includes(root))
+        packageRoots.push(root);
+    return { packageRoots, sourceFiles };
+};
+const importedNames = (source, packageName) => {
+    const names = [];
+    const pattern = new RegExp(`import\\s*\\{([\\s\\S]*?)\\}\\s*from\\s*['"]${packageName}['"]`, 'g');
+    for (const match of source.matchAll(pattern)) {
+        for (const entry of (match[1] ?? '').split(',')) {
+            const name = entry.trim().split(/\s+as\s+/u)[0];
+            if (name)
+                names.push(name);
+        }
+    }
+    return names;
+};
+const finding = (file, rule, message, remediation, severity = 'error') => ({ file, message, remediation, rule, severity });
+const packageNamePattern = String.raw `@santi020k\/lumen-(?:astro|elements|react)(?:\/[^'"]*)?`;
+const packageReferencePattern = new RegExp(String.raw `(?:^|\n)\s*(?:export|import)\s+(?:type\s+)?(?:[^'"\n]*?\s+from\s+)?['"]` +
+    String.raw `(${packageNamePattern})['"]`, 'g');
+const dynamicPackageReferencePattern = new RegExp(String.raw `import\(\s*['"](${packageNamePattern})['"]\s*\)`, 'g');
+const cssPackageReferencePattern = new RegExp(String.raw `(?:^|\n)\s*@import\s+(?:url\(\s*)?['"](${packageNamePattern})['"]`, 'g');
+const layoutFilePattern = /(?:^|\/)(?:layouts?\/[^/]+|[^/]*layout[^/]*)\.astro$/iu;
+const getPackageReferences = (source) => [
+    ...source.matchAll(packageReferencePattern),
+    ...source.matchAll(dynamicPackageReferencePattern),
+    ...source.matchAll(cssPackageReferencePattern)
+].flatMap(match => match[1] ? [match[1]] : []);
+const packageFramework = (packageName) => {
+    const framework = /^@santi020k\/lumen-(astro|elements|react)(?:\/|$)/u.exec(packageName)?.[1];
+    return framework === 'astro' || framework === 'elements' || framework === 'react' ?
+        framework :
+        undefined;
+};
+const getFrameworks = (sources) => [
+    ...new Set(sources.flatMap(item => getPackageReferences(item.source))
+        .filter(packageName => !packageName.endsWith('/styles.css') &&
+        !packageName.endsWith('/layers.css'))
+        .flatMap(packageName => {
+        const framework = packageFramework(packageName);
+        return framework ? [framework] : [];
+    }))
+];
+const getBoundaryRoot = (file, packageRoots, fallback) => packageRoots
+    .filter(packageRoot => file === packageRoot || file.startsWith(`${packageRoot}${sep}`))
+    .sort((left, right) => right.length - left.length)[0] ?? fallback;
+const createBoundaries = (root, packageRoots, sources) => {
+    const grouped = new Map();
+    for (const source of sources) {
+        const boundaryRoot = getBoundaryRoot(source.file, packageRoots, root);
+        const entries = grouped.get(boundaryRoot) ?? [];
+        entries.push(source);
+        grouped.set(boundaryRoot, entries);
+    }
+    return [...grouped].map(([boundaryRoot, boundarySources]) => ({
+        root: boundaryRoot,
+        sources: boundarySources
+    }));
+};
+const collectCompatibilityFindings = (root, sources) => sources.flatMap(item => {
+    const file = relative(root, item.file);
+    const findings = [];
+    if (/surface\s*=\s*["']glass["']/u.test(item.source)) {
+        findings.push(finding(file, 'deprecated-surface-glass', 'The surface="glass" compatibility alias is deprecated.', 'Replace it with the glass prop or attribute.', 'advisory'));
+    }
+    if (item.source.includes('ui:datatable-selection-change')) {
+        findings.push(finding(file, 'deprecated-datatable-event', 'The ui:datatable-selection-change event alias is deprecated.', 'Rename it to ui:data-table-selection-change.', 'advisory'));
+    }
+    return findings;
+});
+const getCatalogFingerprint = (sources) => {
+    const names = [...new Set(sources.flatMap(item => [
+            ...importedNames(item.source, '@santi020k/lumen-astro'),
+            ...importedNames(item.source, '@santi020k/lumen-react')
+        ]))]
+        .filter(name => name in lumenComponentBehavior)
+        .sort();
+    const contracts = names.map(name => [name, lumenComponentBehavior[name]]);
+    return createHash('sha256').update(JSON.stringify(contracts)).digest('hex');
+};
+const hasOnlyRuntimeBypassedComponents = (source, componentName, bypassAttribute) => {
+    const tagPattern = new RegExp(`<${componentName}(?=\\s|/|>)([^>]*)>`, 'g');
+    const tags = [...source.matchAll(tagPattern)];
+    const falsePattern = new RegExp(String.raw `\b${bypassAttribute}\s*=\s*(?:\{false\}|["']false["'])`, 'u');
+    const truePattern = new RegExp(String.raw `\b${bypassAttribute}(?:\s|/|$)|` +
+        String.raw `\b${bypassAttribute}\s*=\s*(?:\{true\}|["']true["'])`, 'u');
+    return tags.length > 0 && tags.every(match => {
+        const attributes = match[1] ?? '';
+        if (falsePattern.test(attributes))
+            return false;
+        return truePattern.test(attributes);
+    });
+};
+const componentNeedsAstroRuntime = (name, importingSources) => {
+    if (!(name in lumenComponentBehavior))
+        return false;
+    const behavior = lumenComponentBehavior[name];
+    if (behavior.astro !== 'ui-primitives')
+        return false;
+    if ('astroRuntimeBypass' in behavior && importingSources.length > 0 &&
+        importingSources.every(item => hasOnlyRuntimeBypassedComponents(item.source, name, behavior.astroRuntimeBypass)))
+        return false;
+    return true;
+};
+const getRuntimeImports = (sources) => {
+    const imports = sources.flatMap(item => importedNames(item.source, '@santi020k/lumen-astro')
+        .map(name => ({ file: item.file, name })));
+    return imports.filter(item => componentNeedsAstroRuntime(item.name, sources.filter(source => importedNames(source.source, '@santi020k/lumen-astro').includes(item.name))));
+};
+const getGlobalRuntimeBehaviors = (sources) => lumenGlobalBehaviors
+    .filter(behavior => sources.some(item => {
+    if (behavior.name === 'form-validation')
+        return item.source.includes('data-ui-form');
+    return behavior.authoredBy.split(',').some(eventName => item.source.includes(eventName.trim()));
+}))
+    .map(behavior => behavior.name);
+const collectRuntimeFindings = (repositoryRoot, boundary) => {
+    const runtimeImports = getRuntimeImports(boundary.sources);
+    const runtimeComponents = [
+        ...new Set([
+            ...runtimeImports.map(item => item.name),
+            ...getGlobalRuntimeBehaviors(boundary.sources)
+        ])
+    ];
+    const mountSources = boundary.sources.filter(item => /<UIPrimitives(?:\s|\/|>)/u.test(item.source));
+    const findings = [];
+    if (runtimeComponents.length > 0 && mountSources.length === 0) {
+        const firstRuntimeImport = runtimeImports[0];
+        findings.push(finding(firstRuntimeImport ? relative(repositoryRoot, firstRuntimeImport.file) : relative(repositoryRoot, boundary.root), 'astro-runtime-missing', `Interactive Astro usage requires UIPrimitives: ${runtimeComponents.join(', ')}.`, 'Mount <UIPrimitives /> once in the application root, or use a documented controlled prop when application code owns the behavior.'));
+    }
+    for (const mount of mountSources) {
+        const mountCount = [...mount.source.matchAll(/<UIPrimitives(?:\s|\/|>)/g)].length;
+        if (mountCount > 1) {
+            findings.push(finding(relative(repositoryRoot, mount.file), 'astro-runtime-duplicate', 'UIPrimitives is mounted more than once in this file.', 'Keep one mount in the application root layout.'));
+        }
+    }
+    const layoutMounts = mountSources.filter(item => layoutFilePattern.test(item.file));
+    if (layoutMounts.length > 0) {
+        for (const mount of mountSources.filter(item => !layoutMounts.includes(item))) {
+            findings.push(finding(relative(repositoryRoot, mount.file), 'astro-runtime-duplicate', 'UIPrimitives is mounted in both a layout and a route within this application boundary.', 'Keep the layout mount and remove the route-level mount.'));
+        }
+    }
+    return { findings, runtimeComponents };
+};
+const styleImportByFramework = {
+    astro: '@santi020k/lumen-astro/styles.css',
+    elements: '@santi020k/lumen-elements/styles.css',
+    react: '@santi020k/lumen-react/styles.css'
+};
+const countOccurrences = (source, value) => source.split(value).length - 1;
+const collectCssFindings = (root, sources) => sources
+    .filter(item => item.file.endsWith('.css'))
+    .flatMap(item => {
+    const layerIndex = item.source.search(/^\s*@import\s+(?:url\(\s*)?["'][^"']*\/layers\.css["']/mu);
+    const tailwindIndex = item.source.search(/^\s*@import\s+(?:url\(\s*)?["']tailwindcss["']/mu);
+    const styleIndex = item.source.search(/^\s*@import\s+(?:url\(\s*)?["'][^"']*\/styles\.css["']/mu);
+    const findings = [];
+    if (tailwindIndex >= 0 &&
+        styleIndex >= 0 &&
+        (layerIndex < 0 || !(layerIndex < tailwindIndex && tailwindIndex < styleIndex))) {
+        findings.push(finding(relative(root, item.file), 'tailwind-layer-order', 'Tailwind and Lumen imports do not use the verified cascade order.', 'Import Lumen layers.css, then tailwindcss, then the matching Lumen styles.css.'));
+    }
+    for (const match of item.source.matchAll(/\.ui-([a-z0-9-]+)/g)) {
+        const selector = match[1] ?? '';
+        if (!publicRootSlots.has(selector)) {
+            findings.push(finding(relative(root, item.file), 'internal-selector', `Selector .ui-${selector} is not a documented stable root hook.`, 'Prefer component props, semantic tokens, documented custom properties, or [data-slot].', 'advisory'));
+        }
+    }
+    return findings;
+});
+const collectFrameworkStyleFindings = (repositoryRoot, boundary, frameworks) => frameworks.flatMap(framework => {
+    const styleImport = styleImportByFramework[framework];
+    const references = boundary.sources.filter(item => item.source.includes(styleImport));
+    if (references.length === 0) {
+        return [finding(relative(repositoryRoot, boundary.root) || '.', 'framework-style-missing', `No ${styleImport} import was found in this application boundary.`, 'Load the matching adapter stylesheet once in the application root.')];
+    }
+    return references.flatMap(item => countOccurrences(item.source, styleImport) > 1 ?
+        [finding(relative(repositoryRoot, item.file), 'framework-style-duplicate', `The ${framework} stylesheet is loaded more than once in this file.`, 'Keep one stylesheet import in the application root.')] :
+        []);
+});
+const collectAdapterMismatchFindings = (repositoryRoot, boundary, frameworks) => {
+    const adapters = Object.entries(styleImportByFramework)
+        .flatMap(([framework, styleImport]) => boundary.sources.some(item => item.source.includes(styleImport)) ?
+        [framework] :
+        []);
+    return [...new Set(adapters)]
+        .filter(adapter => !frameworks.includes(adapter))
+        .map(adapter => finding(relative(repositoryRoot, boundary.root) || '.', 'adapter-style-mismatch', `The ${adapter} stylesheet is loaded without matching ${adapter} imports in this application boundary.`, 'Load the stylesheet from the adapter used by this application boundary.'));
+};
+const uniqueFindings = (findings) => [
+    ...new Map(findings.map(item => [
+        `${item.file}\u0000${item.rule}\u0000${item.message}`,
+        item
+    ])).values()
+];
+export const inspectLumenIntegration = async (repository) => {
+    const root = resolve(repository);
+    if (!(await stat(root)).isDirectory())
+        throw new Error(`Not a directory: ${root}`);
+    const discovered = await discoverProject(root);
+    const sources = await Promise.all(discovered.sourceFiles.map(async (file) => ({
+        file,
+        source: await readFile(file, 'utf8')
+    })));
+    const boundaries = createBoundaries(root, discovered.packageRoots, sources);
+    const frameworks = [...new Set(boundaries.flatMap(boundary => getFrameworks(boundary.sources)))];
+    const runtimeComponents = new Set();
+    const findings = [
+        ...collectCompatibilityFindings(root, sources),
+        ...collectCssFindings(root, sources)
+    ];
+    for (const boundary of boundaries) {
+        const boundaryFrameworks = getFrameworks(boundary.sources);
+        const runtime = collectRuntimeFindings(root, boundary);
+        runtime.runtimeComponents.forEach(component => runtimeComponents.add(component));
+        findings.push(...runtime.findings, ...collectFrameworkStyleFindings(root, boundary, boundaryFrameworks), ...collectAdapterMismatchFindings(root, boundary, boundaryFrameworks));
+    }
+    const deduplicatedFindings = uniqueFindings(findings);
+    return {
+        catalogFingerprint: getCatalogFingerprint(sources),
+        findings: deduplicatedFindings,
+        frameworks,
+        generatedAt: new Date().toISOString(),
+        healthy: deduplicatedFindings.every(item => item.severity !== 'error'),
+        repository: root,
+        runtimeComponents: [...runtimeComponents]
+    };
+};
+export const formatLumenDiagnostics = (report) => {
+    const heading = report.healthy ? 'Lumen integration is healthy.' : 'Lumen integration has blocking findings.';
+    if (report.findings.length === 0)
+        return heading;
+    return [
+        heading,
+        ...report.findings.map(item => `[${item.severity}] ${item.file} ${item.rule}: ${item.message} ${item.remediation}`)
+    ].join('\n');
+};
+export const createLumenSetup = (framework, tailwind = false) => {
+    const setupByFramework = {
+        astro: {
+            styles: '@import "@santi020k/lumen-astro/styles.css";',
+            tailwind: '@import "@santi020k/lumen-astro/layers.css";\n' +
+                '@import "tailwindcss";\n' +
+                '@import "@santi020k/lumen-astro/styles.css";'
+        },
+        elements: {
+            styles: '@import "@santi020k/lumen-elements/styles.css";',
+            tailwind: '@import "@santi020k/lumen-elements/layers.css";\n' +
+                '@import "tailwindcss";\n' +
+                '@import "@santi020k/lumen-elements/styles.css";'
+        },
+        react: {
+            styles: '@import "@santi020k/lumen-react/styles.css";',
+            tailwind: '@import "@santi020k/lumen-react/layers.css";\n' +
+                '@import "tailwindcss";\n' +
+                '@import "@santi020k/lumen-react/styles.css";'
+        }
+    };
+    const styles = tailwind ? setupByFramework[framework].tailwind : setupByFramework[framework].styles;
+    if (framework === 'astro') {
+        return `${styles}\n\n---\nimport { UIPrimitives } from '@santi020k/lumen-astro'\n---\n\n<UIPrimitives />`;
+    }
+    if (framework === 'elements') {
+        return `${styles}\n\n` +
+            'import { defineLumenElements } from \'@santi020k/lumen-elements/define\'\n\n' +
+            'defineLumenElements()';
+    }
+    return styles;
+};

package/dist/registry-data.d.ts

@@ -31,6 +31,42 @@ export declare const lumenRegistry: {
         readonly name: "data-visualization";
         readonly type: "recipe";
         readonly components: readonly ["Chart", "Sparkline", "BarChart", "LineChart", "PieChart", "Stat", "Meter"];
+    }, {
+        readonly name: "analytics-dashboard";
+        readonly type: "recipe";
+        readonly components: readonly ["Sidebar", "Stat", "Sparkline", "LineChart", "BarChart", "DateRangePicker", "Table", "Badge"];
+    }, {
+        readonly name: "saas-admin";
+        readonly type: "recipe";
+        readonly components: readonly ["Sidebar", "Stat", "Sparkline", "Alert", "Progress", "SearchField", "Table", "Badge"];
+    }, {
+        readonly name: "commerce-dashboard";
+        readonly type: "recipe";
+        readonly components: readonly ["Sidebar", "Stat", "Sparkline", "BarChart", "PieChart", "Progress", "Table", "Badge"];
+    }, {
+        readonly name: "project-workspace";
+        readonly type: "recipe";
+        readonly components: readonly ["Sidebar", "Stat", "Sparkline", "Progress", "Timeline", "Avatar", "Table", "Badge"];
+    }, {
+        readonly name: "auth-onboarding";
+        readonly type: "recipe";
+        readonly components: readonly ["Card", "Stepper", "Field", "Label", "Input", "Alert", "Checkbox", "Progress", "Button"];
+    }, {
+        readonly name: "docs-shell";
+        readonly type: "recipe";
+        readonly components: readonly ["SkipLink", "NavigationMenu", "ThemeToggle", "Sidebar", "Sheet", "Prose", "Pagination", "Code", "CodeTabs"];
+    }, {
+        readonly name: "marketing-shell";
+        readonly type: "recipe";
+        readonly components: readonly ["SkipLink", "NavigationMenu", "ButtonLink", "Card", "ScrollReveal", "BackToTop"];
+    }, {
+        readonly name: "dashboard-shell";
+        readonly type: "recipe";
+        readonly components: readonly ["NavigationMenu", "Sidebar", "Card", "Stat", "StatTrend", "Badge", "SearchField", "DateRangePicker", "Empty", "Table", "Chart"];
+    }, {
+        readonly name: "validated-form";
+        readonly type: "recipe";
+        readonly components: readonly ["Form", "Field", "FieldError", "Label", "Input", "NativeSelect", "Textarea", "Button"];
     }, {
         readonly name: "ai-docs";
         readonly type: "documentation";
@@ -166,6 +202,41 @@ export declare const lumenRegistry: {
         readonly category: "Layout";
         readonly files: readonly ["packages/astro/components/Card.astro", "packages/astro/styles/lumen.css"];
         readonly dependencies: readonly ["styles"];
+    }, {
+        readonly name: "CardContent";
+        readonly type: "component";
+        readonly description: "Provides the main content region inside a card.";
+        readonly category: "Layout";
+        readonly files: readonly ["packages/astro/components/CardContent.astro", "packages/astro/styles/lumen.css"];
+        readonly dependencies: readonly ["Card", "styles"];
+    }, {
+        readonly name: "CardDescription";
+        readonly type: "component";
+        readonly description: "Adds supporting copy to a card header.";
+        readonly category: "Layout";
+        readonly files: readonly ["packages/astro/components/CardDescription.astro", "packages/astro/styles/lumen.css"];
+        readonly dependencies: readonly ["Card", "styles"];
+    }, {
+        readonly name: "CardFooter";
+        readonly type: "component";
+        readonly description: "Groups actions at the end of a card.";
+        readonly category: "Layout";
+        readonly files: readonly ["packages/astro/components/CardFooter.astro", "packages/astro/styles/lumen.css"];
+        readonly dependencies: readonly ["Card", "styles"];
+    }, {
+        readonly name: "CardHeader";
+        readonly type: "component";
+        readonly description: "Groups introductory content at the start of a card.";
+        readonly category: "Layout";
+        readonly files: readonly ["packages/astro/components/CardHeader.astro", "packages/astro/styles/lumen.css"];
+        readonly dependencies: readonly ["Card", "styles"];
+    }, {
+        readonly name: "CardTitle";
+        readonly type: "component";
+        readonly description: "Provides a semantic card title with a stable styling hook.";
+        readonly category: "Layout";
+        readonly files: readonly ["packages/astro/components/CardTitle.astro", "packages/astro/styles/lumen.css"];
+        readonly dependencies: readonly ["Card", "styles"];
     }, {
         readonly name: "Carousel";
         readonly type: "component";
@@ -187,6 +258,13 @@ export declare const lumenRegistry: {
         readonly category: "Forms";
         readonly files: readonly ["packages/astro/components/Checkbox.astro", "packages/astro/styles/lumen.css"];
         readonly dependencies: readonly ["styles"];
+    }, {
+        readonly name: "CheckboxGroup";
+        readonly type: "component";
+        readonly description: "Groups related checkbox choices under one legend.";
+        readonly category: "Forms";
+        readonly files: readonly ["packages/astro/components/CheckboxGroup.astro", "packages/astro/styles/lumen.css"];
+        readonly dependencies: readonly ["Checkbox", "styles"];
     }, {
         readonly name: "Collapsible";
         readonly type: "component";
@@ -215,6 +293,20 @@ export declare const lumenRegistry: {
         readonly category: "Forms";
         readonly files: readonly ["packages/astro/components/Combobox.astro", "packages/astro/styles/lumen.css", "packages/astro/runtime/UIPrimitives.astro"];
         readonly dependencies: readonly ["styles", "runtime"];
+    }, {
+        readonly name: "Container";
+        readonly type: "component";
+        readonly description: "Centers page content within responsive gutters and a maximum width.";
+        readonly category: "Layout";
+        readonly files: readonly ["packages/astro/components/Container.astro", "packages/astro/styles/lumen.css"];
+        readonly dependencies: readonly ["styles"];
+    }, {
+        readonly name: "CopyButton";
+        readonly type: "component";
+        readonly description: "Copies arbitrary text or the content of another element with accessible feedback.";
+        readonly category: "Actions";
+        readonly files: readonly ["packages/astro/components/CopyButton.astro", "packages/astro/styles/lumen.css", "packages/astro/runtime/UIPrimitives.astro"];
+        readonly dependencies: readonly ["styles", "runtime"];
     }, {
         readonly name: "Command";
         readonly type: "component";
@@ -292,6 +384,13 @@ export declare const lumenRegistry: {
         readonly category: "Feedback";
         readonly files: readonly ["packages/astro/components/Empty.astro", "packages/astro/styles/lumen.css"];
         readonly dependencies: readonly ["styles"];
+    }, {
+        readonly name: "ErrorSummary";
+        readonly type: "component";
+        readonly description: "Summarizes form errors and links people back to invalid controls.";
+        readonly category: "Forms";
+        readonly files: readonly ["packages/astro/components/ErrorSummary.astro", "packages/astro/styles/lumen.css"];
+        readonly dependencies: readonly ["styles"];
     }, {
         readonly name: "Eyebrow";
         readonly type: "component";
@@ -306,6 +405,13 @@ export declare const lumenRegistry: {
         readonly category: "Forms";
         readonly files: readonly ["packages/astro/components/Input.astro", "packages/astro/components/Label.astro", "packages/astro/components/Field.astro", "packages/astro/styles/lumen.css"];
         readonly dependencies: readonly ["Input", "Label", "styles"];
+    }, {
+        readonly name: "FieldError";
+        readonly type: "component";
+        readonly description: "Displays an error connected to a form control.";
+        readonly category: "Forms";
+        readonly files: readonly ["packages/astro/components/FieldError.astro", "packages/astro/styles/lumen.css"];
+        readonly dependencies: readonly ["Field", "styles"];
     }, {
         readonly name: "FloatingBadge";
         readonly type: "component";
@@ -313,6 +419,13 @@ export declare const lumenRegistry: {
         readonly category: "Data display";
         readonly files: readonly ["packages/astro/components/FloatingBadge.astro", "packages/astro/styles/lumen.css"];
         readonly dependencies: readonly ["styles"];
+    }, {
+        readonly name: "Form";
+        readonly type: "component";
+        readonly description: "Adds consistent validation and submission state to a native form.";
+        readonly category: "Forms";
+        readonly files: readonly ["packages/astro/components/Form.astro", "packages/astro/styles/lumen.css", "packages/astro/runtime/UIPrimitives.astro"];
+        readonly dependencies: readonly ["styles", "runtime"];
     }, {
         readonly name: "FormattedDate";
         readonly type: "component";
@@ -397,6 +510,13 @@ export declare const lumenRegistry: {
         readonly category: "Data display";
         readonly files: readonly ["packages/astro/components/LineChart.astro", "packages/astro/components/Chart.astro", "packages/astro/styles/lumen.css"];
         readonly dependencies: readonly ["Chart", "styles"];
+    }, {
+        readonly name: "ListBox";
+        readonly type: "component";
+        readonly description: "Presents a visible single- or multi-select option list.";
+        readonly category: "Forms";
+        readonly files: readonly ["packages/astro/components/ListBox.astro", "packages/astro/styles/lumen.css", "packages/astro/runtime/UIPrimitives.astro"];
+        readonly dependencies: readonly ["styles", "runtime"];
     }, {
         readonly name: "Marker";
         readonly type: "component";
@@ -453,6 +573,13 @@ export declare const lumenRegistry: {
         readonly category: "Navigation";
         readonly files: readonly ["packages/astro/components/Pagination.astro", "packages/astro/styles/lumen.css"];
         readonly dependencies: readonly ["styles"];
+    }, {
+        readonly name: "PasswordField";
+        readonly type: "component";
+        readonly description: "Combines a password input with guidance, errors, and a visibility toggle.";
+        readonly category: "Forms";
+        readonly files: readonly ["packages/astro/components/PasswordField.astro", "packages/astro/styles/lumen.css", "packages/astro/runtime/UIPrimitives.astro"];
+        readonly dependencies: readonly ["Button", "Field", "FieldError", "Input", "Label", "styles", "runtime"];
     }, {
         readonly name: "PhoneInput";
         readonly type: "component";
@@ -486,8 +613,8 @@ export declare const lumenRegistry: {
         readonly type: "component";
         readonly description: "Shows completion, loading progress, or quota usage.";
         readonly category: "Feedback";
-        readonly files: readonly ["packages/astro/components/Progress.astro", "packages/astro/styles/lumen.css"];
-        readonly dependencies: readonly ["styles"];
+        readonly files: readonly ["packages/astro/components/Progress.astro", "packages/astro/styles/lumen.css", "packages/astro/runtime/UIPrimitives.astro"];
+        readonly dependencies: readonly ["styles", "runtime"];
     }, {
         readonly name: "Prose";
         readonly type: "component";
@@ -765,6 +892,48 @@ export declare const lumenRegistry: {
         readonly category: "Data display";
         readonly description: "A stat component.";
         readonly files: readonly ["packages/astro/components/Stat.astro", "packages/react/src/components.tsx"];
+    }, {
+        readonly name: "StatDescription";
+        readonly type: "component";
+        readonly description: "Adds supporting context to a composed statistic.";
+        readonly category: "Data display";
+        readonly files: readonly ["packages/astro/components/StatDescription.astro", "packages/astro/styles/lumen.css"];
+        readonly dependencies: readonly ["Stat", "styles"];
+    }, {
+        readonly name: "StatIcon";
+        readonly type: "component";
+        readonly description: "Provides an icon region for a composed statistic.";
+        readonly category: "Data display";
+        readonly files: readonly ["packages/astro/components/StatIcon.astro", "packages/astro/styles/lumen.css"];
+        readonly dependencies: readonly ["Stat", "styles"];
+    }, {
+        readonly name: "StatLabel";
+        readonly type: "component";
+        readonly description: "Labels a composed statistic.";
+        readonly category: "Data display";
+        readonly files: readonly ["packages/astro/components/StatLabel.astro", "packages/astro/styles/lumen.css"];
+        readonly dependencies: readonly ["Stat", "styles"];
+    }, {
+        readonly name: "StatTrend";
+        readonly type: "component";
+        readonly description: "Communicates a metric delta with a semantic tone.";
+        readonly category: "Data display";
+        readonly files: readonly ["packages/astro/components/StatTrend.astro", "packages/astro/styles/lumen.css"];
+        readonly dependencies: readonly ["Stat", "styles"];
+    }, {
+        readonly name: "StatValue";
+        readonly type: "component";
+        readonly description: "Displays the prominent value in a composed statistic.";
+        readonly category: "Data display";
+        readonly files: readonly ["packages/astro/components/StatValue.astro", "packages/astro/styles/lumen.css"];
+        readonly dependencies: readonly ["Stat", "styles"];
+    }, {
+        readonly name: "Stack";
+        readonly type: "component";
+        readonly description: "Arranges children with tokenized direction, spacing, and alignment.";
+        readonly category: "Layout";
+        readonly files: readonly ["packages/astro/components/Stack.astro", "packages/astro/styles/lumen.css"];
+        readonly dependencies: readonly ["styles"];
     }, {
         readonly name: "Meter";
         readonly type: "component";
@@ -915,6 +1084,20 @@ export declare const lumenRegistry: {
         readonly category: "Navigation";
         readonly description: "A floating action button with expandable sub-actions.";
         readonly files: readonly ["packages/astro/components/SpeedDial.astro", "packages/react/src/components.tsx"];
+    }, {
+        readonly name: "Grid";
+        readonly type: "component";
+        readonly category: "Layout";
+        readonly description: "Arranges content in fixed or responsive tokenized columns.";
+        readonly files: readonly ["packages/astro/components/Grid.astro", "packages/astro/styles/lumen.css"];
+        readonly dependencies: readonly ["styles"];
+    }, {
+        readonly name: "VisuallyHidden";
+        readonly type: "component";
+        readonly category: "Layout";
+        readonly description: "Keeps meaningful content available to assistive technology without displaying it.";
+        readonly files: readonly ["packages/astro/components/VisuallyHidden.astro", "packages/astro/styles/lumen.css"];
+        readonly dependencies: readonly ["styles"];
     }];
 };
 //# sourceMappingURL=registry-data.d.ts.map

package/dist/registry-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry-data.d.ts","sourceRoot":"","sources":["../src/registry-data.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkyDQ,CAAA"}
+{"version":3,"file":"registry-data.d.ts","sourceRoot":"","sources":["../src/registry-data.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+sEQ,CAAA"}