@primer/primitives 11.4.0-rc.b3c35298 → 11.4.0-rc.daff2d10

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,8 @@
+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']
+ * @param FormatFnArguments
+ * @returns formatted markdown `string`
+ */
+export declare const markdownLlmGuidelines: FormatFn;

package/dist/build/formats/markdownLlmGuidelines.js

@@ -0,0 +1,93 @@
+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';
+/**
+ * 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);
+}
+/**
+ * @description Outputs a markdown file with LLM token guidelines, extracting
+ * description from $description and usage/rules from $extensions['org.primer.llm']
+ * @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)}`, '');
+        for (const guideline of grouped[category]) {
+            lines.push(`### ${guideline.name}`);
+            if (guideline.description) {
+                lines.push(guideline.description);
+            }
+            if (guideline.usage && guideline.usage.length > 0) {
+                lines.push(`**Usage:** ${guideline.usage.join(', ')}`);
+            }
+            if (guideline.rules) {
+                lines.push(`**Rules:** ${guideline.rules}`);
+            }
+            lines.push('');
+        }
+    }
+    return lines.join('\n');
+});

package/dist/build/platforms/css.js

@@ -8,12 +8,12 @@ const getCssSelectors = (outputFile) => {
     const mode = outputBasename.substring(0, 4) === 'dark' ? 'dark' : 'light';
     return [
         {
-            selector: `[data-color-mode="${mode}"][data-${mode}-theme="${themeName}"], [data-color-mode="${mode}"][data-${mode}-theme="${themeName}"] ::backdrop, [data-color-mode="auto"][data-light-theme="${themeName}"], [data-color-mode="auto"][data-light-theme="${themeName}"] ::backdrop`,
+            selector: `[data-color-mode="${mode}"][data-${mode}-theme="${themeName}"], [data-color-mode="auto"][data-light-theme="${themeName}"]`,
         },
         {
             query: '@media (prefers-color-scheme: dark)',
             // [data-color-mode] here is duplicated to increase the specificity so that light mode can't override it when prefers-color-scheme: dark is enabled
-            selector: `[data-color-mode][data-color-mode="auto"][data-dark-theme="${themeName}"], [data-color-mode][data-color-mode="auto"][data-dark-theme="${themeName}"] ::backdrop`,
+            selector: `[data-color-mode][data-color-mode="auto"][data-dark-theme="${themeName}"]`,
         },
     ];
 };

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,16 @@
+import { hasLlmExtensions } from '../filters/index.js';
+export const llmGuidelines = (outputFile, prefix, buildPath) => ({
+    prefix,
+    buildPath,
+    transforms: ['name/pathToKebabCase'],
+    files: [
+        {
+            destination: outputFile,
+            format: 'json/llm-guidelines',
+            filter: hasLlmExtensions,
+            options: {
+                outputReferences: false,
+            },
+        },
+    ],
+});

package/dist/build/primerStyleDictionary.js

@@ -1,6 +1,6 @@
 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 { colorAlphaToCss } from './transformers/colorAlphaToCss.js';
 /**
@@ -55,6 +55,10 @@ PrimerStyleDictionary.registerFormat({
     name: 'json/figma',
     format: jsonFigma,
 });
+PrimerStyleDictionary.registerFormat({
+    name: 'json/llm-guidelines',
+    format: markdownLlmGuidelines,
+});
 /**
  * Transformers
  *

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/dimensionToken.d.ts

@@ -10,5 +10,9 @@ export declare const dimensionToken: z.ZodObject<{
             scopes: z.ZodArray<z.ZodString>;
             group: z.ZodOptional<z.ZodString>;
         }, 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>;

package/dist/build/schemas/dimensionToken.js

@@ -5,6 +5,7 @@ import { collection } from './collections.js';
 import { scopes } from './scopes.js';
 import { dimensionValue } from './dimensionValue.js';
 import { tokenType } from './tokenType.js';
+import { llmExtension } from './llmExtension.js';
 export const dimensionToken = baseToken
     .extend({
     $value: z.union([dimensionValue, referenceValue]),
@@ -12,7 +13,7 @@ export const dimensionToken = baseToken
     $extensions: z
         .object({
         'org.primer.figma': z.object({
-            collection: collection(['base/size', 'functional/size', 'pattern/size', 'typography']),
+            collection: collection(['base/size', 'base/typography', 'functional/size', 'pattern/size', 'typography']),
             scopes: scopes([
                 'all',
                 'size',
@@ -29,6 +30,7 @@ export const dimensionToken = baseToken
             ]),
             group: z.string().optional(),
         }),
+        'org.primer.llm': llmExtension,
     })
         .optional(),
 })

package/dist/build/schemas/dimensionValue.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { schemaErrorMessage } from '../utilities/index.js';
 export const dimensionValue = z.union([
     z.string().superRefine((dim, ctx) => {
-        if (!/(^-?[0-9]+(px|rem)$|^-?[0-9]+\.?[0-9]*em$)/.test(dim)) {
+        if (!/(^-?[0-9]+\.?[0-9]*(px|rem)$|^-?[0-9]+\.?[0-9]*em$)/.test(dim)) {
             ctx.addIssue({
                 code: 'custom',
                 message: schemaErrorMessage(`Invalid dimension: "${dim}"`, `Dimension must be a string with a unit (px, rem or em) or 0`),

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

@@ -4,4 +4,10 @@ export declare const durationToken: z.ZodObject<{
     $deprecated: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>;
     $value: z.ZodUnion<readonly [z.ZodString, 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/durationToken.js

@@ -3,9 +3,15 @@ import { baseToken } from './baseToken.js';
 import { referenceValue } from './referenceValue.js';
 import { durationValue } from './durationValue.js';
 import { tokenType } from './tokenType.js';
+import { llmExtension } from './llmExtension.js';
 export const durationToken = baseToken
     .extend({
     $value: z.union([durationValue, referenceValue]),
     $type: tokenType('duration'),
+    $extensions: z
+        .object({
+        'org.primer.llm': llmExtension,
+    })
+        .optional(),
 })
     .strict();

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

@@ -9,5 +9,9 @@ export declare const fontFamilyToken: z.ZodObject<{
             collection: z.ZodOptional<z.ZodString>;
             scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, 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>;

package/dist/build/schemas/fontFamilyToken.js

@@ -4,6 +4,7 @@ import { baseToken } from './baseToken.js';
 import { tokenType } from './tokenType.js';
 import { collection } from './collections.js';
 import { scopes } from './scopes.js';
+import { llmExtension } from './llmExtension.js';
 export const fontFamilyToken = baseToken
     .extend({
     $value: z.union([z.string(), referenceValue]),
@@ -14,6 +15,7 @@ export const fontFamilyToken = baseToken
             collection: collection(['base/typography', 'typography']).optional(),
             scopes: scopes(['fontFamily']).optional(),
         }),
+        'org.primer.llm': llmExtension,
     })
         .optional(),
 })

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

@@ -9,5 +9,9 @@ export declare const fontWeightToken: z.ZodObject<{
             collection: z.ZodOptional<z.ZodString>;
             scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, 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>;

package/dist/build/schemas/fontWeightToken.js

@@ -5,6 +5,7 @@ import { baseToken } from './baseToken.js';
 import { tokenType } from './tokenType.js';
 import { collection } from './collections.js';
 import { scopes } from './scopes.js';
+import { llmExtension } from './llmExtension.js';
 export const fontWeightToken = baseToken
     .extend({
     $type: tokenType('fontWeight'),
@@ -15,6 +16,7 @@ export const fontWeightToken = baseToken
             collection: collection(['base/typography', 'typography']).optional(),
             scopes: scopes(['fontWeight']).optional(),
         }),
+        'org.primer.llm': llmExtension,
     })
         .optional(),
 })

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

@@ -11,5 +11,9 @@ export declare const gradientToken: z.ZodObject<{
         'org.primer.gradient': z.ZodObject<{
             angle: z.ZodOptional<z.ZodNumber>;
         }, 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>;

package/dist/build/schemas/gradientToken.js

@@ -3,6 +3,7 @@ import { baseToken } from './baseToken.js';
 import { referenceValue } from './referenceValue.js';
 import { tokenType } from './tokenType.js';
 import { colorHexValue } from './colorHexValue.js';
+import { llmExtension } from './llmExtension.js';
 export const gradientToken = baseToken
     .extend({
     $value: z.union([
@@ -20,6 +21,7 @@ export const gradientToken = baseToken
         'org.primer.gradient': z.object({
             angle: z.number().int().min(0).max(360).optional(),
         }),
+        'org.primer.llm': llmExtension,
     })
         .optional(),
 })

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

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+/**
+ * Schema for org.primer.llm extension
+ * Used to provide LLM-friendly metadata for tokens
+ */
+export declare const llmExtension: z.ZodOptional<z.ZodObject<{
+    usage: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    rules: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;

package/dist/build/schemas/llmExtension.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+/**
+ * Schema for org.primer.llm extension
+ * Used to provide LLM-friendly metadata for tokens
+ */
+export const llmExtension = z
+    .object({
+    usage: z.array(z.string()).optional(),
+    rules: z.string().optional(),
+})
+    .optional();

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

@@ -12,5 +12,9 @@ export declare const numberToken: z.ZodObject<{
             collection: z.ZodOptional<z.ZodString>;
             scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, 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>;

package/dist/build/schemas/numberToken.js

@@ -4,6 +4,7 @@ import { referenceValue } from './referenceValue.js';
 import { tokenType } from './tokenType.js';
 import { scopes } from './scopes.js';
 import { collection } from './collections.js';
+import { llmExtension } from './llmExtension.js';
 export const numberToken = baseToken
     .extend({
     $value: z.union([z.number(), referenceValue]),
@@ -21,6 +22,7 @@ export const numberToken = baseToken
             scopes: scopes(['fontWeight', 'lineHeight']).optional(),
         })
             .optional(),
+        'org.primer.llm': llmExtension,
     })
         .optional(),
 })

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

@@ -226,5 +226,9 @@ export declare const shadowToken: z.ZodObject<{
                 }, z.core.$strict>>]>;
             }, 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.$strip>>;
 }, z.core.$strict>;

package/dist/build/schemas/shadowToken.js

@@ -6,6 +6,7 @@ import { alphaValue } from './alphaValue.js';
 import { dimensionValue } from './dimensionValue.js';
 import { tokenType } from './tokenType.js';
 import { collection, mode } from './collections.js';
+import { llmExtension } from './llmExtension.js';
 export const shadowValue = z
     .object({
     color: z.union([colorHexValue, referenceValue]),
@@ -58,6 +59,7 @@ export const shadowToken = baseToken
         })
             .strict()
             .optional(),
+        'org.primer.llm': llmExtension,
     })
         .optional(),
 })

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

@@ -4,4 +4,10 @@ export declare const stringToken: z.ZodObject<{
     $deprecated: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>;
     $value: z.ZodUnion<readonly [z.ZodString, 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/stringToken.js

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

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

@@ -8,4 +8,10 @@ export declare const transitionToken: z.ZodObject<{
         delay: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodString]>, 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/transitionToken.js

@@ -4,6 +4,7 @@ import { referenceValue } from './referenceValue.js';
 import { durationToken } from './durationToken.js';
 import { cubicBezierToken } from './cubicBezierToken.js';
 import { tokenType } from './tokenType.js';
+import { llmExtension } from './llmExtension.js';
 export const transitionToken = baseToken
     .extend({
     $value: z.union([
@@ -15,5 +16,10 @@ export const transitionToken = baseToken
         referenceValue,
     ]),
     $type: tokenType('transition'),
+    $extensions: z
+        .object({
+        'org.primer.llm': llmExtension,
+    })
+        .optional(),
 })
     .strict();

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

@@ -15,4 +15,10 @@ export declare const typographyToken: z.ZodObject<{
         fontFamily: z.ZodUnion<readonly [z.ZodString, 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>;