@santi020k/lumen 1.6.0 → 1.7.0

package/dist/native-audit.js

@@ -1,6 +1,9 @@
-import { readdir, readFile, stat } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { access, readdir, readFile, stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
 import { extname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
 const ignoredDirectories = new Set([
     '.build',
     '.git',
@@ -11,7 +14,8 @@ const ignoredDirectories = new Set([
     'DerivedData',
     'node_modules'
 ]);
-const nativeExtensions = new Set(['.gradle', '.json', '.kts', '.swift', '.toml']);
+const nativeExtensions = new Set(['.gradle', '.json', '.kt', '.kts', '.properties', '.swift', '.toml']);
+const execFileAsync = promisify(execFile);
 const discoverNativeSources = async (root) => {
     const files = [];
     const visit = async (directory) => {
@@ -30,6 +34,235 @@ const discoverNativeSources = async (root) => {
     await visit(root);
     return Promise.all(files.map(async (file) => ({ file, source: await readFile(file, 'utf8') })));
 };
+const adoptionRules = [
+    { componentId: 'text', family: 'content', platform: 'swift', primitive: 'Text' },
+    { componentId: 'button', family: 'actions', platform: 'swift', primitive: 'Button' },
+    { componentId: 'text-field', family: 'forms', platform: 'swift', primitive: 'TextField' },
+    { componentId: 'toggle', family: 'forms', platform: 'swift', primitive: 'Toggle' },
+    { componentId: 'date-field', family: 'forms', platform: 'swift', primitive: 'DatePicker' },
+    { componentId: 'spinner', family: 'feedback', platform: 'swift', primitive: 'ProgressView' },
+    { componentId: 'text', family: 'content', platform: 'compose', primitive: 'Text' },
+    { componentId: 'button', family: 'actions', platform: 'compose', primitive: 'Button' },
+    { componentId: 'text-field', family: 'forms', platform: 'compose', primitive: 'TextField' },
+    { componentId: 'text-field', family: 'forms', platform: 'compose', primitive: 'OutlinedTextField' },
+    { componentId: 'toggle', family: 'forms', platform: 'compose', primitive: 'Switch' },
+    { componentId: 'checkbox', family: 'forms', platform: 'compose', primitive: 'Checkbox' },
+    { componentId: 'radio-group', family: 'forms', platform: 'compose', primitive: 'RadioButton' },
+    { componentId: 'date-field', family: 'forms', platform: 'compose', primitive: 'DatePicker' },
+    { componentId: 'card', family: 'content', platform: 'compose', primitive: 'Card' },
+    { componentId: 'divider', family: 'content', platform: 'compose', primitive: 'HorizontalDivider' },
+    { componentId: 'spinner', family: 'feedback', platform: 'compose', primitive: 'CircularProgressIndicator' }
+];
+const resolveSourcePlatform = (file) => {
+    if (file.endsWith('.swift'))
+        return 'swift';
+    if (file.endsWith('.kt') || file.endsWith('.kts'))
+        return 'compose';
+    return null;
+};
+const inspectAdoptionInventory = (root, sources, registry) => {
+    const symbols = new Map(registry.components.map(component => [component.id, component.symbols]));
+    const suggestions = [];
+    const implementationDirectories = [
+        registry.adapters.compose.sourceDirectory,
+        ...(registry.adapters.compose.additionalSourceDirectories ?? []),
+        registry.adapters.swiftUI.sourceDirectory,
+        ...(registry.adapters.swiftUI.additionalSourceDirectories ?? [])
+    ];
+    for (const entry of sources) {
+        const repositoryPath = relative(root, entry.file);
+        const platform = resolveSourcePlatform(entry.file);
+        if (!platform ||
+            /(?:^|\/)(?:test|tests|androidTest)(?:\/|$)/iu.test(entry.file) ||
+            implementationDirectories.some(directory => repositoryPath === directory || repositoryPath.startsWith(`${directory}/`)))
+            continue;
+        const lines = entry.source.split(/\r?\n/u);
+        lines.forEach((line, index) => {
+            const code = line.split('//', 1)[0] ?? '';
+            for (const rule of adoptionRules) {
+                if (rule.platform !== platform)
+                    continue;
+                const lumenComponent = symbols.get(rule.componentId)?.[platform === 'swift' ? 'swiftUI' : 'compose'];
+                if (!lumenComponent || !new RegExp(`\\b${rule.primitive}\\s*\\(`, 'u').test(code))
+                    continue;
+                suggestions.push({
+                    family: rule.family,
+                    file: repositoryPath,
+                    line: index + 1,
+                    lumenComponent,
+                    nativePrimitive: rule.primitive,
+                    platform
+                });
+            }
+        });
+    }
+    const familyCounts = suggestions.reduce((counts, suggestion) => {
+        counts.set(suggestion.family, (counts.get(suggestion.family) ?? 0) + 1);
+        return counts;
+    }, new Map());
+    const families = [...familyCounts]
+        .map(([family, count]) => ({ count, family }))
+        .sort((first, second) => first.family.localeCompare(second.family));
+    return { families, suggestions };
+};
+const pathExists = async (path) => access(path).then(() => true).catch(() => false);
+const parseJavaMajor = (value) => {
+    const match = /(?:JAVA_VERSION=|version\s+)["']?(?:1\.)?([0-9]+)/u.exec(value);
+    return match?.[1] ? Number.parseInt(match[1], 10) : undefined;
+};
+const readJavaMajor = async (environment) => {
+    const javaHome = environment.JAVA_HOME;
+    if (javaHome) {
+        const release = await readFile(join(javaHome, 'release'), 'utf8').catch(() => '');
+        const major = parseJavaMajor(release);
+        if (major)
+            return { home: javaHome, major };
+    }
+    try {
+        const result = await execFileAsync('java', ['-version'], { env: environment });
+        const major = parseJavaMajor(`${result.stdout}\n${result.stderr}`);
+        return { ...(javaHome ? { home: javaHome } : {}), ...(major ? { major } : {}) };
+    }
+    catch {
+        return javaHome ? { home: javaHome } : {};
+    }
+};
+const resolveAndroidSdkRoot = async (root, environment) => {
+    const localProperties = await readFile(join(root, 'local.properties'), 'utf8').catch(() => '');
+    const localSdk = /^sdk\.dir=(.+)$/mu.exec(localProperties)?.[1]?.replaceAll('\\\\', '\\');
+    const candidates = [
+        environment.ANDROID_SDK_ROOT,
+        environment.ANDROID_HOME,
+        localSdk,
+        join(homedir(), 'Library', 'Android', 'sdk'),
+        join(homedir(), 'Android', 'Sdk')
+    ].filter((value) => Boolean(value));
+    for (const candidate of candidates) {
+        if (await pathExists(candidate))
+            return resolve(candidate);
+    }
+    return undefined;
+};
+const findDeclaredNdkVersion = (sources) => {
+    for (const source of sources) {
+        const version = /(?<![A-Za-z\d_])ndkVersion\s*=\s*["']([^"']+)["']/u.exec(source.source)?.[1];
+        if (version)
+            return version;
+    }
+    return undefined;
+};
+const createJavaCheck = (java, toolchain) => {
+    if (!java.major) {
+        return {
+            detail: 'No readable Java runtime was found through JAVA_HOME or PATH.',
+            id: 'jdk',
+            remediation: `Install JDK ${toolchain.jdk} and set JAVA_HOME for Gradle.`,
+            status: 'failure'
+        };
+    }
+    if (java.major < toolchain.jdk) {
+        return {
+            detail: `JDK ${java.major} is active; Lumen documents JDK ${toolchain.jdk}.`,
+            id: 'jdk',
+            remediation: `Run Gradle with JDK ${toolchain.jdk} or newer.`,
+            status: 'failure'
+        };
+    }
+    return {
+        detail: `JDK ${java.major} is available${java.home ? ` at ${java.home}` : ''}.`,
+        id: 'jdk',
+        status: 'pass'
+    };
+};
+const inspectSdkChecks = async (sdkRoot, toolchain) => {
+    if (!sdkRoot) {
+        return [{
+                detail: 'No Android SDK directory was found through local.properties, ANDROID_SDK_ROOT, ANDROID_HOME, or platform defaults.',
+                id: 'android-sdk',
+                remediation: 'Install the Android SDK and configure sdk.dir or ANDROID_SDK_ROOT.',
+                status: 'failure'
+            }];
+    }
+    const installedPlatforms = await readdir(join(sdkRoot, 'platforms')).catch(() => []);
+    const hasPlatform = (api) => installedPlatforms.some(name => (name === `android-${api}` || name.startsWith(`android-${api}.`)));
+    const requiredPackages = [
+        {
+            available: hasPlatform(toolchain.compileSdk),
+            id: 'compile-sdk',
+            path: join(sdkRoot, 'platforms', `android-${toolchain.compileSdk}`),
+            status: 'failure'
+        },
+        {
+            available: hasPlatform(toolchain.instrumentationApi),
+            id: 'instrumentation-sdk',
+            path: join(sdkRoot, 'platforms', `android-${toolchain.instrumentationApi}`),
+            status: 'warning'
+        },
+        {
+            available: await pathExists(join(sdkRoot, 'platform-tools')),
+            id: 'platform-tools',
+            path: join(sdkRoot, 'platform-tools'),
+            status: 'warning'
+        },
+        {
+            available: await pathExists(join(sdkRoot, 'build-tools')),
+            id: 'build-tools',
+            path: join(sdkRoot, 'build-tools'),
+            status: 'warning'
+        }
+    ];
+    const packageChecks = requiredPackages.map(required => required.available ?
+        { detail: `${required.id} is installed.`, id: required.id, status: 'pass' } :
+        {
+            detail: `${required.id} is missing from the Android SDK.`,
+            id: required.id,
+            remediation: `Install the repository-compatible Android package at ${required.path}.`,
+            status: required.status
+        });
+    return [
+        { detail: `Android SDK is available at ${sdkRoot}.`, id: 'android-sdk', status: 'pass' },
+        ...packageChecks
+    ];
+};
+const inspectNdkCheck = async (sdkRoot, sources) => {
+    const ndkVersion = findDeclaredNdkVersion(sources);
+    const needsNdk = Boolean(ndkVersion) || sources.some(source => (/\b(?:externalNativeBuild|cmake)\b/u.test(source.source)));
+    if (!needsNdk) {
+        return { detail: 'No NDK-backed build configuration was detected.', id: 'ndk', status: 'skipped' };
+    }
+    if (!sdkRoot) {
+        return { detail: 'The NDK cannot be checked until the Android SDK is configured.', id: 'ndk', status: 'failure' };
+    }
+    const ndkPath = ndkVersion ? join(sdkRoot, 'ndk', ndkVersion) : join(sdkRoot, 'ndk');
+    if (await pathExists(ndkPath)) {
+        return {
+            detail: `The required Android NDK${ndkVersion ? ` ${ndkVersion}` : ''} is installed.`,
+            id: 'ndk',
+            status: 'pass'
+        };
+    }
+    return {
+        detail: `The project requires an Android NDK${ndkVersion ? ` (${ndkVersion})` : ''}, but it is not installed.`,
+        id: 'ndk',
+        remediation: `Install the required side-by-side NDK at ${ndkPath}.`,
+        status: 'failure'
+    };
+};
+const inspectAndroidPreflight = async (root, sources, toolchain, environment = process.env) => {
+    const sdkRoot = await resolveAndroidSdkRoot(root, environment);
+    const java = await readJavaMajor(environment);
+    const checks = [
+        createJavaCheck(java, toolchain),
+        ...await inspectSdkChecks(sdkRoot, toolchain),
+        await inspectNdkCheck(sdkRoot, sources)
+    ];
+    return {
+        checks,
+        healthy: !checks.some(check => check.status === 'failure'),
+        ...(sdkRoot ? { sdkRoot } : {}),
+        toolchain
+    };
+};
 const parseSwiftResolution = (entry) => {
     if (!entry.file.endsWith('Package.resolved'))
         return [];
@@ -154,16 +387,35 @@ const collectResolutionFindings = (manifest, resolved, usesSwift, usesCompose) =
     }
     return findings;
 };
-export const inspectNativeAdoption = async (repository, manifestPath = fileURLToPath(new URL('../release-manifest.json', import.meta.url))) => {
+const detectedPlatforms = (usesSwift, usesCompose) => {
+    const platforms = [];
+    if (usesSwift)
+        platforms.push('swift');
+    if (usesCompose)
+        platforms.push('compose');
+    return platforms;
+};
+const nativeAuditIsHealthy = (findings, androidPreflight) => {
+    if (findings.some(finding => finding.severity === 'failure'))
+        return false;
+    return androidPreflight?.healthy ?? true;
+};
+export const inspectNativeAdoption = async (repository, manifestPath = fileURLToPath(new URL('../release-manifest.json', import.meta.url)), registryPath = fileURLToPath(new URL('../native-components.json', import.meta.url)), environment = process.env) => {
     const root = resolve(repository);
     if (!(await stat(root)).isDirectory())
         throw new Error(`Not a directory: ${root}`);
     const manifest = JSON.parse(await readFile(manifestPath, 'utf8'));
+    const registry = JSON.parse(await readFile(registryPath, 'utf8'));
     const sources = await discoverNativeSources(root);
     const swiftSources = sources.filter(entry => entry.file.endsWith('.swift'));
-    const composeSources = sources.filter(entry => ['.gradle', '.kts', '.toml'].includes(extname(entry.file)));
+    const composeSources = sources.filter(entry => ['.gradle', '.kt', '.kts', '.toml'].includes(extname(entry.file)));
     const usesSwift = usesSwiftPackage(sources, swiftSources);
     const usesCompose = usesComposePackage(composeSources);
+    const adoptionInventory = inspectAdoptionInventory(root, sources, registry);
+    let androidPreflight = null;
+    if (usesCompose) {
+        androidPreflight = await inspectAndroidPreflight(root, sources, registry.adapters.compose.toolchain, environment);
+    }
     const resolved = unique([
         ...sources.flatMap(parseSwiftResolution),
         ...composeSources.flatMap(parseComposeResolution)
@@ -174,9 +426,12 @@ export const inspectNativeAdoption = async (repository, manifestPath = fileURLTo
         ...collectResolutionFindings(manifest, resolved, usesSwift, usesCompose)
     ];
     return {
+        adoptionInventory,
+        androidPreflight,
         findings: unique(findings, item => `${item.file}:${item.rule}:${item.message}`),
         generatedAt: new Date().toISOString(),
-        platforms: [usesSwift && 'swift', usesCompose && 'compose'].filter(Boolean),
+        healthy: nativeAuditIsHealthy(findings, androidPreflight),
+        platforms: detectedPlatforms(usesSwift, usesCompose),
         releaseVersion: manifest.release.version,
         repository: root,
         resolved
@@ -193,6 +448,19 @@ export const formatNativeAdoptionAudit = (report) => {
             item.version ? `version=${item.version}` : undefined,
             item.revision ? `revision=${item.revision}` : undefined
         ].filter(Boolean).join(' ')),
-        ...report.findings.map(item => (`[${item.severity}] ${item.file} ${item.rule}: ${item.message} ${item.remediation}`))
+        ...report.findings.map(item => (`[${item.severity}] ${item.file} ${item.rule}: ${item.message} ${item.remediation}`)),
+        ...(report.adoptionInventory.suggestions.length === 0 ?
+            ['[inventory] No likely direct native primitives with public Lumen equivalents were found.'] :
+            [
+                `[inventory] ${report.adoptionInventory.suggestions.length} non-authoritative adoption suggestion${report.adoptionInventory.suggestions.length === 1 ? '' : 's'} across ${report.adoptionInventory.families.length} families.`,
+                ...report.adoptionInventory.families.map(family => `  ${family.family}: ${family.count}`),
+                ...report.adoptionInventory.suggestions.map(suggestion => (`[suggestion] ${suggestion.file}:${suggestion.line} ${suggestion.nativePrimitive} may map to ${suggestion.lumenComponent}; verify product ownership and behavior before adopting.`))
+            ]),
+        ...(report.androidPreflight ?
+            [
+                `[android-preflight] ${report.androidPreflight.healthy ? 'ready' : 'blocked'} for the documented JDK ${report.androidPreflight.toolchain.jdk}, compile SDK ${report.androidPreflight.toolchain.compileSdk}, Gradle ${report.androidPreflight.toolchain.gradle}, AGP ${report.androidPreflight.toolchain.androidGradlePlugin}, and Kotlin ${report.androidPreflight.toolchain.kotlin} toolchain.`,
+                ...report.androidPreflight.checks.map(check => (`[${check.status}] ${check.id}: ${check.detail}${check.remediation ? ` ${check.remediation}` : ''}`))
+            ] :
+            [])
     ].join('\n');
 };

package/dist/registry-data.d.ts

@@ -11,6 +11,11 @@ export declare const lumenRegistry: {
         readonly name: "advanced-fields";
         readonly type: "recipe";
         readonly components: readonly ["Autocomplete", "SearchField", "NumberField", "TimeField", "DateRangePicker", "ColorPicker", "TagGroup"];
+    }, {
+        readonly name: "error-handling";
+        readonly type: "recipe";
+        readonly components: readonly ["Alert", "ErrorState", "ErrorSummary", "FieldError", "Toast"];
+        readonly files: readonly ["docs/error-handling.md"];
     }, {
         readonly name: "scheduler";
         readonly type: "recipe";
@@ -34,7 +39,7 @@ export declare const lumenRegistry: {
     }, {
         readonly name: "data-visualization";
         readonly type: "recipe";
-        readonly components: readonly ["Chart", "Sparkline", "BarChart", "LineChart", "PieChart", "Stat", "Meter"];
+        readonly components: readonly ["Chart", "Sparkline", "BarChart", "LineChart", "PieChart", "ScatterChart", "Heatmap", "RangeChart", "ComboChart", "Stat", "Meter"];
     }, {
         readonly name: "analytics-dashboard";
         readonly type: "recipe";
@@ -402,6 +407,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: "ErrorState";
+        readonly type: "component";
+        readonly description: "Explains why primary content is unavailable and provides an application-owned recovery path.";
+        readonly category: "Feedback";
+        readonly files: readonly ["packages/core/src/error-state.ts", "packages/astro/components/ErrorState.astro", "packages/astro/components/Illustration.astro", "packages/astro/styles/lumen.css", "docs/error-handling.md"];
+        readonly dependencies: readonly ["Illustration", "styles"];
     }, {
         readonly name: "ErrorSummary";
         readonly type: "component";
@@ -629,10 +641,10 @@ export declare const lumenRegistry: {
     }, {
         readonly name: "PhoneInput";
         readonly type: "component";
-        readonly description: "Pairs a country dial-code select with a telephone number input.";
+        readonly description: "Combines localized country metadata, calling codes, formatting, validation, and E.164 output.";
         readonly category: "Forms";
         readonly files: readonly ["packages/astro/components/PhoneInput.astro", "packages/astro/styles/lumen.css"];
-        readonly dependencies: readonly ["Input", "NativeSelect", "styles"];
+        readonly dependencies: readonly ["Input", "NativeSelect", "styles", "runtime"];
     }, {
         readonly name: "PieChart";
         readonly type: "component";
@@ -766,13 +778,6 @@ export declare const lumenRegistry: {
         readonly category: "Forms";
         readonly files: readonly ["packages/astro/components/Slider.astro", "packages/astro/styles/lumen.css"];
         readonly dependencies: readonly ["styles"];
-    }, {
-        readonly name: "Sonner";
-        readonly type: "component";
-        readonly description: "Provides the toast viewport for notifications.";
-        readonly category: "Feedback";
-        readonly files: readonly ["packages/astro/components/Sonner.astro", "packages/astro/styles/lumen.css", "packages/astro/runtime/UIPrimitives.astro"];
-        readonly dependencies: readonly ["styles", "runtime"];
     }, {
         readonly name: "Sparkline";
         readonly type: "component";
@@ -850,6 +855,13 @@ export declare const lumenRegistry: {
         readonly category: "Feedback";
         readonly files: readonly ["packages/astro/components/Toast.astro", "packages/astro/styles/lumen.css", "packages/astro/runtime/UIPrimitives.astro"];
         readonly dependencies: readonly ["styles", "runtime"];
+    }, {
+        readonly name: "ToastViewport";
+        readonly type: "component";
+        readonly description: "Provides the configurable viewport for transient toast notifications.";
+        readonly category: "Feedback";
+        readonly files: readonly ["packages/astro/components/ToastViewport.astro", "packages/astro/styles/lumen.css", "packages/astro/runtime/UIPrimitives.astro"];
+        readonly dependencies: readonly ["styles", "runtime"];
     }, {
         readonly name: "Toggle";
         readonly type: "component";
@@ -1137,6 +1149,34 @@ export declare const lumenRegistry: {
         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: "ScatterChart";
+        readonly type: "component";
+        readonly category: "Data display";
+        readonly description: "Shows numeric scatter and bubble relationships with accessible fallback data.";
+        readonly files: readonly ["packages/astro/components/ScatterChart.astro", "packages/astro/components/Chart.astro", "packages/astro/styles/lumen.css", "packages/react/src/components.tsx"];
+        readonly dependencies: readonly ["Chart", "styles"];
+    }, {
+        readonly name: "Heatmap";
+        readonly type: "component";
+        readonly category: "Data display";
+        readonly description: "Encodes a labeled matrix with the canonical sequential visualization scale.";
+        readonly files: readonly ["packages/astro/components/Heatmap.astro", "packages/astro/components/Chart.astro", "packages/astro/styles/lumen.css", "packages/react/src/components.tsx"];
+        readonly dependencies: readonly ["Chart", "styles"];
+    }, {
+        readonly name: "RangeChart";
+        readonly type: "component";
+        readonly category: "Data display";
+        readonly description: "Shows ordered low-to-high intervals as a tokenized range band.";
+        readonly files: readonly ["packages/astro/components/RangeChart.astro", "packages/astro/components/Chart.astro", "packages/astro/styles/lumen.css", "packages/react/src/components.tsx"];
+        readonly dependencies: readonly ["Chart", "styles"];
+    }, {
+        readonly name: "ComboChart";
+        readonly type: "component";
+        readonly category: "Data display";
+        readonly description: "Mixes bars, lines, and areas on one meaningful shared value domain.";
+        readonly files: readonly ["packages/astro/components/ComboChart.astro", "packages/astro/components/Chart.astro", "packages/astro/styles/lumen.css", "packages/react/src/components.tsx"];
+        readonly dependencies: readonly ["Chart", "styles"];
     }, {
         readonly name: "VisuallyHidden";
         readonly type: "component";

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+yEQ,CAAA"}
+{"version":3,"file":"registry-data.d.ts","sourceRoot":"","sources":["../src/registry-data.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAm5EQ,CAAA"}

package/dist/registry-data.js

@@ -34,6 +34,20 @@ export const lumenRegistry = {
                 'TagGroup'
             ]
         },
+        {
+            name: 'error-handling',
+            type: 'recipe',
+            components: [
+                'Alert',
+                'ErrorState',
+                'ErrorSummary',
+                'FieldError',
+                'Toast'
+            ],
+            files: [
+                'docs/error-handling.md'
+            ]
+        },
         {
             name: 'scheduler',
             type: 'recipe',
@@ -96,6 +110,10 @@ export const lumenRegistry = {
                 'BarChart',
                 'LineChart',
                 'PieChart',
+                'ScatterChart',
+                'Heatmap',
+                'RangeChart',
+                'ComboChart',
                 'Stat',
                 'Meter'
             ]
@@ -901,6 +919,23 @@ export const lumenRegistry = {
                 'styles'
             ]
         },
+        {
+            name: 'ErrorState',
+            type: 'component',
+            description: 'Explains why primary content is unavailable and provides an application-owned recovery path.',
+            category: 'Feedback',
+            files: [
+                'packages/core/src/error-state.ts',
+                'packages/astro/components/ErrorState.astro',
+                'packages/astro/components/Illustration.astro',
+                'packages/astro/styles/lumen.css',
+                'docs/error-handling.md'
+            ],
+            dependencies: [
+                'Illustration',
+                'styles'
+            ]
+        },
         {
             name: 'ErrorSummary',
             type: 'component',
@@ -1361,7 +1396,7 @@ export const lumenRegistry = {
         {
             name: 'PhoneInput',
             type: 'component',
-            description: 'Pairs a country dial-code select with a telephone number input.',
+            description: 'Combines localized country metadata, calling codes, formatting, validation, and E.164 output.',
             category: 'Forms',
             files: [
                 'packages/astro/components/PhoneInput.astro',
@@ -1370,7 +1405,8 @@ export const lumenRegistry = {
             dependencies: [
                 'Input',
                 'NativeSelect',
-                'styles'
+                'styles',
+                'runtime'
             ]
         },
         {
@@ -1646,21 +1682,6 @@ export const lumenRegistry = {
                 'styles'
             ]
         },
-        {
-            name: 'Sonner',
-            type: 'component',
-            description: 'Provides the toast viewport for notifications.',
-            category: 'Feedback',
-            files: [
-                'packages/astro/components/Sonner.astro',
-                'packages/astro/styles/lumen.css',
-                'packages/astro/runtime/UIPrimitives.astro'
-            ],
-            dependencies: [
-                'styles',
-                'runtime'
-            ]
-        },
         {
             name: 'Sparkline',
             type: 'component',
@@ -1812,6 +1833,21 @@ export const lumenRegistry = {
                 'runtime'
             ]
         },
+        {
+            name: 'ToastViewport',
+            type: 'component',
+            description: 'Provides the configurable viewport for transient toast notifications.',
+            category: 'Feedback',
+            files: [
+                'packages/astro/components/ToastViewport.astro',
+                'packages/astro/styles/lumen.css',
+                'packages/astro/runtime/UIPrimitives.astro'
+            ],
+            dependencies: [
+                'styles',
+                'runtime'
+            ]
+        },
         {
             name: 'Toggle',
             type: 'component',
@@ -2335,6 +2371,70 @@ export const lumenRegistry = {
                 'styles'
             ]
         },
+        {
+            name: 'ScatterChart',
+            type: 'component',
+            category: 'Data display',
+            description: 'Shows numeric scatter and bubble relationships with accessible fallback data.',
+            files: [
+                'packages/astro/components/ScatterChart.astro',
+                'packages/astro/components/Chart.astro',
+                'packages/astro/styles/lumen.css',
+                'packages/react/src/components.tsx'
+            ],
+            dependencies: [
+                'Chart',
+                'styles'
+            ]
+        },
+        {
+            name: 'Heatmap',
+            type: 'component',
+            category: 'Data display',
+            description: 'Encodes a labeled matrix with the canonical sequential visualization scale.',
+            files: [
+                'packages/astro/components/Heatmap.astro',
+                'packages/astro/components/Chart.astro',
+                'packages/astro/styles/lumen.css',
+                'packages/react/src/components.tsx'
+            ],
+            dependencies: [
+                'Chart',
+                'styles'
+            ]
+        },
+        {
+            name: 'RangeChart',
+            type: 'component',
+            category: 'Data display',
+            description: 'Shows ordered low-to-high intervals as a tokenized range band.',
+            files: [
+                'packages/astro/components/RangeChart.astro',
+                'packages/astro/components/Chart.astro',
+                'packages/astro/styles/lumen.css',
+                'packages/react/src/components.tsx'
+            ],
+            dependencies: [
+                'Chart',
+                'styles'
+            ]
+        },
+        {
+            name: 'ComboChart',
+            type: 'component',
+            category: 'Data display',
+            description: 'Mixes bars, lines, and areas on one meaningful shared value domain.',
+            files: [
+                'packages/astro/components/ComboChart.astro',
+                'packages/astro/components/Chart.astro',
+                'packages/astro/styles/lumen.css',
+                'packages/react/src/components.tsx'
+            ],
+            dependencies: [
+                'Chart',
+                'styles'
+            ]
+        },
         {
             name: 'VisuallyHidden',
             type: 'component',

package/dist/registry-path.d.ts

@@ -0,0 +1,3 @@
+export declare const isSafeRegistryFilePath: (path: string) => boolean;
+export declare const assertSafeRegistryFilePath: (path: string) => void;
+//# sourceMappingURL=registry-path.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry-path.d.ts","sourceRoot":"","sources":["../src/registry-path.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB,GAAI,MAAM,MAAM,KAAG,OAQrD,CAAA;AAED,eAAO,MAAM,0BAA0B,GAAI,MAAM,MAAM,KAAG,IAIzD,CAAA"}

package/dist/registry-path.js

@@ -0,0 +1,15 @@
+import { isAbsolute } from 'node:path';
+const windowsAbsolutePath = /^[A-Za-z]:[\\/]/;
+export const isSafeRegistryFilePath = (path) => {
+    if (!path || path.includes('\0') || path.includes('\\'))
+        return false;
+    if (isAbsolute(path) || windowsAbsolutePath.test(path))
+        return false;
+    const segments = path.split('/');
+    return segments.every(segment => segment !== '' && segment !== '.' && segment !== '..');
+};
+export const assertSafeRegistryFilePath = (path) => {
+    if (!isSafeRegistryFilePath(path)) {
+        throw new Error(`Unsafe Lumen registry file path: ${JSON.stringify(path)}`);
+    }
+};