@styleframe/cli 4.0.0 → 4.1.1

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/dtcg-D1-iITOr.js

@@ -0,0 +1,14 @@
+import { defineCommand } from "citty";
+//#region src/commands/dtcg/index.ts
+var dtcg_default = defineCommand({
+	meta: {
+		name: "dtcg",
+		description: "Export Styleframe variables to and import them from DTCG format"
+	},
+	subCommands: {
+		export: () => import("./export-CBdPGGEq.js").then((m) => m.default),
+		import: () => import("./import-MqLYxb8d.js").then((m) => m.default)
+	}
+});
+//#endregion
+export { dtcg_default as default };

package/dist/dtcg-D84AfyzO.cjs

@@ -0,0 +1,13 @@
+//#region src/commands/dtcg/index.ts
+var dtcg_default = (0, require("citty").defineCommand)({
+	meta: {
+		name: "dtcg",
+		description: "Export Styleframe variables to and import them from DTCG format"
+	},
+	subCommands: {
+		export: () => Promise.resolve().then(() => require("./export-DmPAU9Wh.cjs")).then((m) => m.default),
+		import: () => Promise.resolve().then(() => require("./import-ibQc_GXm.cjs")).then((m) => m.default)
+	}
+});
+//#endregion
+exports.default = dtcg_default;

package/dist/export-CBdPGGEq.js

@@ -0,0 +1,66 @@
+import { t as buildDTCG } from "./build-dtcg-BpbjBRCf.js";
+import { defineCommand } from "citty";
+import path from "node:path";
+import { loadConfiguration } from "@styleframe/loader";
+import consola from "consola";
+import { mkdir, writeFile } from "node:fs/promises";
+//#region src/commands/dtcg/export.ts
+var export_default = defineCommand({
+	meta: {
+		name: "export",
+		description: "Export Styleframe variables to spec-conformant DTCG JSON"
+	},
+	args: {
+		config: {
+			type: "string",
+			description: "Path to the Styleframe config file",
+			default: "styleframe.config.ts",
+			alias: ["c"],
+			valueHint: "path"
+		},
+		output: {
+			type: "string",
+			description: "Output directory for DTCG files",
+			default: ".",
+			alias: ["o"],
+			valueHint: "path"
+		},
+		collection: {
+			type: "string",
+			description: "Collection name embedded in the export",
+			default: "Design Tokens",
+			alias: ["n", "name"]
+		}
+	},
+	async run({ args }) {
+		const configPath = path.resolve(args.config);
+		const outputDir = path.resolve(args.output);
+		consola.info(`Loading configuration from "${path.relative(process.cwd(), configPath)}"...`);
+		const root = (await loadConfiguration({ entry: configPath })).root;
+		consola.info("Building DTCG document...");
+		const { tokens, resolver, diagnostics, emittedCount, fluidNormalisedCount, maxViewport } = buildDTCG(root, {
+			collectionName: args.collection,
+			tokensSourceRef: "tokens.json"
+		});
+		await mkdir(outputDir, { recursive: true });
+		const tokensPath = path.join(outputDir, "tokens.json");
+		await writeFile(tokensPath, `${JSON.stringify(tokens, null, 2)}\n`);
+		consola.info(`Wrote ${emittedCount} tokens to "${path.relative(process.cwd(), tokensPath)}"`);
+		if (fluidNormalisedCount > 0) consola.info(`Normalised ${fluidNormalisedCount} fluid token(s) using max viewport (${maxViewport}px).`);
+		if (resolver) {
+			const resolverPath = path.join(outputDir, "tokens.resolver.json");
+			await writeFile(resolverPath, `${JSON.stringify(resolver, null, 2)}\n`);
+			consola.info(`Wrote resolver to "${path.relative(process.cwd(), resolverPath)}"`);
+		}
+		const warnings = diagnostics.filter((d) => d.level === "warn");
+		if (warnings.length > 0) {
+			consola.warn(`${warnings.length} variable(s) needed special handling — see Styleframe ↔ DTCG round-trip notes`);
+			for (const w of warnings.slice(0, 10)) consola.info(`  - ${w.name}: ${w.reason}`);
+			if (warnings.length > 10) consola.info(`  ... and ${warnings.length - 10} more`);
+			consola.info("Tip: untyped tokens are usually CSS keywords (e.g. \"normal\", \"thin\", \"italic\") with no DTCG equivalent — they round-trip to Figma as STRING variables.");
+		}
+		consola.success(`Exported ${emittedCount} tokens in DTCG format to "${path.relative(process.cwd(), outputDir)}"`);
+	}
+});
+//#endregion
+export { export_default as default };

package/dist/export-DmPAU9Wh.cjs

@@ -0,0 +1,69 @@
+const require_chunk = require("./chunk-D6vf50IK.cjs");
+const require_build_dtcg = require("./build-dtcg-vuGHy-Sl.cjs");
+let citty = require("citty");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path, 1);
+let _styleframe_loader = require("@styleframe/loader");
+let consola = require("consola");
+consola = require_chunk.__toESM(consola, 1);
+let node_fs_promises = require("node:fs/promises");
+//#region src/commands/dtcg/export.ts
+var export_default = (0, citty.defineCommand)({
+	meta: {
+		name: "export",
+		description: "Export Styleframe variables to spec-conformant DTCG JSON"
+	},
+	args: {
+		config: {
+			type: "string",
+			description: "Path to the Styleframe config file",
+			default: "styleframe.config.ts",
+			alias: ["c"],
+			valueHint: "path"
+		},
+		output: {
+			type: "string",
+			description: "Output directory for DTCG files",
+			default: ".",
+			alias: ["o"],
+			valueHint: "path"
+		},
+		collection: {
+			type: "string",
+			description: "Collection name embedded in the export",
+			default: "Design Tokens",
+			alias: ["n", "name"]
+		}
+	},
+	async run({ args }) {
+		const configPath = node_path.default.resolve(args.config);
+		const outputDir = node_path.default.resolve(args.output);
+		consola.default.info(`Loading configuration from "${node_path.default.relative(process.cwd(), configPath)}"...`);
+		const root = (await (0, _styleframe_loader.loadConfiguration)({ entry: configPath })).root;
+		consola.default.info("Building DTCG document...");
+		const { tokens, resolver, diagnostics, emittedCount, fluidNormalisedCount, maxViewport } = require_build_dtcg.buildDTCG(root, {
+			collectionName: args.collection,
+			tokensSourceRef: "tokens.json"
+		});
+		await (0, node_fs_promises.mkdir)(outputDir, { recursive: true });
+		const tokensPath = node_path.default.join(outputDir, "tokens.json");
+		await (0, node_fs_promises.writeFile)(tokensPath, `${JSON.stringify(tokens, null, 2)}\n`);
+		consola.default.info(`Wrote ${emittedCount} tokens to "${node_path.default.relative(process.cwd(), tokensPath)}"`);
+		if (fluidNormalisedCount > 0) consola.default.info(`Normalised ${fluidNormalisedCount} fluid token(s) using max viewport (${maxViewport}px).`);
+		if (resolver) {
+			const resolverPath = node_path.default.join(outputDir, "tokens.resolver.json");
+			await (0, node_fs_promises.writeFile)(resolverPath, `${JSON.stringify(resolver, null, 2)}\n`);
+			consola.default.info(`Wrote resolver to "${node_path.default.relative(process.cwd(), resolverPath)}"`);
+		}
+		const warnings = diagnostics.filter((d) => d.level === "warn");
+		if (warnings.length > 0) {
+			consola.default.warn(`${warnings.length} variable(s) needed special handling — see Styleframe ↔ DTCG round-trip notes`);
+			for (const w of warnings.slice(0, 10)) consola.default.info(`  - ${w.name}: ${w.reason}`);
+			if (warnings.length > 10) consola.default.info(`  ... and ${warnings.length - 10} more`);
+			consola.default.info("Tip: untyped tokens are usually CSS keywords (e.g. \"normal\", \"thin\", \"italic\") with no DTCG equivalent — they round-trip to Figma as STRING variables.");
+		}
+		consola.default.success(`Exported ${emittedCount} tokens in DTCG format to "${node_path.default.relative(process.cwd(), outputDir)}"`);
+	}
+});
+//#endregion
+exports.default = export_default;