@navecss/tokens 0.1.0

package/dist/lib/builder.d.ts

@@ -0,0 +1,21 @@
+import type { FlatToken } from './reader.ts';
+interface BuildFile {
+    destination: string;
+    format: (tokens: FlatToken[]) => string;
+    filter?: (token: FlatToken) => boolean;
+}
+interface BuildPlatform {
+    buildPath: string;
+    files: BuildFile[];
+}
+export interface BuildConfig {
+    source: string[];
+    platforms: Record<string, BuildPlatform>;
+}
+export interface OutputFile {
+    destination: string;
+    content: string;
+}
+export declare function composeBuild(config: BuildConfig): Promise<OutputFile[]>;
+export declare function writeOutputs(files: readonly OutputFile[]): Promise<void>;
+export {};

package/dist/lib/builder.js

@@ -0,0 +1,41 @@
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { detectDuplicateEmittedNames, refuseOnDuplicateNames } from "./collision.js";
+import { readTokens } from "./reader.js";
+export async function composeBuild(config) {
+    const tokens = [];
+    for (const source of config.source) {
+        const raw = JSON.parse(await readFile(source, 'utf8'));
+        tokens.push(...readTokens(raw, source));
+    }
+    refuseOnDuplicateNames(detectDuplicateEmittedNames(tokens));
+    const outputs = [];
+    for (const platform of Object.values(config.platforms)) {
+        for (const file of platform.files) {
+            const filter = file.filter;
+            const scoped = filter ? tokens.filter((token) => filter(token)) : tokens;
+            outputs.push({
+                destination: path.join(platform.buildPath, file.destination),
+                content: file.format(scoped),
+            });
+        }
+    }
+    return outputs;
+}
+export async function writeOutputs(files) {
+    const staged = [];
+    try {
+        for (const file of files) {
+            await mkdir(path.dirname(file.destination), { recursive: true });
+            const temporary = `${file.destination}.${process.pid}.tmp`;
+            await writeFile(temporary, file.content);
+            staged.push({ destination: file.destination, temporary });
+        }
+        for (const { destination, temporary } of staged)
+            await rename(temporary, destination);
+    }
+    finally {
+        for (const { temporary } of staged)
+            await rm(temporary, { force: true });
+    }
+}

package/dist/lib/collision.d.ts

@@ -0,0 +1,12 @@
+import type { OutputFile } from './builder.ts';
+import type { FlatToken } from './reader.ts';
+export declare function detectCollidingNames(dtcgOutputs: readonly OutputFile[], cssDestination: string, themingCss: string): string[];
+export declare function refuseOnCollision(collidingNames: readonly string[]): void;
+export declare function detectDuplicateEmittedNames(tokens: readonly FlatToken[]): {
+    name: string;
+    paths: string[];
+}[];
+export declare function refuseOnDuplicateNames(duplicates: readonly {
+    name: string;
+    paths: string[];
+}[]): void;

package/dist/lib/collision.js

@@ -0,0 +1,46 @@
+import { DuplicateTokenNameRefusal, TokenCollisionRefusal } from "./errors.js";
+import { scanDeclaredCustomProperties } from "./validate.js";
+export function detectCollidingNames(dtcgOutputs, cssDestination, themingCss) {
+    const dtcgCssFile = dtcgOutputs.find((file) => file.destination === cssDestination);
+    const dtcgNames = dtcgCssFile
+        ? scanDeclaredCustomProperties(dtcgCssFile.content)
+        : new Set();
+    const themingNames = scanDeclaredCustomProperties(themingCss);
+    return [...dtcgNames]
+        .filter((name) => themingNames.has(name))
+        .toSorted((a, b) => a.localeCompare(b));
+}
+export function refuseOnCollision(collidingNames) {
+    if (collidingNames.length === 0)
+        return;
+    const plural = collidingNames.length === 1 ? '' : 's';
+    throw new TokenCollisionRefusal(`Your token source and the generated theming layer both declare ${collidingNames.length} ` +
+        `name${plural} (${collidingNames.join(', ')}). Nothing was written. Declare an override ` +
+        `for ${plural ? 'them' : 'it'} in your own \`@layer overrides\` instead: it wins over ` +
+        `both halves regardless of order, and nothing here needs renaming.`);
+}
+export function detectDuplicateEmittedNames(tokens) {
+    const pathsByName = new Map();
+    for (const token of tokens) {
+        const paths = pathsByName.get(token.name) ?? [];
+        paths.push(token.path.join('.'));
+        pathsByName.set(token.name, paths);
+    }
+    return pathsByName
+        .entries()
+        .filter(([, paths]) => paths.length > 1)
+        .map(([name, paths]) => ({ name, paths: paths.toSorted((a, b) => a.localeCompare(b)) }))
+        .toArray()
+        .toSorted((a, b) => a.name.localeCompare(b.name));
+}
+export function refuseOnDuplicateNames(duplicates) {
+    if (duplicates.length === 0)
+        return;
+    const plural = duplicates.length === 1 ? '' : 's';
+    const detail = duplicates
+        .map((d) => `--nave-${d.name} (from ${d.paths.join(' and ')})`)
+        .join('; ');
+    throw new DuplicateTokenNameRefusal(`Your token source has ${duplicates.length} name${plural} that resolve${plural ? '' : 's'} ` +
+        `to the same emitted custom property after name computation: ${detail}. Nothing was ` +
+        `written. Rename one of the colliding paths in your token source.`);
+}

package/dist/lib/composite-value.d.ts

@@ -0,0 +1,3 @@
+export declare function renderShadow(value: unknown): string;
+export declare function unreadableValueReason(type: string, raw: unknown): string | undefined;
+export declare function renderTokenValue(type: string, raw: unknown, at: string): string | number;

package/dist/lib/composite-value.js

@@ -0,0 +1,152 @@
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+const COLOR_FUNCTION_SPACES = new Set([
+    'a98-rgb',
+    'display-p3',
+    'prophoto-rgb',
+    'rec2020',
+    'srgb',
+    'srgb-linear',
+    'xyz',
+    'xyz-d50',
+    'xyz-d65',
+]);
+const FUNCTION_SPACES = new Map([
+    ['hsl', ['', '%', '%']],
+    ['hwb', ['', '%', '%']],
+    ['lab', ['', '', '']],
+    ['lch', ['', '', '']],
+    ['oklab', ['', '', '']],
+    ['oklch', ['', '', '']],
+]);
+const DIMENSION_UNITS = new Set(['em', 'px', 'rem']);
+const DURATION_UNITS = new Set(['ms', 's']);
+function isColorObject(raw) {
+    const { colorSpace, components, alpha } = raw;
+    if (typeof colorSpace !== 'string')
+        return false;
+    if (!Array.isArray(components) || components.length !== 3)
+        return false;
+    if (components.some((c) => typeof c !== 'number' || !Number.isFinite(c)))
+        return false;
+    return alpha === undefined || (typeof alpha === 'number' && Number.isFinite(alpha));
+}
+function renderMeasure(raw, field, units, kind) {
+    if (isPlainObject(raw)) {
+        const { value, unit } = raw;
+        if (typeof value === 'number' && typeof unit === 'string' && Number.isFinite(value)) {
+            if (!units.has(unit)) {
+                throw new TypeError(`DTCG 2025.10 reader: ${kind} "${field}" unit "${unit}" is not one this reader renders; ` +
+                    `supported: ${[...units].join(', ')}`);
+            }
+            return `${value}${unit}`;
+        }
+    }
+    throw new TypeError(`DTCG 2025.10 reader: ${kind} "${field}" must be a {value, unit} object, got ${JSON.stringify(raw)}`);
+}
+function renderDimension(raw, field = 'value') {
+    return renderMeasure(raw, field, DIMENSION_UNITS, 'dimension');
+}
+function renderDuration(raw) {
+    return renderMeasure(raw, 'value', DURATION_UNITS, 'duration');
+}
+function renderColor(raw, field = 'color') {
+    if (isPlainObject(raw) && isColorObject(raw)) {
+        const { colorSpace, components, alpha } = raw;
+        const alphaSuffix = alpha === undefined ? '' : ` / ${alpha}`;
+        const suffixes = FUNCTION_SPACES.get(colorSpace);
+        if (suffixes !== undefined) {
+            const channels = components.map((c, index) => `${c}${suffixes[index] ?? ''}`).join(' ');
+            return `${colorSpace}(${channels}${alphaSuffix})`;
+        }
+        if (COLOR_FUNCTION_SPACES.has(colorSpace)) {
+            return `color(${colorSpace} ${components.join(' ')}${alphaSuffix})`;
+        }
+        throw new TypeError(`DTCG 2025.10 reader: "${field}" colorSpace "${colorSpace}" is not one this reader renders; ` +
+            `supported: ${[...FUNCTION_SPACES.keys(), ...COLOR_FUNCTION_SPACES].toSorted((a, b) => a.localeCompare(b)).join(', ')}`);
+    }
+    throw new TypeError(`DTCG 2025.10 reader: "${field}" must be a {colorSpace, components, alpha?} object, got ${JSON.stringify(raw)}`);
+}
+const BARE_FAMILY_RE = /^-?[A-Za-z_][\w-]*$/;
+function renderFontFamily(raw) {
+    const families = Array.isArray(raw) ? raw : [raw];
+    return families
+        .map((family) => {
+        if (typeof family !== 'string') {
+            throw new TypeError(`DTCG 2025.10 reader: fontFamily entries must be strings, got ${JSON.stringify(family)}`);
+        }
+        return BARE_FAMILY_RE.test(family) ? family : `'${family}'`;
+    })
+        .join(', ');
+}
+function renderShadowLayer(layer) {
+    if (!isPlainObject(layer)) {
+        throw new TypeError(`DTCG 2025.10 reader: shadow layer must be a plain object, got ${JSON.stringify(layer)}`);
+    }
+    return [
+        renderDimension(layer.offsetX, 'offsetX'),
+        renderDimension(layer.offsetY, 'offsetY'),
+        renderDimension(layer.blur, 'blur'),
+        renderDimension(layer.spread, 'spread'),
+        renderColor(layer.color, 'color'),
+    ].join(' ');
+}
+export function renderShadow(value) {
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return 'none';
+        return value.map((layer) => renderShadowLayer(layer)).join(', ');
+    }
+    return renderShadowLayer(value);
+}
+function renderCubicBezier(value) {
+    if (!Array.isArray(value) || value.length !== 4) {
+        throw new TypeError(`DTCG 2025.10 reader: cubicBezier value must be a 4-element array, got ${JSON.stringify(value)}`);
+    }
+    if (!value.every((n) => typeof n === 'number' && Number.isFinite(n))) {
+        throw new TypeError(`DTCG 2025.10 reader: cubicBezier value must be a 4-element numeric array, got ${JSON.stringify(value)}`);
+    }
+    const [x1, , x2] = value;
+    if (x1 < 0 || x1 > 1 || x2 < 0 || x2 > 1) {
+        throw new TypeError(`DTCG 2025.10 reader: cubicBezier x-coordinates (x1, x2) must be within [0, 1] — CSS cubic-bezier() ` +
+            `rejects an out-of-range x, got ${JSON.stringify(value)}`);
+    }
+    return `cubic-bezier(${value.join(', ')})`;
+}
+export function unreadableValueReason(type, raw) {
+    try {
+        renderTokenValue(type, raw, '');
+        return undefined;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+export function renderTokenValue(type, raw, at) {
+    switch (type) {
+        case 'color': {
+            return typeof raw === 'string' ? raw : renderColor(raw);
+        }
+        case 'cubicBezier': {
+            return renderCubicBezier(raw);
+        }
+        case 'dimension': {
+            return renderDimension(raw);
+        }
+        case 'duration': {
+            return renderDuration(raw);
+        }
+        case 'fontFamily': {
+            return renderFontFamily(raw);
+        }
+        case 'shadow': {
+            return renderShadow(raw);
+        }
+        default: {
+            if (typeof raw === 'string' || typeof raw === 'number')
+                return raw;
+            throw new TypeError(`DTCG 2025.10 reader: unreadable value at "${at}": ${JSON.stringify(raw)}`);
+        }
+    }
+}

package/dist/lib/core-version.d.ts

@@ -0,0 +1,12 @@
+export type CoreVersionProbe = {
+    status: 'resolved';
+    version: string;
+} | {
+    status: 'not-installed';
+} | {
+    status: 'unresolvable';
+} | {
+    message: string;
+    status: 'unreadable';
+};
+export declare function resolveInstalledCoreVersion(): Promise<CoreVersionProbe>;

package/dist/lib/core-version.js

@@ -0,0 +1,40 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+function canResolveCoreDefaultEntry() {
+    try {
+        import.meta.resolve('@navecss/core');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveInstalledCoreVersion() {
+    let resolved;
+    try {
+        resolved = import.meta.resolve('@navecss/core/package.json');
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ERR_PACKAGE_PATH_NOT_EXPORTED')
+            return { status: 'unresolvable' };
+        if (code === 'ERR_MODULE_NOT_FOUND' && !canResolveCoreDefaultEntry()) {
+            return { status: 'not-installed' };
+        }
+        return { message: error.message, status: 'unreadable' };
+    }
+    try {
+        const raw = await readFile(fileURLToPath(resolved), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.version !== 'string') {
+            return {
+                message: '"@navecss/core"\'s package.json has no "version" string field',
+                status: 'unreadable',
+            };
+        }
+        return { status: 'resolved', version: parsed.version };
+    }
+    catch (error) {
+        return { message: error.message, status: 'unreadable' };
+    }
+}

package/dist/lib/dtcg-descriptions.d.ts

@@ -0,0 +1,2 @@
+export declare function collectDescriptions(source: unknown, path_?: readonly string[], out?: Map<string, string>): ReadonlyMap<string, string>;
+export declare function collectDescriptionsFromSources(sourcePaths: readonly string[]): ReadonlyMap<string, string>[];

package/dist/lib/dtcg-descriptions.js

@@ -0,0 +1,23 @@
+import { readFileSync } from 'node:fs';
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function collectDescriptions(source, path_ = [], out = new Map()) {
+    if (!isPlainObject(source)) {
+        throw new Error(`dtcg-descriptions: expected an object at "${path_.join('.')}", got ${JSON.stringify(source)}`);
+    }
+    if (typeof source.$description === 'string')
+        out.set(path_.join('.'), source.$description);
+    for (const [key, child] of Object.entries(source)) {
+        if (key.startsWith('$'))
+            continue;
+        collectDescriptions(child, [...path_, key], out);
+    }
+    return out;
+}
+export function collectDescriptionsFromSources(sourcePaths) {
+    return sourcePaths.map((sourcePath) => {
+        const parsed = JSON.parse(readFileSync(sourcePath, 'utf8'));
+        return collectDescriptions(parsed);
+    });
+}

package/dist/lib/dtcg-malformed.d.ts

@@ -0,0 +1,10 @@
+import type { DraftShapedNode } from './dtcg-shape.ts';
+export interface MalformedNode {
+    readonly path: string;
+    readonly reason: string | undefined;
+    readonly shape: string;
+    readonly type: string;
+    readonly value: unknown;
+}
+export declare function classifyMalformed(path: string, type: string, value: unknown): MalformedNode | undefined;
+export declare function formatUnreadableNodesRefusal(drafts: readonly DraftShapedNode[], malformed: readonly MalformedNode[], sourceName: string | undefined): string;

package/dist/lib/dtcg-malformed.js

@@ -0,0 +1,56 @@
+import { unreadableValueReason } from "./composite-value.js";
+import { formatDraftSection, isAlias, READER, sourceWhere, SPEC_POINTER } from "./dtcg-shape.js";
+const ACCEPTED_SHAPES = {
+    color: 'a "color" value is a CSS colour string, or an object carrying a "colorSpace" and a "components" array (an "alpha" number is optional).',
+    cubicBezier: 'a "cubicBezier" value is a 4-element numeric array [x1, y1, x2, y2], with x1 and x2 each within [0, 1].',
+    dimension: 'a "dimension" value is an object carrying a numeric "value" and a "unit"; this package accepts "px", "rem" and "em".',
+    duration: 'a "duration" value is an object carrying a numeric "value" and a "unit"; the format defines "ms" and "s".',
+    fontFamily: 'a "fontFamily" value is an array of family-name strings, or a single family name written as a bare string.',
+    fontWeight: 'a "fontWeight" value is a JSON number, or one of the format\'s own weight keywords ("bold", "light", "semi-bold" and the rest) written as a string.',
+    number: 'a "number" value is a JSON number.',
+    shadow: 'a "shadow" value is one layer object, or an array of layer objects, each carrying "offsetX", "offsetY" and "blur" as {value, unit} objects, "spread" as a {value, unit} object required on every layer, and "color" as a {colorSpace, components, alpha?} object.',
+};
+const REASON_PREFIX = `${READER} `;
+const AT_FRAGMENT_RE = / at "[^"]*"/;
+const NO_DIAGNOSIS_PREFIX = 'unreadable value';
+function embeddedReason(raw) {
+    const withoutPrefix = raw.startsWith(REASON_PREFIX) ? raw.slice(REASON_PREFIX.length) : raw;
+    const text = withoutPrefix.replace(AT_FRAGMENT_RE, '');
+    return text.startsWith(NO_DIAGNOSIS_PREFIX) ? undefined : text;
+}
+export function classifyMalformed(path, type, value) {
+    if (isAlias(value))
+        return undefined;
+    const raw = unreadableValueReason(type, value);
+    if (raw === undefined)
+        return undefined;
+    return {
+        path,
+        reason: embeddedReason(raw),
+        shape: ACCEPTED_SHAPES[type] ?? ACCEPTED_SHAPES.dimension,
+        type,
+        value,
+    };
+}
+function formatMalformedSection(nodes, sourceName) {
+    const where = sourceWhere(sourceName);
+    const count = nodes.length === 1 ? '1 node' : `${nodes.length} nodes`;
+    const lines = nodes.map((node) => {
+        const reasonLine = node.reason === undefined ? '' : `\n      ${node.reason}`;
+        return (`  - "${node.path}" ($type "${node.type}"), $value ${JSON.stringify(node.value)}` +
+            `${reasonLine}\n` +
+            `      Its own $type accepts: ${node.shape}`);
+    });
+    return [
+        `${READER} ${count} in ${where} ${nodes.length === 1 ? 'is' : 'are'} written in neither the accepted 2025.10 shape nor that earlier, pre-stable revision of the format, for their own $type. Each node below is followed by the shape its own $type accepts; there is no single corrective act to name here, because a malformed value can be wrong in more than one way.`,
+        '',
+        ...lines,
+    ].join('\n');
+}
+export function formatUnreadableNodesRefusal(drafts, malformed, sourceName) {
+    const sections = [
+        ...(drafts.length > 0 ? [formatDraftSection(drafts, sourceName)] : []),
+        ...(malformed.length > 0 ? [formatMalformedSection(malformed, sourceName)] : []),
+    ];
+    return [...sections, SPEC_POINTER].join('\n\n');
+}

package/dist/lib/dtcg-outputs.d.ts

@@ -0,0 +1,2 @@
+import type { OutputFile } from './builder.ts';
+export declare function composeDtcgOutputs(sourcePath: string, outDir: string): Promise<OutputFile[]>;

package/dist/lib/dtcg-outputs.js

@@ -0,0 +1,32 @@
+import { composeBuild } from "./builder.js";
+import { formatCssTokens, formatJsBreakpoints, formatJsTokens, formatTsBreakpoints, formatTsDeclarations, } from "./formats.js";
+const CONSUMER_LAYER = 'tokens.presets';
+export function composeDtcgOutputs(sourcePath, outDir) {
+    return composeBuild({
+        source: [sourcePath],
+        platforms: {
+            css: {
+                buildPath: outDir,
+                files: [
+                    {
+                        destination: 'tokens.css',
+                        format: (tokens) => formatCssTokens(tokens, CONSUMER_LAYER),
+                    },
+                ],
+            },
+            js: {
+                buildPath: outDir,
+                files: [
+                    { destination: 'tokens.js', format: formatJsTokens },
+                    { destination: 'tokens.d.ts', format: formatTsDeclarations },
+                    { destination: 'breakpoints.js', format: formatJsBreakpoints },
+                    {
+                        destination: 'breakpoints.d.ts',
+                        format: formatTsBreakpoints,
+                        filter: (token) => token.path[0] === 'breakpoint',
+                    },
+                ],
+            },
+        },
+    });
+}

package/dist/lib/dtcg-shape.d.ts

@@ -0,0 +1,13 @@
+export declare const SPEC_POINTER = "Specification: Design Tokens Format Module 2025.10, published 28 October 2025.";
+export declare const READER = "DTCG 2025.10 reader:";
+export declare const isAlias: (value: unknown) => boolean;
+export interface DraftShapedNode {
+    readonly conversion: string;
+    readonly path: string;
+    readonly type: string;
+    readonly value: unknown;
+}
+export declare function classifyDraftShape(path: string, type: string, value: unknown): DraftShapedNode | undefined;
+export declare function refuseTypeReason(type: string, path: string): string | undefined;
+export declare function sourceWhere(sourceName: string | undefined): string;
+export declare function formatDraftSection(drafts: readonly DraftShapedNode[], sourceName: string | undefined): string;

package/dist/lib/dtcg-shape.js

@@ -0,0 +1,113 @@
+const SPEC_NAME = 'Design Tokens Format Module 2025.10';
+export const SPEC_POINTER = `Specification: ${SPEC_NAME}, published 28 October 2025.`;
+export const READER = 'DTCG 2025.10 reader:';
+const ACCEPTED_TYPES = new Set([
+    'color',
+    'cubicBezier',
+    'dimension',
+    'duration',
+    'fontFamily',
+    'fontWeight',
+    'number',
+    'shadow',
+]);
+const STRUCTURAL_REFUSALS = new Map([
+    ['gradient', 'a gradient carries no direction, so it cannot render to one CSS value'],
+    ['transition', 'a transition names no CSS property, so it cannot render to one CSS value'],
+    [
+        'typography',
+        "a typography's members do not fit the CSS font shorthand, so it cannot render to one CSS value",
+    ],
+]);
+const SCOPE_REFUSALS = new Set(['border', 'strokeStyle']);
+const SCOPE_RETURN_TRIGGER = 'Returns on the first consumer request, or at 0.2.0, whichever comes first.';
+const FONT_WEIGHT_KEYWORDS = new Set([
+    'black',
+    'bold',
+    'book',
+    'demi-bold',
+    'extra-black',
+    'extra-bold',
+    'extra-light',
+    'hairline',
+    'heavy',
+    'light',
+    'medium',
+    'normal',
+    'regular',
+    'semi-bold',
+    'thin',
+    'ultra-black',
+    'ultra-bold',
+    'ultra-light',
+]);
+const ALIAS_RE = /^\{[^{}]+\}$/;
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export const isAlias = (value) => typeof value === 'string' && ALIAS_RE.test(value);
+const CONVERSIONS = {
+    dimension: 'wrap the value in an object carrying a numeric "value" and a "unit", as in {"value": 16, "unit": "px"}. The unit is required even at zero, and the format defines "px" and "rem".',
+    duration: 'wrap the value in an object carrying a numeric "value" and a "unit", as in {"value": 200, "unit": "ms"}. The format defines "ms" and "s" for this type.',
+    fontFamily: 'write the stack as an array with one family name per element, as in ["system-ui", "Segoe UI", "sans-serif"], and leave a single family as a bare string. Detecting a draft-shaped fontFamily by its comma is a HEURISTIC and not a shape rule: a bare string is a lawful single family name under 2025.10, so a comma is the only signal that a value naming five families means five, and a family name that genuinely contains a comma is caught here in error.',
+    fontWeight: 'drop the quotes and write the weight as a JSON number from 1 to 1000, as in 400. The format\'s own weight keywords ("bold", "light", "semi-bold" and the rest) stay quoted strings and are accepted as they are.',
+    number: 'drop the quotes and write the value as a JSON number, as in 14 rather than "14".',
+    shadow: 'give each layer typed sub-fields: "offsetX", "offsetY", "blur" and "spread" each become an object carrying a numeric "value" and a "unit", "color" becomes an object carrying a "colorSpace" and a "components" array, and "spread" is required on every layer rather than omitted when it is zero.',
+};
+function isDraftShadowLayer(layer) {
+    if (!isPlainObject(layer))
+        return false;
+    if (!('spread' in layer))
+        return true;
+    return ['blur', 'color', 'offsetX', 'offsetY', 'spread'].some((field) => typeof layer[field] === 'string');
+}
+const DRAFT_WROTE_A_STRING = new Set(['dimension', 'duration', 'fontWeight', 'number']);
+function isDraftShaped(type, value) {
+    if (isAlias(value))
+        return false;
+    if (type === 'shadow') {
+        return Array.isArray(value)
+            ? value.some((entry) => isDraftShadowLayer(entry))
+            : isDraftShadowLayer(value);
+    }
+    if (typeof value !== 'string')
+        return false;
+    if (type === 'fontFamily')
+        return value.includes(',');
+    if (type === 'fontWeight')
+        return !FONT_WEIGHT_KEYWORDS.has(value);
+    return DRAFT_WROTE_A_STRING.has(type);
+}
+export function classifyDraftShape(path, type, value) {
+    if (!isDraftShaped(type, value))
+        return undefined;
+    return { conversion: CONVERSIONS[type] ?? CONVERSIONS.dimension, path, type, value };
+}
+export function refuseTypeReason(type, path) {
+    const structural = STRUCTURAL_REFUSALS.get(type);
+    if (structural !== undefined) {
+        return `${READER} "$type": "${type}" at "${path}" is not read by this package, on a structural ground: ${structural}, and this pipeline emits one custom property per token. ${SPEC_POINTER}`;
+    }
+    if (SCOPE_REFUSALS.has(type)) {
+        return `${READER} "$type": "${type}" at "${path}" is not read at 0.1.0, on a scope ground rather than a structural one: it renders cleanly and is cheap to add, and no consumer has asked for it. ${SCOPE_RETURN_TRIGGER} ${SPEC_POINTER}`;
+    }
+    if (!ACCEPTED_TYPES.has(type)) {
+        return `${READER} "$type": "${type}" at "${path}" is not a type the ${SPEC_NAME} defines. ${SPEC_POINTER}`;
+    }
+    return undefined;
+}
+const ANONYMOUS_SOURCE = 'the token source read by this build';
+export function sourceWhere(sourceName) {
+    return sourceName === undefined ? ANONYMOUS_SOURCE : `"${sourceName}"`;
+}
+export function formatDraftSection(drafts, sourceName) {
+    const where = sourceWhere(sourceName);
+    const count = drafts.length === 1 ? '1 node' : `${drafts.length} nodes`;
+    const lines = drafts.map((node) => `  - "${node.path}" ($type "${node.type}"), $value ${JSON.stringify(node.value)}\n` +
+        `      To convert it: ${node.conversion}`);
+    return [
+        `${READER} ${count} in ${where} ${drafts.length === 1 ? 'is' : 'are'} written in the pre-stable draft shape of the Design Tokens Format Module. That is an earlier revision of this same format, not a broken file, and this reader reads 2025.10 only. Each node below carries the edit that brings it up to date.`,
+        '',
+        ...lines,
+    ].join('\n');
+}

package/dist/lib/errors.d.ts

@@ -0,0 +1,23 @@
+export declare class UsageError extends Error {
+    constructor(message: string);
+}
+export interface DtcgRefusedNode {
+    readonly conversion: string;
+    readonly path: string;
+    readonly type: string;
+    readonly value: unknown;
+}
+export declare class DtcgShapeRefusal extends Error {
+    readonly nodes: readonly DtcgRefusedNode[];
+    constructor(message: string, nodes: readonly DtcgRefusedNode[]);
+}
+export declare class TokenCollisionRefusal extends Error {
+    constructor(message: string);
+}
+export declare class DuplicateTokenNameRefusal extends Error {
+    constructor(message: string);
+}
+export declare class MissingContractTokensError extends Error {
+    readonly missing: readonly string[];
+    constructor(missing: readonly string[]);
+}

package/dist/lib/errors.js

@@ -0,0 +1,34 @@
+export class UsageError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'UsageError';
+    }
+}
+export class DtcgShapeRefusal extends Error {
+    nodes;
+    constructor(message, nodes) {
+        super(message);
+        this.name = 'DtcgShapeRefusal';
+        this.nodes = nodes;
+    }
+}
+export class TokenCollisionRefusal extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TokenCollisionRefusal';
+    }
+}
+export class DuplicateTokenNameRefusal extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DuplicateTokenNameRefusal';
+    }
+}
+export class MissingContractTokensError extends Error {
+    missing;
+    constructor(missing) {
+        super(`Consumer build is missing ${missing.length} core contract token(s): ${missing.join(', ')}`);
+        this.name = 'MissingContractTokensError';
+        this.missing = missing;
+    }
+}