@santi020k/lumen 0.1.0 → 0.3.0

package/README.md

@@ -26,8 +26,37 @@ lumen add Button --target elements
 lumen add scheduler
 lumen add scheduler --target react
 lumen add scheduler --target elements
+lumen audit-tokens ./src
 ```
 
 Use `lumen add <component>` for a local Astro wrapper, `--target react` for a React wrapper, or
 `--target elements` for a custom-elements starter. Bundled recipes support the same Astro, React,
 and Elements targets.
+
+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
+are incompatible with Lumen's HSL-channel token format and exits non-zero when it finds conflicts.
+
+## Coordinated consumer rollout
+
+Inventory one or more pnpm consumers before a release:
+
+```bash
+lumen rollout 0.2.0 ../site ../dashboard --exclude ../legacy
+```
+
+The report separates manifest, workspace-catalog, and lockfile references; identifies each
+framework; checks the declared pnpm and Node contracts; and reports the complete resolved Lumen
+package graph. Add `--report ./lumen-rollout.json` for a durable JSON record.
+
+After committing an intentional baseline in each consumer, apply the upgrade serially:
+
+```bash
+lumen rollout 0.2.0 ../site ../dashboard --apply --report ./lumen-rollout.json
+```
+
+The command preserves `catalog:` indirection and pinned/caret range style, temporarily admits the
+new release through `minimumReleaseAgeExclude`, runs installs through Corepack from each consumer
+root, removes obsolete Lumen release-age exceptions, verifies the unified resolved version, and
+runs available framework checks, builds, and browser scripts. It refuses dirty repositories,
+missing exact pnpm declarations, and unsupported Node runtimes unless `--allow-dirty` is explicit.

package/dist/cli.js

@@ -1,4 +1,8 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { consumerRolloutSucceeded, formatConsumerRollout, runConsumerRollout } from './consumer-rollout.js';
 import { addLumenRegistryItem, getLumenRegistryEntries, getLumenRegistryItem, loadLumenRegistry, lumenRegistry } from './registry.js';
+import { auditLumenTokenCss } from './token-audit.js';
 const args = process.argv.slice(2);
 const [command = 'help', name] = args;
 const dryRun = args.includes('--dry-run');
@@ -14,7 +18,36 @@ const registryToken = registryTokenIndex >= 0 ? args[registryTokenIndex + 1] : p
 const targetIndex = args.indexOf('--target');
 const targetProvided = targetIndex >= 0;
 const targetValue = targetIndex >= 0 ? args[targetIndex + 1] : undefined;
+const applyRollout = args.includes('--apply');
+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 excludeValues = args.flatMap((value, index) => {
+    const nextValue = args[index + 1];
+    return value === '--exclude' && nextValue ? [nextValue] : [];
+});
 let conflict = 'skip';
+const getRolloutArguments = () => {
+    const values = [];
+    const optionsWithValues = new Set(['--exclude', '--report']);
+    for (let index = 1; index < args.length; index += 1) {
+        const value = args[index];
+        if (!value)
+            continue;
+        if (optionsWithValues.has(value)) {
+            index += 1;
+            continue;
+        }
+        if (!value.startsWith('--'))
+            values.push(value);
+    }
+    const [targetVersion, ...repositories] = values;
+    return {
+        repositories: repositories.length ? repositories : [process.cwd()],
+        ...(targetVersion ? { targetVersion } : {})
+    };
+};
 const getAddTarget = (value, provided = false) => {
     if (provided && !value) {
         throw new Error('Missing Lumen add target. Use astro, react, or elements.');
@@ -83,6 +116,34 @@ const formatAddResult = async (itemName, registry) => {
         ...result.skipped.map(file => `- skipped existing ${file}`)
     ].join('\n');
 };
+const getCssFiles = async (path) => {
+    const details = await stat(path);
+    if (details.isFile())
+        return path.endsWith('.css') ? [path] : [];
+    const entries = await readdir(path, { withFileTypes: true });
+    const nested = await Promise.all(entries
+        .filter(entry => entry.name !== 'node_modules' && !entry.name.startsWith('.'))
+        .map(entry => getCssFiles(resolve(path, entry.name))));
+    return nested.flat();
+};
+const formatTokenAudit = async (inputPath) => {
+    const target = resolve(inputPath);
+    const files = await getCssFiles(target);
+    const findings = [];
+    for (const file of files) {
+        findings.push(...auditLumenTokenCss(await readFile(file, 'utf8'), file));
+    }
+    if (!findings.length)
+        return `No incompatible Lumen semantic token declarations found in ${target}.`;
+    process.exitCode = 1;
+    return [
+        `Found ${findings.length} incompatible Lumen semantic token declaration${findings.length === 1 ? '' : 's'}:`,
+        ...findings.map(finding => (`${finding.file}:${finding.line}:${finding.column} --${finding.token}: ${finding.value}`)),
+        '',
+        'Lumen semantic colors must be HSL channels such as "220 13% 96%", not complete colors such as "#fff" or "hsl(...)".',
+        'Rename legacy variables during incremental migration or convert their values to channels before importing Lumen.'
+    ].join('\n');
+};
 const help = [
     'Lumen registry helper',
     '',
@@ -91,6 +152,8 @@ const help = [
     '  lumen show <name>      Show components and files for an item',
     '  lumen add <name>       Install a recipe or component into the current project',
     '  lumen install          Print install commands',
+    '  lumen audit-tokens     Report incompatible semantic color custom properties',
+    '  lumen rollout [version] [repositories...]  Inventory or upgrade pnpm consumers',
     '',
     'Options:',
     '  --cwd <path>           Target directory for lumen add',
@@ -101,14 +164,24 @@ const help = [
     '  --registry <source>    Load list/show data from a local or remote registry JSON file',
     '  --registry-token <key> Use a bearer token for private remote registries',
     '  --target <framework>   Generate wrappers or recipe starters for astro, react, or elements',
+    '  --apply                Apply a rollout (requires a target version)',
+    '  --allow-dirty          Allow rollout after recording an uncommitted baseline',
+    '  --exclude <path>       Exclude a repository (repeatable)',
+    '  --no-verify            Skip downstream check, typecheck, build, and browser scripts',
+    '  --report <path>        Write the machine-readable rollout report as JSON',
     ''
 ].join('\n');
+// eslint-disable-next-line complexity -- Command dispatch keeps CLI exit behavior and output in one place.
 const run = async () => {
     let output = help;
     const registry = registrySource
         ? await loadLumenRegistry(registrySource, registryToken ? { token: registryToken } : {})
         : lumenRegistry;
     switch (command) {
+        case 'audit-tokens': {
+            output = await formatTokenAudit(name ?? cwd ?? process.cwd());
+            break;
+        }
         case 'add': {
             if (name)
                 output = await formatAddResult(name, registry);
@@ -122,6 +195,22 @@ const run = async () => {
             output = formatList(registry);
             break;
         }
+        case 'rollout': {
+            const rollout = getRolloutArguments();
+            const report = await runConsumerRollout({
+                allowDirty,
+                apply: applyRollout,
+                exclude: excludeValues,
+                ...(reportPath ? { report: reportPath } : {}),
+                repositories: rollout.repositories,
+                ...(rollout.targetVersion ? { targetVersion: rollout.targetVersion } : {}),
+                verify: !noVerify
+            });
+            output = formatConsumerRollout(report);
+            if (!consumerRolloutSucceeded(report))
+                process.exitCode = 1;
+            break;
+        }
         case 'show': {
             if (name)
                 output = formatItem(name, registry);

package/dist/consumer-rollout.d.ts

@@ -0,0 +1,52 @@
+export type LumenFramework = 'astro' | 'elements' | 'react';
+export interface ConsumerReference {
+    file: string;
+    packageName: string;
+    source: 'catalog' | 'manifest' | 'lockfile';
+    version: string;
+}
+export interface ConsumerInventory {
+    branch: string | undefined;
+    currentCommit: string | undefined;
+    dirty: boolean;
+    frameworks: LumenFramework[];
+    nodeEngine: string | undefined;
+    nodeEngineSatisfied: boolean | undefined;
+    packageManager: string | undefined;
+    references: ConsumerReference[];
+    repository: string;
+    resolvedVersions: Record<string, string[]>;
+    targetVersion?: string;
+    valid: boolean;
+    warnings: string[];
+}
+export interface ConsumerRolloutOptions {
+    allowDirty?: boolean;
+    apply?: boolean;
+    exclude?: string[];
+    report?: string;
+    repositories: string[];
+    targetVersion?: string;
+    verify?: boolean;
+}
+export interface ConsumerRolloutReport {
+    generatedAt: string;
+    mode: 'apply' | 'inventory';
+    repositories: (ConsumerInventory & {
+        commands: {
+            command: string;
+            ok: boolean;
+            output: string;
+        }[];
+    })[];
+    targetVersion?: string;
+}
+export declare const consumerRolloutSucceeded: (report: ConsumerRolloutReport) => boolean;
+export declare const satisfiesNodeEngine: (engine: string | undefined, currentVersion?: string) => boolean | undefined;
+export declare const inspectLumenConsumer: (repository: string, targetVersion?: string) => Promise<ConsumerInventory>;
+export declare const updateLumenManifestSource: (source: string, targetVersion: string) => string;
+export declare const updateLumenWorkspaceSource: (source: string, targetVersion: string) => string;
+export declare const addReleaseAgeTarget: (source: string, packages: string[], version: string) => string;
+export declare const runConsumerRollout: (options: ConsumerRolloutOptions) => Promise<ConsumerRolloutReport>;
+export declare const formatConsumerRollout: (report: ConsumerRolloutReport) => string;
+//# sourceMappingURL=consumer-rollout.d.ts.map

package/dist/consumer-rollout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumer-rollout.d.ts","sourceRoot":"","sources":["../src/consumer-rollout.ts"],"names":[],"mappings":"AAmBA,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,UAAU,GAAG,OAAO,CAAA;AAE3D,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,UAAU,CAAA;IAC3C,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,aAAa,EAAE,MAAM,GAAG,SAAS,CAAA;IACjC,KAAK,EAAE,OAAO,CAAA;IACd,UAAU,EAAE,cAAc,EAAE,CAAA;IAC5B,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;IAC9B,mBAAmB,EAAE,OAAO,GAAG,SAAS,CAAA;IACxC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC,UAAU,EAAE,iBAAiB,EAAE,CAAA;IAC/B,UAAU,EAAE,MAAM,CAAA;IAClB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;IAC1C,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,KAAK,EAAE,OAAO,CAAA;IACd,QAAQ,EAAE,MAAM,EAAE,CAAA;CACnB;AAED,MAAM,WAAW,sBAAsB;IACrC,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,OAAO,GAAG,WAAW,CAAA;IAC3B,YAAY,EAAE,CAAC,iBAAiB,GAAG;QACjC,QAAQ,EAAE;YAAE,OAAO,EAAE,MAAM,CAAC;YAAC,EAAE,EAAE,OAAO,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,EAAE,CAAA;KAC7D,CAAC,EAAE,CAAA;IACJ,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,eAAO,MAAM,wBAAwB,GAAI,QAAQ,qBAAqB,KAAG,OAGtE,CAAA;AA8DH,eAAO,MAAM,mBAAmB,GAC9B,QAAQ,MAAM,GAAG,SAAS,EAC1B,uBAAsC,KACrC,OAAO,GAAG,SAIZ,CAAA;AA+DD,eAAO,MAAM,oBAAoB,GAC/B,YAAY,MAAM,EAClB,gBAAgB,MAAM,KACrB,OAAO,CAAC,iBAAiB,CAiG3B,CAAA;AAUD,eAAO,MAAM,yBAAyB,GACpC,QAAQ,MAAM,EACd,eAAe,MAAM,KACpB,MAYF,CAAA;AAED,eAAO,MAAM,0BAA0B,GACrC,QAAQ,MAAM,EACd,eAAe,MAAM,KACpB,MAIF,CAAA;AAuFD,eAAO,MAAM,mBAAmB,GAAI,QAAQ,MAAM,EAAE,UAAU,MAAM,EAAE,EAAE,SAAS,MAAM,KAAG,MAoCzF,CAAA;AAqGD,eAAO,MAAM,kBAAkB,GAC7B,SAAS,sBAAsB,KAC9B,OAAO,CAAC,qBAAqB,CAmD/B,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAI,QAAQ,qBAAqB,KAAG,MAyBrE,CAAA"}

package/dist/consumer-rollout.js

@@ -0,0 +1,397 @@
+import { execFile } from 'node:child_process';
+import { readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { join, relative, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import { satisfies } from 'semver';
+/* eslint-disable complexity -- Consumer inventory, semver checks, mutation, and verification intentionally evaluate full repository contracts. */
+const execFileAsync = promisify(execFile);
+const lumenPackagePattern = /^@santi020k\/lumen(?:-(?:astro|core|elements|mcp|react))?$/;
+const dependencyFields = [
+    'dependencies',
+    'devDependencies',
+    'optionalDependencies',
+    'peerDependencies'
+];
+export const consumerRolloutSucceeded = (report) => report.repositories.every(repository => repository.valid && repository.commands.every(command => command.ok));
+const isLumenPackage = (name) => lumenPackagePattern.test(name);
+const pathExists = async (path) => {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const findPackageManifests = async (root) => {
+    const results = [];
+    const visit = async (directory) => {
+        const entries = await readdir(directory, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name === 'node_modules' || entry.name === '.git' || entry.name.startsWith('.turbo'))
+                continue;
+            const path = join(directory, entry.name);
+            if (entry.isDirectory()) {
+                await visit(path);
+            }
+            else if (entry.name === 'package.json') {
+                results.push(path);
+            }
+        }
+    };
+    await visit(root);
+    return results;
+};
+const readManifest = async (path) => JSON.parse(await readFile(path, 'utf8'));
+const readGitValue = async (root, args) => {
+    try {
+        const { stdout } = await execFileAsync('git', ['-C', root, ...args]);
+        return stdout.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+export const satisfiesNodeEngine = (engine, currentVersion = process.versions.node) => {
+    if (!engine)
+        return undefined;
+    return satisfies(currentVersion, engine);
+};
+const collectManifestReferences = (manifest, file, root) => dependencyFields.flatMap(field => Object.entries(manifest[field] ?? {})
+    .filter(([packageName]) => isLumenPackage(packageName))
+    .map(([packageName, version]) => ({
+    file: relative(root, file),
+    packageName,
+    source: 'manifest',
+    version
+})));
+const collectYamlReferences = (source, file) => {
+    const references = [];
+    for (const line of source.split(/\r?\n/)) {
+        const match = /^\s*['"]?(@santi020k\/lumen(?:-(?:astro|core|elements|mcp|react))?)['"]?\s*:\s*['"]?([^'"\s#]+)['"]?/.exec(line);
+        if (match?.[1] && match[2]) {
+            references.push({ file, packageName: match[1], source: 'catalog', version: match[2] });
+        }
+    }
+    return references;
+};
+const collectLockReferences = (source) => {
+    const references = [];
+    const pattern = /@santi020k\/(lumen(?:-(?:astro|core|elements|mcp|react))?)@(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)/g;
+    for (const match of source.matchAll(pattern)) {
+        if (match[1] && match[2]) {
+            references.push({
+                file: 'pnpm-lock.yaml',
+                packageName: `@santi020k/${match[1]}`,
+                source: 'lockfile',
+                version: match[2]
+            });
+        }
+    }
+    return references;
+};
+const getResolvedVersions = (references) => {
+    const graph = {};
+    for (const reference of references.filter(item => item.source === 'lockfile')) {
+        graph[reference.packageName] ??= new Set();
+        graph[reference.packageName]?.add(reference.version);
+    }
+    return Object.fromEntries(Object.entries(graph).map(([name, versions]) => [name, [...versions].sort()]));
+};
+export const inspectLumenConsumer = async (repository, targetVersion) => {
+    const root = resolve(repository);
+    const rootManifestPath = join(root, 'package.json');
+    if (!await pathExists(rootManifestPath)) {
+        throw new Error(`No package.json found at consumer root: ${root}`);
+    }
+    const manifestPaths = await findPackageManifests(root);
+    const manifests = await Promise.all(manifestPaths.map(async (file) => ({
+        file,
+        manifest: await readManifest(file)
+    })));
+    const rootManifest = await readManifest(rootManifestPath);
+    const references = manifests.flatMap(({ file, manifest }) => collectManifestReferences(manifest, file, root));
+    const workspacePath = join(root, 'pnpm-workspace.yaml');
+    const lockPath = join(root, 'pnpm-lock.yaml');
+    if (await pathExists(workspacePath)) {
+        references.push(...collectYamlReferences(await readFile(workspacePath, 'utf8'), 'pnpm-workspace.yaml'));
+    }
+    if (await pathExists(lockPath)) {
+        references.push(...collectLockReferences(await readFile(lockPath, 'utf8')));
+    }
+    const resolvedVersions = getResolvedVersions(references);
+    const frameworks = ([
+        references.some(item => item.packageName === '@santi020k/lumen-astro') && 'astro',
+        references.some(item => item.packageName === '@santi020k/lumen-elements') && 'elements',
+        references.some(item => item.packageName === '@santi020k/lumen-react') && 'react'
+    ].filter(Boolean));
+    const warnings = [];
+    const nodeEngineSatisfied = satisfiesNodeEngine(rootManifest.engines?.node);
+    const status = await readGitValue(root, ['status', '--porcelain']);
+    const dirty = Boolean(status);
+    if (!/^pnpm@\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(rootManifest.packageManager ?? '')) {
+        warnings.push('Missing an exact pnpm packageManager declaration.');
+    }
+    if (nodeEngineSatisfied === false) {
+        warnings.push(`Current Node ${process.versions.node} does not satisfy ${rootManifest.engines?.node ?? 'the declared engine'}.`);
+    }
+    if (dirty) {
+        warnings.push('Repository has uncommitted changes; create an intentional baseline or use --allow-dirty.');
+    }
+    if (targetVersion) {
+        for (const reference of references.filter(item => item.source !== 'lockfile')) {
+            const declaredVersion = reference.version.replace(/^[~^]/, '');
+            if (reference.version !== 'catalog:' &&
+                !reference.version.startsWith('workspace:') &&
+                declaredVersion !== targetVersion) {
+                warnings.push(`${reference.packageName} declares ${reference.version} in ${reference.file} instead of ${targetVersion}.`);
+            }
+        }
+        for (const [packageName, versions] of Object.entries(resolvedVersions)) {
+            if (versions.some(version => version !== targetVersion)) {
+                warnings.push(`${packageName} resolves ${versions.join(', ')} instead of only ${targetVersion}.`);
+            }
+        }
+    }
+    return {
+        branch: await readGitValue(root, ['branch', '--show-current']),
+        currentCommit: await readGitValue(root, ['rev-parse', 'HEAD']),
+        dirty,
+        frameworks,
+        nodeEngine: rootManifest.engines?.node,
+        nodeEngineSatisfied,
+        packageManager: rootManifest.packageManager,
+        references,
+        repository: root,
+        resolvedVersions,
+        ...(targetVersion ? { targetVersion } : {}),
+        valid: warnings.length === 0,
+        warnings
+    };
+};
+const replaceRange = (range, targetVersion) => {
+    if (range === 'catalog:' || range.startsWith('workspace:') || range.startsWith('file:'))
+        return range;
+    const prefix = range.startsWith('^') || range.startsWith('~') ? (range.at(0) ?? '') : '';
+    return `${prefix}${targetVersion}`;
+};
+export const updateLumenManifestSource = (source, targetVersion) => {
+    const manifest = JSON.parse(source);
+    for (const field of dependencyFields) {
+        const dependencies = manifest[field];
+        for (const [name, range] of Object.entries(dependencies ?? {})) {
+            if (isLumenPackage(name) && dependencies)
+                dependencies[name] = replaceRange(range, targetVersion);
+        }
+    }
+    return `${JSON.stringify(manifest, undefined, 2)}\n`;
+};
+export const updateLumenWorkspaceSource = (source, targetVersion) => source.replaceAll(/^(\s*['"]?@santi020k\/lumen(?:-(?:astro|core|elements|mcp|react))?['"]?\s*:\s*['"]?)([~^]?)(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)(['"]?\s*(?:#.*)?)$/gm, (_match, before, prefix, _version, after) => `${before}${prefix}${targetVersion}${after}`);
+const getVerificationScripts = (manifest, frameworks) => {
+    const scripts = manifest.scripts ?? {};
+    const preferred = [
+        frameworks.includes('astro') && 'check',
+        (frameworks.includes('react') || frameworks.includes('elements')) && 'typecheck',
+        'build',
+        scripts['test:browser'] && 'test:browser',
+        scripts['test:e2e'] && 'test:e2e'
+    ].filter((script) => Boolean(script && scripts[script]));
+    return [...new Set(preferred)];
+};
+const runCommand = async (root, executable, args) => {
+    const command = [executable, ...args].join(' ');
+    try {
+        const { stderr, stdout } = await execFileAsync(executable, args, {
+            cwd: root,
+            maxBuffer: 10 * 1024 * 1024
+        });
+        return { command, ok: true, output: `${stdout}${stderr}`.trim() };
+    }
+    catch (error) {
+        const detail = error;
+        return {
+            command,
+            ok: false,
+            output: `${detail.stdout ?? ''}${detail.stderr ?? ''}`.trim() || detail.message || 'Command failed.'
+        };
+    }
+};
+const parseFlowSequence = (source) => {
+    const match = /^\[([\s\S]*)\]\s*(?:#.*)?$/.exec(source.trim());
+    if (!match)
+        return undefined;
+    const values = [];
+    let current = '';
+    let quote;
+    for (const character of match[1] ?? '') {
+        if (quote) {
+            current += character;
+            if (character === quote)
+                quote = undefined;
+        }
+        else if (character === '"' || character === "'") {
+            current += character;
+            quote = character;
+        }
+        else if (character === ',') {
+            values.push(current);
+            current = '';
+        }
+        else {
+            current += character;
+        }
+    }
+    if (current.trim())
+        values.push(current);
+    return values.map(value => {
+        const trimmed = value.trim();
+        if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+            (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+            return trimmed.slice(1, -1);
+        }
+        return trimmed;
+    }).filter(Boolean);
+};
+export const addReleaseAgeTarget = (source, packages, version) => {
+    if (!/^\s*minimumReleaseAgeExclude\s*:/m.test(source))
+        return source;
+    const lines = source.split(/\r?\n/);
+    const index = lines.findIndex(line => /^\s*minimumReleaseAgeExclude\s*:/.test(line));
+    const declaration = lines[index] ?? '';
+    const rootIndent = /^\s*/.exec(declaration)?.[0] ?? '';
+    const indent = `${rootIndent}  `;
+    const declarationValue = declaration.slice(declaration.indexOf(':') + 1);
+    const inlineValues = parseFlowSequence(declarationValue);
+    if (declarationValue.trim() && !inlineValues)
+        return source;
+    const existing = new Set([
+        ...(inlineValues ?? []),
+        ...lines.flatMap(line => {
+            const value = /^\s*-\s*['"]?([^'"]+)['"]?\s*$/.exec(line)?.[1];
+            return value ? [value] : [];
+        })
+    ]);
+    const additions = packages
+        .map(packageName => `${packageName}@${version}`)
+        .filter(value => !existing.has(value))
+        .map(value => `${indent}- "${value}"`);
+    if (declaration.slice(declaration.indexOf(':') + 1).trim()) {
+        lines[index] = `${rootIndent}minimumReleaseAgeExclude:`;
+        additions.unshift(...(inlineValues ?? []).map(value => `${indent}- "${value}"`));
+    }
+    lines.splice(index + 1, 0, ...additions);
+    return lines.join('\n');
+};
+const removeObsoleteReleaseAgeEntries = (source, targetVersion) => source.split(/\r?\n/)
+    .filter(line => {
+    const match = /^\s*-\s*['"]?(@santi020k\/lumen(?:-(?:astro|core|elements|mcp|react))?)@([^'"]+)['"]?\s*$/.exec(line);
+    return !match || match[2] === targetVersion;
+})
+    .join('\n');
+const upgradeConsumer = async (inventory, targetVersion, allowDirty, verify) => {
+    if (inventory.dirty && !allowDirty) {
+        throw new Error(`${inventory.repository} is dirty. Commit a baseline or pass --allow-dirty.`);
+    }
+    if (!/^pnpm@\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(inventory.packageManager ?? '')) {
+        throw new Error(`${inventory.repository} must declare an exact pnpm packageManager version.`);
+    }
+    if (inventory.nodeEngineSatisfied === false) {
+        throw new Error(`${inventory.repository} must be upgraded under Node ${inventory.nodeEngine ?? 'matching its engine declaration'}.`);
+    }
+    const manifestPaths = await findPackageManifests(inventory.repository);
+    const desiredManifests = new Map();
+    for (const path of manifestPaths) {
+        const source = await readFile(path, 'utf8');
+        const updated = updateLumenManifestSource(source, targetVersion);
+        desiredManifests.set(path, updated);
+        if (updated !== source)
+            await writeFile(path, updated);
+    }
+    const workspacePath = join(inventory.repository, 'pnpm-workspace.yaml');
+    if (await pathExists(workspacePath)) {
+        const source = await readFile(workspacePath, 'utf8');
+        const packages = [...new Set(inventory.references.map(item => item.packageName))];
+        const updated = addReleaseAgeTarget(updateLumenWorkspaceSource(source, targetVersion), packages, targetVersion);
+        if (updated !== source)
+            await writeFile(workspacePath, updated);
+    }
+    const packageNames = [...new Set(inventory.references.map(item => item.packageName))];
+    const commands = [await runCommand(inventory.repository, 'corepack', [
+            'pnpm',
+            'update',
+            '--recursive',
+            ...packageNames.map(packageName => `${packageName}@${targetVersion}`)
+        ])];
+    if (!commands[0]?.ok)
+        return commands;
+    for (const [path, source] of desiredManifests) {
+        await writeFile(path, source);
+    }
+    commands.push(await runCommand(inventory.repository, 'corepack', ['pnpm', 'install']));
+    if (!commands.at(-1)?.ok)
+        return commands;
+    if (await pathExists(workspacePath)) {
+        const source = await readFile(workspacePath, 'utf8');
+        const updated = removeObsoleteReleaseAgeEntries(source, targetVersion);
+        if (updated !== source) {
+            await writeFile(workspacePath, updated);
+            commands.push(await runCommand(inventory.repository, 'corepack', ['pnpm', 'install']));
+        }
+    }
+    if (verify && commands.every(command => command.ok)) {
+        const manifest = await readManifest(join(inventory.repository, 'package.json'));
+        for (const script of getVerificationScripts(manifest, inventory.frameworks)) {
+            const result = await runCommand(inventory.repository, 'corepack', ['pnpm', 'run', script]);
+            commands.push(result);
+            if (!result.ok)
+                break;
+        }
+    }
+    return commands;
+};
+export const runConsumerRollout = async (options) => {
+    if (options.apply && !options.targetVersion) {
+        throw new Error('A target version is required when applying a consumer rollout.');
+    }
+    const excluded = new Set((options.exclude ?? []).map(path => resolve(path)));
+    const repositories = options.repositories.map(path => resolve(path))
+        .filter(path => !excluded.has(path));
+    const report = {
+        generatedAt: new Date().toISOString(),
+        mode: options.apply ? 'apply' : 'inventory',
+        repositories: [],
+        ...(options.targetVersion ? { targetVersion: options.targetVersion } : {})
+    };
+    for (const repository of repositories) {
+        const before = await inspectLumenConsumer(repository, options.targetVersion);
+        const commands = options.apply
+            ? await upgradeConsumer(before, options.targetVersion ?? '', options.allowDirty ?? false, options.verify ?? true)
+            : [];
+        const after = options.apply
+            ? await inspectLumenConsumer(repository, options.targetVersion)
+            : before;
+        if (options.apply) {
+            after.warnings = after.warnings.filter(warning => !warning.startsWith('Repository has uncommitted changes'));
+            after.valid = after.warnings.length === 0;
+        }
+        report.repositories.push({ ...after, commands });
+        if (commands.some(command => !command.ok))
+            break;
+    }
+    if (options.report) {
+        await writeFile(resolve(options.report), `${JSON.stringify(report, undefined, 2)}\n`);
+    }
+    return report;
+};
+export const formatConsumerRollout = (report) => {
+    const lines = [
+        `Lumen consumer ${report.mode} (${report.repositories.length} repositories)`,
+        ...(report.targetVersion ? [`Target: ${report.targetVersion}`] : [])
+    ];
+    for (const repository of report.repositories) {
+        lines.push('', repository.repository, `  package manager: ${repository.packageManager ?? 'missing'}`, `  node engine: ${repository.nodeEngine ?? 'unspecified'}`, `  frameworks: ${repository.frameworks.join(', ') || 'none'}`, `  resolved graph: ${JSON.stringify(repository.resolvedVersions)}`, `  status: ${repository.valid && repository.commands.every(command => command.ok) ? 'ok' : 'attention required'}`);
+        lines.push(...repository.warnings.map(warning => `  warning: ${warning}`));
+        lines.push(...repository.commands.map(command => `  ${command.ok ? 'pass' : 'fail'}: ${command.command}`));
+    }
+    return lines.join('\n');
+};

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export { type ConsumerInventory, type ConsumerReference, type ConsumerRolloutOptions, type ConsumerRolloutReport, formatConsumerRollout, inspectLumenConsumer, type LumenFramework, runConsumerRollout, updateLumenManifestSource, updateLumenWorkspaceSource } from './consumer-rollout.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 { applyDataViewState, canPlaceScheduleEvent, coerceThemeBuilderExportFormat, coerceThemeBuilderMode, coerceThemeBuilderScheme, composeClassName, createDataViewRequestUrl, createDataViewSearchParams, createDataViewServerRequest, createDataViewState, createDataViewStorageKey, createScheduleSlots, createScheduleStorageKey, createThemeBuilderTokens, createThemePalette, expandRecurringScheduleEvent, exportThemeBuilderCss, exportThemeBuilderValue, exportThemeCss, filterDataRecords, getContrastRatio, getScheduleConflicts, getVirtualRange, loadDataViewState, loadScheduleEvents, type LumenCodeToken, lumenCodeTokenClassNames, type LumenCodeTokenKind, lumenColors, type LumenColorTokenName, lumenColorTokenNames, type LumenComponentName, lumenComponentNames, type LumenContrastScore, lumenDarkTheme, type LumenDataRecord, type LumenDataViewServerRequest, type LumenDataViewState, lumenGlass, type LumenGlassColorTokenName, lumenGlassColorTokenNames, type LumenGlassEffectTokenName, lumenGlassEffectTokenNames, type LumenGlassTokenName, lumenGlassTokenNames, type LumenKeyValueReader, type LumenKeyValueStorage, type LumenKeyValueWriter, lumenLightTheme, lumenPackages, type LumenPackageTarget, type LumenScheduleConflict, type LumenScheduleEvent, type LumenScheduleKeyValueReader, type LumenScheduleKeyValueStorage, type LumenScheduleKeyValueWriter, type LumenScheduleResizeEdge, type LumenScheduleResizeOptions, type LumenScheduleResource, type LumenScheduleSlot, type LumenSemanticColorTokenName, lumenSemanticColorTokenNames, type LumenSortDirection, lumenThemeAttribute, type LumenThemeBuilderExportFormat, type LumenThemeBuilderMode, type LumenThemeBuilderOptions, type LumenThemeBuilderResult, type LumenThemeBuilderScheme, type LumenThemeContrastSuggestion, type LumenThemeTokens, lumenTokenNames, mergeThemeTokens, moveScheduleEvent, normalizeLumenCode, normalizeThemeBuilderHex, normalizeThemeBuilderHue, paginateDataRecords, parseDataViewState, parseScheduleEvents, parseThemeCss, pinDataViewColumn, renderLumenCodeHtml, resizeScheduleEvent, resizeScheduleEvents, saveDataViewState, saveScheduleEvents, scheduleEventsOverlap, scoreThemeContrast, serializeDataViewState, serializeScheduleEvents, sortDataRecords, suggestReadableInk, themeBuilderHexToHsl, toggleDataViewSelection, tokenizeLumenCode, tuneThemeContrast, unpinDataViewColumn } from '@santi020k/lumen-core';
 export declare const lumen: {
@@ -5,4 +6,5 @@ export declare const lumen: {
     readonly packageName: "@santi020k/lumen";
     readonly scope: "@santi020k";
 };
+export { auditLumenTokenCss, type LumenTokenAuditFinding } from './token-audit.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,oBAAoB,EACpB,iBAAiB,EACjB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAClB,aAAa,EACb,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAC9B,MAAM,eAAe,CAAA;AACtB,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,8BAA8B,EAC9B,sBAAsB,EACtB,wBAAwB,EACxB,gBAAgB,EAChB,wBAAwB,EACxB,0BAA0B,EAC1B,2BAA2B,EAC3B,mBAAmB,EACnB,wBAAwB,EACxB,mBAAmB,EACnB,wBAAwB,EACxB,wBAAwB,EACxB,kBAAkB,EAClB,4BAA4B,EAC5B,qBAAqB,EACrB,uBAAuB,EACvB,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,KAAK,cAAc,EACnB,wBAAwB,EACxB,KAAK,kBAAkB,EACvB,WAAW,EACX,KAAK,mBAAmB,EACxB,oBAAoB,EACpB,KAAK,kBAAkB,EACvB,mBAAmB,EACnB,KAAK,kBAAkB,EACvB,cAAc,EACd,KAAK,eAAe,EACpB,KAAK,0BAA0B,EAC/B,KAAK,kBAAkB,EACvB,UAAU,EACV,KAAK,wBAAwB,EAC7B,yBAAyB,EACzB,KAAK,yBAAyB,EAC9B,0BAA0B,EAC1B,KAAK,mBAAmB,EACxB,oBAAoB,EACpB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,eAAe,EACf,aAAa,EACb,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,EAChC,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,EAChC,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAC/B,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,2BAA2B,EAChC,4BAA4B,EAC5B,KAAK,kBAAkB,EACvB,mBAAmB,EACnB,KAAK,6BAA6B,EAClC,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,KAAK,uBAAuB,EAC5B,KAAK,4BAA4B,EACjC,KAAK,gBAAgB,EACrB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,wBAAwB,EACxB,wBAAwB,EACxB,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,aAAa,EACb,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,EAClB,sBAAsB,EACtB,uBAAuB,EACvB,eAAe,EACf,kBAAkB,EAClB,oBAAoB,EACpB,uBAAuB,EACvB,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,uBAAuB,CAAA;AAE9B,eAAO,MAAM,KAAK;;;;CAIR,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,qBAAqB,EACrB,oBAAoB,EACpB,KAAK,cAAc,EACnB,kBAAkB,EAClB,yBAAyB,EACzB,0BAA0B,EAC3B,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,oBAAoB,EACpB,iBAAiB,EACjB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAClB,aAAa,EACb,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAC9B,MAAM,eAAe,CAAA;AACtB,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,8BAA8B,EAC9B,sBAAsB,EACtB,wBAAwB,EACxB,gBAAgB,EAChB,wBAAwB,EACxB,0BAA0B,EAC1B,2BAA2B,EAC3B,mBAAmB,EACnB,wBAAwB,EACxB,mBAAmB,EACnB,wBAAwB,EACxB,wBAAwB,EACxB,kBAAkB,EAClB,4BAA4B,EAC5B,qBAAqB,EACrB,uBAAuB,EACvB,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,KAAK,cAAc,EACnB,wBAAwB,EACxB,KAAK,kBAAkB,EACvB,WAAW,EACX,KAAK,mBAAmB,EACxB,oBAAoB,EACpB,KAAK,kBAAkB,EACvB,mBAAmB,EACnB,KAAK,kBAAkB,EACvB,cAAc,EACd,KAAK,eAAe,EACpB,KAAK,0BAA0B,EAC/B,KAAK,kBAAkB,EACvB,UAAU,EACV,KAAK,wBAAwB,EAC7B,yBAAyB,EACzB,KAAK,yBAAyB,EAC9B,0BAA0B,EAC1B,KAAK,mBAAmB,EACxB,oBAAoB,EACpB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,eAAe,EACf,aAAa,EACb,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,EAChC,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,EAChC,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAC/B,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,2BAA2B,EAChC,4BAA4B,EAC5B,KAAK,kBAAkB,EACvB,mBAAmB,EACnB,KAAK,6BAA6B,EAClC,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,KAAK,uBAAuB,EAC5B,KAAK,4BAA4B,EACjC,KAAK,gBAAgB,EACrB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,wBAAwB,EACxB,wBAAwB,EACxB,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,aAAa,EACb,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,EAClB,sBAAsB,EACtB,uBAAuB,EACvB,eAAe,EACf,kBAAkB,EAClB,oBAAoB,EACpB,uBAAuB,EACvB,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,uBAAuB,CAAA;AAE9B,eAAO,MAAM,KAAK;;;;CAIR,CAAA;AAEV,OAAO,EACL,kBAAkB,EAClB,KAAK,sBAAsB,EAC5B,MAAM,kBAAkB,CAAA"}

package/dist/index.js

@@ -1,3 +1,4 @@
+export { formatConsumerRollout, inspectLumenConsumer, runConsumerRollout, updateLumenManifestSource, updateLumenWorkspaceSource } from './consumer-rollout.js';
 export { addLumenRegistryItem, getLumenRegistryEntries, getLumenRegistryItem, loadLumenRegistry, lumenRegistry } from './registry.js';
 export { applyDataViewState, canPlaceScheduleEvent, coerceThemeBuilderExportFormat, coerceThemeBuilderMode, coerceThemeBuilderScheme, composeClassName, createDataViewRequestUrl, createDataViewSearchParams, createDataViewServerRequest, createDataViewState, createDataViewStorageKey, createScheduleSlots, createScheduleStorageKey, createThemeBuilderTokens, createThemePalette, expandRecurringScheduleEvent, exportThemeBuilderCss, exportThemeBuilderValue, exportThemeCss, filterDataRecords, getContrastRatio, getScheduleConflicts, getVirtualRange, loadDataViewState, loadScheduleEvents, lumenCodeTokenClassNames, lumenColors, lumenColorTokenNames, lumenComponentNames, lumenDarkTheme, lumenGlass, lumenGlassColorTokenNames, lumenGlassEffectTokenNames, lumenGlassTokenNames, lumenLightTheme, lumenPackages, lumenSemanticColorTokenNames, lumenThemeAttribute, lumenTokenNames, mergeThemeTokens, moveScheduleEvent, normalizeLumenCode, normalizeThemeBuilderHex, normalizeThemeBuilderHue, paginateDataRecords, parseDataViewState, parseScheduleEvents, parseThemeCss, pinDataViewColumn, renderLumenCodeHtml, resizeScheduleEvent, resizeScheduleEvents, saveDataViewState, saveScheduleEvents, scheduleEventsOverlap, scoreThemeContrast, serializeDataViewState, serializeScheduleEvents, sortDataRecords, suggestReadableInk, themeBuilderHexToHsl, toggleDataViewSelection, tokenizeLumenCode, tuneThemeContrast, unpinDataViewColumn } from '@santi020k/lumen-core';
 export const lumen = {
@@ -5,3 +6,4 @@ export const lumen = {
     packageName: '@santi020k/lumen',
     scope: '@santi020k'
 };
+export { auditLumenTokenCss } from './token-audit.js';

package/dist/registry-data.d.ts

@@ -39,7 +39,7 @@ export declare const lumenRegistry: {
     readonly components: readonly [{
         readonly name: "Accordion";
         readonly type: "component";
-        readonly description: "Stacks collapsible content sections.";
+        readonly description: "Stacks collapsible content sections as cards or a compact flush list.";
         readonly category: "Layout";
         readonly files: readonly ["packages/astro/components/Accordion.astro", "packages/astro/styles/lumen.css"];
         readonly dependencies: readonly ["styles"];
@@ -190,6 +190,13 @@ export declare const lumenRegistry: {
         readonly category: "Data display";
         readonly files: readonly ["packages/astro/components/Code.astro", "packages/astro/styles/lumen.css", "packages/astro/runtime/UIPrimitives.astro"];
         readonly dependencies: readonly ["styles", "runtime"];
+    }, {
+        readonly name: "CodeTabs";
+        readonly type: "component";
+        readonly description: "Groups related code examples into accessible, persistent tabs.";
+        readonly category: "Data display";
+        readonly files: readonly ["packages/astro/components/CodeTabs.astro", "packages/astro/components/Code.astro", "packages/astro/components/Tabs.astro", "packages/astro/styles/lumen.css", "packages/astro/runtime/UIPrimitives.astro"];
+        readonly dependencies: readonly ["Code", "Tabs", "styles", "runtime"];
     }, {
         readonly name: "Combobox";
         readonly type: "component";
@@ -697,19 +704,22 @@ export declare const lumenRegistry: {
         readonly type: "component";
         readonly category: "Data display";
         readonly description: "Animates a formatted metric while keeping one stable accessible value.";
-        readonly files: readonly ["packages/astro/components/AnimatedNumber.astro", "packages/react/src/components.tsx"];
+        readonly files: readonly ["packages/astro/components/AnimatedNumber.astro", "packages/astro/runtime/UIPrimitives.astro", "packages/astro/styles/lumen.css", "packages/react/src/components.tsx"];
+        readonly dependencies: readonly ["styles", "runtime"];
     }, {
         readonly name: "RevealGroup";
         readonly type: "component";
         readonly category: "Layout";
         readonly description: "Reveals a group of direct children with tokenized, reduced-motion-aware staggering.";
-        readonly files: readonly ["packages/astro/components/RevealGroup.astro", "packages/react/src/components.tsx"];
+        readonly files: readonly ["packages/astro/components/RevealGroup.astro", "packages/astro/runtime/UIPrimitives.astro", "packages/astro/styles/lumen.css", "packages/react/src/components.tsx"];
+        readonly dependencies: readonly ["styles", "runtime"];
     }, {
         readonly name: "ScrollReveal";
         readonly type: "component";
         readonly category: "Layout";
-        readonly description: "A Scroll Reveal component.";
-        readonly files: readonly ["packages/astro/components/ScrollReveal.astro", "packages/react/src/components.tsx"];
+        readonly description: "Animates wrapped content as it first enters the viewport.";
+        readonly files: readonly ["packages/astro/components/ScrollReveal.astro", "packages/astro/runtime/UIPrimitives.astro", "packages/astro/styles/lumen.css", "packages/react/src/components.tsx"];
+        readonly dependencies: readonly ["styles", "runtime"];
     }, {
         readonly name: "Stat";
         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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuqDQ,CAAA"}
+{"version":3,"file":"registry-data.d.ts","sourceRoot":"","sources":["../src/registry-data.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4sDQ,CAAA"}

package/dist/registry-data.js

@@ -98,7 +98,7 @@ export const lumenRegistry = {
         {
             "name": "Accordion",
             "type": "component",
-            "description": "Stacks collapsible content sections.",
+            "description": "Stacks collapsible content sections as cards or a compact flush list.",
             "category": "Layout",
             "files": [
                 "packages/astro/components/Accordion.astro",
@@ -393,6 +393,25 @@ export const lumenRegistry = {
                 "runtime"
             ]
         },
+        {
+            "name": "CodeTabs",
+            "type": "component",
+            "description": "Groups related code examples into accessible, persistent tabs.",
+            "category": "Data display",
+            "files": [
+                "packages/astro/components/CodeTabs.astro",
+                "packages/astro/components/Code.astro",
+                "packages/astro/components/Tabs.astro",
+                "packages/astro/styles/lumen.css",
+                "packages/astro/runtime/UIPrimitives.astro"
+            ],
+            "dependencies": [
+                "Code",
+                "Tabs",
+                "styles",
+                "runtime"
+            ]
+        },
         {
             "name": "Combobox",
             "type": "component",
@@ -1417,7 +1436,13 @@ export const lumenRegistry = {
             "description": "Animates a formatted metric while keeping one stable accessible value.",
             "files": [
                 "packages/astro/components/AnimatedNumber.astro",
+                "packages/astro/runtime/UIPrimitives.astro",
+                "packages/astro/styles/lumen.css",
                 "packages/react/src/components.tsx"
+            ],
+            "dependencies": [
+                "styles",
+                "runtime"
             ]
         },
         {
@@ -1427,17 +1452,29 @@ export const lumenRegistry = {
             "description": "Reveals a group of direct children with tokenized, reduced-motion-aware staggering.",
             "files": [
                 "packages/astro/components/RevealGroup.astro",
+                "packages/astro/runtime/UIPrimitives.astro",
+                "packages/astro/styles/lumen.css",
                 "packages/react/src/components.tsx"
+            ],
+            "dependencies": [
+                "styles",
+                "runtime"
             ]
         },
         {
             "name": "ScrollReveal",
             "type": "component",
             "category": "Layout",
-            "description": "A Scroll Reveal component.",
+            "description": "Animates wrapped content as it first enters the viewport.",
             "files": [
                 "packages/astro/components/ScrollReveal.astro",
+                "packages/astro/runtime/UIPrimitives.astro",
+                "packages/astro/styles/lumen.css",
                 "packages/react/src/components.tsx"
+            ],
+            "dependencies": [
+                "styles",
+                "runtime"
             ]
         },
         {

package/dist/token-audit.d.ts

@@ -0,0 +1,9 @@
+export interface LumenTokenAuditFinding {
+    column: number;
+    file: string;
+    line: number;
+    token: string;
+    value: string;
+}
+export declare const auditLumenTokenCss: (source: string, file?: string) => LumenTokenAuditFinding[];
+//# sourceMappingURL=token-audit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"token-audit.d.ts","sourceRoot":"","sources":["../src/token-audit.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd;AAMD,eAAO,MAAM,kBAAkB,GAAI,QAAQ,MAAM,EAAE,aAAgB,KAAG,sBAAsB,EAwB3F,CAAA"}

package/dist/token-audit.js

@@ -0,0 +1,25 @@
+import { lumenSemanticColorTokenNames } from '@santi020k/lumen-core';
+const declarationPattern = /--([a-z][\w-]*)\s*:\s*([^;}\n]+)/giu;
+const channelPattern = /^(?:var\(.+\)|-?(?:\d+(?:\.\d+)?|\.\d+)(?:deg|grad|rad|turn)?\s+-?(?:\d+(?:\.\d+)?|\.\d+)%\s+-?(?:\d+(?:\.\d+)?|\.\d+)%(?:\s*\/\s*(?:\d+(?:\.\d+)?|\.\d+)%?)?)$/iu;
+const semanticTokens = new Set(lumenSemanticColorTokenNames);
+export const auditLumenTokenCss = (source, file = '<input>') => {
+    const findings = [];
+    for (const match of source.matchAll(declarationPattern)) {
+        const token = match[1];
+        const value = match[2]?.trim();
+        if (!token || !value || !semanticTokens.has(token) || channelPattern.test(value))
+            continue;
+        const index = match.index;
+        const before = source.slice(0, index);
+        const line = before.split('\n').length;
+        const lineStart = before.lastIndexOf('\n') + 1;
+        findings.push({
+            column: index - lineStart + 1,
+            file,
+            line,
+            token,
+            value
+        });
+    }
+    return findings;
+};

package/layers.css

@@ -0,0 +1,5 @@
+/*
+ * Import before Tailwind and Lumen so Tailwind base styles run before Lumen components while
+ * Tailwind utilities remain able to override component presentation.
+ */
+@layer theme, base, lumen.tokens, lumen.base, components, lumen.components, lumen.glass, utilities;

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@santi020k/lumen",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "publishConfig": {
     "access": "public"
   },
   "description": "Umbrella package for the Lumen multi-framework primitive UI system.",
   "type": "module",
   "sideEffects": [
+    "./layers.css",
     "./styles.css"
   ],
   "main": "./dist/index.js",
@@ -22,11 +23,13 @@
       "import": "./dist/registry.js"
     },
     "./styles.css": "./styles.css",
+    "./layers.css": "./layers.css",
     "./package.json": "./package.json"
   },
   "files": [
     "bin",
     "dist",
+    "layers.css",
     "styles.css",
     "README.md",
     "LICENSE"
@@ -35,16 +38,19 @@
     "lumen": "./bin/lumen.mjs"
   },
   "dependencies": {
-    "@santi020k/lumen-core": "^0.1.0"
+    "semver": "^7.8.0",
+    "@santi020k/lumen-core": "^0.3.0"
   },
   "devDependencies": {
     "@types/node": "^26.1.1",
+    "@types/semver": "^7.7.1",
     "@vitest/coverage-v8": "^4.1.10",
     "typescript": "^6.0.3",
+    "tailwindcss": "^4.3.3",
     "vitest": "^4.1.10"
   },
   "engines": {
-    "node": ">=22.18.0"
+    "node": ">=22.12.0"
   },
   "repository": {
     "type": "git",

package/styles.css

@@ -264,7 +264,7 @@
   font-family: var(--ui-font);
 }
 
-:where(.ui-button, .ui-back-to-top, .ui-code__copy, .ui-input, .ui-language-toggle, .ui-link, .ui-select, .ui-skip-link, .ui-textarea, .ui-checkbox, .ui-switch, .ui-toggle, .ui-slider, .ui-color-picker, .ui-resizable__handle):focus-visible {
+:where(.ui-button, .ui-back-to-top, .ui-code__copy, .ui-input, .ui-language-toggle, .ui-link, .ui-select, .ui-skip-link, .ui-textarea, .ui-checkbox, .ui-switch, .ui-toggle, .ui-theme-toggle, .ui-slider, .ui-color-picker, .ui-resizable__handle):focus-visible {
   outline: 2px solid hsl(var(--brand));
   outline-offset: 2px;
 }
@@ -623,6 +623,11 @@
   background: hsl(var(--surface-muted) / 0.72);
 }
 
+.ui-card--unstyled,
+.ui-button-link--unstyled {
+  all: revert-layer;
+}
+
 .ui-card--glass.ui-card--interactive:hover,
 .ui-card--glass.card-interactive:hover {
   border-color: hsl(var(--glass-edge));
@@ -881,6 +886,15 @@
   color: hsl(var(--brand-solid));
 }
 
+.ui-link--inherit {
+  color: inherit;
+  font-weight: inherit;
+}
+
+.ui-link--inherit:hover {
+  color: inherit;
+}
+
 .ui-prose {
   max-width: 65ch;
   color: hsl(var(--ink-soft));
@@ -1702,31 +1716,184 @@
 
 .ui-accordion {
   display: grid;
-  gap: 0.5rem;
+  gap: 0.75rem;
 }
 
 .ui-accordion details,
 .ui-collapsible {
+  overflow: clip;
   border: 1px solid hsl(var(--line));
-  border-radius: var(--ui-radius);
+  border-radius: var(--ui-radius-lg);
   background: hsl(var(--surface));
   color: hsl(var(--ink-soft));
-  padding: 0.85rem 1rem;
+  box-shadow: var(--ui-shadow-sm);
+  transition:
+    border-color var(--ui-duration-fast) var(--ui-ease),
+    box-shadow var(--ui-duration-fast) var(--ui-ease);
+}
+
+.ui-accordion details[open],
+.ui-collapsible[open] {
+  border-color: hsl(var(--brand) / 0.38);
+  box-shadow:
+    0 0 0 1px hsl(var(--brand) / 0.08),
+    var(--ui-shadow-sm);
+}
+
+.ui-accordion--flush {
+  gap: 0;
+  border-top: 1px solid hsl(var(--line));
+}
+
+.ui-accordion--flush details {
+  overflow: visible;
+  border: 0;
+  border-bottom: 1px solid hsl(var(--line));
+  border-radius: 0;
+  background: transparent;
+  box-shadow: none;
+}
+
+.ui-accordion--flush details[open] {
+  border-color: hsl(var(--line));
+  background: transparent;
+  box-shadow: none;
 }
 
 .ui-accordion summary,
 .ui-collapsible summary {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 1rem;
   cursor: pointer;
+  list-style: none;
   color: hsl(var(--ink));
   font-weight: 650;
+  line-height: 1.35;
+  min-height: 3.5rem;
+  padding: 1rem 1.125rem;
+  transition:
+    background-color var(--ui-duration-fast) var(--ui-ease),
+    color var(--ui-duration-fast) var(--ui-ease);
+}
+
+.ui-accordion summary:hover,
+.ui-collapsible summary:hover {
+  background: hsl(var(--surface-muted));
+}
+
+.ui-accordion details[open] > summary,
+.ui-collapsible[open] > summary {
+  color: hsl(var(--brand));
+}
+
+.ui-accordion details[open],
+.ui-collapsible[open] {
+  padding-block-end: 1rem;
+}
+
+.ui-accordion details > :not(summary),
+.ui-collapsible > :not(summary) {
+  margin-inline: 1.125rem;
+}
+
+.ui-accordion summary::-webkit-details-marker,
+.ui-collapsible summary::-webkit-details-marker {
+  display: none;
+}
+
+.ui-accordion summary::after,
+.ui-collapsible summary::after {
+  width: 0.5rem;
+  height: 0.5rem;
+  border-right: 1.5px solid hsl(var(--ink-muted));
+  border-bottom: 1.5px solid hsl(var(--ink-muted));
+  content: "";
+  border-radius: 1px;
+  box-shadow: 0 0 0 0.45rem hsl(var(--surface-muted));
+  transform: rotate(45deg) translate(-0.1rem, -0.1rem);
+  transition:
+    border-color var(--ui-duration-fast) var(--ui-ease),
+    box-shadow var(--ui-duration-fast) var(--ui-ease),
+    transform var(--ui-duration-fast) var(--ui-ease);
+}
+
+.ui-accordion details[open] > summary::after,
+.ui-collapsible[open] > summary::after {
+  border-color: hsl(var(--brand));
+  box-shadow: 0 0 0 0.45rem hsl(var(--brand-soft));
+  transform: rotate(225deg) translate(-0.1rem, -0.1rem);
+}
+
+.ui-accordion summary:hover::after,
+.ui-collapsible summary:hover::after {
+  border-color: hsl(var(--brand));
+  box-shadow: 0 0 0 0.45rem hsl(var(--brand-soft));
+}
+
+.ui-accordion summary:focus-visible,
+.ui-collapsible summary:focus-visible {
+  border-radius: calc(var(--ui-radius-lg) - 1px);
+  outline: 2px solid hsl(var(--brand));
+  outline-offset: -3px;
+}
+
+.ui-accordion--flush details[open] {
+  padding-block-end: 1.25rem;
+}
+
+.ui-accordion--flush summary {
+  min-height: 4rem;
+  padding: 1.125rem 0.25rem;
+}
+
+.ui-accordion--flush summary:hover {
+  border-radius: var(--ui-radius);
+  background: hsl(var(--surface-muted) / 0.72);
+  box-shadow: 0 0 0 0.625rem hsl(var(--surface-muted) / 0.72);
+}
+
+.ui-accordion--flush details[open] > summary {
+  color: hsl(var(--ink));
+}
+
+.ui-accordion--flush details > :not(summary) {
+  margin-inline: 0.25rem;
+}
+
+.ui-accordion--flush details[open] > summary::before {
+  width: 0.2rem;
+  height: 1.25rem;
+  border-radius: 999px;
+  background: hsl(var(--brand));
+  content: "";
+  position: absolute;
+  inset-inline-start: -0.875rem;
+}
+
+.ui-accordion--flush summary {
+  position: relative;
 }
 
 .ui-accordion p,
 .ui-collapsible p {
+  color: hsl(var(--ink-soft));
   margin-block-end: 0;
   line-height: 1.6;
 }
 
+@media (prefers-reduced-motion: reduce) {
+  .ui-accordion details,
+  .ui-collapsible,
+  .ui-accordion summary,
+  .ui-collapsible summary,
+  .ui-accordion summary::after,
+  .ui-collapsible summary::after {
+    transition: none;
+  }
+}
+
 .ui-dialog,
 .ui-alert-dialog,
 .ui-drawer,
@@ -1752,6 +1919,19 @@
   transform: translate(-50%, -50%);
 }
 
+.ui-dialog--fullscreen {
+  inset: 0;
+  width: 100%;
+  max-width: none;
+  height: 100dvh;
+  max-height: none;
+  margin: 0;
+  border: 0;
+  border-radius: 0;
+  padding: 0;
+  transform: none;
+}
+
 .ui-dialog::backdrop,
 .ui-alert-dialog::backdrop,
 .ui-drawer::backdrop,
@@ -1944,6 +2124,19 @@
   color: hsl(var(--ink));
 }
 
+.ui-navigation-menu--unstyled {
+  all: revert-layer;
+}
+
+.ui-navigation-menu--unstyled :where(a, button) {
+  all: revert-layer;
+}
+
+.ui-navigation-menu--unstyled :where(a, button):hover,
+.ui-navigation-menu--unstyled :where(a, button)[aria-current="page"] {
+  all: revert-layer;
+}
+
 .ui-breadcrumb {
   color: hsl(var(--ink-muted));
   font-size: 0.875rem;
@@ -2100,6 +2293,96 @@
   color: hsl(var(--ink-soft));
 }
 
+.ui-code-tabs {
+  display: block;
+  overflow: hidden;
+  border: 1px solid hsl(var(--line));
+  border-radius: var(--ui-radius-lg);
+  background: hsl(var(--surface-muted));
+}
+
+.ui-code-tabs .ui-code-tabs__list {
+  display: flex;
+  width: auto;
+  gap: 0.25rem;
+  border: 0;
+  border-bottom: 1px solid hsl(var(--line));
+  border-radius: 0;
+  background: hsl(var(--surface));
+  padding: 0.375rem;
+}
+
+.ui-code-tabs .ui-code-tabs__tab {
+  min-width: 4.25rem;
+  border: 0;
+  border-radius: var(--ui-radius-sm);
+  background: transparent;
+  color: hsl(var(--ink-muted));
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
+  font-size: 0.8125rem;
+  font-weight: 500;
+  padding: 0.5rem 0.875rem;
+  transition:
+    background-color 150ms ease,
+    color 150ms ease;
+}
+
+.ui-code-tabs .ui-code-tabs__tab:hover {
+  background: hsl(var(--surface-muted));
+  color: hsl(var(--ink));
+}
+
+.ui-code-tabs .ui-code-tabs__tab[aria-selected="true"] {
+  background: hsl(var(--brand-soft));
+  box-shadow: none;
+  color: hsl(var(--brand));
+}
+
+.ui-code-tabs .ui-code-tabs__tab:focus-visible {
+  outline: 2px solid hsl(var(--brand));
+  outline-offset: 1px;
+}
+
+.ui-code-tabs .ui-code-tabs__panel {
+  color: hsl(var(--ink));
+}
+
+.ui-code-tabs .ui-code--block {
+  margin: 0;
+  border: 0;
+  border-radius: 0;
+  background: transparent;
+  box-shadow: none;
+}
+
+.ui-code-tabs .ui-code__header {
+  position: absolute;
+  z-index: 1;
+  inset-block-start: 0.75rem;
+  inset-inline-end: 0.75rem;
+  display: block;
+  min-height: 0;
+  border: 0;
+  background: transparent;
+  padding: 0;
+}
+
+.ui-code-tabs .ui-code__dots,
+.ui-code-tabs .ui-code__meta {
+  display: none;
+}
+
+.ui-code-tabs .ui-code--block :where(pre) {
+  min-height: 3.5rem;
+  padding: 1rem 3.75rem 1rem 1.25rem;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .ui-code-tabs .ui-code-tabs__tab {
+    transition: none;
+  }
+}
+
 .ui-table-wrap,
 .ui-data-table {
   width: 100%;
@@ -2314,6 +2597,16 @@
   color: hsl(var(--brand-solid));
 }
 
+.ui-sidebar--unstyled {
+  all: revert-layer;
+}
+
+.ui-sidebar--unstyled a,
+.ui-sidebar--unstyled a:hover,
+.ui-sidebar--unstyled a[aria-current="page"] {
+  all: revert-layer;
+}
+
 .ui-empty {
   display: grid;
   place-items: center;
@@ -2452,6 +2745,9 @@
 .ui-code--block {
   position: relative;
   overflow: hidden;
+  width: 100%;
+  max-width: 100%;
+  min-width: 0;
   margin: 0;
   border: 1px solid var(--ui-code-border);
   border-radius: var(--ui-radius-lg);
@@ -2601,6 +2897,16 @@
   white-space: pre;
 }
 
+.ui-code--wrap :where(pre) {
+  overflow-x: hidden;
+}
+
+.ui-code--wrap :where(code) {
+  min-width: 0;
+  overflow-wrap: anywhere;
+  white-space: pre-wrap;
+}
+
 .ui-code--block :where(code span) {
   color: var(--shiki-light, var(--ui-code-token, var(--ui-code-fg)));
   font-style: var(--shiki-light-font-style, var(--ui-code-token-font-style, normal));
@@ -4009,6 +4315,16 @@
     }
   }
 
+  .ui-dialog--fullscreen:not([open]) {
+    transform: none;
+  }
+
+  @starting-style {
+    .ui-dialog--fullscreen[open] {
+      transform: none;
+    }
+  }
+
   .ui-drawer {
     transition:
       opacity var(--ui-duration) var(--ui-ease),
@@ -4584,6 +4900,16 @@
   font-variant-numeric: tabular-nums;
 }
 
+a.ui-pill {
+  cursor: pointer;
+  text-decoration: none;
+}
+
+a.ui-pill:hover {
+  border-color: hsl(var(--brand) / 0.42);
+  color: hsl(var(--brand-solid));
+}
+
 /* CoverImage hover lift + bottom gradient overlay */
 .ui-cover-image--hover {
   transition: transform 300ms ease;