@santi020k/lumen 0.2.0 → 0.3.0

package/README.md

@@ -36,3 +36,27 @@ 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,5 +1,6 @@
 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);
@@ -17,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.');
@@ -123,6 +153,7 @@ const help = [
     '  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',
@@ -133,6 +164,11 @@ 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.
@@ -159,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: {

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;AAEV,OAAO,EACL,kBAAkB,EAClB,KAAK,sBAAsB,EAC5B,MAAM,kBAAkB,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 = {

package/dist/registry-data.d.ts

@@ -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";

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyrDQ,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

@@ -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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@santi020k/lumen",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "publishConfig": {
     "access": "public"
   },
@@ -38,10 +38,12 @@
     "lumen": "./bin/lumen.mjs"
   },
   "dependencies": {
-    "@santi020k/lumen-core": "^0.2.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",

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;
 }
@@ -1716,16 +1716,28 @@
 
 .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 {
@@ -1734,11 +1746,18 @@
 }
 
 .ui-accordion--flush details {
+  overflow: visible;
   border: 0;
   border-bottom: 1px solid hsl(var(--line));
   border-radius: 0;
   background: transparent;
-  padding: 1.25rem 0;
+  box-shadow: none;
+}
+
+.ui-accordion--flush details[open] {
+  border-color: hsl(var(--line));
+  background: transparent;
+  box-shadow: none;
 }
 
 .ui-accordion summary,
@@ -1751,6 +1770,32 @@
   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,
@@ -1765,33 +1810,90 @@
   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: transform var(--ui-duration-fast) var(--ui-ease-standard);
+  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) * 0.6);
+  border-radius: calc(var(--ui-radius-lg) - 1px);
   outline: 2px solid hsl(var(--brand));
-  outline-offset: 0.35rem;
+  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,
@@ -1817,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,
@@ -2178,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%;
@@ -4110,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),