@santi020k/lumen 1.3.0 → 1.5.0

package/README.md

@@ -43,6 +43,7 @@ lumen add saas-admin --target react
 lumen add commerce-dashboard --target elements
 lumen audit-tokens ./src
 lumen doctor --json
+lumen doctor-native --json
 lumen init --framework astro --tailwind
 ```
 
@@ -57,8 +58,22 @@ Complete product recipes are also bundled for `analytics-dashboard`, `saas-admin
 Run `lumen doctor` to check adapter/style agreement, Tailwind layer order, Astro runtime mounts,
 and fragile internal selector dependencies. In a workspace, diagnostics are scoped to the nearest
 package boundary, generated build trees are ignored, and application-controlled Astro `Toggle`
-instances do not require the shared runtime. Use `--json` for CI and rollout automation. `lumen
-init --framework <astro|react|elements> [--tailwind]` prints the canonical non-destructive setup.
+instances do not require the shared runtime. It also suggests matching Lumen primitives for likely
+hand-built dropdown, theme, dialog-focus, and keyboard-menu behavior. These suggestions stay
+advisory because product-specific composition can be intentional. Use `--json` for CI and rollout
+automation. `lumen init --framework <astro|react|elements> [--tailwind]` prints the canonical
+non-destructive setup.
+
+Run `lumen doctor-native` in an Apple or Android consumer to report the resolved Swift package
+tag/revision or Compose artifact version, compare it with Lumen's bundled cross-platform release
+manifest, and audit public theme placement. Findings are suggestions or warnings: the command does
+not classify application-owned navigation or controls as migration failures. Pass `--manifest`
+to audit against a prerelease manifest and `--json` for CI.
+
+The same machine-readable metadata is published as
+`@santi020k/lumen/release-manifest.json`. It records every npm package version and peer range, the
+Swift tag, Maven coordinates, required stylesheet/runtime setup, deprecations, removals, and
+codemod availability.
 
 Run `lumen audit-tokens [path]` before incremental adoption when an existing stylesheet may already
 declare names such as `--surface`, `--ink`, or `--line`. The audit reports complete CSS colors that

package/dist/cli.js

@@ -2,6 +2,7 @@ import { readdir, readFile, stat } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { consumerRolloutSucceeded, formatConsumerRollout, resolveConsumerRolloutTargets, runConsumerRollout } from './consumer-rollout.js';
 import { createLumenSetup, formatLumenDiagnostics, inspectLumenIntegration } from './integration-diagnostics.js';
+import { formatNativeAdoptionAudit, inspectNativeAdoption } from './native-audit.js';
 import { addLumenRegistryItem, getLumenRegistryEntries, getLumenRegistryItem, loadLumenRegistry, lumenRegistry } from './registry.js';
 import { auditLumenTokenCss } from './token-audit.js';
 const args = process.argv.slice(2);
@@ -24,6 +25,8 @@ const allowDirty = args.includes('--allow-dirty');
 const noVerify = args.includes('--no-verify');
 const reportIndex = args.indexOf('--report');
 const reportPath = reportIndex >= 0 ? args[reportIndex + 1] : undefined;
+const manifestIndex = args.indexOf('--manifest');
+const manifestPath = manifestIndex >= 0 ? args[manifestIndex + 1] : undefined;
 const frameworkIndex = args.indexOf('--framework');
 const frameworkValue = frameworkIndex >= 0 ? args[frameworkIndex + 1] : undefined;
 const json = args.includes('--json');
@@ -160,6 +163,7 @@ const help = [
     '  lumen install          Print install commands',
     '  lumen audit-tokens     Report incompatible semantic color custom properties',
     '  lumen doctor           Inspect styles, adapters, runtime mounts, and selector usage',
+    '  lumen doctor-native    Inspect native versions, package pins, and theme placement',
     '  lumen init             Print canonical framework setup without changing files',
     '  lumen rollout [version] [repositories...]  Inventory or upgrade pnpm consumers',
     '',
@@ -175,6 +179,7 @@ const help = [
     '  --framework <name>     Select astro, react, or elements for lumen init',
     '  --tailwind             Include the verified Tailwind cascade setup in lumen init',
     '  --json                 Print lumen doctor output as JSON',
+    '  --manifest <path>      Use a specific cross-platform release manifest',
     '  --apply                Apply a rollout (requires a target version)',
     '  --allow-dirty          Allow rollout after recording an uncommitted baseline',
     '  --exclude <path>       Exclude a repository (repeatable)',
@@ -205,6 +210,11 @@ const run = async () => {
                 process.exitCode = 1;
             break;
         }
+        case 'doctor-native': {
+            const report = await inspectNativeAdoption(cwd ?? process.cwd(), manifestPath);
+            output = json ? JSON.stringify(report, undefined, 2) : formatNativeAdoptionAudit(report);
+            break;
+        }
         case 'init': {
             output = createLumenSetup(getFramework(frameworkValue), tailwind);
             break;

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { type ConsumerInventory, type ConsumerReference, type ConsumerRolloutOptions, type ConsumerRolloutReport, formatConsumerRollout, inspectLumenConsumer, type LumenFramework, runConsumerRollout, updateLumenManifestSource, updateLumenWorkspaceSource } from './consumer-rollout.js';
+export { formatNativeAdoptionAudit, inspectNativeAdoption, type NativeAuditFinding, type NativeAuditPlatform, type NativeAuditReport, type NativeAuditSeverity, type NativeResolvedVersion } from './native-audit.js';
 export { addLumenRegistryItem, getLumenRegistryEntries, getLumenRegistryItem, loadLumenRegistry, type LumenAddOptions, type LumenAddResult, type LumenAddTarget, type LumenMergeConflict, type LumenRegistry, lumenRegistry, type LumenRegistryComponent, type LumenRegistryEntry, type LumenRegistryFile, type LumenRegistryItem, type LumenRegistryLoadOptions } from './registry.js';
 export { alignLumenChartSeries, applyDataViewState, canPlaceScheduleEvent, coerceThemeBuilderExportFormat, coerceThemeBuilderMode, coerceThemeBuilderScheme, composeClassName, createDataViewRequestUrl, createDataViewSearchParams, createDataViewServerRequest, createDataViewState, createDataViewStorageKey, createLumenBarGeometry, createLumenFormFailure, createLumenFormSuccess, createLumenLineGeometry, createLumenPieGeometry, createScheduleSlots, createScheduleStorageKey, createThemeBuilderTokens, createThemePalette, expandRecurringScheduleEvent, exportThemeBuilderCss, exportThemeBuilderValue, exportThemeCss, filterDataRecords, getContrastRatio, getLumenChartCategories, getLumenChartDomain, getLumenChartTicks, getLumenChartValueRatio, getLumenFieldErrors, getScheduleConflicts, getVirtualRange, hasLumenPieData, loadDataViewState, loadScheduleEvents, type LumenBarChartLayout, type LumenBarGeometry, type LumenBarGeometryCategory, type LumenBarGeometryMark, type LumenBarGeometryOptions, lumenChart, type LumenChartDatum, type LumenChartDomain, type LumenChartGeometryPoint, type LumenChartOrientation, type LumenChartSeries, type LumenChartTone, lumenChartTones, type LumenCodeToken, lumenCodeTokenClassNames, type LumenCodeTokenKind, lumenColors, type LumenColorScheme, type LumenColorTokenName, lumenColorTokenNames, lumenColorTokens, type LumenComponentName, lumenComponentNames, type LumenContrastScore, lumenCssColorTokens, lumenDarkColors, lumenDarkTheme, type LumenDataRecord, type LumenDataViewServerRequest, type LumenDataViewState, lumenDurations, lumenEasings, lumenElevation, type LumenFieldError, lumenFontFamilies, lumenFontSizes, lumenFontWeights, type LumenFormErrorInput, type LumenFormErrors, type LumenFormFailure, type LumenFormResult, type LumenFormStatus, lumenFormStatuses, type LumenFormSuccess, lumenGlass, type LumenGlassColorTokenName, lumenGlassColorTokenNames, type LumenGlassEffectTokenName, lumenGlassEffectTokenNames, type LumenGlassTokenName, lumenGlassTokenNames, type LumenKeyValueReader, type LumenKeyValueStorage, type LumenKeyValueWriter, lumenLightTheme, type LumenLineGeometry, type LumenLineGeometryOptions, lumenPackages, type LumenPackageTarget, type LumenPieChartVariant, type LumenPieGeometry, type LumenPieGeometryOptions, type LumenPieGeometrySlice, lumenRadii, type LumenScheduleConflict, type LumenScheduleEvent, type LumenScheduleKeyValueReader, type LumenScheduleKeyValueStorage, type LumenScheduleKeyValueWriter, type LumenScheduleResizeEdge, type LumenScheduleResizeOptions, type LumenScheduleResource, type LumenScheduleSlot, type LumenSemanticColor, type LumenSemanticColorTokenName, lumenSemanticColorTokenNames, type LumenSortDirection, lumenSpacing, lumenThemeAttribute, type LumenThemeBuilderExportFormat, type LumenThemeBuilderMode, type LumenThemeBuilderOptions, type LumenThemeBuilderResult, type LumenThemeBuilderScheme, type LumenThemeContrastSuggestion, type LumenThemeTokens, lumenTokenNames, mergeThemeTokens, moveScheduleEvent, normalizeLumenCode, normalizeLumenFormErrors, normalizeThemeBuilderHex, normalizeThemeBuilderHue, paginateDataRecords, parseDataViewState, parseScheduleEvents, parseThemeCss, pinDataViewColumn, renderLumenCodeHtml, resizeScheduleEvent, resizeScheduleEvents, resolveLumenChartTone, saveDataViewState, saveScheduleEvents, scaleLumenChartValue, scheduleEventsOverlap, scoreThemeContrast, serializeDataViewState, serializeScheduleEvents, sortDataRecords, suggestReadableInk, themeBuilderHexToHsl, toggleDataViewSelection, tokenizeLumenCode, tuneThemeContrast, unpinDataViewColumn } from '@santi020k/lumen-core';
 export declare const lumen: {

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -1,4 +1,5 @@
 export { formatConsumerRollout, inspectLumenConsumer, runConsumerRollout, updateLumenManifestSource, updateLumenWorkspaceSource } from './consumer-rollout.js';
+export { formatNativeAdoptionAudit, inspectNativeAdoption } from './native-audit.js';
 export { addLumenRegistryItem, getLumenRegistryEntries, getLumenRegistryItem, loadLumenRegistry, lumenRegistry } from './registry.js';
 export { alignLumenChartSeries, applyDataViewState, canPlaceScheduleEvent, coerceThemeBuilderExportFormat, coerceThemeBuilderMode, coerceThemeBuilderScheme, composeClassName, createDataViewRequestUrl, createDataViewSearchParams, createDataViewServerRequest, createDataViewState, createDataViewStorageKey, createLumenBarGeometry, createLumenFormFailure, createLumenFormSuccess, createLumenLineGeometry, createLumenPieGeometry, createScheduleSlots, createScheduleStorageKey, createThemeBuilderTokens, createThemePalette, expandRecurringScheduleEvent, exportThemeBuilderCss, exportThemeBuilderValue, exportThemeCss, filterDataRecords, getContrastRatio, getLumenChartCategories, getLumenChartDomain, getLumenChartTicks, getLumenChartValueRatio, getLumenFieldErrors, getScheduleConflicts, getVirtualRange, hasLumenPieData, loadDataViewState, loadScheduleEvents, lumenChart, lumenChartTones, lumenCodeTokenClassNames, lumenColors, lumenColorTokenNames, lumenColorTokens, lumenComponentNames, lumenCssColorTokens, lumenDarkColors, lumenDarkTheme, lumenDurations, lumenEasings, lumenElevation, lumenFontFamilies, lumenFontSizes, lumenFontWeights, lumenFormStatuses, lumenGlass, lumenGlassColorTokenNames, lumenGlassEffectTokenNames, lumenGlassTokenNames, lumenLightTheme, lumenPackages, lumenRadii, lumenSemanticColorTokenNames, lumenSpacing, lumenThemeAttribute, lumenTokenNames, mergeThemeTokens, moveScheduleEvent, normalizeLumenCode, normalizeLumenFormErrors, normalizeThemeBuilderHex, normalizeThemeBuilderHue, paginateDataRecords, parseDataViewState, parseScheduleEvents, parseThemeCss, pinDataViewColumn, renderLumenCodeHtml, resizeScheduleEvent, resizeScheduleEvents, resolveLumenChartTone, saveDataViewState, saveScheduleEvents, scaleLumenChartValue, scheduleEventsOverlap, scoreThemeContrast, serializeDataViewState, serializeScheduleEvents, sortDataRecords, suggestReadableInk, themeBuilderHexToHsl, toggleDataViewSelection, tokenizeLumenCode, tuneThemeContrast, unpinDataViewColumn } from '@santi020k/lumen-core';
 export const lumen = {

package/dist/integration-diagnostics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integration-diagnostics.d.ts","sourceRoot":"","sources":["../src/integration-diagnostics.ts"],"names":[],"mappings":"AAWA,MAAM,MAAM,uBAAuB,GAAG,UAAU,GAAG,OAAO,CAAA;AAE1D,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,uBAAuB,CAAA;CAClC;AAED,MAAM,WAAW,qBAAqB;IACpC,kBAAkB,EAAE,MAAM,CAAA;IAC1B,QAAQ,EAAE,sBAAsB,EAAE,CAAA;IAClC,UAAU,EAAE,CAAC,OAAO,GAAG,UAAU,GAAG,OAAO,CAAC,EAAE,CAAA;IAC9C,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,iBAAiB,EAAE,MAAM,EAAE,CAAA;CAC5B;AAoZD,eAAO,MAAM,uBAAuB,GAAU,YAAY,MAAM,KAAG,OAAO,CAAC,qBAAqB,CA6C/F,CAAA;AAED,eAAO,MAAM,sBAAsB,GAAI,QAAQ,qBAAqB,KAAG,MAWtE,CAAA;AAED,eAAO,MAAM,gBAAgB,GAAI,WAAW,OAAO,GAAG,UAAU,GAAG,OAAO,EAAE,kBAAgB,KAAG,MAsC9F,CAAA"}
+{"version":3,"file":"integration-diagnostics.d.ts","sourceRoot":"","sources":["../src/integration-diagnostics.ts"],"names":[],"mappings":"AAWA,MAAM,MAAM,uBAAuB,GAAG,UAAU,GAAG,OAAO,CAAA;AAE1D,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,uBAAuB,CAAA;CAClC;AAED,MAAM,WAAW,qBAAqB;IACpC,kBAAkB,EAAE,MAAM,CAAA;IAC1B,QAAQ,EAAE,sBAAsB,EAAE,CAAA;IAClC,UAAU,EAAE,CAAC,OAAO,GAAG,UAAU,GAAG,OAAO,CAAC,EAAE,CAAA;IAC9C,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,iBAAiB,EAAE,MAAM,EAAE,CAAA;CAC5B;AA+dD,eAAO,MAAM,uBAAuB,GAAU,YAAY,MAAM,KAAG,OAAO,CAAC,qBAAqB,CA8C/F,CAAA;AAED,eAAO,MAAM,sBAAsB,GAAI,QAAQ,qBAAqB,KAAG,MAWtE,CAAA;AAED,eAAO,MAAM,gBAAgB,GAAI,WAAW,OAAO,GAAG,UAAU,GAAG,OAAO,EAAE,kBAAgB,KAAG,MAsC9F,CAAA"}

package/dist/integration-diagnostics.js

@@ -110,6 +110,62 @@ const collectCompatibilityFindings = (root, sources) => sources.flatMap(item =>
     }
     return findings;
 });
+const hasImportedPrimitive = (sources, names) => [
+    '@santi020k/lumen-astro',
+    '@santi020k/lumen-react'
+].some(packageName => sources.some(item => (importedNames(item.source, packageName).some(name => names.includes(name)))));
+const duplicatedBehaviorRules = [
+    {
+        detects: (_source, sourceLower) => sourceLower.includes('<details') &&
+            (sourceLower.includes('dropdown') || sourceLower.includes('menu')),
+        imports: ['Collapsible', 'DropdownMenu'],
+        message: 'A details-based dropdown or menu may duplicate Lumen disclosure or menu behavior.',
+        remediation: 'Review DropdownMenu or Collapsible before maintaining a separate controller; keep the custom composition when its semantics differ.',
+        rule: 'hand-built-dropdown'
+    },
+    {
+        detects: (source, sourceLower) => source.includes('localStorage') &&
+            sourceLower.includes('theme') &&
+            (source.includes('classList') || sourceLower.includes('data-theme') || source.includes('dataset')),
+        imports: ['ThemeToggle'],
+        message: 'Custom theme persistence may duplicate ThemeToggle behavior.',
+        remediation: 'Review ThemeToggle before maintaining separate storage and document-theme synchronization.',
+        rule: 'hand-built-theme-persistence'
+    },
+    {
+        detects: (source, sourceLower) => [
+            'role="dialog"',
+            'role=\'dialog\'',
+            'aria-modal'
+        ].some(value => sourceLower.includes(value)) &&
+            source.includes('Tab') &&
+            source.includes('focus') &&
+            (source.includes('keydown') || source.includes('onKeyDown')),
+        imports: ['Dialog'],
+        message: 'Custom dialog keyboard and focus management may duplicate Lumen Dialog behavior.',
+        remediation: 'Review Dialog before maintaining a separate focus trap; keep product-specific dialog content application-owned.',
+        rule: 'hand-built-dialog-focus'
+    },
+    {
+        detects: (source, sourceLower) => [
+            'role="menu"',
+            'role=\'menu\''
+        ].some(value => sourceLower.includes(value)) &&
+            ['ArrowDown', 'ArrowLeft', 'ArrowRight', 'ArrowUp'].some(key => source.includes(key)),
+        imports: ['DropdownMenu', 'Menubar', 'NavigationMenu'],
+        message: 'A raw menu with arrow-key handling may duplicate Lumen menu behavior.',
+        remediation: 'Review DropdownMenu, Menubar, or NavigationMenu before maintaining a separate keyboard controller.',
+        rule: 'hand-built-menu-keyboard'
+    }
+];
+const collectDuplicatedBehaviorFindings = (root, sources) => sources.flatMap(item => {
+    const file = relative(root, item.file);
+    const source = item.source;
+    const sourceLower = source.toLowerCase();
+    return duplicatedBehaviorRules.flatMap(rule => (rule.detects(source, sourceLower) && !hasImportedPrimitive(sources, rule.imports) ?
+        [finding(file, rule.rule, rule.message, rule.remediation, 'advisory')] :
+        []));
+});
 const getCatalogFingerprint = (sources) => {
     const names = [...new Set(sources.flatMap(item => [
             ...importedNames(item.source, '@santi020k/lumen-astro'),
@@ -255,7 +311,7 @@ export const inspectLumenIntegration = async (repository) => {
         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));
+        findings.push(...collectDuplicatedBehaviorFindings(root, boundary.sources), ...runtime.findings, ...collectFrameworkStyleFindings(root, boundary, boundaryFrameworks), ...collectAdapterMismatchFindings(root, boundary, boundaryFrameworks));
     }
     const deduplicatedFindings = uniqueFindings(findings);
     return {

package/dist/native-audit.d.ts

@@ -0,0 +1,26 @@
+export type NativeAuditPlatform = 'compose' | 'swift';
+export type NativeAuditSeverity = 'suggestion' | 'warning';
+export interface NativeAuditFinding {
+    file: string;
+    message: string;
+    remediation: string;
+    rule: string;
+    severity: NativeAuditSeverity;
+}
+export interface NativeResolvedVersion {
+    platform: NativeAuditPlatform;
+    reference: string;
+    revision?: string;
+    version?: string;
+}
+export interface NativeAuditReport {
+    findings: NativeAuditFinding[];
+    generatedAt: string;
+    platforms: NativeAuditPlatform[];
+    releaseVersion: string;
+    repository: string;
+    resolved: NativeResolvedVersion[];
+}
+export declare const inspectNativeAdoption: (repository: string, manifestPath?: string) => Promise<NativeAuditReport>;
+export declare const formatNativeAdoptionAudit: (report: NativeAuditReport) => string;
+//# sourceMappingURL=native-audit.d.ts.map

package/dist/native-audit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-audit.d.ts","sourceRoot":"","sources":["../src/native-audit.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,OAAO,CAAA;AACrD,MAAM,MAAM,mBAAmB,GAAG,YAAY,GAAG,SAAS,CAAA;AAE1D,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,mBAAmB,CAAA;CAC9B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,mBAAmB,CAAA;IAC7B,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,kBAAkB,EAAE,CAAA;IAC9B,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,mBAAmB,EAAE,CAAA;IAChC,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,qBAAqB,EAAE,CAAA;CAClC;AAiOD,eAAO,MAAM,qBAAqB,GAChC,YAAY,MAAM,EAClB,qBAAkF,KACjF,OAAO,CAAC,iBAAiB,CA+B3B,CAAA;AAED,eAAO,MAAM,yBAAyB,GAAI,QAAQ,iBAAiB,KAAG,MAgBrE,CAAA"}

package/dist/native-audit.js

@@ -0,0 +1,198 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { extname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const ignoredDirectories = new Set([
+    '.build',
+    '.git',
+    '.gradle',
+    '.idea',
+    ['.', 'swift', 'pm'].join(''),
+    'build',
+    'DerivedData',
+    'node_modules'
+]);
+const nativeExtensions = new Set(['.gradle', '.json', '.kts', '.swift', '.toml']);
+const discoverNativeSources = async (root) => {
+    const files = [];
+    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 (nativeExtensions.has(extname(entry.name)) || entry.name === 'Package.resolved') {
+                files.push(path);
+            }
+        }
+    };
+    await visit(root);
+    return Promise.all(files.map(async (file) => ({ file, source: await readFile(file, 'utf8') })));
+};
+const parseSwiftResolution = (entry) => {
+    if (!entry.file.endsWith('Package.resolved'))
+        return [];
+    try {
+        const value = JSON.parse(entry.source);
+        const pins = value.pins ?? value.object?.pins ?? [];
+        return pins.flatMap(pinValue => {
+            const pin = pinValue;
+            const reference = pin.location ?? pin.repositoryURL ?? pin.identity ?? pin.package ?? '';
+            if (!reference.toLowerCase().includes('lumen'))
+                return [];
+            return [{
+                    platform: 'swift',
+                    reference,
+                    ...(pin.state?.revision ? { revision: pin.state.revision } : {}),
+                    ...(pin.state?.version ? { version: pin.state.version } : {})
+                }];
+        });
+    }
+    catch {
+        return [];
+    }
+};
+const composeCoordinatePattern = /com\.santi020k:lumen-compose(?:-wear)?[:"]([0-9A-Za-z][0-9A-Za-z._-]*)/g;
+const parseComposeCatalog = (entry) => {
+    if (!entry.file.endsWith('.toml'))
+        return [];
+    const versions = new Map();
+    const lines = entry.source.split(/\r?\n/u);
+    for (const line of lines) {
+        const match = /^\s*([A-Za-z0-9_.-]+)\s*=\s*"([^"]+)"\s*$/u.exec(line);
+        if (match?.[1] && match[2])
+            versions.set(match[1], match[2]);
+    }
+    return lines.flatMap(line => {
+        const module = /module\s*=\s*"(com\.santi020k:lumen-compose(?:-wear)?)"/u.exec(line)?.[1];
+        if (!module)
+            return [];
+        const directVersion = /version\s*=\s*"([^"]+)"/u.exec(line)?.[1];
+        const versionReference = /version\.ref\s*=\s*"([^"]+)"/u.exec(line)?.[1];
+        const version = directVersion ?? (versionReference ? versions.get(versionReference) : undefined);
+        return version ? [{ platform: 'compose', reference: module, version }] : [];
+    });
+};
+const parseComposeResolution = (entry) => {
+    const resolutions = parseComposeCatalog(entry);
+    for (const match of entry.source.matchAll(composeCoordinatePattern)) {
+        const version = match[1];
+        if (version)
+            resolutions.push({ platform: 'compose', reference: match[0], version });
+    }
+    return resolutions;
+};
+const addThemeFindings = (root, sources, platform, usesLumen) => {
+    if (!usesLumen)
+        return [];
+    const pattern = platform === 'swift' ? /\.lumenTheme\s*\(/g : /\bLumenTheme\s*\(/g;
+    const providers = sources.flatMap(entry => {
+        const count = [...entry.source.matchAll(pattern)].length;
+        return count ? [{ count, file: entry.file }] : [];
+    });
+    if (providers.length === 0) {
+        return [{
+                file: '.',
+                message: `No ${platform === 'swift' ? '.lumenTheme(...) modifier' : 'LumenTheme(...) provider'} was found.`,
+                remediation: platform === 'swift' ?
+                    'Place the product theme at each application scene and preview that renders Lumen components.' :
+                    'Place LumenTheme at the application root and pass the existing Material color scheme, typography, and shapes.',
+                rule: `${platform}-theme-missing`,
+                severity: 'warning'
+            }];
+    }
+    return providers.flatMap(provider => provider.count > 1 ?
+        [{
+                file: relative(root, provider.file),
+                message: `This file mounts ${provider.count} ${platform} theme providers.`,
+                remediation: 'Confirm the providers belong to independent scenes or previews; remove accidental nesting around the same surface.',
+                rule: `${platform}-theme-repeated`,
+                severity: 'suggestion'
+            }] :
+        []);
+};
+const unique = (values, key) => [
+    ...new Map(values.map(value => [key(value), value])).values()
+];
+const usesSwiftPackage = (sources, swiftSources) => (sources.some(entry => entry.file.endsWith('Package.swift') && entry.source.includes('LumenUI')) ||
+    swiftSources.some(entry => entry.source.includes('import LumenUI')));
+const usesComposePackage = (sources) => sources.some(entry => (entry.source.includes('com.santi020k.lumen') || entry.source.includes('com.santi020k:lumen-compose')));
+const collectResolutionFindings = (manifest, resolved, usesSwift, usesCompose) => {
+    const findings = [];
+    if (usesSwift && !resolved.some(item => item.platform === 'swift')) {
+        findings.push({
+            file: 'Package.resolved',
+            message: 'LumenUI is used but no resolved Swift package pin was found.',
+            remediation: 'Resolve package dependencies and commit Package.resolved with the intended release tag and revision.',
+            rule: 'swift-resolution-missing',
+            severity: 'warning'
+        });
+    }
+    if (usesCompose && !resolved.some(item => item.platform === 'compose')) {
+        findings.push({
+            file: '.',
+            message: 'Compose source uses Lumen but no Maven coordinate with an explicit version was found.',
+            remediation: `Declare com.santi020k:lumen-compose:${manifest.release.compose.version} directly or through a version catalog.`,
+            rule: 'compose-resolution-missing',
+            severity: 'warning'
+        });
+    }
+    for (const item of resolved) {
+        const expected = item.platform === 'compose' ?
+            manifest.release.compose.version :
+            manifest.release.swift.tag.replace(/^v/u, '');
+        if (item.version && item.version !== expected) {
+            findings.push({
+                file: '.',
+                message: `${item.reference} resolves ${item.version}; the release manifest expects ${expected}.`,
+                remediation: 'Align the native adapter with the cross-platform release manifest, then refresh the resolver lock file.',
+                rule: `${item.platform}-release-mismatch`,
+                severity: 'warning'
+            });
+        }
+    }
+    return findings;
+};
+export const inspectNativeAdoption = async (repository, manifestPath = fileURLToPath(new URL('../release-manifest.json', import.meta.url))) => {
+    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 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 usesSwift = usesSwiftPackage(sources, swiftSources);
+    const usesCompose = usesComposePackage(composeSources);
+    const resolved = unique([
+        ...sources.flatMap(parseSwiftResolution),
+        ...composeSources.flatMap(parseComposeResolution)
+    ], value => `${value.platform}:${value.reference}:${value.version ?? ''}:${value.revision ?? ''}`);
+    const findings = [
+        ...addThemeFindings(root, swiftSources, 'swift', usesSwift),
+        ...addThemeFindings(root, composeSources, 'compose', usesCompose),
+        ...collectResolutionFindings(manifest, resolved, usesSwift, usesCompose)
+    ];
+    return {
+        findings: unique(findings, item => `${item.file}:${item.rule}:${item.message}`),
+        generatedAt: new Date().toISOString(),
+        platforms: [usesSwift && 'swift', usesCompose && 'compose'].filter(Boolean),
+        releaseVersion: manifest.release.version,
+        repository: root,
+        resolved
+    };
+};
+export const formatNativeAdoptionAudit = (report) => {
+    const heading = report.findings.length === 0 ?
+        'Native Lumen adoption matches the release manifest.' :
+        `Native Lumen adoption has ${report.findings.length} finding${report.findings.length === 1 ? '' : 's'}.`;
+    return [
+        heading,
+        ...report.resolved.map(item => [
+            `[resolved] ${item.platform} ${item.reference}`,
+            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}`))
+    ].join('\n');
+};

package/dist/registry-data.d.ts

@@ -136,6 +136,13 @@ export declare const lumenRegistry: {
         readonly category: "Data display";
         readonly files: readonly ["packages/astro/components/Avatar.astro", "packages/astro/styles/lumen.css"];
         readonly dependencies: readonly ["styles"];
+    }, {
+        readonly name: "Backdrop";
+        readonly type: "component";
+        readonly description: "Adds a token-aware ambient pattern behind meaningful content.";
+        readonly category: "Brand";
+        readonly files: readonly ["packages/astro/components/Backdrop.astro", "packages/astro/styles/lumen.css", "packages/react/src/components.tsx"];
+        readonly dependencies: readonly ["styles"];
     }, {
         readonly name: "BackToTop";
         readonly type: "component";
@@ -444,6 +451,13 @@ export declare const lumenRegistry: {
         readonly category: "Data display";
         readonly files: readonly ["packages/astro/components/FormattedDate.astro", "packages/astro/styles/lumen.css"];
         readonly dependencies: readonly ["styles"];
+    }, {
+        readonly name: "Graphic";
+        readonly type: "component";
+        readonly description: "Frames custom artwork in a token-aware glow, grid, or orbit graphic.";
+        readonly category: "Brand";
+        readonly files: readonly ["packages/astro/components/Graphic.astro", "packages/astro/styles/lumen.css", "packages/react/src/components.tsx"];
+        readonly dependencies: readonly ["styles"];
     }, {
         readonly name: "HoverCard";
         readonly type: "component";
@@ -465,6 +479,13 @@ export declare const lumenRegistry: {
         readonly category: "Data display";
         readonly files: readonly ["packages/astro/components/Image.astro", "packages/astro/styles/lumen.css"];
         readonly dependencies: readonly ["styles"];
+    }, {
+        readonly name: "Illustration";
+        readonly type: "component";
+        readonly description: "Renders a built-in semantic empty, success, error, or offline illustration.";
+        readonly category: "Feedback";
+        readonly files: readonly ["packages/astro/components/Illustration.astro", "packages/astro/styles/lumen.css", "packages/react/src/components.tsx"];
+        readonly dependencies: readonly ["styles"];
     }, {
         readonly name: "Input";
         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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqwEQ,CAAA"}
+{"version":3,"file":"registry-data.d.ts","sourceRoot":"","sources":["../src/registry-data.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+yEQ,CAAA"}

package/dist/registry-data.js

@@ -357,6 +357,20 @@ export const lumenRegistry = {
                 'styles'
             ]
         },
+        {
+            name: 'Backdrop',
+            type: 'component',
+            description: 'Adds a token-aware ambient pattern behind meaningful content.',
+            category: 'Brand',
+            files: [
+                'packages/astro/components/Backdrop.astro',
+                'packages/astro/styles/lumen.css',
+                'packages/react/src/components.tsx'
+            ],
+            dependencies: [
+                'styles'
+            ]
+        },
         {
             name: 'BackToTop',
             type: 'component',
@@ -985,6 +999,20 @@ export const lumenRegistry = {
                 'styles'
             ]
         },
+        {
+            name: 'Graphic',
+            type: 'component',
+            description: 'Frames custom artwork in a token-aware glow, grid, or orbit graphic.',
+            category: 'Brand',
+            files: [
+                'packages/astro/components/Graphic.astro',
+                'packages/astro/styles/lumen.css',
+                'packages/react/src/components.tsx'
+            ],
+            dependencies: [
+                'styles'
+            ]
+        },
         {
             name: 'HoverCard',
             type: 'component',
@@ -1027,6 +1055,20 @@ export const lumenRegistry = {
                 'styles'
             ]
         },
+        {
+            name: 'Illustration',
+            type: 'component',
+            description: 'Renders a built-in semantic empty, success, error, or offline illustration.',
+            category: 'Feedback',
+            files: [
+                'packages/astro/components/Illustration.astro',
+                'packages/astro/styles/lumen.css',
+                'packages/react/src/components.tsx'
+            ],
+            dependencies: [
+                'styles'
+            ]
+        },
         {
             name: 'Input',
             type: 'component',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@santi020k/lumen",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "publishConfig": {
     "access": "public"
   },
@@ -22,6 +22,7 @@
       "types": "./dist/registry.d.ts",
       "import": "./dist/registry.js"
     },
+    "./release-manifest.json": "./release-manifest.json",
     "./styles.css": "./styles.css",
     "./layers.css": "./layers.css",
     "./package.json": "./package.json"
@@ -30,6 +31,7 @@
     "bin",
     "dist",
     "layers.css",
+    "release-manifest.json",
     "styles.css",
     "README.md",
     "LICENSE"
@@ -39,7 +41,7 @@
   },
   "dependencies": {
     "semver": "^7.8.0",
-    "@santi020k/lumen-core": "^1.3.0"
+    "@santi020k/lumen-core": "^1.4.0"
   },
   "devDependencies": {
     "@types/node": "^26.1.1",

package/release-manifest.json

@@ -0,0 +1,88 @@
+{
+  "schemaVersion": 1,
+  "release": {
+    "compose": {
+      "artifacts": [
+        "com.santi020k:lumen-compose",
+        "com.santi020k:lumen-compose-wear"
+      ],
+      "version": "0.4.0"
+    },
+    "npm": {
+      "packages": {
+        "@santi020k/lumen-astro": {
+          "peerDependencies": {
+            "astro": ">=5"
+          },
+          "version": "1.4.0"
+        },
+        "@santi020k/lumen-core": {
+          "peerDependencies": {},
+          "version": "1.4.0"
+        },
+        "@santi020k/lumen-elements": {
+          "peerDependencies": {},
+          "version": "1.4.0"
+        },
+        "@santi020k/lumen-icons-brand": {
+          "peerDependencies": {},
+          "version": "1.0.1"
+        },
+        "@santi020k/lumen": {
+          "peerDependencies": {},
+          "version": "1.5.0"
+        },
+        "@santi020k/lumen-mcp": {
+          "peerDependencies": {},
+          "version": "1.5.0"
+        },
+        "@santi020k/lumen-react": {
+          "peerDependencies": {
+            "react": ">=19"
+          },
+          "version": "1.4.0"
+        },
+        "@santi020k/lumen-react-hook-form": {
+          "peerDependencies": {
+            "@santi020k/lumen-react": "^1.0.0",
+            "react": ">=19",
+            "react-hook-form": ">=7.76.0 <8"
+          },
+          "version": "1.0.1"
+        },
+        "@santi020k/lumen-react-native": {
+          "peerDependencies": {
+            "react": ">=19.2",
+            "react-native": ">=0.86.2"
+          },
+          "version": "0.4.0"
+        },
+        "@santi020k/lumen-tokens": {
+          "peerDependencies": {},
+          "version": "0.1.0"
+        }
+      }
+    },
+    "swift": {
+      "package": "https://github.com/santi020k/lumen.git",
+      "revision": null,
+      "tag": "v1.5.0"
+    },
+    "version": "1.5.0"
+  },
+  "migration": {
+    "codemod": null,
+    "css": {
+      "astro": "@santi020k/lumen-astro/styles.css",
+      "elements": "@santi020k/lumen-elements/styles.css",
+      "react": "@santi020k/lumen-react/styles.css"
+    },
+    "deprecatedExports": [],
+    "removedExports": [],
+    "runtime": {
+      "astro": "Mount UIPrimitives once when an imported component declares the ui-primitives runtime.",
+      "elements": "Call defineLumenElements once before rendering lumen-* elements.",
+      "react": "Use the public React behavior hooks for behavior-heavy primitives."
+    }
+  }
+}

package/styles.css

@@ -194,6 +194,12 @@
   }
 }
 
+@keyframes ui-graphic-orbit {
+  to {
+    transform: rotate(1turn);
+  }
+}
+
 .ui-sr-only {
   position: absolute;
   width: 1px;
@@ -216,6 +222,7 @@
   .ui-attachment,
   .ui-autocomplete,
   .ui-avatar,
+  .ui-backdrop,
   .ui-back-to-top,
   .ui-badge,
   .ui-bubble,
@@ -242,12 +249,14 @@
   .ui-floating-badge,
   .ui-formatted-date,
   .ui-gradient-divider,
+  .ui-graphic,
   .ui-icon,
   .ui-input,
   .ui-input-group,
   .ui-input-otp-field,
   .ui-input-otp,
   .ui-image,
+  .ui-illustration,
   .ui-item,
   .ui-kbd,
   .ui-label,
@@ -1040,6 +1049,166 @@
   );
 }
 
+.ui-backdrop {
+  --ui-backdrop-color: var(--brand);
+  --ui-backdrop-secondary: var(--accent);
+  --ui-backdrop-opacity: 0.68;
+  isolation: isolate;
+  overflow: hidden;
+  position: relative;
+}
+
+.ui-backdrop::before {
+  content: '';
+  inset: 0;
+  opacity: var(--ui-backdrop-opacity);
+  pointer-events: none;
+  position: absolute;
+}
+
+.ui-backdrop__content,
+.ui-backdrop > * {
+  position: relative;
+  z-index: 1;
+}
+
+.ui-backdrop--subtle { --ui-backdrop-opacity: 0.4; }
+.ui-backdrop--strong { --ui-backdrop-opacity: 1; }
+.ui-backdrop--accent { --ui-backdrop-color: var(--accent); --ui-backdrop-secondary: var(--brand); }
+.ui-backdrop--neutral { --ui-backdrop-color: var(--ink-muted); --ui-backdrop-secondary: var(--ink-soft); }
+
+.ui-backdrop--aurora::before {
+  background:
+    radial-gradient(ellipse at 18% 8%, hsl(var(--ui-backdrop-color) / 0.28), transparent 46%),
+    radial-gradient(ellipse at 86% 92%, hsl(var(--ui-backdrop-secondary) / 0.2), transparent 48%);
+}
+
+.ui-backdrop--dots::before {
+  background-image: radial-gradient(circle, hsl(var(--ui-backdrop-color) / 0.28) 1px, transparent 1.5px);
+  background-size: 1.25rem 1.25rem;
+  mask-image: radial-gradient(ellipse, black 12%, transparent 76%);
+}
+
+.ui-backdrop--grid::before {
+  background-image:
+    linear-gradient(hsl(var(--ui-backdrop-color) / 0.14) 1px, transparent 1px),
+    linear-gradient(90deg, hsl(var(--ui-backdrop-color) / 0.14) 1px, transparent 1px);
+  background-size: 2rem 2rem;
+  mask-image: linear-gradient(black, transparent 92%);
+}
+
+.ui-backdrop--rays::before {
+  background: repeating-conic-gradient(from 210deg at 50% 0%, hsl(var(--ui-backdrop-color) / 0.12) 0 4deg, transparent 4deg 13deg);
+  mask-image: linear-gradient(black, transparent 88%);
+}
+
+.ui-illustration {
+  --ui-illustration-color: var(--brand);
+  color: hsl(var(--ui-illustration-color));
+  display: inline-grid;
+  place-items: center;
+  width: var(--ui-illustration-size, 8rem);
+}
+
+.ui-illustration svg { display: block; height: auto; overflow: visible; width: 100%; }
+.ui-illustration :where(path, circle) { stroke: currentColor; stroke-linecap: round; stroke-linejoin: round; stroke-width: 3; vector-effect: non-scaling-stroke; }
+.ui-illustration__wash { fill: hsl(var(--ui-illustration-color) / 0.1); stroke: none !important; }
+.ui-illustration--sm { --ui-illustration-size: 6rem; }
+.ui-illustration--lg { --ui-illustration-size: 11rem; }
+.ui-illustration--auto.ui-illustration--success { --ui-illustration-color: var(--success); }
+.ui-illustration--auto.ui-illustration--error { --ui-illustration-color: var(--danger); }
+.ui-illustration--auto.ui-illustration--offline { --ui-illustration-color: var(--ink-muted); }
+.ui-illustration--accent { --ui-illustration-color: var(--accent); }
+.ui-illustration--neutral { --ui-illustration-color: var(--ink-muted); }
+
+.ui-graphic {
+  --ui-graphic-color: var(--brand);
+  --ui-graphic-secondary: var(--accent);
+  aspect-ratio: 1;
+  display: grid;
+  isolation: isolate;
+  max-width: 100%;
+  overflow: hidden;
+  place-items: center;
+  position: relative;
+  width: var(--ui-graphic-size, 15rem);
+}
+
+.ui-graphic::before,
+.ui-graphic::after {
+  content: '';
+  inset: 0;
+  pointer-events: none;
+  position: absolute;
+}
+
+.ui-graphic > *,
+.ui-graphic__content {
+  position: relative;
+  z-index: 1;
+}
+
+.ui-graphic--sm {
+  --ui-graphic-size: 10rem;
+}
+
+.ui-graphic--md {
+  --ui-graphic-size: 15rem;
+}
+
+.ui-graphic--lg {
+  --ui-graphic-size: 20rem;
+}
+
+.ui-graphic--accent {
+  --ui-graphic-color: var(--accent);
+  --ui-graphic-secondary: var(--brand);
+}
+
+.ui-graphic--neutral {
+  --ui-graphic-color: var(--ink-muted);
+  --ui-graphic-secondary: var(--ink-soft);
+}
+
+.ui-graphic--glow::before {
+  background: radial-gradient(
+    circle,
+    hsl(var(--ui-graphic-color) / 0.3),
+    hsl(var(--ui-graphic-secondary) / 0.12) 38%,
+    transparent 70%
+  );
+  filter: blur(0.75rem);
+}
+
+.ui-graphic--grid::before {
+  background-image:
+    linear-gradient(hsl(var(--ui-graphic-color) / 0.13) 1px, transparent 1px),
+    linear-gradient(90deg, hsl(var(--ui-graphic-color) / 0.13) 1px, transparent 1px),
+    radial-gradient(circle, hsl(var(--ui-graphic-secondary) / 0.18), transparent 66%);
+  background-size: 1.5rem 1.5rem, 1.5rem 1.5rem, 100% 100%;
+  mask-image: radial-gradient(circle, black 20%, transparent 74%);
+}
+
+.ui-graphic--orbit::before {
+  background:
+    linear-gradient(90deg, transparent 49.75%, hsl(var(--ui-graphic-color) / 0.16) 50%, transparent 50.25%),
+    linear-gradient(transparent 49.75%, hsl(var(--ui-graphic-color) / 0.16) 50%, transparent 50.25%),
+    radial-gradient(circle, transparent 0 17%, hsl(var(--ui-graphic-color) / 0.22) 17.4% 17.8%, transparent 18.2% 31%, hsl(var(--ui-graphic-color) / 0.28) 31.4% 31.8%, transparent 32.2% 45%, hsl(var(--ui-graphic-color) / 0.18) 45.4% 45.8%, transparent 46.2% 49%, hsl(var(--ui-graphic-secondary) / 0.28) 49.4% 49.8%, transparent 50.2%),
+    radial-gradient(circle, hsl(var(--ui-graphic-color) / 0.18), transparent 68%);
+}
+
+.ui-graphic--orbit::after {
+  animation: ui-graphic-orbit 18s linear infinite;
+  background: conic-gradient(
+    from 0deg,
+    transparent 0 72%,
+    hsl(var(--ui-graphic-color) / 0.42) 82%,
+    transparent 92%
+  );
+  inset: 8%;
+  mask-image: radial-gradient(circle, transparent 0 42%, black 42.5% 49%, transparent 49.5%);
+}
+
 .ui-particles {
   position: relative;
   display: block;
@@ -1149,6 +1318,10 @@
     animation: none;
   }
 
+  .ui-graphic--orbit::after {
+    animation: none;
+  }
+
   .ui-scroll-reveal[data-ui-scroll-reveal-bound="true"] {
     opacity: 1;
     transform: none;