@styleframe/cli 4.0.0 → 4.1.1

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # @styleframe/cli
 
+## 4.1.1
+
+### Patch Changes
+
+- [#238](https://github.com/styleframe-dev/styleframe/pull/238) [`4ace91d`](https://github.com/styleframe-dev/styleframe/commit/4ace91d5e15020c29d585848ee66f6250946b2d1) Thanks [@alexgrozav](https://github.com/alexgrozav)! - Bundle type declarations on build. The shared Vite config now enables `vite-plugin-dts`'s `bundleTypes`, so each package ships a single rolled-up `.d.ts` per entry (via `@microsoft/api-extractor`) instead of a tree of per-file declarations. `@microsoft/api-extractor` is now a peer dependency of `@styleframe/config-vite`.
+
+- Updated dependencies [[`4ace91d`](https://github.com/styleframe-dev/styleframe/commit/4ace91d5e15020c29d585848ee66f6250946b2d1)]:
+  - @styleframe/loader@3.0.3
+
+## 4.1.0
+
+### Minor Changes
+
+- [#229](https://github.com/styleframe-dev/styleframe/pull/229) [`19e9866`](https://github.com/styleframe-dev/styleframe/commit/19e986618c669546972924840189fc5f16f1a1cd) Thanks [@alexgrozav](https://github.com/alexgrozav)! - **Fix:** Resolve critical token loss bug in Figma plugin export where 121 of 464 variables were dropped due to `setNestedToken` overwriting group subtrees instead of promoting parent tokens to `$root`.
+
+  **Feature:** Add mode selector dropdown to Figma plugin Export tab for filtering variables by specific theme/mode before export.
+
+  **Feature:** Add CLI commands for Figma-compatible DTCG sync: `figma export` and `figma import` enable bidirectional token synchronization between Figma collections and design token files.
+
+  **Improvement:** Embed collection metadata in DTCG output via `$extensions.dev.styleframe.collection` for better round-trip awareness.
+
+  **Improvement:** Restore BOOLEAN variable support by converting to string type with `dev.styleframe.boolean: true` extension metadata.
+
+  **Fix:** Correct UI variable count display to read from `msg.result.tokens` instead of wrapper object, ensuring accurate exported variable count and collection name extraction.
+
+### Patch Changes
+
+- [#231](https://github.com/styleframe-dev/styleframe/pull/231) [`c0cfbdc`](https://github.com/styleframe-dev/styleframe/commit/c0cfbdc65ddca0b5ea4a420902be2a23580b392f) Thanks [@alexgrozav](https://github.com/alexgrozav)! - Update `styleframe init` to install v3.x dependencies instead of v2.x. Remove `@styleframe/pro` from scaffolded dependencies.
+
+- [#235](https://github.com/styleframe-dev/styleframe/pull/235) [`6acd766`](https://github.com/styleframe-dev/styleframe/commit/6acd766eefc82139d8cd98dfb9b553449945d704) Thanks [@alexgrozav](https://github.com/alexgrozav)! - Generate DTS output as two files that describe the virtual modules in two complementary forms. The transpiler's `dts` mode now emits:
+  - `styleframe.d.ts` — top-level exports describing the `virtual:styleframe` module
+  - `shims.d.ts` — self-contained ambient declarations: a `declare module "virtual:styleframe"` carrying the full typed exports, plus the `virtual:styleframe.css` string shim
+
+  Non-Vue consumers resolve both virtual modules from `shims.d.ts` alone (picked up via the `.styleframe/**/*.d.ts` include) with **zero `paths` configuration**. Vue consumers additionally map `virtual:styleframe` to `styleframe.d.ts` via a `compilerOptions.paths` entry, because `vue-tsc` won't resolve a bare-specifier ambient module imported inside a `.vue` SFC. `styleframe init` detects plain Vue projects (a `vue` dependency without `nuxt`) and writes that `paths` entry only for them, merging into any existing `paths`; non-Vue projects just get the includes. Nuxt is excluded because its module already injects the mapping via `prepare:types`, and writing `paths` into an `extends`-based Nuxt root tsconfig would replace (not merge) Nuxt's inherited aliases.
+
+  The Nuxt module registers the same `virtual:styleframe` path mapping into Nuxt's generated types via the `prepare:types` hook, so imports type-check without manual tsconfig changes. It also fixes the module's `configKey`/`name`, which were leftover `unpluginStarter` placeholders that caused `styleframe: {}` options in `nuxt.config` to be ignored.
+
+- [#233](https://github.com/styleframe-dev/styleframe/pull/233) [`0ef38e6`](https://github.com/styleframe-dev/styleframe/commit/0ef38e69ca941cefab31463c23980f52cae1541f) Thanks [@alexgrozav](https://github.com/alexgrozav)! - Migrate from Vite 7 to Vite 8 with native Rolldown integration. Replace esbuild transforms with Oxc in the plugin, rename `rollupOptions` to `rolldownOptions`, upgrade `vite-plugin-dts` v4 to v5 (`rollupTypes` → `bundleTypes`), and bump vitest from v3 to v4.
+
+- Updated dependencies [[`19e9866`](https://github.com/styleframe-dev/styleframe/commit/19e986618c669546972924840189fc5f16f1a1cd), [`0ef38e6`](https://github.com/styleframe-dev/styleframe/commit/0ef38e69ca941cefab31463c23980f52cae1541f)]:
+  - @styleframe/figma@2.1.0
+  - @styleframe/loader@3.0.2
+
 ## 4.0.0
 
 ### Major Changes

package/dist/build-CBdsifMN.js

@@ -0,0 +1,47 @@
+import { defineCommand } from "citty";
+import path from "node:path";
+import { build, loadConfiguration } from "@styleframe/loader";
+import consola from "consola";
+//#region src/commands/build.ts
+var build_default = defineCommand({
+	meta: {
+		name: "build",
+		description: "Build Styleframe project from source files"
+	},
+	args: {
+		entry: {
+			type: "positional",
+			description: "Entry point file(s) for the build",
+			default: "styleframe.config.ts",
+			valueHint: "path"
+		},
+		outputDir: {
+			type: "string",
+			description: "Output directory for built files",
+			default: "styleframe",
+			alias: ["o", "out"],
+			valueHint: "path"
+		},
+		clean: {
+			type: "boolean",
+			description: "Clean output directory before build",
+			default: false
+		}
+	},
+	async run({ args }) {
+		consola.info(`Loading configuration from "${path.relative(process.cwd(), path.resolve(args.entry))}"...`);
+		const instance = await loadConfiguration({ entry: args.entry });
+		consola.info("Building styleframe...");
+		try {
+			await build(instance, {
+				outputDir: args.outputDir,
+				clean: args.clean
+			});
+			consola.success("Styleframe built successfully!");
+		} catch (error) {
+			consola.error("Failed to build Styleframe:", error);
+		}
+	}
+});
+//#endregion
+export { build_default as default };

package/dist/build-D7cinF0l.cjs

@@ -0,0 +1,50 @@
+const require_chunk = require("./chunk-D6vf50IK.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);
+//#region src/commands/build.ts
+var build_default = (0, citty.defineCommand)({
+	meta: {
+		name: "build",
+		description: "Build Styleframe project from source files"
+	},
+	args: {
+		entry: {
+			type: "positional",
+			description: "Entry point file(s) for the build",
+			default: "styleframe.config.ts",
+			valueHint: "path"
+		},
+		outputDir: {
+			type: "string",
+			description: "Output directory for built files",
+			default: "styleframe",
+			alias: ["o", "out"],
+			valueHint: "path"
+		},
+		clean: {
+			type: "boolean",
+			description: "Clean output directory before build",
+			default: false
+		}
+	},
+	async run({ args }) {
+		consola.default.info(`Loading configuration from "${node_path.default.relative(process.cwd(), node_path.default.resolve(args.entry))}"...`);
+		const instance = await (0, _styleframe_loader.loadConfiguration)({ entry: args.entry });
+		consola.default.info("Building styleframe...");
+		try {
+			await (0, _styleframe_loader.build)(instance, {
+				outputDir: args.outputDir,
+				clean: args.clean
+			});
+			consola.default.success("Styleframe built successfully!");
+		} catch (error) {
+			consola.default.error("Failed to build Styleframe:", error);
+		}
+	}
+});
+//#endregion
+exports.default = build_default;

package/dist/build-dtcg-BpbjBRCf.js

@@ -0,0 +1,429 @@
+import { classifyValue, formatAlias } from "@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 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: 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 = 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 = 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
+export { buildDTCG as t };