@primer/primitives 11.4.0-rc.f798df25 → 11.4.0

package/dist/build/filters/hasLlmExtensions.d.ts

@@ -0,0 +1,7 @@
+import type { TransformedToken } from 'style-dictionary/types';
+/**
+ * @description Checks if token has LLM extensions (`org.primer.llm` in `$extensions`)
+ * @param arguments [TransformedToken](https://github.com/amzn/style-dictionary/blob/main/types/TransformedToken.d.ts)
+ * @returns boolean
+ */
+export declare const hasLlmExtensions: (token: TransformedToken) => boolean;

package/dist/build/filters/hasLlmExtensions.js

@@ -0,0 +1,11 @@
+/**
+ * @description Checks if token has LLM extensions (`org.primer.llm` in `$extensions`)
+ * @param arguments [TransformedToken](https://github.com/amzn/style-dictionary/blob/main/types/TransformedToken.d.ts)
+ * @returns boolean
+ */
+export const hasLlmExtensions = (token) => {
+    return (token.$extensions !== undefined &&
+        token.$extensions !== null &&
+        typeof token.$extensions === 'object' &&
+        'org.primer.llm' in token.$extensions);
+};

package/dist/build/filters/index.d.ts

@@ -1,3 +1,4 @@
+export { hasLlmExtensions } from './hasLlmExtensions.js';
 export { isBorder } from './isBorder.js';
 export { isColor } from './isColor.js';
 export { isColorWithAlpha } from './isColorWithAlpha.js';

package/dist/build/filters/index.js

@@ -1,3 +1,4 @@
+export { hasLlmExtensions } from './hasLlmExtensions.js';
 export { isBorder } from './isBorder.js';
 export { isColor } from './isColor.js';
 export { isColorWithAlpha } from './isColorWithAlpha.js';

package/dist/build/formats/index.d.ts

@@ -1,5 +1,6 @@
 export { cssCustomMedia } from './cssCustomMedia.js';
 export { cssAdvanced } from './cssAdvanced.js';
+export { markdownLlmGuidelines } from './markdownLlmGuidelines.js';
 export { jsonFigma } from './jsonFigma.js';
 export { javascriptCommonJs } from './javascriptCommonJs.js';
 export { javascriptEsm } from './javascriptEsm.js';

package/dist/build/formats/index.js

@@ -1,5 +1,6 @@
 export { cssCustomMedia } from './cssCustomMedia.js';
 export { cssAdvanced } from './cssAdvanced.js';
+export { markdownLlmGuidelines } from './markdownLlmGuidelines.js';
 export { jsonFigma } from './jsonFigma.js';
 export { javascriptCommonJs } from './javascriptCommonJs.js';
 export { javascriptEsm } from './javascriptEsm.js';

package/dist/build/formats/markdownLlmGuidelines.d.ts

@@ -0,0 +1,10 @@
+import type { FormatFn } from 'style-dictionary/types';
+/**
+ * @description Outputs a markdown file with LLM token guidelines, extracting
+ * description from $description and usage/rules from $extensions['org.primer.llm'].
+ * Tokens with identical guidelines (from group-level inheritance) are consolidated
+ * into a single entry listing all token names.
+ * @param FormatFnArguments
+ * @returns formatted markdown `string`
+ */
+export declare const markdownLlmGuidelines: FormatFn;

package/dist/build/formats/markdownLlmGuidelines.js

@@ -0,0 +1,194 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { sortByName } from 'style-dictionary/utils';
+/**
+ * Creates a unique key for grouping tokens with identical guidelines
+ */
+function createGuidelineKey(guideline) {
+    var _a;
+    return JSON.stringify({
+        description: guideline.description || '',
+        usage: ((_a = guideline.usage) === null || _a === void 0 ? void 0 : _a.sort()) || [],
+        rules: guideline.rules || '',
+    });
+}
+/**
+ * Extracts category from token name
+ * - For "base-*" tokens, uses second word (e.g., "base-easing-ease" -> "easing")
+ * - Otherwise uses first word (e.g., "bgColor-danger-emphasis" -> "bgColor")
+ */
+function extractCategory(tokenName) {
+    const parts = tokenName.split('-');
+    if (parts[0] === 'base' && parts[1]) {
+        return parts[1];
+    }
+    return parts[0] || 'other';
+}
+/**
+ * Formats category name for display
+ */
+function formatCategoryName(category) {
+    const categoryMap = {
+        bgColor: 'background color',
+        fgColor: 'text and foreground color',
+    };
+    if (categoryMap[category]) {
+        return categoryMap[category];
+    }
+    // Capitalize first letter
+    return category.charAt(0).toUpperCase() + category.slice(1);
+}
+/**
+ * Creates a key for grouping by usage and rules only (not description)
+ */
+function createUsageRulesKey(guideline) {
+    var _a;
+    return JSON.stringify({
+        usage: ((_a = guideline.usage) === null || _a === void 0 ? void 0 : _a.sort()) || [],
+        rules: guideline.rules || '',
+    });
+}
+/**
+ * Extracts a subcategory name from token names for headings
+ * e.g., "border-accent-emphasis" -> "accent"
+ */
+function extractSubcategory(tokenNames) {
+    if (tokenNames.length < 2)
+        return null;
+    // Get the second part of each token name
+    const subcategories = tokenNames.map(name => {
+        const parts = name.split('-');
+        return parts[1] || null;
+    });
+    // Check if all tokens share the same subcategory
+    const uniqueSubcats = [...new Set(subcategories.filter(Boolean))];
+    if (uniqueSubcats.length === 1) {
+        return uniqueSubcats[0];
+    }
+    return null;
+}
+/**
+ * @description Outputs a markdown file with LLM token guidelines, extracting
+ * description from $description and usage/rules from $extensions['org.primer.llm'].
+ * Tokens with identical guidelines (from group-level inheritance) are consolidated
+ * into a single entry listing all token names.
+ * @param FormatFnArguments
+ * @returns formatted markdown `string`
+ */
+export const markdownLlmGuidelines = (_a) => __awaiter(void 0, [_a], void 0, function* ({ dictionary }) {
+    var _b;
+    const tokens = dictionary.allTokens.sort(sortByName);
+    const guidelines = [];
+    for (const token of tokens) {
+        const llmExt = (_b = token.$extensions) === null || _b === void 0 ? void 0 : _b['org.primer.llm'];
+        if (!llmExt)
+            continue;
+        const guideline = {
+            name: token.name,
+            category: extractCategory(token.name),
+        };
+        if (token.$description && typeof token.$description === 'string') {
+            guideline.description = token.$description;
+        }
+        if (llmExt.usage && Array.isArray(llmExt.usage)) {
+            guideline.usage = llmExt.usage;
+        }
+        if (llmExt.rules && typeof llmExt.rules === 'string') {
+            guideline.rules = llmExt.rules;
+        }
+        guidelines.push(guideline);
+    }
+    // Group by category
+    const grouped = {};
+    for (const guideline of guidelines) {
+        if (!Object.hasOwn(grouped, guideline.category)) {
+            grouped[guideline.category] = [];
+        }
+        grouped[guideline.category].push(guideline);
+    }
+    // Build markdown output
+    const lines = ['# Token Guidelines', ''];
+    for (const category of Object.keys(grouped).sort()) {
+        lines.push(`## ${formatCategoryName(category)}`, '');
+        const categoryGuidelines = grouped[category];
+        // Check if all tokens in category share the same usage/rules AND there are multiple tokens
+        const usageRulesKeys = new Set(categoryGuidelines.map(createUsageRulesKey));
+        const sharedUsageRules = usageRulesKeys.size === 1 && categoryGuidelines.length > 1;
+        // If shared, output usage/rules once at category level
+        if (sharedUsageRules) {
+            const first = categoryGuidelines[0];
+            if (first.usage && first.usage.length > 0) {
+                lines.push(`**Usage:** ${first.usage.join(', ')}`);
+            }
+            if (first.rules) {
+                lines.push(`**Rules:** ${first.rules}`);
+            }
+            lines.push('');
+        }
+        // Group tokens with identical guidelines (description + usage + rules)
+        const consolidatedGroups = new Map();
+        for (const guideline of categoryGuidelines) {
+            const key = createGuidelineKey(guideline);
+            if (!consolidatedGroups.has(key)) {
+                consolidatedGroups.set(key, []);
+            }
+            consolidatedGroups.get(key).push(guideline);
+        }
+        for (const [, guidelinesGroup] of consolidatedGroups) {
+            const first = guidelinesGroup[0];
+            const tokenNames = guidelinesGroup.map(g => g.name);
+            if (guidelinesGroup.length > 1) {
+                // Multiple tokens share the same guidelines - consolidate
+                const subcategory = extractSubcategory(tokenNames);
+                if (subcategory) {
+                    lines.push(`### ${subcategory}`);
+                }
+                else {
+                    // No common subcategory - use "general" or skip heading if description serves as intro
+                    if (first.description && consolidatedGroups.size > 1) {
+                        lines.push(`### general`);
+                    }
+                }
+                if (first.description) {
+                    lines.push(first.description);
+                }
+                // Only show usage/rules if not already shown at category level
+                if (!sharedUsageRules) {
+                    if (first.usage && first.usage.length > 0) {
+                        lines.push(`**Usage:** ${first.usage.join(', ')}`);
+                    }
+                    if (first.rules) {
+                        lines.push(`**Rules:** ${first.rules}`);
+                    }
+                }
+                lines.push(`**Tokens:** ${tokenNames.join(', ')}`);
+                lines.push('');
+            }
+            else {
+                // Single token - output individually
+                lines.push(`### ${first.name}`);
+                if (first.description) {
+                    lines.push(first.description);
+                }
+                // Only show usage/rules if not already shown at category level
+                if (!sharedUsageRules) {
+                    if (first.usage && first.usage.length > 0) {
+                        lines.push(`**Usage:** ${first.usage.join(', ')}`);
+                    }
+                    if (first.rules) {
+                        lines.push(`**Rules:** ${first.rules}`);
+                    }
+                }
+                lines.push('');
+            }
+        }
+    }
+    return lines.join('\n');
+});

package/dist/build/platforms/index.d.ts

@@ -1,3 +1,4 @@
+export { llmGuidelines } from './llmGuidelines.js';
 export { css } from './css.js';
 export { deprecatedJson } from './deprecatedJson.js';
 export { docJson } from './docJson.js';

package/dist/build/platforms/index.js

@@ -1,3 +1,4 @@
+export { llmGuidelines } from './llmGuidelines.js';
 export { css } from './css.js';
 export { deprecatedJson } from './deprecatedJson.js';
 export { docJson } from './docJson.js';

package/dist/build/platforms/llmGuidelines.d.ts

@@ -0,0 +1,2 @@
+import type { PlatformInitializer } from '../types/platformInitializer.js';
+export declare const llmGuidelines: PlatformInitializer;

package/dist/build/platforms/llmGuidelines.js

@@ -0,0 +1,17 @@
+import { hasLlmExtensions } from '../filters/index.js';
+export const llmGuidelines = (outputFile, prefix, buildPath) => ({
+    prefix,
+    buildPath,
+    preprocessors: ['inheritGroupProperties'],
+    transforms: ['name/pathToKebabCase'],
+    files: [
+        {
+            destination: outputFile,
+            format: 'json/llm-guidelines',
+            filter: hasLlmExtensions,
+            options: {
+                outputReferences: false,
+            },
+        },
+    ],
+});

package/dist/build/preprocessors/inheritGroupProperties.d.ts

@@ -0,0 +1,7 @@
+import type { Preprocessor } from 'style-dictionary/types';
+/**
+ * Preprocessor that inherits group-level $description and $extensions to child tokens.
+ * This enables W3C Design Tokens group properties to be available on individual tokens
+ * during formatting.
+ */
+export declare const inheritGroupProperties: Preprocessor;

package/dist/build/preprocessors/inheritGroupProperties.js

@@ -0,0 +1,70 @@
+/**
+ * Recursively walks tokens and inherits group-level properties to child tokens.
+ * Group properties ($description, $extensions at group level) are merged into child tokens
+ * that don't have their own values for those properties.
+ *
+ * Per W3C Design Tokens spec: https://www.designtokens.org/tr/drafts/format/#group-properties
+ */
+function inheritProperties(tokens, inheritedProps = {}) {
+    var _a;
+    const result = {};
+    // Extract group-level properties from current level
+    const currentGroupProps = {};
+    if (typeof tokens.$description === 'string') {
+        currentGroupProps.$description = tokens.$description;
+    }
+    if (tokens.$extensions && typeof tokens.$extensions === 'object') {
+        currentGroupProps.$extensions = tokens.$extensions;
+    }
+    // Merge inherited with current (current takes precedence)
+    const mergedProps = Object.assign(Object.assign({}, inheritedProps), currentGroupProps);
+    // Merge $extensions deeply
+    if (inheritedProps.$extensions || currentGroupProps.$extensions) {
+        mergedProps.$extensions = Object.assign(Object.assign({}, inheritedProps.$extensions), currentGroupProps.$extensions);
+    }
+    for (const [key, value] of Object.entries(tokens)) {
+        // Skip group-level properties (they're inherited, not copied)
+        if (key === '$description' || key === '$extensions') {
+            continue;
+        }
+        if (typeof value !== 'object' || value === null) {
+            result[key] = value;
+            continue;
+        }
+        const tokenValue = value;
+        // Check if this is a design token (has $value or value)
+        if ('$value' in tokenValue || 'value' in tokenValue) {
+            // It's a token - merge inherited properties
+            const token = tokenValue;
+            // Only inherit $description if token doesn't have its own
+            const inheritedDescription = !token.$description && mergedProps.$description ? mergedProps.$description : undefined;
+            // Merge $extensions (token-level takes precedence over inherited)
+            let mergedExtensions = token.$extensions;
+            if (mergedProps.$extensions) {
+                const inheritedLlm = mergedProps.$extensions['org.primer.llm'];
+                const tokenLlm = (_a = token.$extensions) === null || _a === void 0 ? void 0 : _a['org.primer.llm'];
+                if (inheritedLlm && !tokenLlm) {
+                    // Token has no LLM extension, inherit from group
+                    mergedExtensions = Object.assign(Object.assign({}, token.$extensions), { 'org.primer.llm': inheritedLlm });
+                }
+            }
+            result[key] = Object.assign(Object.assign(Object.assign({}, token), (inheritedDescription ? { $description: inheritedDescription } : {})), (mergedExtensions ? { $extensions: mergedExtensions } : {}));
+        }
+        else {
+            // It's a nested group - recurse with merged properties
+            result[key] = inheritProperties(tokenValue, mergedProps);
+        }
+    }
+    return result;
+}
+/**
+ * Preprocessor that inherits group-level $description and $extensions to child tokens.
+ * This enables W3C Design Tokens group properties to be available on individual tokens
+ * during formatting.
+ */
+export const inheritGroupProperties = {
+    name: 'inheritGroupProperties',
+    preprocessor: (dictionary) => {
+        return inheritProperties(dictionary);
+    },
+};

package/dist/build/primerStyleDictionary.js

@@ -1,7 +1,8 @@
 import StyleDictionary from 'style-dictionary';
 import { borderToCss, colorToRgbAlpha, colorToHex, colorToRgbaFloat, cubicBezierToCss, dimensionToRem, dimensionToPixelUnitless, durationToCss, figmaAttributes, fontFamilyToCss, fontFamilyToFigma, fontWeightToNumber, gradientToCss, jsonDeprecated, namePathToDotNotation, namePathToCamelCase, namePathToPascalCase, namePathToKebabCase, namePathToSlashNotation, namePathToFigma, shadowToCss, typographyToCss, dimensionToRemPxArray, floatToPixel, floatToPixelUnitless, transitionToCss, } from './transformers/index.js';
-import { javascriptCommonJs, javascriptEsm, typescriptExportDefinition, jsonNestedPrefixed, cssCustomMedia, jsonOneDimensional, jsonPostCssFallback, cssAdvanced, jsonFigma, } from './formats/index.js';
+import { javascriptCommonJs, javascriptEsm, typescriptExportDefinition, jsonNestedPrefixed, cssCustomMedia, jsonOneDimensional, jsonPostCssFallback, cssAdvanced, jsonFigma, markdownLlmGuidelines, } from './formats/index.js';
 import { themeOverrides } from './preprocessors/themeOverrides.js';
+import { inheritGroupProperties } from './preprocessors/inheritGroupProperties.js';
 import { colorAlphaToCss } from './transformers/colorAlphaToCss.js';
 /**
  * @name {@link PrimerStyleDictionary}
@@ -55,6 +56,10 @@ PrimerStyleDictionary.registerFormat({
     name: 'json/figma',
     format: jsonFigma,
 });
+PrimerStyleDictionary.registerFormat({
+    name: 'json/llm-guidelines',
+    format: markdownLlmGuidelines,
+});
 /**
  * Transformers
  *
@@ -88,3 +93,4 @@ PrimerStyleDictionary.registerTransform(fontFamilyToCss);
 PrimerStyleDictionary.registerTransform(fontFamilyToFigma);
 PrimerStyleDictionary.registerTransform(gradientToCss);
 PrimerStyleDictionary.registerPreprocessor(themeOverrides);
+PrimerStyleDictionary.registerPreprocessor(inheritGroupProperties);

package/dist/build/schemas/borderToken.d.ts

@@ -31,4 +31,10 @@ export declare const borderToken: z.ZodObject<{
         width: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"0">, z.ZodLiteral<0>]>, z.ZodString]>;
     }, z.core.$strip>, z.ZodString]>;
     $type: z.ZodLiteral<"string" | "number" | "border" | "color" | "fontFamily" | "fontWeight" | "transition" | "dimension" | "duration" | "gradient" | "shadow" | "typography" | "cubicBezier" | "custom-viewportRange">;
+    $extensions: z.ZodOptional<z.ZodObject<{
+        'org.primer.llm': z.ZodOptional<z.ZodObject<{
+            usage: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            rules: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strict>;

package/dist/build/schemas/borderToken.js

@@ -4,6 +4,7 @@ import { referenceValue } from './referenceValue.js';
 import { colorHexValue } from './colorHexValue.js';
 import { dimensionValue } from './dimensionValue.js';
 import { tokenType } from './tokenType.js';
+import { llmExtension } from './llmExtension.js';
 export const borderValue = z.object({
     color: z.union([colorHexValue, referenceValue]),
     style: z.enum(['solid', 'dashed', 'dotted', 'double', 'groove', 'ridge', 'outset', 'inset']),
@@ -13,5 +14,10 @@ export const borderToken = baseToken
     .extend({
     $value: z.union([borderValue, referenceValue]),
     $type: tokenType('border'),
+    $extensions: z
+        .object({
+        'org.primer.llm': llmExtension,
+    })
+        .optional(),
 })
     .strict();

package/dist/build/schemas/colorToken.d.ts

@@ -98,5 +98,9 @@ export declare const colorToken: z.ZodObject<{
                 alpha: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodAny>>>;
             }, z.core.$strict>]>>;
         }, z.core.$strict>>;
+        'org.primer.llm': z.ZodOptional<z.ZodObject<{
+            usage: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            rules: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;

package/dist/build/schemas/colorToken.js

@@ -6,6 +6,7 @@ import { baseToken } from './baseToken.js';
 import { collection, mode } from './collections.js';
 import { scopes } from './scopes.js';
 import { tokenType } from './tokenType.js';
+import { llmExtension } from './llmExtension.js';
 const baseColorToken = baseToken.extend({
     $value: z.union([colorHexValue, referenceValue]),
     alpha: alphaValue.optional().nullable(),
@@ -75,6 +76,7 @@ export const colorToken = baseColorToken
         })
             .strict()
             .optional(),
+        'org.primer.llm': llmExtension,
     })
         .strict()
         .optional(),

package/dist/build/schemas/cubicBezierToken.d.ts

@@ -4,4 +4,10 @@ export declare const cubicBezierToken: z.ZodObject<{
     $deprecated: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>;
     $value: z.ZodUnion<readonly [z.ZodArray<z.ZodNumber>, z.ZodString]>;
     $type: z.ZodLiteral<"string" | "number" | "border" | "color" | "fontFamily" | "fontWeight" | "transition" | "dimension" | "duration" | "gradient" | "shadow" | "typography" | "cubicBezier" | "custom-viewportRange">;
+    $extensions: z.ZodOptional<z.ZodObject<{
+        'org.primer.llm': z.ZodOptional<z.ZodObject<{
+            usage: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            rules: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strict>;

package/dist/build/schemas/cubicBezierToken.js

@@ -2,7 +2,15 @@ import { z } from 'zod';
 import { baseToken } from './baseToken.js';
 import { referenceValue } from './referenceValue.js';
 import { tokenType } from './tokenType.js';
-export const cubicBezierToken = baseToken.extend({
+import { llmExtension } from './llmExtension.js';
+export const cubicBezierToken = baseToken
+    .extend({
     $value: z.union([z.array(z.number()).length(4), referenceValue]),
     $type: tokenType('cubicBezier'),
-});
+    $extensions: z
+        .object({
+        'org.primer.llm': llmExtension,
+    })
+        .optional(),
+})
+    .strict();

package/dist/build/schemas/designToken.d.ts

@@ -1,2 +1,2 @@
 import { z } from 'zod';
-export declare const designToken: z.ZodRecord<z.ZodString, z.ZodLazy<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+export declare const designToken: z.ZodType<unknown>;

package/dist/build/schemas/designToken.js

@@ -14,26 +14,118 @@ import { durationToken } from './durationToken.js';
 import { cubicBezierToken } from './cubicBezierToken.js';
 import { gradientToken } from './gradientToken.js';
 import { transitionToken } from './transitionToken.js';
+import { llmExtension } from './llmExtension.js';
+/**
+ * Group-level extensions schema (W3C Design Tokens spec)
+ * https://www.designtokens.org/tr/drafts/format/#group-properties
+ */
+const groupExtensions = z
+    .object({
+    'org.primer.llm': llmExtension,
+})
+    .passthrough();
+/**
+ * All valid token types with $type discriminator
+ */
+const tokenTypes = z.discriminatedUnion('$type', [
+    colorToken,
+    cubicBezierToken,
+    dimensionToken,
+    shadowToken,
+    borderToken,
+    fontFamilyToken,
+    fontWeightToken,
+    gradientToken,
+    typographyToken,
+    viewportRangeToken,
+    numberToken,
+    durationToken,
+    stringToken,
+    transitionToken,
+]);
+/**
+ * Validates a record allowing both token names and group properties ($description, $extensions)
+ * Recursively validates nested groups
+ */
+const createDesignTokenSchema = () => {
+    return z.record(z.string(), z.unknown()).superRefine((obj, ctx) => {
+        for (const [key, value] of Object.entries(obj)) {
+            if (key === '$description') {
+                // Group-level $description must be a string
+                if (typeof value !== 'string') {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `$description must be a string, got ${typeof value}`,
+                        path: [key],
+                    });
+                }
+            }
+            else if (key === '$extensions') {
+                // Group-level $extensions must be an object
+                if (typeof value !== 'object' || value === null) {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `$extensions must be an object`,
+                        path: [key],
+                    });
+                }
+                else {
+                    const result = groupExtensions.safeParse(value);
+                    if (!result.success) {
+                        for (const issue of result.error.issues) {
+                            ctx.addIssue(Object.assign(Object.assign({}, issue), { path: [key, ...issue.path] }));
+                        }
+                    }
+                }
+            }
+            else if (key.startsWith('$')) {
+                // Unknown $-prefixed keys at group level are not allowed
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `Unknown group property: ${key}. Only $description and $extensions are allowed.`,
+                    path: [key],
+                });
+            }
+            else {
+                // Validate token name
+                const nameResult = tokenName.safeParse(key);
+                if (!nameResult.success) {
+                    for (const issue of nameResult.error.issues) {
+                        ctx.addIssue(Object.assign(Object.assign({}, issue), { path: [key] }));
+                    }
+                }
+                // Validate value as either a token or nested group
+                if (typeof value === 'object' && value !== null) {
+                    // Check if it's a token (has $type) or a nested group
+                    if ('$type' in value) {
+                        const tokenResult = tokenTypes.safeParse(value);
+                        if (!tokenResult.success) {
+                            for (const issue of tokenResult.error.issues) {
+                                ctx.addIssue(Object.assign(Object.assign({}, issue), { path: [key, ...issue.path] }));
+                            }
+                        }
+                    }
+                    else {
+                        // Recursively validate nested group
+                        const nestedResult = designToken.safeParse(value);
+                        if (!nestedResult.success) {
+                            for (const issue of nestedResult.error.issues) {
+                                ctx.addIssue(Object.assign(Object.assign({}, issue), { path: [key, ...issue.path] }));
+                            }
+                        }
+                    }
+                }
+                else {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `Expected token or group object, got ${typeof value}`,
+                        path: [key],
+                    });
+                }
+            }
+        }
+    });
+};
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore: TODO: fix this
-export const designToken = z.record(tokenName, z.lazy(() => {
-    return z.union([
-        z.discriminatedUnion('$type', [
-            colorToken,
-            cubicBezierToken,
-            dimensionToken,
-            shadowToken,
-            borderToken,
-            fontFamilyToken,
-            fontWeightToken,
-            gradientToken,
-            typographyToken,
-            viewportRangeToken,
-            numberToken,
-            durationToken,
-            stringToken,
-            transitionToken,
-        ]),
-        designToken,
-    ]);
-}));
+export const designToken = createDesignTokenSchema();

package/dist/build/schemas/dimensionToken.d.ts

@@ -5,10 +5,14 @@ export declare const dimensionToken: z.ZodObject<{
     $value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"0">, z.ZodLiteral<0>]>, z.ZodString]>;
     $type: z.ZodLiteral<"string" | "number" | "border" | "color" | "fontFamily" | "fontWeight" | "transition" | "dimension" | "duration" | "gradient" | "shadow" | "typography" | "cubicBezier" | "custom-viewportRange">;
     $extensions: z.ZodOptional<z.ZodObject<{
-        'org.primer.figma': z.ZodObject<{
+        'org.primer.figma': z.ZodOptional<z.ZodObject<{
             collection: z.ZodString;
             scopes: z.ZodArray<z.ZodString>;
             group: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
+        }, z.core.$strip>>;
+        'org.primer.llm': z.ZodOptional<z.ZodObject<{
+            usage: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            rules: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strict>;