@primer/primitives 11.4.0-rc.f798df25 → 11.4.1-rc.4e2d1de5

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

@@ -11,7 +11,14 @@ export declare const borderValue: z.ZodObject<{
         ridge: "ridge";
         outset: "outset";
     }>;
-    width: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"0">, z.ZodLiteral<0>]>, z.ZodString]>;
+    width: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+        value: z.ZodNumber;
+        unit: z.ZodEnum<{
+            em: "em";
+            px: "px";
+            rem: "rem";
+        }>;
+    }, z.core.$strict>, z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"0">, z.ZodLiteral<0>]>]>, z.ZodString]>;
 }, z.core.$strip>;
 export declare const borderToken: z.ZodObject<{
     $description: z.ZodOptional<z.ZodString>;
@@ -28,7 +35,20 @@ export declare const borderToken: z.ZodObject<{
             ridge: "ridge";
             outset: "outset";
         }>;
-        width: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"0">, z.ZodLiteral<0>]>, z.ZodString]>;
+        width: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+            value: z.ZodNumber;
+            unit: z.ZodEnum<{
+                em: "em";
+                px: "px";
+                rem: "rem";
+            }>;
+        }, z.core.$strict>, 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

@@ -2,13 +2,24 @@ import { z } from 'zod';
 export declare const dimensionToken: z.ZodObject<{
     $description: z.ZodOptional<z.ZodString>;
     $deprecated: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>;
-    $value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"0">, z.ZodLiteral<0>]>, z.ZodString]>;
+    $value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+        value: z.ZodNumber;
+        unit: z.ZodEnum<{
+            em: "em";
+            px: "px";
+            rem: "rem";
+        }>;
+    }, z.core.$strict>, 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>;

package/dist/build/schemas/dimensionToken.js

@@ -5,13 +5,15 @@ 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]),
     $type: tokenType('dimension'),
     $extensions: z
         .object({
-        'org.primer.figma': z.object({
+        'org.primer.figma': z
+            .object({
             collection: collection(['base/size', 'base/typography', 'functional/size', 'pattern/size', 'typography']),
             scopes: scopes([
                 'all',
@@ -28,7 +30,9 @@ export const dimensionToken = baseToken
                 'paragraphIndent',
             ]),
             group: z.string().optional(),
-        }),
+        })
+            .optional(),
+        'org.primer.llm': llmExtension,
     })
         .optional(),
 })

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

@@ -1,2 +1,25 @@
 import { z } from 'zod';
-export declare const dimensionValue: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"0">, z.ZodLiteral<0>]>;
+/**
+ * W3C DTCG dimension value format
+ * @link https://www.designtokens.org/tr/drafts/format/#dimension
+ */
+export declare const dimensionValueObject: z.ZodObject<{
+    value: z.ZodNumber;
+    unit: z.ZodEnum<{
+        em: "em";
+        px: "px";
+        rem: "rem";
+    }>;
+}, z.core.$strict>;
+/**
+ * Dimension value - supports both W3C DTCG object format and legacy string format
+ * Note: Transformers only accept W3C format, but schema validates both for migration period
+ */
+export declare const dimensionValue: z.ZodUnion<readonly [z.ZodObject<{
+    value: z.ZodNumber;
+    unit: z.ZodEnum<{
+        em: "em";
+        px: "px";
+        rem: "rem";
+    }>;
+}, z.core.$strict>, z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"0">, z.ZodLiteral<0>]>]>;

package/dist/build/schemas/dimensionValue.js

@@ -1,6 +1,20 @@
 import { z } from 'zod';
 import { schemaErrorMessage } from '../utilities/index.js';
-export const dimensionValue = z.union([
+/**
+ * W3C DTCG dimension value format
+ * @link https://www.designtokens.org/tr/drafts/format/#dimension
+ */
+export const dimensionValueObject = z
+    .object({
+    value: z.number(),
+    unit: z.enum(['px', 'rem', 'em']),
+})
+    .strict();
+/**
+ * Legacy dimension value format (string with unit)
+ * @deprecated Use W3C DTCG object format instead
+ */
+const dimensionValueLegacy = z.union([
     z.string().superRefine((dim, ctx) => {
         if (!/(^-?[0-9]+\.?[0-9]*(px|rem)$|^-?[0-9]+\.?[0-9]*em$)/.test(dim)) {
             ctx.addIssue({
@@ -12,3 +26,8 @@ export const dimensionValue = z.union([
     z.literal('0'),
     z.literal(0),
 ]);
+/**
+ * Dimension value - supports both W3C DTCG object format and legacy string format
+ * Note: Transformers only accept W3C format, but schema validates both for migration period
+ */
+export const dimensionValue = z.union([dimensionValueObject, dimensionValueLegacy]);

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

@@ -2,6 +2,18 @@ import { z } from 'zod';
 export declare const durationToken: z.ZodObject<{
     $description: z.ZodOptional<z.ZodString>;
     $deprecated: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>;
-    $value: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    $value: z.ZodUnion<readonly [z.ZodObject<{
+        value: z.ZodNumber;
+        unit: z.ZodEnum<{
+            s: "s";
+            ms: "ms";
+        }>;
+    }, z.core.$strict>, 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/durationValue.d.ts

@@ -1,2 +1,12 @@
 import { z } from 'zod';
-export declare const durationValue: z.ZodString;
+/**
+ * W3C DTCG duration value format
+ * @see https://www.designtokens.org/tr/2025.10/format/#duration
+ */
+export declare const durationValue: z.ZodObject<{
+    value: z.ZodNumber;
+    unit: z.ZodEnum<{
+        s: "s";
+        ms: "ms";
+    }>;
+}, z.core.$strict>;

package/dist/build/schemas/durationValue.js

@@ -1,10 +1,20 @@
 import { z } from 'zod';
 import { schemaErrorMessage } from '../utilities/index.js';
-export const durationValue = z.string().superRefine((duration, ctx) => {
-    if (!/^[0-9]+ms$/.test(duration)) {
+/**
+ * W3C DTCG duration value format
+ * @see https://www.designtokens.org/tr/2025.10/format/#duration
+ */
+export const durationValue = z
+    .object({
+    value: z.number(),
+    unit: z.enum(['ms', 's']),
+})
+    .strict()
+    .superRefine((duration, ctx) => {
+    if (typeof duration.value !== 'number') {
         ctx.addIssue({
             code: 'custom',
-            message: schemaErrorMessage(`Invalid duration: "${duration}"`, `A duration must be a string with an "ms"`),
+            message: schemaErrorMessage(`Invalid duration value: "${duration.value}"`, `Duration value must be a number`),
         });
     }
 });

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(),
 })