@3fn/core 13.0.0

package/dist/generators/DTCGFormatGenerator.js

@@ -0,0 +1,1224 @@
+"use strict";
+/**
+ * DTCG Token Format Generator
+ *
+ * Transforms DesignerPunk Rosetta System tokens into DTCG (Design Tokens Community Group)
+ * Format Module 2025.10 compliant JSON output. Enables integration with industry-standard
+ * design tools (Figma, Style Dictionary, Tokens Studio, Terrazzo) while preserving
+ * DesignerPunk's mathematical foundations and governance rules through extensions.
+ *
+ * Key Principle: DTCG output is a parallel export for external tools.
+ * DesignerPunk components continue importing tokens from TypeScript sources.
+ * Code (Rosetta) remains the source of truth.
+ *
+ * @see https://tr.designtokens.org/format/
+ * @requirements 7.1, 10.1-10.5
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DTCGFormatGenerator = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const DTCGGeneratorConfig_1 = require("./DTCGGeneratorConfig");
+const index_1 = require("../tokens/index");
+const index_2 = require("../tokens/semantic/index");
+// Primitive token imports
+const SpacingTokens_1 = require("../tokens/SpacingTokens");
+const ColorTokens_1 = require("../tokens/ColorTokens");
+const FontSizeTokens_1 = require("../tokens/FontSizeTokens");
+const FontWeightTokens_1 = require("../tokens/FontWeightTokens");
+const FontFamilyTokens_1 = require("../tokens/FontFamilyTokens");
+const LineHeightTokens_1 = require("../tokens/LineHeightTokens");
+const LetterSpacingTokens_1 = require("../tokens/LetterSpacingTokens");
+const RadiusTokens_1 = require("../tokens/RadiusTokens");
+const BorderWidthTokens_1 = require("../tokens/BorderWidthTokens");
+const TapAreaTokens_1 = require("../tokens/TapAreaTokens");
+const DensityTokens_1 = require("../tokens/DensityTokens");
+const BreakpointTokens_1 = require("../tokens/BreakpointTokens");
+const OpacityTokens_1 = require("../tokens/OpacityTokens");
+const DurationTokens_1 = require("../tokens/DurationTokens");
+const EasingTokens_1 = require("../tokens/EasingTokens");
+const ScaleTokens_1 = require("../tokens/ScaleTokens");
+const BlendTokens_1 = require("../tokens/BlendTokens");
+// Shadow primitive token imports
+const BlurTokens_1 = require("../tokens/BlurTokens");
+const SizingTokens_1 = require("../tokens/SizingTokens");
+const ShadowOffsetTokens_1 = require("../tokens/ShadowOffsetTokens");
+const ShadowOpacityTokens_1 = require("../tokens/ShadowOpacityTokens");
+// Glow primitive token imports
+const GlowOpacityTokens_1 = require("../tokens/GlowOpacityTokens");
+// Semantic token imports
+const ColorTokens_2 = require("../tokens/semantic/ColorTokens");
+const SpacingTokens_2 = require("../tokens/semantic/SpacingTokens");
+const BorderWidthTokens_2 = require("../tokens/semantic/BorderWidthTokens");
+const RadiusTokens_2 = require("../tokens/semantic/RadiusTokens");
+const OpacityTokens_2 = require("../tokens/semantic/OpacityTokens");
+const BlendTokens_2 = require("../tokens/semantic/BlendTokens");
+const ZIndexTokens_1 = require("../tokens/semantic/ZIndexTokens");
+const ElevationTokens_1 = require("../tokens/semantic/ElevationTokens");
+const GridSpacingTokens_1 = require("../tokens/semantic/GridSpacingTokens");
+const IconTokens_1 = require("../tokens/semantic/IconTokens");
+const AccessibilityTokens_1 = require("../tokens/semantic/AccessibilityTokens");
+const MotionTokens_1 = require("../tokens/semantic/MotionTokens");
+const TypographyTokens_1 = require("../tokens/semantic/TypographyTokens");
+const ColorTokens_3 = require("../tokens/semantic/ColorTokens");
+const ShadowTokens_1 = require("../tokens/semantic/ShadowTokens");
+const SemanticOverrides_1 = require("../tokens/themes/dark/SemanticOverrides");
+const SemanticValueResolver_1 = require("../resolvers/SemanticValueResolver");
+/** Set of valid DTCG types for validation (Format Module 2025.10) */
+const VALID_DTCG_TYPES = new Set([
+    'color', 'dimension', 'fontFamily', 'fontWeight', 'duration',
+    'cubicBezier', 'linearEasing', 'number', 'shadow', 'typography', 'transition',
+]);
+/** Minimum expected primitive token count (programmatic validation threshold) */
+const MIN_PRIMITIVE_TOKEN_COUNT = 200;
+/** Minimum expected semantic token count (programmatic validation threshold) */
+const MIN_SEMANTIC_TOKEN_COUNT = 180;
+/**
+ * DTCGFormatGenerator — Main generator class that orchestrates token transformation
+ * from Rosetta System tokens to DTCG Format Module 2025.10 compliant JSON.
+ *
+ * Usage:
+ * ```typescript
+ * const generator = new DTCGFormatGenerator();
+ * const output = generator.generate();
+ * generator.writeToFile('dist/DesignTokens.dtcg.json');
+ * ```
+ */
+class DTCGFormatGenerator {
+    constructor(config = {}) {
+        this.config = { ...DTCGGeneratorConfig_1.DEFAULT_DTCG_GENERATOR_CONFIG, ...config };
+    }
+    /**
+     * Generate DTCG-compliant JSON from Rosetta tokens.
+     *
+     * Orchestrates all token generation methods, adds root-level metadata,
+     * and validates token counts before returning the complete DTCG output.
+     *
+     * @returns Complete DTCGTokenFile ready for serialization
+     * @throws Error if token count validation fails
+     */
+    generate() {
+        const output = {
+            $schema: this.config.schemaUrl,
+        };
+        // Add root-level DesignerPunk extensions (version, generatedAt, rosettaVersion)
+        if (this.config.includeExtensions) {
+            output.$extensions = {
+                designerpunk: this.generateRootExtensions(),
+            };
+        }
+        // --- Primitive token groups ---
+        // Each method will be implemented in Task 2.2
+        output.space = this.generateSpacingTokens();
+        output.color = this.generateColorTokens();
+        output.fontSize = this.generateFontSizeTokens();
+        output.fontWeight = this.generateFontWeightTokens();
+        output.fontFamily = this.generateFontFamilyTokens();
+        output.lineHeight = this.generateLineHeightTokens();
+        output.letterSpacing = this.generateLetterSpacingTokens();
+        output.radius = this.generateRadiusTokens();
+        output.borderWidth = this.generateBorderWidthTokens();
+        output.tapArea = this.generateTapAreaTokens();
+        output.density = this.generateDensityTokens();
+        output.breakpoint = this.generateBreakpointTokens();
+        output.opacity = this.generateOpacityTokens();
+        output.duration = this.generateDurationTokens();
+        output.easing = this.generateEasingTokens();
+        output.scale = this.generateScaleTokens();
+        output.blend = this.generateBlendTokens();
+        output.blur = this.generateBlurTokens();
+        output.sizing = this.generateSizingTokens();
+        // --- Semantic token groups ---
+        output.semanticColor = this.generateSemanticColorTokens();
+        output.semanticSpace = this.generateSemanticSpacingTokens();
+        output.semanticBorderWidth = this.generateSemanticBorderWidthTokens();
+        output.semanticRadius = this.generateSemanticRadiusTokens();
+        output.semanticOpacity = this.generateSemanticOpacityTokens();
+        output.semanticBlend = this.generateSemanticBlendTokens();
+        output.gridSpacing = this.generateGridSpacingTokens();
+        output.icon = this.generateIconTokens();
+        output.accessibility = this.generateAccessibilityTokens();
+        output.progressColor = this.generateProgressColorTokens();
+        output.zIndex = this.generateZIndexTokens();
+        output.elevation = this.generateElevationTokens();
+        // --- Shadow & glow token groups (Tasks 2.4, 2.5) ---
+        output.shadow = this.generateShadowTokens();
+        output.glow = this.generateGlowTokens();
+        // --- Composite token groups (Task 2.6) ---
+        output.typography = this.generateTypographyTokens();
+        output.motion = this.generateMotionTokens();
+        // Validate token counts against expected minimums
+        this.validateTokenCounts(output);
+        // Post-processing: strip deprecated tokens if configured
+        if (!this.config.includeDeprecated) {
+            this.stripDeprecatedTokens(output);
+        }
+        return output;
+    }
+    /**
+     * Write generated DTCG output to a JSON file.
+     *
+     * Creates the output directory if it doesn't exist. Overwrites existing files
+     * without prompting (generation is idempotent).
+     *
+     * @param outputPath - File path for the output (e.g., 'dist/DesignTokens.dtcg.json')
+     * @throws Error if file write fails (permissions, disk full, etc.)
+     */
+    writeToFile(outputPath) {
+        const output = this.generate();
+        const indent = this.config.prettyPrint ? 2 : undefined;
+        const json = JSON.stringify(output, null, indent);
+        try {
+            const dir = path.dirname(outputPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(outputPath, json, 'utf-8');
+            // Log generation summary
+            const primitiveCount = (0, index_1.getAllPrimitiveTokens)().length;
+            const semanticCount = (0, index_2.getAllSemanticTokens)().length;
+            console.log(`✅ DTCG output written to ${outputPath} — Generated ${primitiveCount} primitive tokens, ${semanticCount} semantic tokens`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to write DTCG output to ${outputPath}: ${message}`);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    /**
+     * Generate root-level DesignerPunk extension metadata.
+     *
+     * Includes generator version, generation timestamp, and Rosetta system version
+     * for traceability and debugging.
+     */
+    generateRootExtensions() {
+        // Read version from package.json at runtime
+        let rosettaVersion = 'unknown';
+        try {
+            const pkgPath = path.resolve(__dirname, '../../package.json');
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            rosettaVersion = pkg.version || 'unknown';
+        }
+        catch {
+            // Fallback — package.json not found or unreadable
+        }
+        const extensions = {
+            version: '1.0.0',
+            generatedAt: new Date().toISOString(),
+            rosettaVersion,
+        };
+        // Include registered theme metadata when themes are configured (Spec 094)
+        if (this.config.registeredThemes.length > 0) {
+            extensions.themes = this.config.registeredThemes;
+        }
+        return extensions;
+    }
+    /**
+     * Validate that generated token counts meet expected minimums.
+     *
+     * Uses programmatic counting via getAllPrimitiveTokens() and getAllSemanticTokens()
+     * rather than hard-coded values, so validation stays current as the token system grows.
+     *
+     * @param _output - The generated DTCGTokenFile (reserved for future per-group validation)
+     * @throws Error if primitive or semantic token counts fall below minimum thresholds
+     */
+    validateTokenCounts(_output) {
+        const primitiveCount = (0, index_1.getAllPrimitiveTokens)().length;
+        const semanticCount = (0, index_2.getAllSemanticTokens)().length;
+        if (primitiveCount < MIN_PRIMITIVE_TOKEN_COUNT) {
+            throw new Error(`Token count validation failed. Expected at least ${MIN_PRIMITIVE_TOKEN_COUNT} primitive tokens, got ${primitiveCount}. ` +
+                `This may indicate a missing token category in the generator.`);
+        }
+        if (semanticCount < MIN_SEMANTIC_TOKEN_COUNT) {
+            throw new Error(`Token count validation failed. Expected at least ${MIN_SEMANTIC_TOKEN_COUNT} semantic tokens, got ${semanticCount}. ` +
+                `This may indicate a missing semantic token category in the generator.`);
+        }
+    }
+    /**
+     * Remove deprecated tokens from the output when includeDeprecated is false.
+     *
+     * Recursively walks the DTCG output tree and removes any token that has
+     * `$extensions.designerpunk.deprecated: true`. This preserves the group structure
+     * while filtering out individual deprecated tokens.
+     *
+     * @param obj - The DTCG output object to filter (mutated in place)
+     */
+    stripDeprecatedTokens(obj) {
+        for (const key of Object.keys(obj)) {
+            if (key.startsWith('$'))
+                continue; // Skip DTCG meta-properties
+            const value = obj[key];
+            if (value && typeof value === 'object') {
+                const token = value;
+                // Check if this is a token with deprecated extension
+                const extensions = token.$extensions;
+                if (extensions?.designerpunk?.deprecated) {
+                    delete obj[key];
+                }
+                else {
+                    // Recurse into groups
+                    this.stripDeprecatedTokens(token);
+                }
+            }
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Token generation stubs — implemented in Tasks 2.2–2.6
+    // ---------------------------------------------------------------------------
+    // ---------------------------------------------------------------------------
+    // Primitive token generation (Task 2.2)
+    // ---------------------------------------------------------------------------
+    /**
+     * Generate spacing primitive tokens as DTCG dimension type.
+     * Maps spacing baseValue to `{value}px` dimension format.
+     */
+    generateSpacingTokens() {
+        return this.generateDimensionGroup(SpacingTokens_1.spacingTokens, 'spacing', SpacingTokens_1.SPACING_BASE_VALUE);
+    }
+    /**
+     * Generate color primitive tokens as DTCG color type.
+     * Resolves mode-aware RGBA values using light.base as default.
+     */
+    generateColorTokens() {
+        const group = { $type: 'color' };
+        for (const [key, token] of Object.entries(ColorTokens_1.colorTokens)) {
+            const colorValue = this.resolveColorValue(token, key);
+            const extensions = this.buildPrimitiveExtensions(token, 'color');
+            group[key] = this.toDTCGToken(colorValue, 'color', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate font size primitive tokens as DTCG dimension type.
+     * Uses baseValue (unitless) converted to `{value}px`.
+     */
+    generateFontSizeTokens() {
+        return this.generateDimensionGroup(FontSizeTokens_1.fontSizeTokens, 'fontSize', FontSizeTokens_1.FONT_SIZE_BASE_VALUE);
+    }
+    /**
+     * Generate font weight primitive tokens as DTCG fontWeight type.
+     * Font weights are numeric values (100–900).
+     */
+    generateFontWeightTokens() {
+        const group = { $type: 'fontWeight' };
+        for (const [key, token] of Object.entries(FontWeightTokens_1.fontWeightTokens)) {
+            const extensions = this.buildPrimitiveExtensions(token, 'fontWeight', FontWeightTokens_1.FONT_WEIGHT_BASE_VALUE);
+            group[key] = this.toDTCGToken(token.baseValue, 'fontWeight', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate font family primitive tokens as DTCG fontFamily type.
+     * DTCG fontFamily expects an array of font names.
+     */
+    generateFontFamilyTokens() {
+        const group = { $type: 'fontFamily' };
+        for (const [key, token] of Object.entries(FontFamilyTokens_1.fontFamilyTokens)) {
+            const fontStack = String(token.platforms.web.value);
+            const families = fontStack.split(',').map(f => f.trim().replace(/^["']|["']$/g, ''));
+            const extensions = this.buildPrimitiveExtensions(token, 'fontFamily');
+            group[key] = this.toDTCGToken(families, 'fontFamily', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate line height primitive tokens as DTCG number type.
+     * Line heights are unitless multipliers.
+     */
+    generateLineHeightTokens() {
+        const group = { $type: 'number' };
+        for (const [key, token] of Object.entries(LineHeightTokens_1.lineHeightTokens)) {
+            const extensions = this.buildPrimitiveExtensions(token, 'lineHeight', LineHeightTokens_1.LINE_HEIGHT_BASE_VALUE);
+            group[key] = this.toDTCGToken(token.baseValue, 'number', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate letter spacing primitive tokens as DTCG dimension type.
+     * Letter spacing uses em units.
+     */
+    generateLetterSpacingTokens() {
+        const group = { $type: 'dimension' };
+        for (const [key, token] of Object.entries(LetterSpacingTokens_1.letterSpacingTokens)) {
+            const extensions = this.buildPrimitiveExtensions(token, 'letterSpacing', LetterSpacingTokens_1.LETTER_SPACING_BASE_VALUE);
+            group[key] = this.toDTCGToken(`${token.baseValue}em`, 'dimension', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate radius primitive tokens as DTCG dimension type.
+     * Handles special cases: radiusMax (9999px), radiusHalf (50%).
+     */
+    generateRadiusTokens() {
+        const group = { $type: 'dimension' };
+        for (const [key, token] of Object.entries(RadiusTokens_1.radiusTokens)) {
+            let value;
+            if (token.name === 'radiusHalf') {
+                value = '50%';
+            }
+            else {
+                value = `${token.baseValue}px`;
+            }
+            const extensions = this.buildPrimitiveExtensions(token, 'radius', RadiusTokens_1.RADIUS_BASE_VALUE);
+            group[key] = this.toDTCGToken(value, 'dimension', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate border width primitive tokens as DTCG dimension type.
+     */
+    generateBorderWidthTokens() {
+        return this.generateDimensionGroup(BorderWidthTokens_1.borderWidthTokens, 'borderWidth', BorderWidthTokens_1.BORDER_WIDTH_BASE_VALUE);
+    }
+    /**
+     * Generate tap area primitive tokens as DTCG dimension type.
+     */
+    generateTapAreaTokens() {
+        return this.generateDimensionGroup(TapAreaTokens_1.tapAreaTokens, 'tapArea', TapAreaTokens_1.TAP_AREA_BASE_VALUE);
+    }
+    /**
+     * Generate density primitive tokens as DTCG number type.
+     * Density values are unitless multipliers.
+     */
+    generateDensityTokens() {
+        const group = { $type: 'number' };
+        for (const [key, token] of Object.entries(DensityTokens_1.densityTokens)) {
+            const extensions = this.buildPrimitiveExtensions(token, 'density', DensityTokens_1.DENSITY_BASE_VALUE);
+            group[key] = this.toDTCGToken(token.baseValue, 'number', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate breakpoint primitive tokens as DTCG dimension type.
+     */
+    generateBreakpointTokens() {
+        return this.generateDimensionGroup(BreakpointTokens_1.breakpointTokens, 'breakpoint', BreakpointTokens_1.BREAKPOINT_BASE_VALUE);
+    }
+    /**
+     * Generate opacity primitive tokens as DTCG number type.
+     * Opacity values are unitless (0–1).
+     */
+    generateOpacityTokens() {
+        const group = { $type: 'number' };
+        for (const [key, token] of Object.entries(OpacityTokens_1.opacityTokens)) {
+            const extensions = this.buildPrimitiveExtensions(token, 'opacity', OpacityTokens_1.OPACITY_BASE_VALUE);
+            group[key] = this.toDTCGToken(token.baseValue, 'number', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate duration primitive tokens as DTCG duration type.
+     * DTCG duration format: `{value}ms`.
+     */
+    generateDurationTokens() {
+        const group = { $type: 'duration' };
+        for (const [key, token] of Object.entries(DurationTokens_1.durationTokens)) {
+            const extensions = this.buildPrimitiveExtensions(token, 'duration', DurationTokens_1.DURATION_BASE_VALUE);
+            group[key] = this.toDTCGToken(`${token.baseValue}ms`, 'duration', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate easing primitive tokens as DTCG cubicBezier type.
+     * Parses cubic-bezier CSS string into [p1, p2, p3, p4] array.
+     */
+    generateEasingTokens() {
+        const group = {};
+        for (const [key, token] of Object.entries(EasingTokens_1.easingTokens)) {
+            const extensions = this.buildPrimitiveExtensions(token, 'easing');
+            if (token.easingType === 'linear' && token.stops) {
+                group[key] = this.toDTCGToken(token.stops, 'linearEasing', token.description, extensions);
+            }
+            else {
+                const bezierStr = String(token.platforms.web.value);
+                const match = bezierStr.match(/cubic-bezier\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*\)/);
+                if (!match) {
+                    throw new Error(`Invalid easing value for ${token.name}: ${bezierStr}. Expected cubic-bezier(p1, p2, p3, p4) format.`);
+                }
+                const bezierArray = [parseFloat(match[1]), parseFloat(match[2]), parseFloat(match[3]), parseFloat(match[4])];
+                group[key] = this.toDTCGToken(bezierArray, 'cubicBezier', token.description, extensions);
+            }
+        }
+        return group;
+    }
+    /**
+     * Generate scale primitive tokens as DTCG number type.
+     * Scale values are unitless multipliers.
+     */
+    generateScaleTokens() {
+        const group = { $type: 'number' };
+        for (const [key, token] of Object.entries(ScaleTokens_1.scaleTokens)) {
+            const extensions = this.buildPrimitiveExtensions(token, 'scale', ScaleTokens_1.SCALE_BASE_VALUE);
+            group[key] = this.toDTCGToken(token.baseValue, 'number', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate blur primitive tokens as DTCG dimension type.
+     */
+    generateBlurTokens() {
+        const group = { $type: 'dimension' };
+        for (const [key, token] of Object.entries(BlurTokens_1.blur)) {
+            const extensions = this.buildPrimitiveExtensions(token, 'blur', BlurTokens_1.BLUR_BASE_VALUE);
+            group[key] = this.toDTCGToken(`${token.baseValue}px`, 'dimension', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate sizing primitive tokens as DTCG dimension type.
+     */
+    generateSizingTokens() {
+        const group = { $type: 'dimension' };
+        for (const [key, token] of Object.entries(SizingTokens_1.sizingTokens)) {
+            const extensions = this.buildPrimitiveExtensions(token, 'sizing', SizingTokens_1.SIZING_BASE_VALUE);
+            group[key] = this.toDTCGToken(`${token.baseValue}px`, 'dimension', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate blend primitive tokens as DTCG number type with blendType extension.
+     * Blend values are unitless (0–1) with blendType metadata.
+     */
+    generateBlendTokens() {
+        const group = { $type: 'number' };
+        for (const [key, token] of Object.entries(BlendTokens_1.blendTokens)) {
+            const extensions = this.buildPrimitiveExtensions(token, 'blend', BlendTokens_1.BLEND_BASE_VALUE);
+            group[key] = this.toDTCGToken(token.baseValue, 'number', token.description, extensions);
+        }
+        return group;
+    }
+    // ---------------------------------------------------------------------------
+    // Semantic token generation (Task 2.3)
+    // ---------------------------------------------------------------------------
+    /**
+     * Generate semantic color tokens with alias references to primitive colors.
+     * Uses `{color.primitiveRef}` syntax to preserve primitive→semantic hierarchy.
+     */
+    generateSemanticColorTokens() {
+        const group = { $type: 'color' };
+        for (const [key, token] of Object.entries(ColorTokens_2.colorTokens)) {
+            const refs = token.primitiveReferences;
+            // Determine alias value — use {color.primitiveRef} syntax
+            const primaryRef = refs.value || refs.color;
+            if (!primaryRef)
+                continue;
+            const aliasValue = this.config.resolveAliases
+                ? this.resolvePrimitiveColorAlias(primaryRef)
+                : `{color.${primaryRef}}`;
+            const extensions = {
+                family: 'color',
+            };
+            // Spec 080: emit mode contexts for Level 2 overrides or Level 1 primitive differences
+            const override = SemanticOverrides_1.darkSemanticOverrides[key];
+            if (override) {
+                // Level 2: semantic override swaps primitive name in dark mode
+                // Resolve both modes to concrete rgba values
+                const lightResolved = (0, SemanticValueResolver_1.resolveSemanticTokenValue)(token, 'light');
+                const darkToken = { ...token, primitiveReferences: override.primitiveReferences };
+                const darkResolved = (0, SemanticValueResolver_1.resolveSemanticTokenValue)(darkToken, 'dark');
+                const lightVal = lightResolved.primitiveReferences?.value;
+                const darkVal = darkResolved.primitiveReferences?.value;
+                if (lightVal && darkVal && lightVal !== darkVal) {
+                    if (!extensions.modes)
+                        extensions.modes = {};
+                    extensions.modes.light = lightVal;
+                    extensions.modes.dark = darkVal;
+                }
+            }
+            else {
+                // Level 1: check if primitive itself has distinct light/dark values
+                const primitiveToken = ColorTokens_1.colorTokens[primaryRef];
+                if (primitiveToken) {
+                    const colorVal = primitiveToken.platforms.web.value;
+                    if (colorVal?.light?.base && colorVal?.dark?.base && colorVal.light.base !== colorVal.dark.base) {
+                        if (!extensions.modes)
+                            extensions.modes = {};
+                        extensions.modes.light = colorVal.light.base;
+                        extensions.modes.dark = colorVal.dark.base;
+                    }
+                }
+            }
+            // If token has separate color + opacity composition, note it
+            if (refs.color && refs.opacity) {
+                extensions.primitiveRefs = { color: refs.color, opacity: refs.opacity };
+            }
+            // If token has modifier-based opacity composition, note it
+            const semanticToken = token;
+            if (semanticToken.modifiers?.length) {
+                const opacityMod = semanticToken.modifiers.find((m) => m.type === 'opacity');
+                if (opacityMod) {
+                    extensions.primitiveRefs = { color: refs.value, opacity: opacityMod.reference };
+                    extensions.modifiers = semanticToken.modifiers;
+                }
+            }
+            group[key] = this.toDTCGToken(aliasValue, 'color', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate semantic spacing tokens with alias references to primitive spacing.
+     * Preserves hierarchical structure: grouped/related/separated/sectioned + inset.
+     */
+    generateSemanticSpacingTokens() {
+        const group = { $type: 'dimension' };
+        for (const [category, levels] of Object.entries(SpacingTokens_2.spacingTokens)) {
+            const subGroup = { $type: 'dimension' };
+            for (const [level, token] of Object.entries(levels)) {
+                const aliasValue = this.config.resolveAliases
+                    ? this.resolvePrimitiveDimensionAlias(token.value, SpacingTokens_1.spacingTokens)
+                    : `{space.${token.value}}`;
+                const extensions = {
+                    family: 'spacing',
+                    primitiveRefs: { value: token.value },
+                };
+                subGroup[level] = this.toDTCGToken(aliasValue, 'dimension', `Semantic spacing: ${category}.${level}`, extensions);
+            }
+            group[category] = subGroup;
+        }
+        return group;
+    }
+    /**
+     * Generate semantic border width tokens with alias references to primitive border widths.
+     */
+    generateSemanticBorderWidthTokens() {
+        const group = { $type: 'dimension' };
+        for (const [key, token] of Object.entries(BorderWidthTokens_2.SemanticBorderWidthTokens)) {
+            const aliasValue = this.config.resolveAliases
+                ? this.resolvePrimitiveDimensionAlias(token.value, BorderWidthTokens_1.borderWidthTokens)
+                : `{borderWidth.${token.value}}`;
+            const extensions = {
+                family: 'borderWidth',
+                primitiveRefs: { value: token.value },
+            };
+            group[key] = this.toDTCGToken(aliasValue, 'dimension', `Semantic border width: ${key}`, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate semantic radius tokens with alias references to primitive radius.
+     */
+    generateSemanticRadiusTokens() {
+        const group = { $type: 'dimension' };
+        for (const [key, token] of Object.entries(RadiusTokens_2.SemanticRadiusTokens)) {
+            const aliasValue = this.config.resolveAliases
+                ? this.resolvePrimitiveDimensionAlias(token.value, RadiusTokens_1.radiusTokens)
+                : `{radius.${token.value}}`;
+            const extensions = {
+                family: 'radius',
+                primitiveRefs: { value: token.value },
+            };
+            group[key] = this.toDTCGToken(aliasValue, 'dimension', `Semantic radius: ${key}`, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate semantic opacity tokens with alias references to primitive opacity.
+     */
+    generateSemanticOpacityTokens() {
+        const group = { $type: 'number' };
+        for (const [key, token] of Object.entries(OpacityTokens_2.opacityTokens)) {
+            const ref = token.primitiveReferences.value;
+            const aliasValue = this.config.resolveAliases
+                ? this.resolvePrimitiveNumberAlias(ref, OpacityTokens_1.opacityTokens)
+                : `{opacity.${ref}}`;
+            const extensions = {
+                family: 'opacity',
+                primitiveRefs: { value: ref },
+            };
+            group[key] = this.toDTCGToken(aliasValue, 'number', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate semantic blend tokens with alias references to primitive blend values.
+     * Includes blendType extension for blend direction.
+     */
+    generateSemanticBlendTokens() {
+        const group = { $type: 'number' };
+        for (const [key, token] of Object.entries(BlendTokens_2.blendTokens)) {
+            const ref = token.primitiveReferences.value;
+            const aliasValue = this.config.resolveAliases
+                ? this.resolvePrimitiveNumberAlias(ref, BlendTokens_1.blendTokens)
+                : `{blend.${ref}}`;
+            const extensions = {
+                family: 'blend',
+                primitiveRefs: { value: ref },
+            };
+            // Map BlendDirection to DesignerPunk blendType extension
+            if (token.direction === 'darker') {
+                extensions.blendType = 'darkerBlend';
+            }
+            else if (token.direction === 'lighter') {
+                extensions.blendType = 'lighterBlend';
+            }
+            group[key] = this.toDTCGToken(aliasValue, 'number', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate z-index tokens as DTCG number type.
+     * Z-index tokens are semantic-only (no primitive layer).
+     */
+    generateZIndexTokens() {
+        const group = { $type: 'number' };
+        for (const [key, token] of Object.entries(ZIndexTokens_1.zIndexTokens)) {
+            const extensions = {
+                family: 'zIndex',
+                platforms: {
+                    web: { supported: true },
+                    ios: { supported: true },
+                    android: { supported: false, note: 'Use elevation tokens instead' },
+                },
+            };
+            group[key] = this.toDTCGToken(token.value, 'number', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate elevation tokens as DTCG number type with platform extensions.
+     * Elevation tokens are Android-only semantic tokens.
+     */
+    generateElevationTokens() {
+        const group = { $type: 'number' };
+        for (const [key, token] of Object.entries(ElevationTokens_1.elevationTokens)) {
+            const extensions = {
+                family: 'elevation',
+                platforms: {
+                    web: { supported: false, note: 'Use z-index + shadow tokens instead' },
+                    ios: { supported: false, note: 'Use z-index + shadow tokens instead' },
+                    android: { supported: true, elevation: token.value },
+                },
+            };
+            group[key] = this.toDTCGToken(token.value, 'number', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate grid spacing tokens with alias references to primitive spacing.
+     */
+    generateGridSpacingTokens() {
+        const group = { $type: 'dimension' };
+        for (const [key, token] of Object.entries(GridSpacingTokens_1.gridSpacingTokens)) {
+            const ref = token.primitiveReferences.spacing;
+            const aliasValue = this.config.resolveAliases
+                ? this.resolvePrimitiveDimensionAlias(ref, SpacingTokens_1.spacingTokens)
+                : `{space.${ref}}`;
+            const extensions = {
+                family: 'gridSpacing',
+                primitiveRefs: { spacing: ref },
+            };
+            group[key] = this.toDTCGToken(aliasValue, 'dimension', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate icon tokens as DTCG dimension type.
+     * Icon sizes are calculated from fontSize × multiplier.
+     */
+    generateIconTokens() {
+        const group = { $type: 'dimension' };
+        for (const [key, token] of Object.entries(IconTokens_1.iconTokens)) {
+            const refs = token.primitiveReferences;
+            // icon.strokeWidth references a borderWidth primitive
+            if (refs.value) {
+                const aliasValue = this.config.resolveAliases
+                    ? this.resolvePrimitiveDimensionAlias(refs.value, BorderWidthTokens_1.borderWidthTokens)
+                    : `{borderWidth.${refs.value}}`;
+                const extensions = {
+                    family: 'icon',
+                    primitiveRefs: { value: refs.value },
+                };
+                group[key] = this.toDTCGToken(aliasValue, 'dimension', token.description, extensions);
+            }
+            else if (refs.fontSize && refs.multiplier) {
+                // Icon size tokens — calculated value, include formula in extensions
+                const extensions = {
+                    family: 'icon',
+                    primitiveRefs: { fontSize: refs.fontSize, multiplier: refs.multiplier },
+                };
+                // For icon sizes, use the alias to fontSize as the value
+                const aliasValue = this.config.resolveAliases
+                    ? this.resolvePrimitiveDimensionAlias(refs.fontSize, FontSizeTokens_1.fontSizeTokens)
+                    : `{fontSize.${refs.fontSize}}`;
+                group[key] = this.toDTCGToken(aliasValue, 'dimension', token.description, extensions);
+            }
+        }
+        return group;
+    }
+    /**
+     * Generate accessibility tokens with alias references to their primitive sources.
+     */
+    generateAccessibilityTokens() {
+        const group = {};
+        for (const [key, token] of Object.entries(AccessibilityTokens_1.accessibilityTokens)) {
+            const ref = token.primitiveReferences.value;
+            // Determine DTCG type based on what the token references
+            let dtcgType;
+            let aliasValue;
+            if (key.includes('color')) {
+                dtcgType = 'color';
+                aliasValue = this.config.resolveAliases
+                    ? this.resolvePrimitiveColorAlias(ref)
+                    : `{color.${ref}}`;
+            }
+            else if (key.includes('width')) {
+                dtcgType = 'dimension';
+                aliasValue = this.config.resolveAliases
+                    ? this.resolvePrimitiveDimensionAlias(ref, BorderWidthTokens_1.borderWidthTokens)
+                    : `{borderWidth.${ref}}`;
+            }
+            else {
+                // offset references a spacing primitive
+                dtcgType = 'dimension';
+                aliasValue = this.config.resolveAliases
+                    ? this.resolvePrimitiveDimensionAlias(ref, SpacingTokens_1.spacingTokens)
+                    : `{space.${ref}}`;
+            }
+            const extensions = {
+                family: 'accessibility',
+                primitiveRefs: { value: ref },
+            };
+            group[key] = this.toDTCGToken(aliasValue, dtcgType, token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate progress color tokens with alias references to primitive colors.
+     */
+    generateProgressColorTokens() {
+        const group = { $type: 'color' };
+        for (const [key, token] of Object.entries(ColorTokens_3.progressColorTokens)) {
+            const ref = token.primitiveReferences.value;
+            const aliasValue = this.config.resolveAliases
+                ? this.resolvePrimitiveColorAlias(ref)
+                : `{color.${ref}}`;
+            const extensions = {
+                family: 'color',
+                primitiveRefs: { value: ref },
+            };
+            group[key] = this.toDTCGToken(aliasValue, 'color', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Resolve a primitive color alias to its actual value.
+     * Used when resolveAliases is true.
+     */
+    resolvePrimitiveColorAlias(primitiveName) {
+        const primitiveToken = ColorTokens_1.colorTokens[primitiveName];
+        if (primitiveToken) {
+            return this.resolveColorValue(primitiveToken, primitiveName);
+        }
+        // Fallback: return alias syntax if primitive not found
+        return `{color.${primitiveName}}`;
+    }
+    /**
+     * Resolve a primitive dimension alias to its actual `{value}px` value.
+     * Used when resolveAliases is true.
+     */
+    resolvePrimitiveDimensionAlias(primitiveName, registry) {
+        const primitiveToken = registry[primitiveName];
+        if (primitiveToken) {
+            return `${primitiveToken.baseValue}px`;
+        }
+        // Fallback: return alias syntax if primitive not found
+        return `{${primitiveName}}`;
+    }
+    /**
+     * Resolve a primitive number alias to its actual numeric value.
+     * Used when resolveAliases is true for unitless tokens (opacity, blend, etc.).
+     */
+    resolvePrimitiveNumberAlias(primitiveName, registry) {
+        const primitiveToken = registry[primitiveName];
+        if (primitiveToken) {
+            return primitiveToken.baseValue;
+        }
+        return 0;
+    }
+    // Shadow token generation (Task 2.4)
+    /**
+     * Generate shadow composition tokens as DTCG shadow type.
+     *
+     * Each semantic shadow token references primitives for offsetX, offsetY, blur,
+     * opacity, and color. The generator resolves these primitives, merges color+opacity
+     * into a single RGBA value (shadow opacity replaces color alpha per Design Decision 3),
+     * and outputs a DTCG shadow composite value.
+     *
+     * @requirements 5.1-5.5
+     */
+    generateShadowTokens() {
+        const group = { $type: 'shadow' };
+        for (const [key, token] of Object.entries(ShadowTokens_1.shadowTokens)) {
+            const refs = token.primitiveReferences;
+            // Resolve primitive values
+            const offsetXToken = this.resolveShadowPrimitive(refs.offsetX, ShadowOffsetTokens_1.shadowOffsetX);
+            const offsetYToken = this.resolveShadowPrimitive(refs.offsetY, ShadowOffsetTokens_1.shadowOffsetY);
+            const blurToken = this.resolveShadowPrimitive(refs.blur, BlurTokens_1.blur);
+            const opacityToken = this.resolveShadowPrimitive(refs.opacity, ShadowOpacityTokens_1.shadowOpacityTokens);
+            const colorToken = ColorTokens_1.colorTokens[refs.color];
+            if (!offsetXToken || !offsetYToken || !blurToken || !opacityToken || !colorToken) {
+                throw new Error(`Shadow token "${key}" has unresolvable primitive references. ` +
+                    `Missing: ${[
+                        !offsetXToken && `offsetX(${refs.offsetX})`,
+                        !offsetYToken && `offsetY(${refs.offsetY})`,
+                        !blurToken && `blur(${refs.blur})`,
+                        !opacityToken && `opacity(${refs.opacity})`,
+                        !colorToken && `color(${refs.color})`,
+                    ].filter(Boolean).join(', ')}`);
+            }
+            // Resolve color RGBA and merge with shadow opacity (replace alpha, don't multiply)
+            const colorRgba = this.resolveColorValue(colorToken, `shadow.${key}.color`);
+            const opacityValue = opacityToken.baseValue;
+            const mergedColor = this.mergeShadowColor(colorRgba, opacityValue, key);
+            // Build DTCG shadow composite value
+            const shadowValue = {
+                offsetX: `${offsetXToken.baseValue}px`,
+                offsetY: `${offsetYToken.baseValue}px`,
+                blur: `${blurToken.baseValue}px`,
+                spread: '0px',
+                color: mergedColor,
+            };
+            // Build extensions
+            const extensions = {
+                family: 'shadow',
+                primitiveRefs: {
+                    offsetX: refs.offsetX,
+                    offsetY: refs.offsetY,
+                    blur: refs.blur,
+                    opacity: refs.opacity,
+                    color: refs.color,
+                },
+            };
+            // Include Android elevation
+            if (token.platforms?.android?.elevation !== undefined) {
+                extensions.platforms = {
+                    android: {
+                        supported: true,
+                        elevation: token.platforms.android.elevation,
+                    },
+                };
+            }
+            // Use dot-separated key for DTCG group (shadow.container → container)
+            const dtcgKey = key.startsWith('shadow.') ? key.slice('shadow.'.length) : key;
+            group[dtcgKey] = this.toDTCGToken(shadowValue, 'shadow', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Resolve a shadow primitive token from its registry.
+     * Handles dot-notation names (e.g., 'shadowOffsetX.000' → key '000').
+     */
+    resolveShadowPrimitive(tokenName, registry) {
+        // Try direct lookup first
+        if (registry[tokenName]) {
+            return registry[tokenName];
+        }
+        // Handle dot notation (e.g., 'shadowOffsetX.000' → '000')
+        const dotIndex = tokenName.lastIndexOf('.');
+        if (dotIndex !== -1) {
+            const shortKey = tokenName.slice(dotIndex + 1);
+            if (registry[shortKey]) {
+                return registry[shortKey];
+            }
+        }
+        return null;
+    }
+    /**
+       * Generate glow primitive tokens as individual DTCG tokens.
+       *
+       * Glow primitives (blur, opacity) are exported individually — composed glow tokens
+       * are not yet implemented. Glows share offset primitives with shadows (shadowOffsetX,
+       * shadowOffsetY) and use the same color primitives.
+       *
+       * All glow tokens include:
+       * - `$extensions.designerpunk.glowType: "emission"` — identifies glow effect type
+       * - `$extensions.designerpunk.status: "partial"` — composed glows not yet implemented
+       *
+       * @requirements 5.6, 5.7
+       */
+    generateGlowTokens() {
+        const group = {
+            $description: 'Glow effect primitives. Composed glows not yet implemented — glows share offset primitives with shadows (shadowOffsetX, shadowOffsetY).',
+        };
+        // Glow blur tokens → DTCG dimension type (blur050–blur250 from unified blur family)
+        const blur = { $type: 'dimension' };
+        const glowBlurRange = ['blur050', 'blur100', 'blur150', 'blur200', 'blur250'];
+        for (const key of glowBlurRange) {
+            const token = BlurTokens_1.blur[key];
+            if (!token)
+                continue;
+            const extensions = this.buildPrimitiveExtensions(token, 'glow', BlurTokens_1.BLUR_BASE_VALUE);
+            extensions.glowType = 'emission';
+            extensions.status = 'partial';
+            blur[key] = this.toDTCGToken(`${token.baseValue}px`, 'dimension', token.description, extensions);
+        }
+        group.blur = blur;
+        // Glow opacity tokens → DTCG number type
+        const opacity = { $type: 'number' };
+        for (const [key, token] of Object.entries(GlowOpacityTokens_1.glowOpacity)) {
+            const extensions = this.buildPrimitiveExtensions(token, 'glow', GlowOpacityTokens_1.GLOW_OPACITY_BASE_VALUE);
+            extensions.glowType = 'emission';
+            extensions.status = 'partial';
+            opacity[key] = this.toDTCGToken(token.baseValue, 'number', token.description, extensions);
+        }
+        group.opacity = opacity;
+        return group;
+    }
+    /**
+     * Generate typography composition tokens as DTCG typography type.
+     *
+     * Typography tokens compose primitive references (fontFamily, fontSize, fontWeight,
+     * lineHeight, letterSpacing) into DTCG typography composite values using alias syntax.
+     *
+     * @requirements 6.1, 6.5
+     */
+    generateTypographyTokens() {
+        const group = { $type: 'typography' };
+        for (const [key, token] of Object.entries(TypographyTokens_1.typographyTokens)) {
+            const refs = token.primitiveReferences;
+            // Build DTCG typography composite value — resolve or alias based on config
+            let typographyValue;
+            if (this.config.resolveAliases) {
+                const ffToken = FontFamilyTokens_1.fontFamilyTokens[refs.fontFamily];
+                const fontStack = ffToken ? String(ffToken.platforms.web.value) : refs.fontFamily;
+                const families = fontStack.split(',').map(f => f.trim().replace(/^["']|["']$/g, ''));
+                typographyValue = {
+                    fontFamily: families,
+                    fontSize: this.resolvePrimitiveDimensionAlias(refs.fontSize, FontSizeTokens_1.fontSizeTokens),
+                    fontWeight: FontWeightTokens_1.fontWeightTokens[refs.fontWeight]?.baseValue ?? refs.fontWeight,
+                    lineHeight: LineHeightTokens_1.lineHeightTokens[refs.lineHeight]?.baseValue ?? refs.lineHeight,
+                    letterSpacing: LetterSpacingTokens_1.letterSpacingTokens[refs.letterSpacing]
+                        ? `${LetterSpacingTokens_1.letterSpacingTokens[refs.letterSpacing].baseValue}em`
+                        : refs.letterSpacing,
+                };
+            }
+            else {
+                typographyValue = {
+                    fontFamily: `{fontFamily.${refs.fontFamily}}`,
+                    fontSize: `{fontSize.${refs.fontSize}}`,
+                    fontWeight: `{fontWeight.${refs.fontWeight}}`,
+                    lineHeight: `{lineHeight.${refs.lineHeight}}`,
+                    letterSpacing: `{letterSpacing.${refs.letterSpacing}}`,
+                };
+            }
+            // Build extensions with primitive references
+            const extensions = {
+                family: 'typography',
+                primitiveRefs: { ...refs },
+            };
+            // Use dot-separated key for DTCG group (typography.bodyMd → bodyMd)
+            const dtcgKey = key.startsWith('typography.') ? key.slice('typography.'.length) : key;
+            group[dtcgKey] = this.toDTCGToken(typographyValue, 'typography', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Generate motion composition tokens as DTCG transition type.
+     *
+     * Motion tokens compose primitive duration and easing references into DTCG transition
+     * composite values. Delay defaults to '0ms' when not defined. Scale is included in
+     * extensions when present.
+     *
+     * @requirements 6.2, 6.3, 6.4, 6.5
+     */
+    generateMotionTokens() {
+        const group = { $type: 'transition' };
+        for (const [key, token] of Object.entries(MotionTokens_1.motionTokens)) {
+            const refs = token.primitiveReferences;
+            // Build DTCG transition composite value — resolve or alias based on config
+            let transitionValue;
+            if (this.config.resolveAliases) {
+                const durToken = DurationTokens_1.durationTokens[refs.duration];
+                const easToken = EasingTokens_1.easingTokens[refs.easing];
+                // Resolve easing to cubicBezier array
+                let timingFunction = refs.easing;
+                if (easToken) {
+                    const bezierStr = String(easToken.platforms.web.value);
+                    const match = bezierStr.match(/cubic-bezier\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*\)/);
+                    if (match) {
+                        timingFunction = [parseFloat(match[1]), parseFloat(match[2]), parseFloat(match[3]), parseFloat(match[4])];
+                    }
+                }
+                transitionValue = {
+                    duration: durToken ? `${durToken.baseValue}ms` : `{duration.${refs.duration}}`,
+                    timingFunction,
+                    delay: '0ms',
+                };
+            }
+            else {
+                transitionValue = {
+                    duration: `{duration.${refs.duration}}`,
+                    timingFunction: `{easing.${refs.easing}}`,
+                    delay: '0ms',
+                };
+            }
+            // Build extensions with primitive references
+            const extensions = {
+                family: 'motion',
+                primitiveRefs: {
+                    duration: refs.duration,
+                    easing: refs.easing,
+                },
+            };
+            // Include scale in extensions when present (Requirement 6.4)
+            if (refs.scale) {
+                extensions.primitiveRefs.scale = refs.scale;
+                extensions.scale = this.config.resolveAliases
+                    ? ScaleTokens_1.scaleTokens[refs.scale]?.baseValue ?? `{scale.${refs.scale}}`
+                    : `{scale.${refs.scale}}`;
+            }
+            // Use dot-separated key for DTCG group (motion.floatLabel → floatLabel)
+            const dtcgKey = key.startsWith('motion.') ? key.slice('motion.'.length) : key;
+            group[dtcgKey] = this.toDTCGToken(transitionValue, 'transition', token.description, extensions);
+        }
+        return group;
+    }
+    // ---------------------------------------------------------------------------
+    // Shared helpers for primitive token generation
+    // ---------------------------------------------------------------------------
+    /**
+     * Generate a DTCG group of dimension tokens from a record of PrimitiveTokens.
+     * Converts baseValue to `{value}px` format.
+     */
+    generateDimensionGroup(tokens, family, familyBase) {
+        const group = { $type: 'dimension' };
+        for (const [key, token] of Object.entries(tokens)) {
+            const extensions = this.buildPrimitiveExtensions(token, family, familyBase);
+            group[key] = this.toDTCGToken(`${token.baseValue}px`, 'dimension', token.description, extensions);
+        }
+        return group;
+    }
+    /**
+     * Resolve a color token's RGBA value from its mode/theme structure.
+     * Uses light.base as the default resolved value for DTCG output.
+     *
+     * @param token - The primitive color token to resolve
+     * @param tokenName - Optional token name for error messages
+     * @returns Resolved color string (e.g., "rgba(255, 0, 0, 1)")
+     * @throws Error if the resolved color value is not a valid color format
+     */
+    resolveColorValue(token, tokenName) {
+        const webValue = token.platforms.web.value;
+        let resolved;
+        if (typeof webValue === 'string') {
+            resolved = webValue;
+        }
+        else {
+            // ColorTokenValue structure: { light: { base, wcag }, dark: { base, wcag } }
+            const colorVal = webValue;
+            resolved = colorVal.light.base;
+        }
+        // Validate the resolved color is a recognizable format
+        if (!resolved || typeof resolved !== 'string') {
+            const name = tokenName || token.name || 'unknown';
+            throw new Error(`Invalid token value for "${name}": ${String(resolved)}. Expected valid color format (hex, rgb, rgba).`);
+        }
+        const isValidColor = /^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/.test(resolved) ||
+            /^rgba?\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*(,\s*[\d.]+\s*)?\)$/.test(resolved);
+        if (!isValidColor) {
+            const name = tokenName || token.name || 'unknown';
+            throw new Error(`Invalid token value for "${name}": ${resolved}. Expected valid color format (hex, rgb, rgba).`);
+        }
+        return resolved;
+    }
+    /**
+     * Build DesignerPunk extension metadata for a primitive token.
+     * Includes formula, family, and baseValue when includeExtensions is true.
+     */
+    buildPrimitiveExtensions(token, family, familyBase) {
+        const ext = {
+            formula: token.mathematicalRelationship,
+            family,
+        };
+        if (familyBase !== undefined && familyBase !== 0) {
+            ext.baseValue = familyBase;
+        }
+        return ext;
+    }
+    /**
+     * Merge shadow color and opacity into a single RGBA value.
+     *
+     * Replaces the color's alpha channel with the shadow's opacity value
+     * (does NOT multiply). Shadow opacity is authoritative per Design Decision 3.
+     *
+     * @param colorRgba - Color in rgba(r, g, b, a) format
+     * @param opacity - Shadow opacity value (0–1)
+     * @param shadowName - Optional shadow token name for error messages
+     * @returns Merged rgba string with shadow opacity as alpha
+     * @throws Error if colorRgba is not in valid rgba format
+     */
+    mergeShadowColor(colorRgba, opacity, shadowName) {
+        const match = colorRgba.match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*[\d.eE+-]+\s*)?\)$/);
+        if (!match) {
+            const context = shadowName ? ` for "${shadowName}"` : '';
+            throw new Error(`Shadow color merge failed${context}: ${colorRgba}. Expected rgba(r, g, b, a) format.`);
+        }
+        const [, r, g, b] = match;
+        return `rgba(${r}, ${g}, ${b}, ${opacity})`;
+    }
+    /**
+     * Convert a Rosetta primitive token to a DTCG token with optional extensions.
+     *
+     * @param value - The token value in DTCG format
+     * @param type - The DTCG type for this token
+     * @param description - Optional token description
+     * @param extensions - Optional DesignerPunk extension metadata
+     * @returns A DTCGToken object
+     * @throws Error if the type is not a valid DTCG type
+     */
+    toDTCGToken(value, type, description, extensions) {
+        // Validate DTCG type
+        if (!VALID_DTCG_TYPES.has(type)) {
+            throw new Error(`Invalid token type: "${type}". No DTCG mapping exists. ` +
+                `Valid types: ${Array.from(VALID_DTCG_TYPES).join(', ')}.`);
+        }
+        const token = {
+            $value: value,
+            $type: type,
+        };
+        if (description) {
+            token.$description = description;
+        }
+        if (this.config.includeExtensions && extensions && Object.keys(extensions).length > 0) {
+            token.$extensions = { designerpunk: extensions };
+        }
+        return token;
+    }
+}
+exports.DTCGFormatGenerator = DTCGFormatGenerator;
+//# sourceMappingURL=DTCGFormatGenerator.js.map