@reforma/project-tokens 0.0.1

package/dist/compilation/compiler.d.ts

@@ -0,0 +1,61 @@
+import type { DtcgTokenType, TokenAuthoring, TokenEditingProfile, TokenGroup } from '../authoring.js';
+export { DTCG_TOKEN_TYPES } from '../authoring.js';
+export type { DtcgTokenType } from '../authoring.js';
+export interface TokenDiagnostic {
+    severity: 'error' | 'warning';
+    code: string;
+    message: string;
+    file?: string;
+    pointer?: string;
+    input?: Record<string, string>;
+    expectedType?: DtcgTokenType;
+    actualType?: unknown;
+}
+export interface TokenDependency {
+    path: string;
+    hash: string | null;
+}
+export interface TokenSource {
+    file: string;
+    pointer: string;
+}
+export interface ProjectToken {
+    path: string;
+    type: DtcgTokenType;
+    value: unknown;
+    css: Record<string, string>;
+    source: TokenSource;
+    description?: string;
+    deprecated?: boolean | string;
+    authoring?: TokenAuthoring;
+}
+export interface TokenPermutation {
+    input: Record<string, string>;
+    selector: string;
+    tokens: ProjectToken[];
+    groups?: TokenGroup[];
+}
+export interface TokenCompilationOptions {
+    workspaceRoot: string;
+    entry?: string;
+    /** Required values for modifiers without a default. */
+    input?: Record<string, string>;
+    /** In-memory candidate files, keyed by workspace-relative path. Never persisted by compilation. */
+    documents?: Readonly<Record<string, string>>;
+}
+export interface TokenCompilation {
+    ok: boolean;
+    diagnostics: TokenDiagnostic[];
+    dependencies: TokenDependency[];
+    revision: string;
+    permutations: TokenPermutation[];
+    editing?: TokenEditingProfile;
+    output?: {
+        tokensCss: string;
+        tailwindCss: string;
+        modesJson: string;
+    };
+}
+/** Compile canonical project files without changing source or generated output. */
+export declare function compileProjectTokens(options: TokenCompilationOptions): Promise<TokenCompilation>;
+//# sourceMappingURL=compiler.d.ts.map

package/dist/compilation/compiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../../src/compilation/compiler.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAEtG,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,YAAY,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,MAAM,WAAW,eAAe;IAC5B,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,YAAY,CAAC,EAAE,aAAa,CAAC;IAC7B,UAAU,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED,MAAM,WAAW,WAAW;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,aAAa,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,MAAM,EAAE,WAAW,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC9B,SAAS,CAAC,EAAE,cAAc,CAAC;CAC9B;AAED,MAAM,WAAW,gBAAgB;IAC7B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,MAAM,CAAC,EAAE,UAAU,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,uBAAuB;IACpC,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uDAAuD;IACvD,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,mGAAmG;IACnG,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAChD;AAED,MAAM,WAAW,gBAAgB;IAC7B,EAAE,EAAE,OAAO,CAAC;IACZ,WAAW,EAAE,eAAe,EAAE,CAAC;IAC/B,YAAY,EAAE,eAAe,EAAE,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,gBAAgB,EAAE,CAAC;IACjC,OAAO,CAAC,EAAE,mBAAmB,CAAC;IAC9B,MAAM,CAAC,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CAC1E;AAUD,mFAAmF;AACnF,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAiStG"}

package/dist/compilation/compiler.js

@@ -0,0 +1,254 @@
+import { defineConfig, Logger, parse } from '@terrazzo/parser';
+import { createHash } from 'node:crypto';
+import { readFile, realpath } from 'node:fs/promises';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { describeTokenAuthoring, getTokenEditingProfile } from '../authoring.js';
+import { loadTokenSources } from '../source/load.js';
+import { collectTokenDefinitions, createTerrazzoSource, fromTerrazzoTokenValue } from './definitions.js';
+import { validateComposedTokenScopes, validateTokenScopes } from './scope-validation.js';
+import { validateAuthoredColorValues, validateTokenValue } from './validation.js';
+import { buildWebProjection, createPermutationSelector, serializeTokenCss, } from './web-projection.js';
+export { DTCG_TOKEN_TYPES } from '../authoring.js';
+function hash(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function compareNames(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+/** Compile canonical project files without changing source or generated output. */
+export async function compileProjectTokens(options) {
+    const diagnostics = [];
+    const files = new Map();
+    const documents = new Map();
+    const reads = new Map();
+    const permutations = [];
+    let editing;
+    let projection;
+    const root = await realpath(options.workspaceRoot).catch(() => resolve(options.workspaceRoot));
+    const entry = pathToFileURL(resolve(root, options.entry ?? '.reforma/tokens/tokens.resolver.json'));
+    const local = (filename) => relative(root, filename).split(sep).join('/');
+    const fail = (code, message, source) => {
+        diagnostics.push({ severity: 'error', code, message, ...source });
+        throw new Error(message);
+    };
+    const load = async (url) => {
+        if (url.protocol !== 'file:' || url.host || url.search) {
+            fail('REFERENCE_REMOTE', `Only local workspace references are supported: ${url.href}`);
+        }
+        const filename = fileURLToPath(url);
+        const path = local(filename);
+        if (path === '..' || path.startsWith('../') || isAbsolute(path)) {
+            fail('REFERENCE_OUTSIDE_WORKSPACE', `Reference escapes the workspace: ${path}`);
+        }
+        if (!reads.has(path)) {
+            const reading = (async () => {
+                files.set(path, null);
+                const actualFilename = await realpath(filename).catch((error) => {
+                    if (error.code === 'ENOENT'
+                        && Object.hasOwn(options.documents ?? {}, path)) {
+                        return filename;
+                    }
+                    throw error;
+                });
+                const actual = local(actualFilename);
+                if (actual === '..' || actual.startsWith('../') || isAbsolute(actual)) {
+                    fail('REFERENCE_OUTSIDE_WORKSPACE', `Symlink escapes the workspace: ${path}`);
+                }
+                const src = Object.hasOwn(options.documents ?? {}, path)
+                    ? options.documents[path]
+                    : await readFile(actualFilename, 'utf8');
+                files.set(path, src);
+                try {
+                    documents.set(path, JSON.parse(src));
+                }
+                catch {
+                    fail('INVALID_JSON', 'Expected strict JSON.', { file: path, pointer: '' });
+                }
+                return src;
+            })();
+            reads.set(path, reading);
+        }
+        return reads.get(path);
+    };
+    let activeInput;
+    let tokenPaths = [];
+    const logger = new Logger({ level: 'silent' });
+    logger.error = (...entries) => {
+        for (const log of entries) {
+            diagnostics.push({
+                severity: 'error',
+                code: 'DTCG_INVALID',
+                message: log.message.replace(/token(\d+)/g, (id, index) => tokenPaths[Number(index)] ?? id),
+                file: local(fileURLToPath(entry)),
+                input: activeInput,
+            });
+        }
+        throw new Error(entries[0]?.message);
+    };
+    logger.warn = (...entries) => {
+        for (const log of entries) {
+            diagnostics.push({
+                severity: 'warning',
+                code: 'DTCG_WARNING',
+                message: log.message.replace(/token(\d+)/g, (id, index) => tokenPaths[Number(index)] ?? id),
+                file: local(fileURLToPath(entry)),
+                input: activeInput,
+            });
+        }
+    };
+    try {
+        const source = await loadTokenSources(entry, async (url) => {
+            await load(url);
+            return documents.get(local(fileURLToPath(url)));
+        }, url => local(fileURLToPath(url)), diagnostics);
+        editing = getTokenEditingProfile({ workspaceRoot: root, entry: local(fileURLToPath(entry)) }, documents);
+        const modifiers = source.items.filter((item) => item.type === 'modifier');
+        const defaultInput = Object.create(null);
+        for (const modifier of modifiers) {
+            const value = options.input?.[modifier.name] ?? modifier.default;
+            if (typeof value !== 'string' || !Object.hasOwn(modifier.contexts, value)) {
+                fail('INPUT_INVALID', `Select a valid context for modifier ${modifier.name}.`);
+            }
+            defaultInput[modifier.name] = value;
+        }
+        for (const name of Object.keys(options.input ?? {})) {
+            if (!modifiers.some(modifier => modifier.name === name)) {
+                fail('INPUT_INVALID', `Unknown modifier ${name}.`);
+            }
+        }
+        let inputs = [{}];
+        for (const modifier of modifiers) {
+            const contexts = Object.keys(modifier.contexts);
+            if (inputs.length * contexts.length > 1000) {
+                fail('PERMUTATION_LIMIT', 'At most 1000 permutations can be compiled.');
+            }
+            inputs = inputs.flatMap(input => contexts.map(context => ({
+                ...input,
+                [modifier.name]: context,
+            })));
+        }
+        const isDefault = (input) => (Object.keys(defaultInput).every(key => input[key] === defaultInput[key]));
+        inputs.sort((left, right) => Number(isDefault(right)) - Number(isDefault(left)));
+        const managedProfile = editing.supported ? editing : undefined;
+        const managedBase = managedProfile ? await source.compose({ mode: managedProfile.defaultMode }) : undefined;
+        if (editing.supported && managedBase) {
+            const issues = validateTokenScopes(documents, editing, managedBase);
+            diagnostics.push(...issues);
+            if (issues.length > 0) {
+                editing = { supported: false, reason: { code: 'INVALID_SCOPE', message: issues[0].message } };
+            }
+        }
+        const names = new Map();
+        for (const input of inputs) {
+            activeInput = input;
+            const composed = await source.compose(input);
+            if (managedBase && managedProfile) {
+                const issues = validateComposedTokenScopes(composed, managedBase, input, documents, managedProfile, root);
+                diagnostics.push(...issues);
+                if (issues.length > 0) {
+                    editing = { supported: false, reason: { code: 'INVALID_SCOPE', message: issues[0].message } };
+                }
+            }
+            // Neutral internal IDs let Terrazzo parse legal names such as constructor and __proto__.
+            const { definitions, groups } = collectTokenDefinitions(composed, documents);
+            for (const definition of definitions) {
+                if (!validateAuthoredColorValues(definition.token.$type, definition.token.$value)) {
+                    fail('DTCG_VALUE', `Invalid authored DTCG ${definition.token.$type} color value for ${definition.path}.`, definition.token.$extensions?.['ai.reforma.compiler']);
+                }
+            }
+            tokenPaths = definitions.map(definition => definition.path);
+            const parserSource = createTerrazzoSource(definitions);
+            const config = defineConfig({}, { cwd: pathToFileURL(`${root}/`), logger });
+            config.lint.rules['core/consistent-naming'] = ['off', {}];
+            // Terrazzo still models missing color channels as null and only permits them in hue positions.
+            // The DTCG 2025.10 contract permits the "none" keyword in every component; validate it below.
+            config.lint.rules['core/valid-color'] = ['off', {}];
+            const { tokens: tokensSet } = await parse([{ filename: entry, src: parserSource }], { config, logger, req: load });
+            const tokens = [];
+            for (const token of Object.values(tokensSet)) {
+                const path = tokenPaths[Number(token.id.slice(5))];
+                const value = fromTerrazzoTokenValue(token.$type, token.$value);
+                if (!validateTokenValue(token.$type, value)) {
+                    fail('DTCG_VALUE', `Invalid final DTCG ${token.$type} value for ${path}.`, token.$extensions?.['ai.reforma.compiler']);
+                }
+                const css = serializeTokenCss(token, path, tokensSet, input);
+                for (const key of Object.keys(css)) {
+                    if (names.has(key) && names.get(key) !== path) {
+                        fail('CSS_COLLISION', `${path} and ${names.get(key)} both map to ${key}.`);
+                    }
+                    names.set(key, path);
+                }
+                const resolved = definitions[Number(token.id.slice(5))].token;
+                const result = {
+                    path,
+                    type: token.$type,
+                    value,
+                    css,
+                    source: token.$extensions?.['ai.reforma.compiler'],
+                    description: resolved.$description,
+                    deprecated: resolved.$deprecated ?? false,
+                };
+                result.authoring = describeTokenAuthoring(result, documents, input.mode, editing);
+                tokens.push(result);
+            }
+            const selector = createPermutationSelector(input);
+            permutations.push({ input, selector, tokens, groups });
+        }
+        if (!diagnostics.some(diagnostic => diagnostic.severity === 'error')) {
+            projection = buildWebProjection(permutations, names.keys(), defaultInput, modifiers);
+        }
+    }
+    catch (error) {
+        if (!diagnostics.some(diagnostic => diagnostic.severity === 'error')) {
+            diagnostics.push({
+                severity: 'error',
+                code: 'COMPILE_FAILED',
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    const dependencies = [...files]
+        .sort(([left], [right]) => compareNames(left, right))
+        .map(([path, text]) => ({
+        path,
+        hash: text === null ? null : hash(text),
+    }));
+    if (editing?.supported && diagnostics.some(diagnostic => diagnostic.severity === 'error')) {
+        editing = { supported: false, reason: { code: 'INVALID_SOURCE', message: 'Fix token diagnostics before structured editing.' } };
+    }
+    if (editing && !editing.supported) {
+        for (const permutation of permutations) {
+            for (const token of permutation.tokens) {
+                token.authoring = describeTokenAuthoring(token, documents, permutation.input.mode, editing);
+            }
+        }
+    }
+    const input = Object.fromEntries(Object.entries(options.input ?? {})
+        .sort(([left], [right]) => compareNames(left, right)));
+    const revision = hash(JSON.stringify({
+        entry: local(fileURLToPath(entry)),
+        input,
+        dependencies,
+    }));
+    const output = projection && {
+        tokensCss: projection.tokensCss,
+        tailwindCss: projection.tailwindCss,
+        modesJson: JSON.stringify({ ...projection.modes, revision, dependencies }, null, 2) + '\n',
+    };
+    const uniqueDiagnostics = [
+        ...new Map(diagnostics.map(diagnostic => [
+            JSON.stringify(diagnostic),
+            diagnostic,
+        ])).values(),
+    ];
+    return {
+        ok: !diagnostics.some(diagnostic => diagnostic.severity === 'error'),
+        diagnostics: uniqueDiagnostics,
+        dependencies,
+        revision,
+        permutations,
+        ...(editing ? { editing } : {}),
+        ...(output ? { output } : {}),
+    };
+}

package/dist/compilation/definitions.d.ts

@@ -0,0 +1,17 @@
+import { type TokenGroup } from '../authoring.js';
+interface TokenDefinition {
+    path: string;
+    token: Record<string, any>;
+}
+export declare function collectTokenDefinitions(composed: Record<string, any>, documents: ReadonlyMap<string, Record<string, any>>): {
+    definitions: TokenDefinition[];
+    groups: TokenGroup[];
+};
+export declare function createTerrazzoSource(definitions: TokenDefinition[]): {
+    [k: string]: {
+        $value: unknown;
+    };
+};
+export declare function fromTerrazzoTokenValue(type: string, value: unknown): unknown;
+export {};
+//# sourceMappingURL=definitions.d.ts.map

package/dist/compilation/definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/compilation/definitions.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2C,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAI3F,UAAU,eAAe;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B;AAED,wBAAgB,uBAAuB,CACnC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC7B,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;;;EAuCtD;AAED,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,eAAe,EAAE;;;;EA6BlE;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAE5E"}

package/dist/compilation/definitions.js

@@ -0,0 +1,103 @@
+import { readTokenDefinition } from '../authoring.js';
+export function collectTokenDefinitions(composed, documents) {
+    const definitions = [];
+    const groups = [];
+    const collect = (group, path = [], inheritedType, inheritedDeprecated) => {
+        const type = group.$type ?? inheritedType;
+        const deprecated = group.$deprecated ?? inheritedDeprecated;
+        if ('$value' in group) {
+            definitions.push({
+                path: path.join('.'),
+                token: {
+                    ...group,
+                    $type: type,
+                    $deprecated: deprecated,
+                },
+            });
+            return;
+        }
+        groups.push(describeGroup(group, path, type, deprecated, documents));
+        for (const [key, child] of Object.entries(group)) {
+            if (!key.startsWith('$') || key === '$root') {
+                collect(child, [...path, key], type, deprecated);
+            }
+        }
+    };
+    collect(composed);
+    definitions.sort((left, right) => left.path.localeCompare(right.path));
+    return { definitions, groups };
+}
+export function createTerrazzoSource(definitions) {
+    const aliases = new Map(definitions.map((definition, index) => [definition.path, `token${index}`]));
+    const rebaseAliases = (value) => {
+        if (typeof value === 'string' && /^\{[^{}]+\}$/.test(value)) {
+            return `{${aliases.get(value.slice(1, -1))}}`;
+        }
+        if (Array.isArray(value)) {
+            return value.map(rebaseAliases);
+        }
+        if (value && typeof value === 'object') {
+            return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, rebaseAliases(child)]));
+        }
+        return value;
+    };
+    return Object.fromEntries(definitions.map((definition, index) => [
+        `token${index}`,
+        {
+            ...definition.token,
+            $value: rebaseAliases(toTerrazzoTokenValue(definition.token.$type, definition.token.$value)),
+        },
+    ]));
+}
+export function fromTerrazzoTokenValue(type, value) {
+    return mapMissingColorComponents(type, value, null, 'none');
+}
+function toTerrazzoTokenValue(type, value) {
+    return mapMissingColorComponents(type, value, 'none', null);
+}
+function mapMissingColorComponents(type, value, from, to) {
+    if (typeof value === 'string' || !value || typeof value !== 'object') {
+        return value;
+    }
+    if (type === 'color') {
+        return mapColor(value, from, to);
+    }
+    if (type === 'border') {
+        return { ...value, color: mapColor(value.color, from, to) };
+    }
+    if (type === 'gradient' && Array.isArray(value)) {
+        return value.map(stop => (stop && typeof stop === 'object'
+            ? { ...stop, color: mapColor(stop.color, from, to) }
+            : stop));
+    }
+    if (type === 'shadow') {
+        const layers = Array.isArray(value) ? value : [value];
+        const mapped = layers.map(layer => (layer && typeof layer === 'object'
+            ? { ...layer, color: mapColor(layer.color, from, to) }
+            : layer));
+        return Array.isArray(value) ? mapped : mapped[0];
+    }
+    return value;
+}
+function mapColor(value, from, to) {
+    if (typeof value === 'string' || !value || typeof value !== 'object' || Array.isArray(value)) {
+        return value;
+    }
+    const color = value;
+    return Array.isArray(color.components)
+        ? { ...color, components: color.components.map(component => component === from ? to : component) }
+        : value;
+}
+function describeGroup(group, path, type, deprecated, documents) {
+    const source = group.$extensions?.['ai.reforma.compiler'] ?? null;
+    const original = source ? readTokenDefinition(source, documents) : {};
+    const definition = Object.fromEntries(Object.entries(original).filter(([key]) => key.startsWith('$') && key !== '$root'));
+    return {
+        path: path.join('.'),
+        source,
+        definition,
+        type,
+        description: group.$description,
+        deprecated: deprecated ?? false,
+    };
+}

package/dist/compilation/scope-validation.d.ts

@@ -0,0 +1,12 @@
+import type { DtcgTokenType, TokenEditingProfile } from '../authoring.js';
+import type { TokenDiagnostic } from './compiler.js';
+/** Check inherited group types and paths after $extends and mode composition. */
+export declare function validateComposedTokenScopes(composed: Record<string, any>, base: Record<string, any>, input: Record<string, string>, documents: ReadonlyMap<string, Record<string, any>>, profile: Extract<TokenEditingProfile, {
+    supported: true;
+}>, workspaceRoot: string): TokenDiagnostic[];
+/** Validate authored declarations before composition can hide a mode's type changes. */
+export declare function validateTokenScopes(documents: ReadonlyMap<string, Record<string, any>>, profile: Extract<TokenEditingProfile, {
+    supported: true;
+}>, base: Record<string, any>): TokenDiagnostic[];
+export declare function isDtcgTokenType(type: unknown): type is DtcgTokenType;
+//# sourceMappingURL=scope-validation.d.ts.map

package/dist/compilation/scope-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope-validation.d.ts","sourceRoot":"","sources":["../../src/compilation/scope-validation.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD,iFAAiF;AACjF,wBAAgB,2BAA2B,CACvC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC7B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACzB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,EACnD,OAAO,EAAE,OAAO,CAAC,mBAAmB,EAAE;IAAE,SAAS,EAAE,IAAI,CAAA;CAAE,CAAC,EAC1D,aAAa,EAAE,MAAM,GACtB,eAAe,EAAE,CAgDnB;AAED,wFAAwF;AACxF,wBAAgB,mBAAmB,CAC/B,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,EACnD,OAAO,EAAE,OAAO,CAAC,mBAAmB,EAAE;IAAE,SAAS,EAAE,IAAI,CAAA;CAAE,CAAC,EAC1D,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC1B,eAAe,EAAE,CA6CnB;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,aAAa,CAEpE"}

package/dist/compilation/scope-validation.js

@@ -0,0 +1,105 @@
+import { relative, resolve, sep } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { DTCG_TOKEN_TYPES, readTokenDefinition } from '../authoring.js';
+import { decodeJsonPointer, encodeJsonPointer, readJsonPointer } from '../json-pointer.js';
+/** Check inherited group types and paths after $extends and mode composition. */
+export function validateComposedTokenScopes(composed, base, input, documents, profile, workspaceRoot) {
+    const diagnostics = [];
+    const visit = (node, baseNode, path, scopeType) => {
+        const type = node.$type ?? scopeType;
+        const expectedType = path.length === 1 ? baseNode?.$type : scopeType;
+        const source = node.$extensions?.['ai.reforma.compiler'];
+        if (path.length > 0 && type !== expectedType) {
+            diagnostics.push({ severity: 'error', code: 'SCOPE_TYPE_MISMATCH', ...source, input,
+                expectedType, actualType: type,
+                message: `${path.join('.')}: Expected scope type ${expectedType}; received ${type}.` });
+        }
+        if (!baseNode || ('$value' in node) !== ('$value' in baseNode)) {
+            diagnostics.push({ severity: 'error', code: 'SCOPE_BASE_PATH_REQUIRED', ...source, input,
+                message: `${path.join('.')}: The base must own every mode path of the same kind.` });
+        }
+        if ('$value' in node) {
+            const value = readTokenDefinition(source, documents).$value;
+            const reference = value && typeof value === 'object' ? value.$ref : undefined;
+            if (typeof reference === 'string') {
+                const owner = pathToFileURL(resolve(workspaceRoot, source.file));
+                const url = new URL(reference, owner);
+                const targetPath = decodeJsonPointer(url.hash);
+                if (targetPath.at(-1) === '$value') {
+                    const file = relative(workspaceRoot, fileURLToPath(url)).split(sep).join('/');
+                    const target = reference.startsWith('#') ? composed : documents.get(file);
+                    let group = target;
+                    let targetType = target?.$type ?? (Object.values(profile.modeFiles).includes(file) ? base[targetPath[0]]?.$type : undefined);
+                    for (const part of targetPath.slice(0, -1)) {
+                        group = readJsonPointer(group, [part]);
+                        targetType = group.$type ?? targetType;
+                    }
+                    if (targetType !== undefined && targetType !== expectedType) {
+                        diagnostics.push({ severity: 'error', code: 'SCOPE_ALIAS_TYPE_MISMATCH', ...source, input,
+                            expectedType, actualType: targetType,
+                            message: `${path.join('.')}: A whole-token value reference must use scope type ${expectedType}; received ${targetType}.` });
+                    }
+                }
+            }
+            return;
+        }
+        for (const [key, child] of Object.entries(node)) {
+            if (!key.startsWith('$') || key === '$root') {
+                visit(child, baseNode && Object.hasOwn(baseNode, key) ? baseNode[key] : undefined, [...path, key], expectedType);
+            }
+        }
+    };
+    visit(composed, base, []);
+    return diagnostics;
+}
+/** Validate authored declarations before composition can hide a mode's type changes. */
+export function validateTokenScopes(documents, profile, base) {
+    const diagnostics = [];
+    for (const file of new Set([profile.baseFile, ...Object.values(profile.modeFiles)])) {
+        if (!file)
+            continue;
+        const mode = file !== profile.baseFile;
+        const visit = (node, baseNode, path, scopeType) => {
+            if (!node || typeof node !== 'object' || Array.isArray(node))
+                return;
+            const token = Object.hasOwn(node, '$value');
+            const scope = path.length === 1 && !token;
+            const expectedType = scope ? baseNode?.$type : scopeType;
+            const report = (code, message) => diagnostics.push({
+                severity: 'error', code, file, pointer: encodeJsonPointer(path),
+                message: `${path.join('.') || '<root>'}: ${message}`,
+                ...(expectedType ? { expectedType } : {}),
+                ...(Object.hasOwn(node, '$type') ? { actualType: node.$type } : {}),
+            });
+            const name = path.at(-1);
+            if (name !== undefined && (!name.trim() || name !== name.trim())) {
+                report('SCOPE_INVALID_NAME', 'Use a nonempty name without outer whitespace.');
+            }
+            if (token && path.length < 2) {
+                report('SCOPE_REQUIRED', 'Tokens must belong to a typed top-level scope.');
+            }
+            if (scope && !mode && !isDtcgTokenType(node.$type)) {
+                report('SCOPE_TYPE_REQUIRED', 'A scope must declare one standard DTCG $type.');
+            }
+            if (Object.hasOwn(node, '$type') && (mode || token || path.length === 0
+                || !scope && node.$type !== scopeType)) {
+                report('SCOPE_TYPE_DECLARATION', `Expected inherited ${expectedType ?? 'scope'} type; authored $type ${JSON.stringify(node.$type)} is not allowed here.`);
+            }
+            if (mode && (!baseNode || token !== Object.hasOwn(baseNode, '$value'))) {
+                report('SCOPE_BASE_PATH_REQUIRED', 'Mode sources may only override existing base paths of the same kind.');
+            }
+            if (token)
+                return;
+            for (const [key, child] of Object.entries(node)) {
+                if (!key.startsWith('$') || key === '$root') {
+                    visit(child, baseNode && Object.hasOwn(baseNode, key) ? baseNode[key] : undefined, [...path, key], expectedType);
+                }
+            }
+        };
+        visit(documents.get(file), base, []);
+    }
+    return diagnostics;
+}
+export function isDtcgTokenType(type) {
+    return DTCG_TOKEN_TYPES.some(candidate => candidate === type);
+}

package/dist/compilation/validation.d.ts

@@ -0,0 +1,4 @@
+import type { DtcgTokenType } from '../authoring.js';
+export declare function validateTokenValue(type: string, value: unknown): type is DtcgTokenType;
+export declare function validateAuthoredColorValues(type: string, value: unknown): boolean;
+//# sourceMappingURL=validation.d.ts.map

package/dist/compilation/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/compilation/validation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAqCrD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,IAAI,aAAa,CA+BtF;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAkBjF"}