figma-console-mcp 1.33.2 → 1.35.0

package/dist/cloudflare/core/tokens/dialect.js

@@ -0,0 +1,232 @@
+/**
+ * DTCG dialect helpers — legacy vs 2025.10 value encodings.
+ *
+ * The token pipeline historically speaks the "legacy" DTCG dialect: colors
+ * as hex strings ("#4085F2"), FLOAT dimensions as bare numbers. The DTCG
+ * 2025.10 spec (https://tr.designtokens.org/format/) switched to object
+ * forms:
+ *
+ *   color     = { colorSpace: "srgb", components: [r, g, b], alpha?, hex? }
+ *   dimension = { value: number, unit: "px" | "rem" }
+ *   duration  = { value: number, unit: "ms" | "s" }   (we already emit this)
+ *
+ * Export stays legacy by default (downstream consumers depend on it) and
+ * opts into 2025 via the `dtcgDialect` option. Import accepts BOTH dialects
+ * unconditionally. This module centralizes:
+ *
+ *   - 2025 encoding helpers used by the dtcg/json formatters at render time
+ *   - dialect-agnostic canonicalization used by the import diff so a 2025
+ *     color object compares equal to the same color's legacy hex string
+ *     (both are quantized to 1/255 per channel, tolerating the 8-bit
+ *     precision loss inherent to hex)
+ *   - stripping of the transient `rawColor` field the converter carries on
+ *     COLOR TokenValues (full-precision floats for 2025 components) so it
+ *     never leaks into serialized output
+ */
+export function clamp01(n) {
+    if (Number.isNaN(n))
+        return 0;
+    return Math.max(0, Math.min(1, n));
+}
+function byteHex(f) {
+    return Math.round(clamp01(f) * 255)
+        .toString(16)
+        .padStart(2, "0");
+}
+/**
+ * Canonicalize any color-like literal to a lowercase 8-digit hex string
+ * (`#rrggbbaa`), or return null when the literal isn't recognizably a color.
+ *
+ * Accepts:
+ *   - hex strings: #rgb, #rrggbb, #rrggbbaa
+ *   - 2025.10 color objects with srgb (or unspecified) colorSpace +
+ *     3 numeric components (+ optional alpha)
+ *   - color objects with a hex fallback field (any colorSpace) + optional alpha
+ *
+ * Both the components form and the hex form quantize to 1 / 255 per channel,
+ * so a full-precision components array compares equal to the hex string the
+ * legacy pipeline derived from the same Figma floats.
+ */
+export function colorLiteralToCanonicalHex(literal) {
+    if (typeof literal === "string") {
+        const m = literal
+            .trim()
+            .match(/^#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i);
+        if (!m)
+            return null;
+        let digits = m[1].toLowerCase();
+        if (digits.length === 3) {
+            digits = digits
+                .split("")
+                .map((c) => c + c)
+                .join("");
+        }
+        if (digits.length === 6)
+            digits += "ff";
+        return `#${digits}`;
+    }
+    if (literal && typeof literal === "object" && !Array.isArray(literal)) {
+        const o = literal;
+        const colorSpace = typeof o.colorSpace === "string" ? o.colorSpace : undefined;
+        const comps = o.components;
+        if ((colorSpace === undefined || colorSpace === "srgb") &&
+            Array.isArray(comps) &&
+            comps.length === 3 &&
+            comps.every((c) => typeof c === "number")) {
+            const [r, g, b] = comps;
+            const a = typeof o.alpha === "number" ? o.alpha : 1;
+            return `#${byteHex(r)}${byteHex(g)}${byteHex(b)}${byteHex(a)}`;
+        }
+        if (typeof o.hex === "string") {
+            const base = colorLiteralToCanonicalHex(o.hex);
+            if (!base)
+                return null;
+            if (typeof o.alpha === "number") {
+                return base.slice(0, 7) + byteHex(o.alpha);
+            }
+            return base;
+        }
+    }
+    return null;
+}
+/**
+ * Parse a hex color string to raw rgba floats (0–1). Returns null on
+ * anything that isn't a valid 3/6/8-digit hex string.
+ */
+export function hexToRawRgba(hex) {
+    const canonical = colorLiteralToCanonicalHex(hex);
+    if (!canonical)
+        return null;
+    const d = canonical.slice(1);
+    return {
+        r: parseInt(d.slice(0, 2), 16) / 255,
+        g: parseInt(d.slice(2, 4), 16) / 255,
+        b: parseInt(d.slice(4, 6), 16) / 255,
+        a: parseInt(d.slice(6, 8), 16) / 255,
+    };
+}
+/**
+ * Encode a color TokenValue in the DTCG 2025.10 object form.
+ *
+ * Prefers the converter's transient `rawColor` floats (full precision — NOT
+ * round-tripped through 8-bit hex); falls back to parsing a hex-string
+ * literal. Literals already in object form pass through verbatim. Returns
+ * null when the value can't be encoded (caller keeps the legacy rendering).
+ *
+ * `alpha` is emitted only when < 1; `hex` is always included as the interop
+ * courtesy field (#RRGGBB, alpha carried separately).
+ */
+export function colorValueTo2025(value) {
+    const lit = value.literal;
+    if (lit && typeof lit === "object" && !Array.isArray(lit)) {
+        // Already object-form (e.g. a re-exported 2025 document) — pass through.
+        const o = lit;
+        if ("colorSpace" in o || "components" in o || "hex" in o)
+            return o;
+        return null;
+    }
+    let floats = value.rawColor ?? null;
+    if (!floats && typeof lit === "string") {
+        floats = hexToRawRgba(lit);
+    }
+    if (!floats)
+        return null;
+    const { r, g, b, a } = floats;
+    return {
+        colorSpace: "srgb",
+        components: [r, g, b],
+        ...(a < 1 ? { alpha: a } : {}),
+        hex: `#${byteHex(r)}${byteHex(g)}${byteHex(b)}`.toUpperCase(),
+    };
+}
+/**
+ * Encode a dimension literal in the DTCG 2025.10 object form. The converter
+ * emits Figma FLOAT dimensions as bare unitless numbers conventionally
+ * interpreted as px (the same convention the css/json formatters use), so
+ * only bare finite numbers are converted; everything else (unit strings,
+ * pre-encoded objects) keeps its current rendering.
+ */
+export function dimensionLiteralTo2025(literal) {
+    if (typeof literal === "number" && Number.isFinite(literal)) {
+        return { value: literal, unit: "px" };
+    }
+    return null;
+}
+/**
+ * Normalize a TokenValue to a dialect-agnostic comparable form for diffing:
+ *
+ *   - the transient `rawColor` field is dropped (Figma-side values carry it;
+ *     parsed code-side values never do)
+ *   - color-like literals (hex strings OR 2025 color objects) normalize to a
+ *     lowercase 8-digit hex string, quantized to 1/255 per channel
+ *   - `{ value, unit }` objects with px/ms normalize to the bare number
+ *     ("s" converts to ms first), so `{value: 16, unit: "px"}` equals 16 and
+ *     `{value: 0.3, unit: "s"}` equals `{value: 300, unit: "ms"}`
+ *   - "16px"-style strings normalize to the bare number
+ *
+ * Conservative by design: anything not confidently recognized is returned
+ * unchanged (minus rawColor), falling back to the existing deep comparison.
+ */
+export function canonicalizeTokenValueForComparison(v) {
+    if (v === null || typeof v !== "object" || Array.isArray(v))
+        return v;
+    const obj = v;
+    if (!("literal" in obj) && !("reference" in obj))
+        return v;
+    const { rawColor: _rawColor, ...rest } = obj;
+    if (rest.literal !== undefined) {
+        const hex = colorLiteralToCanonicalHex(rest.literal);
+        if (hex !== null)
+            return { ...rest, literal: hex };
+        const num = numericLiteralToCanonical(rest.literal);
+        if (num !== null)
+            return { ...rest, literal: num };
+    }
+    return rest;
+}
+/**
+ * Normalize dimension/duration-shaped literals to a bare comparable number:
+ *   - `{ value: n, unit: "px" | "ms" }` → n
+ *   - `{ value: n, unit: "s" }` → n * 1000 (canonical ms)
+ *   - `"16px"` strings → 16
+ * Returns null for everything else (including rem/em/% and objects with
+ * extra fields — those keep structural comparison).
+ */
+function numericLiteralToCanonical(literal) {
+    if (typeof literal === "string") {
+        const m = literal.trim().match(/^(-?(?:\d+\.?\d*|\.\d+))px$/i);
+        return m ? Number(m[1]) : null;
+    }
+    if (literal &&
+        typeof literal === "object" &&
+        !Array.isArray(literal) &&
+        Object.keys(literal).length === 2) {
+        const o = literal;
+        if (typeof o.value === "number" && typeof o.unit === "string") {
+            if (o.unit === "px" || o.unit === "ms")
+                return o.value;
+            if (o.unit === "s")
+                return o.value * 1000;
+        }
+    }
+    return null;
+}
+/**
+ * Return a copy of a mode-keyed TokenValue map with the transient `rawColor`
+ * field removed from every entry. Used wherever values get serialized
+ * (lastSyncedValue snapshots, diff-plan samples) so the transient field never
+ * appears in output — keeping legacy output byte-identical.
+ */
+export function stripRawColorFromValues(values) {
+    const out = {};
+    for (const [k, v] of Object.entries(values)) {
+        if (v && typeof v === "object" && "rawColor" in v) {
+            const { rawColor: _rawColor, ...rest } = v;
+            out[k] = rest;
+        }
+        else {
+            out[k] = v;
+        }
+    }
+    return out;
+}

package/dist/cloudflare/core/tokens/figma-converter.js

@@ -12,6 +12,7 @@
  * $extensions["figma-console-mcp"] for round-trip non-destructiveness.
  */
 import { slugifySetName } from "./alias-resolver.js";
+import { stripRawColorFromValues } from "./dialect.js";
 /**
  * Convert a Figma variables payload to our canonical TokenDocument.
  */
@@ -126,14 +127,35 @@ function convertVariable(variable, wantedModes, variableById, collectionNameById
                 // reconstruct it.
                 ...(strippedTypeSuffix ? { figmaName: variable.name } : {}),
                 ...(Object.keys(springByMode).length > 0 ? { spring: springByMode } : {}),
+                // Scopes: stash only when NON-default. ["ALL_SCOPES"] (Figma's
+                // default) and empty/absent arrays are omitted so pre-existing
+                // exports stay byte-identical. codeSyntax: stash only when
+                // non-empty, same reasoning.
+                ...(hasNonDefaultScopes(variable.scopes)
+                    ? { scopes: [...variable.scopes] }
+                    : {}),
+                ...(variable.codeSyntax && Object.keys(variable.codeSyntax).length > 0
+                    ? { codeSyntax: { ...variable.codeSyntax } }
+                    : {}),
                 lastSyncedAt: new Date().toISOString(),
                 // We snapshot the synced value so future merge calls can detect
-                // two-sided conflicts.
-                lastSyncedValue: { ...values },
+                // two-sided conflicts. rawColor is transient render-time data and
+                // must not leak into serialized extensions (legacy output stays
+                // byte-identical).
+                lastSyncedValue: stripRawColorFromValues({ ...values }),
             },
         },
     };
 }
+/**
+ * True when a variable's scopes array is meaningfully restrictive — i.e.
+ * present, non-empty, and not just the default ["ALL_SCOPES"].
+ */
+function hasNonDefaultScopes(scopes) {
+    if (!Array.isArray(scopes) || scopes.length === 0)
+        return false;
+    return !(scopes.length === 1 && scopes[0] === "ALL_SCOPES");
+}
 function mapResolvedType(resolvedType, variableName, warnings) {
     switch (resolvedType) {
         case "COLOR":
@@ -212,7 +234,19 @@ function convertValue(rawValue, variable, modeName, variableById, collectionName
     // Literal values per type.
     if (resolvedType === "COLOR") {
         if (typeof rawValue === "object" && rawValue !== null && "r" in rawValue) {
-            return { literal: rgbaToHex(rawValue) };
+            // The hex string stays the literal (legacy dialect + back-compat), but
+            // we also carry the raw full-precision floats so the 2025.10 dialect
+            // can emit `components` without round-tripping through 8-bit hex.
+            // `rawColor` is transient — see TokenValue.rawColor in types.ts.
+            return {
+                literal: rgbaToHex(rawValue),
+                rawColor: {
+                    r: rawValue.r,
+                    g: rawValue.g,
+                    b: rawValue.b,
+                    a: rawValue.a ?? 1,
+                },
+            };
         }
         warnings.push(`COLOR value isn't an RGB object: ${JSON.stringify(rawValue)}`);
         return { literal: String(rawValue) };

package/dist/cloudflare/core/tokens/formatters/dtcg.js

@@ -19,11 +19,12 @@
  *      structured $value form. Aliases emit `"$value": "{path.to.target}"`.
  *
  * This formatter is the canonical output — the format every other
- * formatter (CSS variables today, Tailwind/SCSS/etc. in future minor
- * versions) ultimately derives from.
+ * formatter (CSS variables, Tailwind v4/v3, SCSS, TS module, JSON
+ * flat/nested, Style Dictionary v3, Tokens Studio) ultimately derives from.
  */
 import { FIGMA_MCP_EXTENSION_KEY } from "../types.js";
 import { formatDtcgReference } from "../alias-resolver.js";
+import { colorValueTo2025, dimensionLiteralTo2025, } from "../dialect.js";
 export function formatDtcg(doc, opts) {
     const warnings = [];
     const files = [];
@@ -35,6 +36,9 @@ export function formatDtcg(doc, opts) {
     //   4. neither → one file with everything
     const splitByMode = opts.target.splitByMode ?? false;
     const splitByCollection = opts.target.splitByCollection ?? false;
+    // Value-encoding dialect. 'legacy' (default) is byte-identical to the
+    // historical output; '2025' opts into DTCG 2025.10 object colors/dimensions.
+    const dialect = opts.target.dtcgDialect ?? "legacy";
     if (splitByMode && splitByCollection) {
         for (const set of doc.sets) {
             for (const mode of set.modes) {
@@ -43,7 +47,7 @@ export function formatDtcg(doc, opts) {
                     .filter((t) => t !== null);
                 files.push({
                     path: filenameFor(opts, set, mode),
-                    content: serializeAsDtcg({ sets: [{ ...set, modes: [mode], tokens: fileTokens }], meta: doc.meta }, warnings, mode),
+                    content: serializeAsDtcg({ sets: [{ ...set, modes: [mode], tokens: fileTokens }], meta: doc.meta }, warnings, dialect, mode),
                 });
             }
         }
@@ -65,7 +69,7 @@ export function formatDtcg(doc, opts) {
             }));
             files.push({
                 path: filenameFor(opts, undefined, mode),
-                content: serializeAsDtcg({ sets: fileSets, meta: doc.meta }, warnings, mode),
+                content: serializeAsDtcg({ sets: fileSets, meta: doc.meta }, warnings, dialect, mode),
             });
         }
     }
@@ -73,14 +77,14 @@ export function formatDtcg(doc, opts) {
         for (const set of doc.sets) {
             files.push({
                 path: filenameFor(opts, set),
-                content: serializeAsDtcg({ sets: [set], meta: doc.meta }, warnings),
+                content: serializeAsDtcg({ sets: [set], meta: doc.meta }, warnings, dialect),
             });
         }
     }
     else {
         files.push({
             path: filenameFor(opts),
-            content: serializeAsDtcg(doc, warnings),
+            content: serializeAsDtcg(doc, warnings, dialect),
         });
     }
     return { files, warnings };
@@ -131,7 +135,7 @@ function slugify(s) {
  * file represents — otherwise the parser sees only `$value` literals and
  * labels them "Default", which breaks round-trip diffs on multi-mode files.
  */
-function serializeAsDtcg(doc, warnings, fileMode) {
+function serializeAsDtcg(doc, warnings, dialect, fileMode) {
     // Build the nested DTCG group tree by walking every token's path and
     // building groups along the way.
     const tree = {};
@@ -176,7 +180,7 @@ function serializeAsDtcg(doc, warnings, fileMode) {
             tree[setKey] = setGroup;
         }
         for (const token of set.tokens) {
-            writeTokenIntoTree(setGroup, token, set.modes, warnings, fileMode);
+            writeTokenIntoTree(setGroup, token, set.modes, warnings, dialect, fileMode);
         }
     }
     return JSON.stringify(sortKeys(tree), null, 2) + "\n";
@@ -200,7 +204,7 @@ function setKeyFor(set) {
  * figma-console-mcp $extensions so the parser can restore the original
  * name on round-trip. A warning names both sides of the conflict.
  */
-function writeTokenIntoTree(root, token, setModes, warnings, fileMode) {
+function writeTokenIntoTree(root, token, setModes, warnings, dialect, fileMode) {
     let cursor = root;
     for (let i = 0; i < token.path.length - 1; i++) {
         const segment = token.path[i];
@@ -222,7 +226,7 @@ function writeTokenIntoTree(root, token, setModes, warnings, fileMode) {
         cursor = next;
     }
     const leafKey = token.path[token.path.length - 1];
-    const rendered = renderToken(token, setModes, warnings, fileMode);
+    const rendered = renderToken(token, setModes, warnings, dialect, fileMode);
     const existing = cursor[leafKey];
     if (existing &&
         typeof existing === "object" &&
@@ -261,7 +265,7 @@ function isToken(node) {
  * splitByMode. Callers who want one-file-per-mode should set splitByMode at
  * the formatter level.
  */
-function renderToken(token, setModes, warnings, fileMode) {
+function renderToken(token, setModes, warnings, dialect, fileMode) {
     const result = {
         $value: "",
         $type: token.type,
@@ -273,13 +277,13 @@ function renderToken(token, setModes, warnings, fileMode) {
     // Pick the primary mode: the set's first mode when the token has a value
     // for it, otherwise the token's first mode.
     const primaryMode = setModes[0] in token.values ? setModes[0] : modeKeys[0];
-    result.$value = encodeValue(token.values[primaryMode], token, warnings);
+    result.$value = encodeValue(token.values[primaryMode], token, warnings, dialect);
     const otherModes = {};
     if (!isSingleMode) {
         for (const m of modeKeys) {
             if (m === primaryMode)
                 continue;
-            otherModes[m] = encodeValue(token.values[m], token, warnings);
+            otherModes[m] = encodeValue(token.values[m], token, warnings, dialect);
         }
     }
     // Preserve any pre-existing extensions (e.g. studio.tokens, our own metadata).
@@ -311,7 +315,7 @@ function renderToken(token, setModes, warnings, fileMode) {
     }
     return result;
 }
-function encodeValue(value, token, warnings) {
+function encodeValue(value, token, warnings, dialect) {
     if (!value) {
         warnings.push(`Token ${token.path.join(".")} has no mode values — emitting empty string.`);
         return "";
@@ -323,6 +327,23 @@ function encodeValue(value, token, warnings) {
         warnings.push(`Token ${token.path.join(".")} has neither literal nor reference — emitting empty string.`);
         return "";
     }
+    // DTCG 2025.10 dialect: colors emit the object form (components from the
+    // converter's full-precision rawColor floats, hex kept as the interop
+    // courtesy field); dimension-typed bare numbers emit { value, unit: "px" }.
+    // duration already emits { value, unit: "ms" } in both dialects. Anything
+    // the encoders don't recognize keeps the legacy rendering.
+    if (dialect === "2025") {
+        if (token.type === "color") {
+            const encoded = colorValueTo2025(value);
+            if (encoded)
+                return encoded;
+        }
+        else if (token.type === "dimension") {
+            const encoded = dimensionLiteralTo2025(value.literal);
+            if (encoded)
+                return encoded;
+        }
+    }
     return value.literal;
 }
 function mergeExtension(token, key, payload) {

package/dist/cloudflare/core/tokens/formatters/json.js

@@ -31,11 +31,13 @@
  * aliases get a `null` (caller can decide how to fill those in).
  */
 import { buildTokenIndex, resolveAliasChain } from "../alias-resolver.js";
+import { colorValueTo2025, dimensionLiteralTo2025, } from "../dialect.js";
 export function formatJsonFlat(doc, opts) {
     const warnings = [];
     const files = [];
     const splitByCollection = opts.target.splitByCollection ?? false;
     const prefix = opts.target.prefix ?? "";
+    const dialect = opts.target.dtcgDialect ?? "legacy";
     // Plain JSON has no native alias mechanism — resolve aliases to their
     // literal target so consumers get usable values, not opaque `{ref}` strings.
     const tokenIndex = buildTokenIndex(doc);
@@ -43,14 +45,14 @@ export function formatJsonFlat(doc, opts) {
         for (const set of doc.sets) {
             files.push({
                 path: filenameFor(opts, set, "flat"),
-                content: renderFlat([set], prefix, tokenIndex, warnings),
+                content: renderFlat([set], prefix, tokenIndex, warnings, dialect),
             });
         }
     }
     else {
         files.push({
             path: filenameFor(opts, undefined, "flat"),
-            content: renderFlat(doc.sets, prefix, tokenIndex, warnings),
+            content: renderFlat(doc.sets, prefix, tokenIndex, warnings, dialect),
         });
     }
     return { files, warnings };
@@ -59,19 +61,20 @@ export function formatJsonNested(doc, opts) {
     const warnings = [];
     const files = [];
     const splitByCollection = opts.target.splitByCollection ?? false;
+    const dialect = opts.target.dtcgDialect ?? "legacy";
     const tokenIndex = buildTokenIndex(doc);
     if (splitByCollection) {
         for (const set of doc.sets) {
             files.push({
                 path: filenameFor(opts, set, "nested"),
-                content: renderNested([set], tokenIndex, warnings),
+                content: renderNested([set], tokenIndex, warnings, dialect),
             });
         }
     }
     else {
         files.push({
             path: filenameFor(opts, undefined, "nested"),
-            content: renderNested(doc.sets, tokenIndex, warnings),
+            content: renderNested(doc.sets, tokenIndex, warnings, dialect),
         });
     }
     return { files, warnings };
@@ -92,7 +95,7 @@ function slugify(s) {
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-+|-+$/g, "");
 }
-function renderFlat(sets, prefix, tokenIndex, warnings) {
+function renderFlat(sets, prefix, tokenIndex, warnings, dialect) {
     const out = {};
     for (const set of sets) {
         const primaryMode = pickPrimaryMode(set.modes);
@@ -102,7 +105,7 @@ function renderFlat(sets, prefix, tokenIndex, warnings) {
                 const key = modeName === primaryMode
                     ? baseName
                     : `${baseName}--${slugify(modeName)}`;
-                const resolved = resolveValue(value, token, modeName, tokenIndex, warnings);
+                const resolved = resolveValue(value, token, modeName, tokenIndex, warnings, dialect);
                 if (resolved !== undefined)
                     out[key] = resolved;
             }
@@ -112,7 +115,7 @@ function renderFlat(sets, prefix, tokenIndex, warnings) {
     const sorted = Object.fromEntries(Object.entries(out).sort(([a], [b]) => a.localeCompare(b)));
     return JSON.stringify(sorted, null, 2) + "\n";
 }
-function renderNested(sets, tokenIndex, warnings) {
+function renderNested(sets, tokenIndex, warnings, dialect) {
     const out = {};
     for (const set of sets) {
         const isMultiMode = set.modes.length > 1;
@@ -131,7 +134,7 @@ function renderNested(sets, tokenIndex, warnings) {
             if (isMultiMode) {
                 const modeValues = {};
                 for (const [modeName, value] of Object.entries(token.values)) {
-                    const resolved = resolveValue(value, token, modeName, tokenIndex, warnings);
+                    const resolved = resolveValue(value, token, modeName, tokenIndex, warnings, dialect);
                     if (resolved !== undefined)
                         modeValues[modeName] = resolved;
                 }
@@ -140,7 +143,7 @@ function renderNested(sets, tokenIndex, warnings) {
             else {
                 const [onlyModeName, onlyValue] = Object.entries(token.values)[0] ?? [];
                 if (onlyValue) {
-                    const resolved = resolveValue(onlyValue, token, onlyModeName, tokenIndex, warnings);
+                    const resolved = resolveValue(onlyValue, token, onlyModeName, tokenIndex, warnings, dialect);
                     if (resolved !== undefined)
                         cursor[leafKey] = resolved;
                 }
@@ -152,7 +155,7 @@ function renderNested(sets, tokenIndex, warnings) {
 function pickPrimaryMode(modes) {
     return modes.find((m) => /^(default|light|value)$/i.test(m)) ?? modes[0];
 }
-function resolveValue(value, token, mode, tokenIndex, warnings) {
+function resolveValue(value, token, mode, tokenIndex, warnings, dialect) {
     let effective = value;
     if (value.reference) {
         effective = resolveAliasChain(value, mode, tokenIndex);
@@ -168,6 +171,21 @@ function resolveValue(value, token, mode, tokenIndex, warnings) {
     if (!effective || effective.literal === undefined || effective.literal === null) {
         return undefined;
     }
+    // DTCG 2025.10 dialect (opt-in): colors emit the object form, dimensions
+    // emit { value, unit: "px" }. Legacy (default) keeps hex strings and
+    // "16px" strings — byte-identical to historical output.
+    if (dialect === "2025") {
+        if (token.type === "color") {
+            const encoded = colorValueTo2025(effective);
+            if (encoded)
+                return encoded;
+        }
+        else if (token.type === "dimension") {
+            const encoded = dimensionLiteralTo2025(effective.literal);
+            if (encoded)
+                return encoded;
+        }
+    }
     if (typeof effective.literal === "number") {
         if (token.type === "dimension")
             return `${effective.literal}px`;

package/dist/cloudflare/core/tokens/index.js

@@ -11,5 +11,6 @@ export { TokensConfigSchema, loadTokensConfig, findTokensConfig, DEFAULT_TOKENS_
 export { ExportTokensInputSchema, ImportTokensInputSchema, ExportFormatSchema, ImportFormatSchema, SyncStrategySchema, ConflictResolutionSchema, } from "./schemas.js";
 export { parse, detectFormat, } from "./parsers/index.js";
 export { format, } from "./formatters/index.js";
-export { buildTokenIndex, resolveReference, resolveAliasChain, validateAliases, formatDtcgReference, parseDtcgReference, referenceTargetPath, slugifySetName, } from "./alias-resolver.js";
+export { buildTokenIndex, buildTokenLookup, resolveReference, resolveAliasChain, validateAliases, formatDtcgReference, parseDtcgReference, referenceTargetPath, slugifySetName, } from "./alias-resolver.js";
 export { convertFigmaVariablesToDocument, } from "./figma-converter.js";
+export { canonicalizeTokenValueForComparison, colorLiteralToCanonicalHex, colorValueTo2025, dimensionLiteralTo2025, hexToRawRgba, stripRawColorFromValues, clamp01, } from "./dialect.js";

package/dist/cloudflare/core/tokens/schemas.js

@@ -88,6 +88,10 @@ export const ExportTokensInputSchema = z.object({
         .boolean()
         .optional()
         .describe("Emit one file per Figma collection. Default false. Useful when collections map to different runtime themes."),
+    dtcgDialect: z
+        .enum(["legacy", "2025"])
+        .optional()
+        .describe("DTCG dialect for dtcg/json-flat/json-nested outputs. legacy (default): hex-string colors, maximum compatibility (Style Dictionary v4, Tokens Studio). 2025: DTCG 2025.10 object colors/dimensions (Style Dictionary v5+). Other formats (css-vars, scss, tailwind, ts-module) render final code and ignore this option."),
     colorFormat: ColorFormatSchema.optional().describe("Color value format in the output. Default: 'hex'. Use 'oklch' for modern Tailwind v4 charts."),
     sizeUnit: SizeUnitSchema.optional().describe("Unit for dimension tokens. Default: 'rem' for web outputs, 'pt' for iOS, 'dp' for Android."),
     remBase: z