@styleframe/cli 4.0.0 → 4.1.0

package/dist/build-dtcg-vuGHy-Sl.cjs

@@ -0,0 +1,434 @@
+let _styleframe_dtcg = require("@styleframe/dtcg");
+//#region src/commands/dtcg/evaluate.ts
+function isReference(value) {
+	return typeof value === "object" && value !== null && "type" in value && value.type === "reference";
+}
+function isCss(value) {
+	return typeof value === "object" && value !== null && "type" in value && value.type === "css";
+}
+function isPrimitive(value) {
+	return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+/**
+* Resolve a Reference's *primitive* value (following alias chains). Returns
+* null if the chain is broken (missing target or cycle).
+*/
+function resolveReferenceTarget(ref, context) {
+	const visited = context.visited ?? /* @__PURE__ */ new Set();
+	if (visited.has(ref.name)) return {
+		resolved: null,
+		reason: `Reference cycle: ${[...visited, ref.name].join(" → ")}`
+	};
+	const target = context.variables.get(ref.name);
+	if (!target) {
+		if (ref.fallback !== void 0 && ref.fallback !== null) return evaluateValue(ref.fallback, context);
+		return {
+			resolved: null,
+			reason: `Unknown reference target: ${ref.name}`
+		};
+	}
+	const nextContext = {
+		variables: context.variables,
+		visited: new Set([...visited, ref.name]),
+		maxViewport: context.maxViewport
+	};
+	return evaluateValue(target.value, nextContext);
+}
+/**
+* Try to evaluate a CSS template literal. Two strategies:
+*
+*   1. **String-template fold**: replace each `Reference` part with its
+*      resolved primitive (stringified) and concatenate. If the resulting
+*      string parses as a known CSS form (cubic-bezier(...), a hex color,
+*      a dimension, a duration), return it.
+*   2. **Pure arithmetic**: if every part reduces to a finite number or one
+*      of `+`/`-`/`*`/`/`/`(`/`)` operators with whitespace, evaluate the
+*      arithmetic and return the numeric result.
+*
+* Otherwise, return `{resolved: null, cssExpression: <fold>}` so the caller
+* can preserve the expression in an extension.
+*/
+function evaluateCss(css, context) {
+	const parts = [];
+	let unevaluable = false;
+	let unevaluableReason;
+	for (const part of css.value) {
+		if (typeof part === "string") {
+			parts.push({
+				kind: "literal",
+				text: part
+			});
+			continue;
+		}
+		const evaluated = evaluateValue(part, context);
+		if (evaluated.resolved === null) {
+			unevaluable = true;
+			unevaluableReason = evaluated.reason;
+			parts.push({
+				kind: "value",
+				text: ""
+			});
+			continue;
+		}
+		const text = String(evaluated.resolved);
+		const numeric = typeof evaluated.resolved === "number" ? evaluated.resolved : void 0;
+		parts.push({
+			kind: "value",
+			text,
+			numeric
+		});
+	}
+	const folded = parts.map((p) => p.text).join("");
+	if (unevaluable) return {
+		resolved: null,
+		cssExpression: folded,
+		reason: unevaluableReason ?? "Computed expression includes an unresolvable reference"
+	};
+	if (parts.every((p) => {
+		if (p.kind === "value") return p.numeric !== void 0;
+		return /^[\d.\s+\-*/()]*$/.test(p.text);
+	}) && parts.some((p) => p.kind === "value")) try {
+		const result = safeArithmetic(folded.trim());
+		if (typeof result === "number" && Number.isFinite(result)) return { resolved: result };
+	} catch (err) {
+		return {
+			resolved: null,
+			cssExpression: folded,
+			reason: `Arithmetic evaluation failed: ${err.message}`
+		};
+	}
+	const subResult = substituteFluidUnits(folded, context.maxViewport ?? 1440);
+	if (subResult && /^[\d.\s+\-*/()]+$/.test(subResult.rebased)) try {
+		const result = safeArithmetic(subResult.rebased.trim());
+		if (typeof result === "number" && Number.isFinite(result)) return {
+			resolved: result,
+			...subResult.substituted ? { normalisationSource: "fluid-max" } : {}
+		};
+	} catch {}
+	return { resolved: folded };
+}
+/**
+* Replace fluid-friendly literals so a `calc()` expression mixing `100vw`,
+* `rem`, and `px` reduces to pure arithmetic.
+*
+* Returns `null` when the input still contains units we don't substitute
+* (e.g. `vh`, `%`, `em`) — the caller should fall back to the
+* verbatim-string path.
+*
+* `substituted` indicates whether at least one fluid unit was actually
+* substituted. `false` means we only stripped a bare `calc(...)` wrapper —
+* the expression was effectively pure arithmetic and the result should NOT
+* be flagged as fluid-normalised.
+*/
+function substituteFluidUnits(expression, maxViewport) {
+	let substituted = false;
+	let rebased = expression.replace(/\bcalc\b/g, "");
+	if (rebased.includes("100vw")) {
+		rebased = rebased.replace(/100vw/g, String(maxViewport));
+		substituted = true;
+	}
+	if (/(-?\d*\.?\d+)\s*rem/.test(rebased)) {
+		rebased = rebased.replace(/(-?\d*\.?\d+)\s*rem/g, "($1 * 16)");
+		substituted = true;
+	}
+	if (/(-?\d*\.?\d+)\s*px/.test(rebased)) {
+		rebased = rebased.replace(/(-?\d*\.?\d+)\s*px/g, "$1");
+		substituted = true;
+	}
+	if (/[a-zA-Z%]/.test(rebased)) return null;
+	return {
+		rebased,
+		substituted
+	};
+}
+/**
+* Safe arithmetic over a whitespace-trimmed expression containing only
+* numbers, parentheses, and `+`/`-`/`*`/`/`. Throws on anything else.
+*/
+function safeArithmetic(expression) {
+	if (!/^[\d.\s+\-*/()]+$/.test(expression)) throw new Error(`Disallowed characters in expression: "${expression}"`);
+	return new Function(`return (${expression});`)();
+}
+function evaluateValue(value, context) {
+	if (value === null || value === void 0) return {
+		resolved: null,
+		reason: "Value is null/undefined"
+	};
+	if (isPrimitive(value)) return { resolved: value };
+	if (isReference(value)) {
+		const targetResolution = resolveReferenceTarget(value, context);
+		if ((!context.visited || context.visited.size === 0) && targetResolution.resolved !== null) return {
+			...targetResolution,
+			aliasTarget: value.name
+		};
+		return targetResolution;
+	}
+	if (isCss(value)) return evaluateCss(value, context);
+	if (Array.isArray(value)) return {
+		resolved: null,
+		reason: "Heterogeneous array — DTCG composite encoding not yet implemented"
+	};
+	return {
+		resolved: null,
+		reason: `Unsupported value shape: ${typeof value}`
+	};
+}
+//#endregion
+//#region src/commands/dtcg/build-dtcg.ts
+var TOKENS_SCHEMA_URL = "https://design-tokens.org/schemas/2025.10/tokens.json";
+var RESOLVER_SCHEMA_URL = "https://www.designtokens.org/schemas/2025.10/resolver.json";
+function buildVariableMap(root) {
+	const map = /* @__PURE__ */ new Map();
+	for (const v of root.variables) map.set(v.name, v);
+	for (const theme of root.themes) for (const v of theme.variables) if (!map.has(v.name)) map.set(v.name, v);
+	return map;
+}
+function processVariable(variable, context) {
+	const evaluation = evaluateValue(variable.value, context);
+	const classification = classifyValueForVariable(variable.name, evaluation);
+	return {
+		name: variable.name,
+		evaluation,
+		classification
+	};
+}
+function classifyValueForVariable(name, evaluation) {
+	if (evaluation.resolved === null) return void 0;
+	return (0, _styleframe_dtcg.classifyValue)(evaluation.resolved, { path: name });
+}
+/**
+* Place a token at `dotPath` in `doc`. Two collision cases need handling:
+*
+*   1. **Token at a path whose group already has children.** If we set
+*      `border-width = {...token}` after `border-width.thin = {...}` was
+*      written, a naive overwrite drops the children. Instead, we promote
+*      the parent token into a `$root` slot inside the existing group.
+*   2. **Children written into a slot that's already a token.** Reverse
+*      ordering: if `border-width = {...token}` was written first and we
+*      now need to add `border-width.thin = {...}`, we move the existing
+*      token into `$root` and continue descending into the new group.
+*
+* Both cases are handled by checking whether the slot looks like a token
+* (`$value` present) or a group, and by upgrading to `$root` whenever a
+* token coexists with siblings at the same path.
+*/
+function setNestedToken(doc, dotPath, token) {
+	const segments = dotPath.split(".");
+	let cursor = doc;
+	for (let i = 0; i < segments.length - 1; i++) {
+		const segment = segments[i];
+		const next = cursor[segment];
+		if (typeof next !== "object" || next === null || Array.isArray(next)) cursor[segment] = {};
+		else if ("$value" in next) cursor[segment] = { $root: next };
+		cursor = cursor[segment];
+	}
+	const leaf = segments[segments.length - 1];
+	const existing = cursor[leaf];
+	if (typeof existing === "object" && existing !== null && !Array.isArray(existing) && !("$value" in existing)) existing.$root = token;
+	else cursor[leaf] = token;
+}
+function hasRootToken(doc, dotPath) {
+	const segments = dotPath.split(".");
+	let cursor = doc;
+	for (const segment of segments) {
+		if (typeof cursor !== "object" || cursor === null || Array.isArray(cursor)) return false;
+		cursor = cursor[segment];
+	}
+	return typeof cursor === "object" && cursor !== null && !Array.isArray(cursor) && "$root" in cursor;
+}
+function setNestedOverride(context, dotPath, value, type) {
+	const segments = dotPath.split(".");
+	let cursor = context;
+	for (let i = 0; i < segments.length - 1; i++) {
+		const segment = segments[i];
+		const next = cursor[segment];
+		if (typeof next !== "object" || next === null || Array.isArray(next) || "$value" in next) cursor[segment] = {};
+		cursor = cursor[segment];
+	}
+	const token = { $value: value };
+	if (type !== void 0) token.$type = type;
+	cursor[segments[segments.length - 1]] = token;
+}
+function makeAliasToken(target, type, description) {
+	const token = { $value: (0, _styleframe_dtcg.formatAlias)(target) };
+	if (type !== void 0) token.$type = type;
+	if (description) token.$description = description;
+	return token;
+}
+function makeValueToken(classification, description, fluidBound) {
+	const token = {
+		$value: classification.value,
+		$type: classification.type
+	};
+	if (description) token.$description = description;
+	if (fluidBound) token.$extensions = { "dev.styleframe": { fluidBound } };
+	return token;
+}
+function makeExpressionToken(expression, description) {
+	const token = {
+		$value: expression,
+		$extensions: { "dev.styleframe": { expression } }
+	};
+	if (description) token.$description = description;
+	return token;
+}
+function valuesEqual(a, b) {
+	if (a === b) return true;
+	if (typeof a !== typeof b) return false;
+	if (typeof a === "object") return JSON.stringify(a) === JSON.stringify(b);
+	return false;
+}
+function capitalizeContextName(name) {
+	if (name.length === 0) return name;
+	return name.charAt(0).toUpperCase() + name.slice(1);
+}
+function buildDTCG(root, options = {}) {
+	const includeSchema = options.includeSchema ?? true;
+	const schemaUrl = options.schemaUrl ?? TOKENS_SCHEMA_URL;
+	const modifierName = options.modifierName ?? "theme";
+	const collectionName = options.collectionName ?? "Design Tokens";
+	const defaultModeName = options.defaultModeName ?? "Default";
+	const tokensSourceRef = options.tokensSourceRef ?? "tokens.json";
+	const variableMap = buildVariableMap(root);
+	const fluidMaxVariable = variableMap.get("fluid.max-width");
+	const fluidMaxResolved = fluidMaxVariable ? evaluateValue(fluidMaxVariable.value, { variables: variableMap }).resolved : null;
+	const maxViewport = typeof fluidMaxResolved === "number" ? fluidMaxResolved : 1440;
+	const context = {
+		variables: variableMap,
+		maxViewport
+	};
+	const processed = /* @__PURE__ */ new Map();
+	const typeMap = /* @__PURE__ */ new Map();
+	for (const variable of root.variables) {
+		const p = processVariable(variable, context);
+		processed.set(variable.name, p);
+		if (p.classification) typeMap.set(variable.name, p.classification.type);
+	}
+	const resolveTypeFromAliasChain = (name, seen) => {
+		if (seen.has(name)) return void 0;
+		const direct = typeMap.get(name);
+		if (direct) return direct;
+		const p = processed.get(name);
+		if (p?.evaluation.aliasTarget) return resolveTypeFromAliasChain(p.evaluation.aliasTarget, new Set([...seen, name]));
+	};
+	const tokens = {};
+	if (includeSchema) tokens.$schema = schemaUrl;
+	tokens.$extensions = { "dev.styleframe": { collection: collectionName } };
+	const diagnostics = [];
+	let emittedCount = 0;
+	let fluidNormalisedCount = 0;
+	for (const variable of root.variables) {
+		const p = processed.get(variable.name);
+		if (!p) continue;
+		const { evaluation, classification } = p;
+		if (evaluation.aliasTarget) {
+			const targetType = resolveTypeFromAliasChain(evaluation.aliasTarget, /* @__PURE__ */ new Set());
+			setNestedToken(tokens, variable.name, makeAliasToken(evaluation.aliasTarget, targetType));
+			emittedCount++;
+			continue;
+		}
+		if (classification) {
+			const fluidBound = evaluation.normalisationSource === "fluid-max" ? "max" : void 0;
+			const promoted = fluidBound && classification.type === "number" && typeof classification.value === "number" ? {
+				type: "dimension",
+				value: {
+					value: classification.value,
+					unit: "px"
+				}
+			} : classification;
+			setNestedToken(tokens, variable.name, makeValueToken(promoted, void 0, fluidBound));
+			if (fluidBound) fluidNormalisedCount++;
+			emittedCount++;
+			continue;
+		}
+		if (evaluation.cssExpression) {
+			setNestedToken(tokens, variable.name, makeExpressionToken(evaluation.cssExpression));
+			diagnostics.push({
+				name: variable.name,
+				level: "warn",
+				reason: evaluation.reason ?? "Computed expression — preserved as dev.styleframe.expression extension"
+			});
+			emittedCount++;
+			continue;
+		}
+		if (evaluation.resolved !== null && typeof evaluation.resolved !== "boolean") {
+			setNestedToken(tokens, variable.name, {
+				$value: String(evaluation.resolved),
+				$extensions: { "dev.styleframe": { unknownType: true } }
+			});
+			diagnostics.push({
+				name: variable.name,
+				level: "warn",
+				reason: "Could not infer DTCG $type — emitted as untyped string"
+			});
+			emittedCount++;
+			continue;
+		}
+		diagnostics.push({
+			name: variable.name,
+			level: "warn",
+			reason: evaluation.reason ?? "Unrepresentable value — skipped"
+		});
+	}
+	const themedThemes = root.themes.filter((t) => t.variables.length > 0);
+	let resolver;
+	if (themedThemes.length > 0) {
+		const contexts = {};
+		for (const theme of themedThemes) {
+			const contextDoc = {};
+			for (const variable of theme.variables) {
+				const themeProcessed = processVariable(variable, context);
+				const defaultProcessed = processed.get(variable.name);
+				let themeValue;
+				let themeType;
+				if (themeProcessed.evaluation.aliasTarget) {
+					themeValue = (0, _styleframe_dtcg.formatAlias)(themeProcessed.evaluation.aliasTarget);
+					themeType = resolveTypeFromAliasChain(themeProcessed.evaluation.aliasTarget, /* @__PURE__ */ new Set());
+				} else if (themeProcessed.classification) {
+					themeValue = themeProcessed.classification.value;
+					themeType = themeProcessed.classification.type;
+				}
+				if (themeValue === void 0) continue;
+				let defaultValue;
+				if (defaultProcessed?.evaluation.aliasTarget) defaultValue = (0, _styleframe_dtcg.formatAlias)(defaultProcessed.evaluation.aliasTarget);
+				else if (defaultProcessed?.classification) defaultValue = defaultProcessed.classification.value;
+				if (defaultValue !== void 0 && valuesEqual(themeValue, defaultValue)) continue;
+				setNestedOverride(contextDoc, hasRootToken(tokens, variable.name) ? `${variable.name}.$root` : variable.name, themeValue, themeType);
+			}
+			contexts[capitalizeContextName(theme.name)] = contextDoc;
+		}
+		for (const key of Object.keys(contexts)) if (Object.keys(contexts[key]).length === 0) delete contexts[key];
+		const themeContextNames = Object.keys(contexts);
+		if (themeContextNames.length > 0) {
+			const allContexts = { [defaultModeName]: [] };
+			for (const name of themeContextNames) allContexts[name] = [contexts[name]];
+			resolver = {
+				$schema: RESOLVER_SCHEMA_URL,
+				version: "2025.10",
+				modifiers: { [modifierName]: {
+					contexts: allContexts,
+					default: defaultModeName
+				} },
+				resolutionOrder: [{
+					type: "set",
+					sources: [{ $ref: tokensSourceRef }]
+				}, { $ref: `#/modifiers/${modifierName}` }]
+			};
+		}
+	}
+	return {
+		tokens,
+		resolver,
+		diagnostics,
+		emittedCount,
+		fluidNormalisedCount,
+		maxViewport
+	};
+}
+//#endregion
+Object.defineProperty(exports, "buildDTCG", {
+	enumerable: true,
+	get: function() {
+		return buildDTCG;
+	}
+});

package/dist/chunk-D6vf50IK.cjs

@@ -0,0 +1,28 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});

package/dist/commands/build.d.ts

@@ -0,0 +1,22 @@
+declare const _default: import('citty').CommandDef<{
+    entry: {
+        type: "positional";
+        description: string;
+        default: string;
+        valueHint: string;
+    };
+    outputDir: {
+        type: "string";
+        description: string;
+        default: string;
+        alias: string[];
+        valueHint: string;
+    };
+    clean: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+export default _default;
+//# sourceMappingURL=build.d.ts.map

package/dist/commands/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/commands/build.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAKA,wBA6CG"}

package/dist/commands/dtcg/build-dtcg.d.ts

@@ -0,0 +1,36 @@
+import { Root } from '@styleframe/core';
+import { DTCGDocument, DTCGResolverDocument } from '@styleframe/dtcg';
+export interface BuildDTCGOptions {
+    collectionName?: string;
+    defaultModeName?: string;
+    modifierName?: string;
+    includeSchema?: boolean;
+    schemaUrl?: string;
+    /**
+     * Filename referenced as the base `set` in the resolver's `resolutionOrder`.
+     * Resolver consumers must be able to load this path via their `fileLoader`.
+     * Defaults to `"tokens.json"`.
+     */
+    tokensSourceRef?: string;
+}
+export interface BuildDiagnostic {
+    name: string;
+    level: "warn" | "info";
+    reason: string;
+}
+export interface BuildDTCGResult {
+    tokens: DTCGDocument;
+    resolver?: DTCGResolverDocument;
+    diagnostics: BuildDiagnostic[];
+    emittedCount: number;
+    /**
+     * Number of tokens whose final value was derived via fluid-unit
+     * substitution (`100vw` → max viewport, `rem` → px) rather than direct
+     * arithmetic. Useful for the export CLI's diagnostic summary.
+     */
+    fluidNormalisedCount: number;
+    /** Max viewport (in px) used when substituting `100vw` for fluid tokens. */
+    maxViewport: number;
+}
+export declare function buildDTCG(root: Root, options?: BuildDTCGOptions): BuildDTCGResult;
+//# sourceMappingURL=build-dtcg.d.ts.map

package/dist/commands/dtcg/build-dtcg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-dtcg.d.ts","sourceRoot":"","sources":["../../../src/commands/dtcg/build-dtcg.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAmB,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EAGN,KAAK,YAAY,EAEjB,KAAK,oBAAoB,EAMzB,MAAM,kBAAkB,CAAC;AAY1B,MAAM,WAAW,gBAAgB;IAChC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,eAAe;IAC/B,MAAM,EAAE,YAAY,CAAC;IACrB,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,WAAW,EAAE,eAAe,EAAE,CAAC;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,oBAAoB,EAAE,MAAM,CAAC;IAC7B,4EAA4E;IAC5E,WAAW,EAAE,MAAM,CAAC;CACpB;AA4LD,wBAAgB,SAAS,CACxB,IAAI,EAAE,IAAI,EACV,OAAO,GAAE,gBAAqB,GAC5B,eAAe,CAsPjB"}

package/dist/commands/dtcg/build-dtcg.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=build-dtcg.test.d.ts.map

package/dist/commands/dtcg/build-dtcg.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-dtcg.test.d.ts","sourceRoot":"","sources":["../../../src/commands/dtcg/build-dtcg.test.ts"],"names":[],"mappings":""}

package/dist/commands/dtcg/evaluate.d.ts

@@ -0,0 +1,30 @@
+import { TokenValue, Variable } from '@styleframe/core';
+export interface EvaluateContext {
+    variables: Map<string, Variable>;
+    /** Visited variable names — used to detect ref cycles. */
+    visited?: Set<string>;
+    /**
+     * Viewport width in px substituted for `100vw` when reducing fluid
+     * expressions. Defaults to `1440` (the styleframe theme's default
+     * `fluid.max-width`); pass an explicit value when the project overrides it.
+     */
+    maxViewport?: number;
+}
+export interface EvaluatedValue {
+    /** Concrete primitive form, or `null` if the expression couldn't be reduced. */
+    resolved: string | number | boolean | null;
+    /** When the expression is exactly one reference, this is the target name. */
+    aliasTarget?: string;
+    /** Original CSS-string form, populated when `resolved` is null. */
+    cssExpression?: string;
+    /** Diagnostic reason, populated when `resolved` is null. */
+    reason?: string;
+    /**
+     * Set when the value was derived via unit substitution (`100vw` → max
+     * viewport, `rem` → px) rather than direct arithmetic. Lets callers attach
+     * a `dev.styleframe.fluidBound` extension so the substitution is auditable.
+     */
+    normalisationSource?: "fluid-max";
+}
+export declare function evaluateValue(value: TokenValue, context: EvaluateContext): EvaluatedValue;
+//# sourceMappingURL=evaluate.d.ts.map

package/dist/commands/dtcg/evaluate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate.d.ts","sourceRoot":"","sources":["../../../src/commands/dtcg/evaluate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAGX,UAAU,EACV,QAAQ,EACR,MAAM,kBAAkB,CAAC;AAE1B,MAAM,WAAW,eAAe;IAC/B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACjC,0DAA0D;IAC1D,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACtB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC9B,gFAAgF;IAChF,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;IAC3C,6EAA6E;IAC7E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mEAAmE;IACnE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,WAAW,CAAC;CAClC;AAsND,wBAAgB,aAAa,CAC5B,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,eAAe,GACtB,cAAc,CAuChB"}

package/dist/commands/dtcg/evaluate.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=evaluate.test.d.ts.map

package/dist/commands/dtcg/evaluate.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate.test.d.ts","sourceRoot":"","sources":["../../../src/commands/dtcg/evaluate.test.ts"],"names":[],"mappings":""}

package/dist/commands/dtcg/export.d.ts

@@ -0,0 +1,24 @@
+declare const _default: import('citty').CommandDef<{
+    config: {
+        type: "string";
+        description: string;
+        default: string;
+        alias: string[];
+        valueHint: string;
+    };
+    output: {
+        type: "string";
+        description: string;
+        default: string;
+        alias: string[];
+        valueHint: string;
+    };
+    collection: {
+        type: "string";
+        description: string;
+        default: string;
+        alias: string[];
+    };
+}>;
+export default _default;
+//# sourceMappingURL=export.d.ts.map

package/dist/commands/dtcg/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../../src/commands/dtcg/export.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAQA,wBA8FG"}

package/dist/commands/dtcg/import.d.ts

@@ -0,0 +1,38 @@
+declare const _default: import('citty').CommandDef<{
+    input: {
+        type: "string";
+        description: string;
+        required: true;
+        alias: string[];
+        valueHint: string;
+    };
+    output: {
+        type: "string";
+        description: string;
+        default: string;
+        alias: string[];
+        valueHint: string;
+    };
+    composables: {
+        type: "boolean";
+        description: string;
+        default: true;
+    };
+    rem: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    baseFontSize: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    instanceName: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+}>;
+export default _default;
+//# sourceMappingURL=import.d.ts.map

package/dist/commands/dtcg/import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../../src/commands/dtcg/import.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,wBA4FG"}

package/dist/commands/dtcg/index.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import('citty').CommandDef<import('citty').ArgsDef>;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/dtcg/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/dtcg/index.ts"],"names":[],"mappings":";AAEA,wBAUG"}