@reforma/project-tokens 0.0.1

package/dist/source/composer.js

@@ -0,0 +1,226 @@
+import { decodeJsonPointer, encodeJsonPointer, readJsonPointer, } from '../json-pointer.js';
+import { isObject, mergeSourceValues, } from './values.js';
+export class TokenSourceComposer {
+    documents;
+    constructor(documents) {
+        this.documents = documents;
+    }
+    async compose(entry, items, input) {
+        let composed = Object.create(null);
+        for (const item of items) {
+            const sources = item.type === 'set'
+                ? item.sources
+                : item.contexts[input[item.name]];
+            for (const source of sources) {
+                composed = mergeSourceValues(composed, this.annotate(source));
+            }
+        }
+        composed = this.expandGroups(composed);
+        composed = await this.resolveValuePointers(composed, composed, entry);
+        this.validateAliases(composed, composed);
+        return this.expandArrayAliases(composed, composed);
+    }
+    annotate(node) {
+        const origin = this.documents.origin(node);
+        if (node.$extensions !== undefined && !isObject(node.$extensions)) {
+            this.documents.fail('EXTENSIONS_OBJECT', '$extensions must be an object.', node);
+        }
+        if ('$value' in node) {
+            return this.annotateToken(node, origin);
+        }
+        const result = Object.create(null);
+        result.$extensions = this.compilerSource(origin);
+        for (const [key, value] of Object.entries(node)) {
+            if (key === '$extensions') {
+                continue;
+            }
+            if (key.startsWith('$') && key !== '$root') {
+                if (!['$type', '$description', '$deprecated', '$extends'].includes(key)) {
+                    this.documents.fail('TOKEN_NAME', `Unknown group property: ${key}`, node);
+                }
+                result[key] = value;
+                continue;
+            }
+            if (key !== '$root' && (key.startsWith('$') || /[.{}]/.test(key))) {
+                this.documents.fail('TOKEN_NAME', `Invalid token/group name: ${key}`, node);
+            }
+            if (!isObject(value)) {
+                this.documents.fail('TOKEN_GROUP', `Expected token or group at ${key}.`, node);
+            }
+            if (key === '$root' && !Object.hasOwn(value, '$value')) {
+                this.documents.fail('ROOT_TOKEN', '$root must be a token.', node);
+            }
+            result[key] = this.annotate(value);
+        }
+        return result;
+    }
+    annotateToken(node, origin) {
+        if (Object.keys(node).some(key => !key.startsWith('$')) || '$extends' in node) {
+            this.documents.fail('TOKEN_GROUP', 'A token cannot contain children or $extends.', node);
+        }
+        return {
+            ...node,
+            $value: this.rebaseValueReferences(node.$value, origin.url),
+            $extensions: this.compilerSource(origin),
+        };
+    }
+    rebaseValueReferences(value, owner) {
+        if (Array.isArray(value)) {
+            return value.map(child => this.rebaseValueReferences(child, owner));
+        }
+        if (!isObject(value)) {
+            return value;
+        }
+        return Object.fromEntries(Object.entries(value).map(([key, child]) => [
+            key,
+            key === '$ref' && typeof child === 'string' && !child.startsWith('#')
+                ? new URL(child, owner).href
+                : this.rebaseValueReferences(child, owner),
+        ]));
+    }
+    compilerSource(origin) {
+        return {
+            'ai.reforma.compiler': {
+                file: this.documents.formatFilename(origin.url),
+                pointer: encodeJsonPointer(origin.path),
+            },
+        };
+    }
+    expandGroups(composed) {
+        const expanded = new Map();
+        const expand = (group, path, chain) => {
+            const id = encodeJsonPointer(path);
+            if (chain.includes(id)) {
+                this.documents.fail('EXTENDS_CYCLE', `Circular group inheritance at ${id}.`);
+            }
+            const cached = expanded.get(id);
+            if (cached) {
+                return cached;
+            }
+            if ('$value' in group) {
+                this.documents.fail('EXTENDS_TOKEN', '$extends must reference a group.');
+            }
+            let result = group;
+            if ('$extends' in group) {
+                result = extendGroup(group, path, chain);
+            }
+            const children = { ...result };
+            for (const [key, child] of Object.entries(result)) {
+                if ((!key.startsWith('$') || key === '$root')
+                    && isObject(child)
+                    && !('$value' in child)) {
+                    children[key] = expand(child, [...path, key], [...chain, id]);
+                }
+            }
+            expanded.set(id, children);
+            return children;
+        };
+        const extendGroup = (group, path, chain) => {
+            const reference = group.$extends;
+            if (typeof reference !== 'string') {
+                this.documents.fail('EXTENDS_INVALID', '$extends must be a group reference.');
+            }
+            const targetPath = reference.startsWith('{') && reference.endsWith('}')
+                ? reference.slice(1, -1).split('.')
+                : decodeJsonPointer(reference);
+            const target = readJsonPointer(composed, targetPath);
+            if (!isObject(target) || '$value' in target) {
+                this.documents.fail('EXTENDS_TOKEN', '$extends must reference a group.');
+            }
+            const { $extends: _, ...own } = group;
+            const id = encodeJsonPointer(path);
+            return mergeSourceValues(expand(target, targetPath, [...chain, id]), own);
+        };
+        return expand(composed, [], []);
+    }
+    async resolveValuePointers(value, document, owner, chain = []) {
+        if (Array.isArray(value)) {
+            return Promise.all(value.map(child => (this.resolveValuePointers(child, document, owner, chain))));
+        }
+        if (!isObject(value)) {
+            return value;
+        }
+        if ('$ref' in value) {
+            return this.resolveValuePointer(value, document, owner, chain);
+        }
+        const entries = await Promise.all(Object.entries(value).map(async ([key, child]) => [
+            key,
+            key === '$extensions'
+                ? child
+                : await this.resolveValuePointers(child, document, owner, chain),
+        ]));
+        return Object.fromEntries(entries);
+    }
+    async resolveValuePointer(value, document, owner, chain) {
+        if (typeof value.$ref !== 'string') {
+            this.documents.fail('REFERENCE_INVALID', '$ref must be a string.');
+        }
+        const url = new URL(value.$ref, owner);
+        const sameDocument = value.$ref.startsWith('#');
+        const targetDocument = sameDocument
+            ? document
+            : await this.documents.load(url);
+        const targetPath = decodeJsonPointer(url.hash);
+        const documentUrl = sameDocument ? owner.href : url.href.split('#')[0];
+        const id = `${documentUrl}#${encodeJsonPointer(targetPath)}`;
+        if (chain.includes(id)) {
+            this.documents.fail('REFERENCE_CYCLE', 'Circular value pointer.');
+        }
+        const target = readJsonPointer(targetDocument, targetPath);
+        const targetOwner = new URL(url);
+        targetOwner.hash = '';
+        const resolved = await this.resolveValuePointers(target, targetDocument, targetOwner, [...chain, id]);
+        const { $ref: _, ...overrides } = value;
+        if (Object.keys(overrides).length === 0) {
+            return resolved;
+        }
+        if (!isObject(resolved)) {
+            this.documents.fail('REFERENCE_OBJECT', 'Reference siblings require an object target.');
+        }
+        return {
+            ...resolved,
+            ...await this.resolveValuePointers(overrides, document, owner, chain),
+        };
+    }
+    validateAliases(value, composed) {
+        if (typeof value === 'string' && /^\{[^{}]+\}$/.test(value)) {
+            const target = readJsonPointer(composed, value.slice(1, -1).split('.'));
+            if (!isObject(target) || !('$value' in target)) {
+                this.documents.fail('ALIAS_GROUP', `Alias ${value} must name a token, including $root explicitly.`);
+            }
+            return;
+        }
+        if (!value || typeof value !== 'object') {
+            return;
+        }
+        for (const [key, child] of Object.entries(value)) {
+            if (!['$extensions', '$description', '$deprecated'].includes(key)) {
+                this.validateAliases(child, composed);
+            }
+        }
+    }
+    expandArrayAliases(value, composed, chain = []) {
+        if (Array.isArray(value)) {
+            return value.flatMap(item => {
+                if (typeof item === 'string' && /^\{[^{}]+\}$/.test(item)) {
+                    if (chain.includes(item)) {
+                        this.documents.fail('ALIAS_CYCLE', `Circular array alias ${item}.`);
+                    }
+                    const target = readJsonPointer(composed, item.slice(1, -1).split('.'));
+                    const resolved = this.expandArrayAliases(target.$value, composed, [...chain, item]);
+                    return Array.isArray(resolved) ? resolved : [resolved];
+                }
+                return [this.expandArrayAliases(item, composed, chain)];
+            });
+        }
+        if (isObject(value)) {
+            return Object.fromEntries(Object.entries(value).map(([key, child]) => [
+                key,
+                key === '$extensions'
+                    ? child
+                    : this.expandArrayAliases(child, composed, chain),
+            ]));
+        }
+        return value;
+    }
+}

package/dist/source/documents.d.ts

@@ -0,0 +1,18 @@
+import type { TokenDiagnostic } from '../compilation/compiler.js';
+import type { FormatFilename, ObjectValue, ReadDocument, SourceOrigin } from './values.js';
+export declare class TokenSourceDocuments {
+    private readonly read;
+    private readonly filename;
+    private readonly diagnostics;
+    private readonly documents;
+    private readonly origins;
+    constructor(read: ReadDocument, filename: FormatFilename, diagnostics: TokenDiagnostic[]);
+    load(url: URL): Promise<ObjectValue>;
+    origin(node: object): SourceOrigin;
+    setOrigin(node: object, origin: SourceOrigin): void;
+    formatFilename(url: URL): string;
+    warn(code: string, message: string): void;
+    fail(code: string, message: string, node?: object): never;
+    private recordOrigins;
+}
+//# sourceMappingURL=documents.d.ts.map

package/dist/source/documents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"documents.d.ts","sourceRoot":"","sources":["../../src/source/documents.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EACR,cAAc,EACd,WAAW,EACX,YAAY,EACZ,YAAY,EACf,MAAM,aAAa,CAAC;AAErB,qBAAa,oBAAoB;IAKzB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,WAAW;IANhC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkC;IAC5D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuC;IAE/D,YACqB,IAAI,EAAE,YAAY,EAClB,QAAQ,EAAE,cAAc,EACxB,WAAW,EAAE,eAAe,EAAE,EAC/C;IAEE,IAAI,CAAC,GAAG,EAAE,GAAG,wBAoBlB;IAED,MAAM,CAAC,IAAI,EAAE,MAAM,gBAElB;IAED,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,QAE3C;IAED,cAAc,CAAC,GAAG,EAAE,GAAG,UAEtB;IAED,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,QAEjC;IAED,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,CAYxD;IAED,OAAO,CAAC,aAAa;CAgBxB"}

package/dist/source/documents.js

@@ -0,0 +1,68 @@
+import { encodeJsonPointer } from '../json-pointer.js';
+import { isObject } from './values.js';
+export class TokenSourceDocuments {
+    read;
+    filename;
+    diagnostics;
+    documents = new Map();
+    origins = new WeakMap();
+    constructor(read, filename, diagnostics) {
+        this.read = read;
+        this.filename = filename;
+        this.diagnostics = diagnostics;
+    }
+    async load(url) {
+        const cleanUrl = new URL(url);
+        cleanUrl.hash = '';
+        const cached = this.documents.get(cleanUrl.href);
+        if (cached) {
+            return cached;
+        }
+        const document = await this.read(cleanUrl);
+        if (!isObject(document)) {
+            this.fail('DOCUMENT_OBJECT', 'Token and resolver documents must be JSON objects.');
+        }
+        this.recordOrigins(document, cleanUrl);
+        this.documents.set(cleanUrl.href, document);
+        return document;
+    }
+    origin(node) {
+        return this.origins.get(node);
+    }
+    setOrigin(node, origin) {
+        this.origins.set(node, origin);
+    }
+    formatFilename(url) {
+        return this.filename(url);
+    }
+    warn(code, message) {
+        this.diagnostics.push({ severity: 'warning', code, message });
+    }
+    fail(code, message, node) {
+        const origin = node && this.origins.get(node);
+        this.diagnostics.push({
+            severity: 'error',
+            code,
+            message,
+            ...(origin ? {
+                file: this.filename(origin.url),
+                pointer: encodeJsonPointer(origin.path),
+            } : {}),
+        });
+        throw new Error(message);
+    }
+    recordOrigins(value, url, path = []) {
+        if (!value || typeof value !== 'object') {
+            return;
+        }
+        this.origins.set(value, { url, path });
+        if (isObject(value) && '$value' in value) {
+            return;
+        }
+        for (const [key, child] of Object.entries(value)) {
+            if (key !== '$extensions') {
+                this.recordOrigins(child, url, [...path, key]);
+            }
+        }
+    }
+}

package/dist/source/load.d.ts

@@ -0,0 +1,8 @@
+import type { TokenDiagnostic } from '../compilation/compiler.js';
+import type { FormatFilename, ReadDocument } from './values.js';
+/** Adapt resolver references and group inheritance before Terrazzo's value parser. */
+export declare function loadTokenSources(entry: URL, read: ReadDocument, filename: FormatFilename, diagnostics: TokenDiagnostic[]): Promise<{
+    items: import("./values.js").SourceItem[];
+    compose: (input: Record<string, string>) => Promise<any>;
+}>;
+//# sourceMappingURL=load.d.ts.map

package/dist/source/load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../src/source/load.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhE,sFAAsF;AACtF,wBAAsB,gBAAgB,CAClC,KAAK,EAAE,GAAG,EACV,IAAI,EAAE,YAAY,EAClB,QAAQ,EAAE,cAAc,EACxB,WAAW,EAAE,eAAe,EAAE;;qBAQT,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;GAE9C"}

package/dist/source/load.js

@@ -0,0 +1,13 @@
+import { TokenSourceComposer } from './composer.js';
+import { TokenSourceDocuments } from './documents.js';
+import { TokenSourceResolver } from './resolver.js';
+/** Adapt resolver references and group inheritance before Terrazzo's value parser. */
+export async function loadTokenSources(entry, read, filename, diagnostics) {
+    const documents = new TokenSourceDocuments(read, filename, diagnostics);
+    const items = await new TokenSourceResolver(documents).load(entry);
+    const composer = new TokenSourceComposer(documents);
+    return {
+        items,
+        compose: (input) => composer.compose(entry, items, input),
+    };
+}

package/dist/source/resolver.d.ts

@@ -0,0 +1,14 @@
+import { TokenSourceDocuments } from './documents.js';
+import type { SourceItem } from './values.js';
+export declare class TokenSourceResolver {
+    private readonly documents;
+    constructor(documents: TokenSourceDocuments);
+    load(entry: URL): Promise<SourceItem[]>;
+    private dereference;
+    private expandSources;
+    private validateResolver;
+    private normalizeItem;
+    private validateDefinitions;
+    private loadResolutionOrder;
+}
+//# sourceMappingURL=resolver.d.ts.map

package/dist/source/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/source/resolver.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAGtD,OAAO,KAAK,EAAe,UAAU,EAAE,MAAM,aAAa,CAAC;AAE3D,qBAAa,mBAAmB;IAChB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAAtC,YAA6B,SAAS,EAAE,oBAAoB,EAAI;IAE1D,IAAI,CAAC,KAAK,EAAE,GAAG,yBAMpB;YAEa,WAAW;YA8DX,aAAa;IAwC3B,OAAO,CAAC,gBAAgB;YAkDV,aAAa;YA4Eb,mBAAmB;YAanB,mBAAmB;CAwBpC"}

package/dist/source/resolver.js

@@ -0,0 +1,180 @@
+import { decodeJsonPointer, readJsonPointer } from '../json-pointer.js';
+import { isObject } from './values.js';
+export class TokenSourceResolver {
+    documents;
+    constructor(documents) {
+        this.documents = documents;
+    }
+    async load(entry) {
+        const root = await this.documents.load(entry);
+        this.validateResolver(root);
+        await this.validateDefinitions(root);
+        return this.loadResolutionOrder(root);
+    }
+    async dereference(node, allowModifier, chain = []) {
+        if (!isObject(node)) {
+            this.documents.fail('RESOLVER_OBJECT', 'Expected a resolver object.');
+        }
+        if (!Object.hasOwn(node, '$ref')) {
+            return node;
+        }
+        if (typeof node.$ref !== 'string') {
+            this.documents.fail('REFERENCE_INVALID', '$ref must be a string.', node);
+        }
+        const origin = this.documents.origin(node);
+        const url = new URL(node.$ref, origin.url);
+        const path = decodeJsonPointer(url.hash);
+        const referencesModifier = path[0] === 'modifiers' && !allowModifier;
+        if (path[0] === 'resolutionOrder' || referencesModifier) {
+            this.documents.fail('REFERENCE_FORBIDDEN', 'Only resolutionOrder may reference modifiers; inline entries cannot be referenced.', node);
+        }
+        if (chain.includes(url.href)) {
+            this.documents.fail('REFERENCE_CYCLE', 'Circular resolver reference.', node);
+        }
+        const document = await this.documents.load(url);
+        const target = readJsonPointer(document, path);
+        if (!isObject(target)) {
+            this.documents.fail('REFERENCE_OBJECT', 'Resolver reference must target an object.', node);
+        }
+        const resolved = await this.dereference(target, allowModifier, [...chain, url.href]);
+        // Resolver §4.2.2: sibling keys override shallowly, including arrays and objects.
+        const { $ref: _, ...overrides } = node;
+        const result = { ...resolved, ...overrides };
+        this.documents.setOrigin(result, this.documents.origin(target));
+        if (path.length === 2 && ['sets', 'modifiers'].includes(path[0])) {
+            result.name ??= path[1];
+            result.type ??= path[0] === 'sets' ? 'set' : 'modifier';
+        }
+        return result;
+    }
+    async expandSources(sources, chain = []) {
+        if (!Array.isArray(sources)) {
+            this.documents.fail('SOURCES_ARRAY', 'Token sources must be an array.');
+        }
+        const result = [];
+        for (const source of sources) {
+            if (!isObject(source)) {
+                this.documents.fail('SOURCE_OBJECT', 'A token source must be an object.');
+            }
+            if (chain.includes(source)) {
+                this.documents.fail('REFERENCE_CYCLE', 'Circular set reference.', source);
+            }
+            const expanded = await this.dereference(source, false);
+            if (expanded.type === 'modifier') {
+                this.documents.fail('REFERENCE_FORBIDDEN', 'A token source cannot reference a modifier.', source);
+            }
+            if (expanded.type === 'set') {
+                result.push(...await this.expandSources(expanded.sources, [...chain, source]));
+            }
+            else {
+                result.push(expanded);
+            }
+        }
+        return result;
+    }
+    validateResolver(root) {
+        if (root.version !== '2025.10' || !Array.isArray(root.resolutionOrder)) {
+            this.documents.fail('RESOLVER_VERSION', 'Expected a DTCG 2025.10 resolver with resolutionOrder.', root);
+        }
+        for (const key of ['name', 'description', '$schema']) {
+            if (root[key] !== undefined && typeof root[key] !== 'string') {
+                this.documents.fail('RESOLVER_PROPERTY', `${key} must be a string.`, root);
+            }
+        }
+        for (const key of ['sets', 'modifiers', '$defs', '$extensions']) {
+            if (root[key] !== undefined && !isObject(root[key])) {
+                this.documents.fail('RESOLVER_PROPERTY', `${key} must be an object.`, root);
+            }
+        }
+        const allowed = new Set([
+            '$defs',
+            '$extensions',
+            '$schema',
+            'description',
+            'modifiers',
+            'name',
+            'resolutionOrder',
+            'sets',
+            'version',
+        ]);
+        if (Object.keys(root).some(key => !allowed.has(key))) {
+            this.documents.fail('RESOLVER_PROPERTY', 'Unknown resolver property; use $extensions for vendor data.', root);
+        }
+    }
+    async normalizeItem(item) {
+        const invalidDescription = item.description !== undefined
+            && typeof item.description !== 'string';
+        const invalidExtensions = item.$extensions !== undefined
+            && !isObject(item.$extensions);
+        if (invalidDescription || invalidExtensions) {
+            this.documents.fail('RESOLVER_PROPERTY', 'Expected a string description and object $extensions.', item);
+        }
+        const allowed = [
+            '$defs',
+            '$extensions',
+            'description',
+            'name',
+            'type',
+            ...(item.type === 'set' ? ['sources'] : ['contexts', 'default']),
+        ];
+        if (Object.keys(item).some(key => !allowed.includes(key))) {
+            this.documents.fail('RESOLVER_PROPERTY', 'Unknown set or modifier property.', item);
+        }
+        if (item.type === 'set') {
+            return {
+                name: item.name,
+                type: 'set',
+                sources: await this.expandSources(item.sources),
+            };
+        }
+        if (!isObject(item.contexts) || Object.keys(item.contexts).length === 0) {
+            this.documents.fail('CONTEXTS_EMPTY', 'A modifier must have at least one context.', item);
+        }
+        if (item.default !== undefined
+            && (typeof item.default !== 'string'
+                || !Object.hasOwn(item.contexts, item.default))) {
+            this.documents.fail('DEFAULT_INVALID', 'Modifier default must name an existing context.', item);
+        }
+        if (Object.keys(item.contexts).length === 1) {
+            this.documents.warn('SINGLE_CONTEXT', `Modifier ${item.name} has one context; DTCG recommends at least two.`);
+        }
+        const contexts = Object.create(null);
+        for (const [name, sources] of Object.entries(item.contexts)) {
+            contexts[name] = await this.expandSources(sources);
+        }
+        return {
+            name: item.name,
+            type: 'modifier',
+            contexts,
+            default: item.default,
+        };
+    }
+    async validateDefinitions(root) {
+        // Unused definitions still belong to the resolver and must be structurally valid.
+        for (const [section, type] of [
+            ['sets', 'set'],
+            ['modifiers', 'modifier'],
+        ]) {
+            for (const [name, raw] of Object.entries(root[section] ?? {})) {
+                const item = await this.dereference(raw, false);
+                await this.normalizeItem({ ...item, name, type });
+            }
+        }
+    }
+    async loadResolutionOrder(root) {
+        const items = [];
+        const names = new Set();
+        for (const raw of root.resolutionOrder) {
+            const item = await this.dereference(raw, true);
+            const invalid = typeof item.name !== 'string'
+                || !['set', 'modifier'].includes(item.type)
+                || names.has(item.name);
+            if (invalid) {
+                this.documents.fail('RESOLUTION_ORDER', 'Each resolutionOrder entry requires a unique name and set or modifier type.', raw);
+            }
+            names.add(item.name);
+            items.push(await this.normalizeItem(item));
+        }
+        return items;
+    }
+}

package/dist/source/values.d.ts

@@ -0,0 +1,17 @@
+export type ObjectValue = Record<string, any>;
+export interface SourceItem {
+    name: string;
+    type: 'set' | 'modifier';
+    sources?: ObjectValue[];
+    contexts?: Record<string, ObjectValue[]>;
+    default?: string;
+}
+export interface SourceOrigin {
+    url: URL;
+    path: string[];
+}
+export type ReadDocument = (url: URL) => Promise<ObjectValue>;
+export type FormatFilename = (url: URL) => string;
+export declare function isObject(value: unknown): value is ObjectValue;
+export declare function mergeSourceValues(base: ObjectValue, override: ObjectValue): ObjectValue;
+//# sourceMappingURL=values.d.ts.map

package/dist/source/values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.d.ts","sourceRoot":"","sources":["../../src/source/values.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAE9C,MAAM,WAAW,UAAU;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,KAAK,GAAG,UAAU,CAAC;IACzB,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,CAAC;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IACzB,GAAG,EAAE,GAAG,CAAC;IACT,IAAI,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;AAC9D,MAAM,MAAM,cAAc,GAAG,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC;AAElD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAE7D;AAGD,wBAAgB,iBAAiB,CAC7B,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,WAAW,GACtB,WAAW,CAmBb"}

package/dist/source/values.js

@@ -0,0 +1,21 @@
+export function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+// Groups merge recursively; a later token replaces the complete earlier token.
+export function mergeSourceValues(base, override) {
+    const result = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        const recursive = isObject(value)
+            && isObject(base[key])
+            && !('$value' in value)
+            && !('$value' in base[key])
+            && !key.startsWith('$');
+        Object.defineProperty(result, key, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: recursive ? mergeSourceValues(base[key], value) : value,
+        });
+    }
+    return result;
+}

package/package.json

@@ -0,0 +1,66 @@
+{
+    "name": "@reforma/project-tokens",
+    "version": "0.0.1",
+    "description": "Portable DTCG 2025.10 compiler for project design tokens.",
+    "type": "module",
+    "license": "UNLICENSED",
+    "author": "Reforma, Inc. <dev@reforma.ai>",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/reforma-dev/reforma",
+        "directory": "packages/project-tokens"
+    },
+    "exports": {
+        ".": {
+            "types": "./dist/compilation/compiler.d.ts",
+            "default": "./dist/compilation/compiler.js"
+        },
+        "./mutations": {
+            "types": "./dist/mutation/mutations.d.ts",
+            "default": "./dist/mutation/mutations.js"
+        },
+        "./generation": {
+            "types": "./dist/generation.d.ts",
+            "default": "./dist/generation.js"
+        },
+        "./color-value": {
+            "types": "./dist/color-value.d.ts",
+            "default": "./dist/color-value.js"
+        }
+    },
+    "bin": {
+        "reforma-tokens": "./dist/cli.js"
+    },
+    "files": [
+        "dist",
+        "README.md"
+    ],
+    "engines": {
+        "node": ">=24"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "build": "tsc -p tsconfig.json",
+        "dev:prepare": "bun run build",
+        "build:publish": "bun run build",
+        "test": "bun run build && vitest run --testTimeout=15000",
+        "typecheck": "tsc -p tsconfig.json --noEmit",
+        "lint": "eslint src scripts --fix",
+        "verify:project": "bun scripts/verify-project.ts"
+    },
+    "dependencies": {
+        "@terrazzo/parser": "2.7.1",
+        "@terrazzo/token-tools": "2.7.1",
+        "colorjs.io": "0.7.1",
+        "jsonc-parser": "3.3.1"
+    },
+    "devDependencies": {
+        "@reforma/config-typescript": "workspace:*",
+        "@reforma/eslint-config": "workspace:*",
+        "@types/node": "^24",
+        "typescript": "^7",
+        "vitest": "^5.0.1"
+    }
+}