@vellira-ui/tokens 2.104.14 → 2.104.16

package/dist/component-token-dependencies.d.ts

@@ -123,18 +123,26 @@ export declare const componentTokenDependencyAuditV1: readonly [{
 export declare const semanticDependencyRepairsV1: readonly [{
     readonly component: "formField";
     readonly paths: readonly ["requiredMark.fg", "labelInfo.border"];
+    readonly target: "factory";
+    readonly assertion: "form-field-presentation";
     readonly repair: "Move component-specific presentation paint out of unrelated status/text semantic roles while preserving the resolved theme values.";
 }, {
     readonly component: "input";
     readonly paths: readonly ["clearButton.hoverFg", "clearButton.hoverBg"];
+    readonly target: "theme";
+    readonly assertion: "clear-button-danger";
     readonly repair: "Use canonical danger icon semantics when value-equivalent; otherwise use explicit component-owned presentation paint to preserve the existing resolved value without depending on validation status.";
 }, {
     readonly component: "input";
     readonly paths: readonly ["error.ring"];
+    readonly target: "theme";
+    readonly assertion: "input-error-ring";
     readonly repair: "Use status.error.ring rather than a coincidentally equal status.error.fg value.";
 }, {
     readonly component: "select";
     readonly paths: readonly ["clearButton.hoverFg", "clearButton.hoverBg"];
+    readonly target: "theme";
+    readonly assertion: "clear-button-danger";
     readonly repair: "Use canonical danger icon semantics when value-equivalent; otherwise use explicit component-owned presentation paint to preserve the existing resolved value without depending on validation status.";
 }];
 //# sourceMappingURL=component-token-dependencies.d.ts.map

package/dist/component-token-dependencies.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"component-token-dependencies.d.ts","sourceRoot":"","sources":["../src/component-token-dependencies.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;CA8BnC,CAAC;AAEX,MAAM,MAAM,4BAA4B,GACtC,MAAM,GAAG,6BAA6B,GAAG,8BAA8B,CAAC;AAE1E,eAAO,MAAM,wCAAwC;;;;;;;;;;EAe3C,CAAC;AAEX,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmHlC,CAAC;AAEX,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;EAyB9B,CAAC"}
+{"version":3,"file":"component-token-dependencies.d.ts","sourceRoot":"","sources":["../src/component-token-dependencies.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;CA8BnC,CAAC;AAEX,MAAM,MAAM,4BAA4B,GACtC,MAAM,GAAG,6BAA6B,GAAG,8BAA8B,CAAC;AAE1E,eAAO,MAAM,wCAAwC;;;;;;;;;;EAe3C,CAAC;AAEX,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmHlC,CAAC;AAEX,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;EAiC9B,CAAC"}

package/dist/component-token-dependencies.js

@@ -161,21 +161,29 @@ export const semanticDependencyRepairsV1 = [
     {
         component: 'formField',
         paths: ['requiredMark.fg', 'labelInfo.border'],
+        target: 'factory',
+        assertion: 'form-field-presentation',
         repair: 'Move component-specific presentation paint out of unrelated status/text semantic roles while preserving the resolved theme values.',
     },
     {
         component: 'input',
         paths: ['clearButton.hoverFg', 'clearButton.hoverBg'],
+        target: 'theme',
+        assertion: 'clear-button-danger',
         repair: 'Use canonical danger icon semantics when value-equivalent; otherwise use explicit component-owned presentation paint to preserve the existing resolved value without depending on validation status.',
     },
     {
         component: 'input',
         paths: ['error.ring'],
+        target: 'theme',
+        assertion: 'input-error-ring',
         repair: 'Use status.error.ring rather than a coincidentally equal status.error.fg value.',
     },
     {
         component: 'select',
         paths: ['clearButton.hoverFg', 'clearButton.hoverBg'],
+        target: 'theme',
+        assertion: 'clear-button-danger',
         repair: 'Use canonical danger icon semantics when value-equivalent; otherwise use explicit component-owned presentation paint to preserve the existing resolved value without depending on validation status.',
     },
 ];

package/dist/component-token-dependency-audit.d.ts

@@ -0,0 +1,15 @@
+import { type semanticDependencyRepairsV1 } from './component-token-dependencies.js';
+export type ComponentDependencyTheme = 'light' | 'dark' | 'highContrast';
+export type SemanticDependencyRepair = (typeof semanticDependencyRepairsV1)[number];
+export type SemanticDependencySourceIssue = {
+    code: string;
+    evidence: string;
+    expected: string;
+};
+export declare function auditSemanticDependencyRepairSource(input: {
+    repair: SemanticDependencyRepair;
+    source: string;
+    theme?: ComponentDependencyTheme | null;
+}): SemanticDependencySourceIssue[];
+export declare function auditGeneratedThemeTokenDependencySource(content: string): SemanticDependencySourceIssue[];
+//# sourceMappingURL=component-token-dependency-audit.d.ts.map

package/dist/component-token-dependency-audit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-token-dependency-audit.d.ts","sourceRoot":"","sources":["../src/component-token-dependency-audit.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,mCAAmC,CAAC;AAE3C,MAAM,MAAM,wBAAwB,GAAG,OAAO,GAAG,MAAM,GAAG,cAAc,CAAC;AACzE,MAAM,MAAM,wBAAwB,GAClC,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/C,MAAM,MAAM,6BAA6B,GAAG;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAUF,wBAAgB,mCAAmC,CAAC,KAAK,EAAE;IACzD,MAAM,EAAE,wBAAwB,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,wBAAwB,GAAG,IAAI,CAAC;CACzC,GAAG,6BAA6B,EAAE,CA0GlC;AAED,wBAAgB,wCAAwC,CACtD,OAAO,EAAE,MAAM,GACd,6BAA6B,EAAE,CAwBjC"}

package/dist/component-token-dependency-audit.js

@@ -0,0 +1,60 @@
+import { componentTokenDependencyPolicyV1, } from './component-token-dependencies.js';
+function issue(code, evidence, expected) {
+    return { code, evidence, expected };
+}
+export function auditSemanticDependencyRepairSource(input) {
+    const findings = [];
+    switch (input.repair.assertion) {
+        case 'form-field-presentation': {
+            if (!input.source.includes('border: presentation.labelInfoBorder')) {
+                findings.push(issue('missing-form-field-label-info-presentation', 'FormField no longer maps labelInfo.border through component-owned presentation paint.', 'Keep labelInfo.border on presentation.labelInfoBorder.'));
+            }
+            if (!input.source.includes('fg: presentation.requiredMarkFg')) {
+                findings.push(issue('missing-form-field-required-mark-presentation', 'FormField no longer maps requiredMark.fg through component-owned presentation paint.', 'Keep requiredMark.fg on presentation.requiredMarkFg.'));
+            }
+            if (input.source.includes('border: text.secondary')) {
+                findings.push(issue('form-field-unrelated-text-semantic', 'FormField labelInfo.border depends on text.secondary.', 'Component presentation paint must not borrow an unrelated text semantic role.'));
+            }
+            break;
+        }
+        case 'clear-button-danger': {
+            if (!input.theme) {
+                findings.push(issue('missing-clear-button-theme-context', 'Clear-button repair validation was invoked without a theme.', 'Validate clear-button semantic repair for every maintained theme.'));
+                break;
+            }
+            if (input.source.includes('hoverFg: status.error.fg')) {
+                findings.push(issue('clear-button-validation-fg-dependency', 'Destructive clear-button hover foreground depends on validation status.error.fg.', 'Use danger icon semantics or explicit component-owned presentation paint.'));
+            }
+            if (input.source.includes('hoverBg: status.error.bg')) {
+                findings.push(issue('clear-button-validation-bg-dependency', 'Destructive clear-button hover background depends on validation status.error.bg.', 'Use explicit danger presentation paint rather than validation status paint.'));
+            }
+            const expectedHoverFg = input.theme === 'highContrast'
+                ? 'hoverFg: colors.error[400]'
+                : 'hoverFg: icons.danger';
+            if (!input.source.includes(expectedHoverFg)) {
+                findings.push(issue('clear-button-danger-foreground-drift', `Expected ${expectedHoverFg} for the ${input.theme} clear-button repair.`, 'Preserve the accepted #888 danger foreground repair for this theme.'));
+            }
+            break;
+        }
+        case 'input-error-ring': {
+            if (!input.source.includes('ring: status.error.ring')) {
+                findings.push(issue('input-error-ring-role-drift', 'Input validation ring no longer consumes status.error.ring.', 'Use the dedicated status.error.ring semantic role.'));
+            }
+            if (input.source.includes('ring: status.error.fg')) {
+                findings.push(issue('input-error-ring-foreground-bypass', 'Input validation ring consumes status.error.fg.', 'Do not substitute a value-equal foreground role for the dedicated ring role.'));
+            }
+            break;
+        }
+    }
+    return findings;
+}
+export function auditGeneratedThemeTokenDependencySource(content) {
+    const findings = [];
+    if (content.includes('../../primitives/colors.js')) {
+        findings.push(issue('generated-token-primitive-bypass', 'Generated theme token construction imports primitive colors directly.', componentTokenDependencyPolicyV1.generatorRule));
+    }
+    if (content.includes('../semantic/action.js')) {
+        findings.push(issue('generated-token-deprecated-action-dependency', 'Generated theme token construction imports deprecated semantic/action.', componentTokenDependencyPolicyV1.generatorRule));
+    }
+    return findings;
+}

package/dist/component-token-factory-conventions.d.ts

@@ -0,0 +1,55 @@
+export declare const componentTokenFactoryConventionV1: {
+    readonly rootEntries: readonly [{
+        readonly name: "components";
+        readonly kind: "directory";
+    }, {
+        readonly name: "index.ts";
+        readonly kind: "file";
+    }, {
+        readonly name: "palettes";
+        readonly kind: "directory";
+    }, {
+        readonly name: "shared";
+        readonly kind: "directory";
+    }];
+    readonly paletteFamilies: readonly [{
+        readonly component: "button";
+        readonly componentName: "Button";
+        readonly factory: "createButtonTokens";
+        readonly helper: "createButtonIntentPalette.ts";
+        readonly themeFile: "button.ts";
+    }, {
+        readonly component: "checkbox";
+        readonly componentName: "Checkbox";
+        readonly factory: "createCheckboxTokens";
+        readonly helper: "createCheckboxIntentPalette.ts";
+        readonly themeFile: "checkbox.ts";
+    }, {
+        readonly component: "dropdown";
+        readonly componentName: "Dropdown";
+        readonly factory: "createDropdownTokens";
+        readonly helper: "createDropdownIntentPalette.ts";
+        readonly themeFile: "dropdown.ts";
+    }, {
+        readonly component: "input";
+        readonly componentName: "Input";
+        readonly factory: "createInputTokens";
+        readonly helper: "createInputIntentPalette.ts";
+        readonly themeFile: "input.ts";
+    }, {
+        readonly component: "radio";
+        readonly componentName: "Radio";
+        readonly factory: "createRadioTokens";
+        readonly helper: "createRadioIntentPalette.ts";
+        readonly themeFile: "radio.ts";
+    }, {
+        readonly component: "select";
+        readonly componentName: "Select";
+        readonly factory: "createSelectTokens";
+        readonly helper: "createSelectIntentPalette.ts";
+        readonly themeFile: "select.ts";
+    }];
+    readonly sharedHelpers: readonly ["componentFocusRing.ts"];
+};
+export type ComponentTokenFactoryConvention = typeof componentTokenFactoryConventionV1;
+//# sourceMappingURL=component-token-factory-conventions.d.ts.map

package/dist/component-token-factory-conventions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-token-factory-conventions.d.ts","sourceRoot":"","sources":["../src/component-token-factory-conventions.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDpC,CAAC;AAEX,MAAM,MAAM,+BAA+B,GACzC,OAAO,iCAAiC,CAAC"}

package/dist/component-token-factory-conventions.js

@@ -0,0 +1,53 @@
+export const componentTokenFactoryConventionV1 = {
+    rootEntries: [
+        { name: 'components', kind: 'directory' },
+        { name: 'index.ts', kind: 'file' },
+        { name: 'palettes', kind: 'directory' },
+        { name: 'shared', kind: 'directory' },
+    ],
+    paletteFamilies: [
+        {
+            component: 'button',
+            componentName: 'Button',
+            factory: 'createButtonTokens',
+            helper: 'createButtonIntentPalette.ts',
+            themeFile: 'button.ts',
+        },
+        {
+            component: 'checkbox',
+            componentName: 'Checkbox',
+            factory: 'createCheckboxTokens',
+            helper: 'createCheckboxIntentPalette.ts',
+            themeFile: 'checkbox.ts',
+        },
+        {
+            component: 'dropdown',
+            componentName: 'Dropdown',
+            factory: 'createDropdownTokens',
+            helper: 'createDropdownIntentPalette.ts',
+            themeFile: 'dropdown.ts',
+        },
+        {
+            component: 'input',
+            componentName: 'Input',
+            factory: 'createInputTokens',
+            helper: 'createInputIntentPalette.ts',
+            themeFile: 'input.ts',
+        },
+        {
+            component: 'radio',
+            componentName: 'Radio',
+            factory: 'createRadioTokens',
+            helper: 'createRadioIntentPalette.ts',
+            themeFile: 'radio.ts',
+        },
+        {
+            component: 'select',
+            componentName: 'Select',
+            factory: 'createSelectTokens',
+            helper: 'createSelectIntentPalette.ts',
+            themeFile: 'select.ts',
+        },
+    ],
+    sharedHelpers: ['componentFocusRing.ts'],
+};

package/dist/interaction-state-contract.d.ts

@@ -0,0 +1,138 @@
+export type CompoundInteractionResolution = {
+    readonly strategy: 'selected-variant' | 'disabled-wins' | 'orthogonal-focus' | 'domain-specific-active';
+    readonly semanticPath: string | null;
+    readonly meaning: string;
+};
+/**
+ * Companion contract for Interaction State Vocabulary V1 (#882).
+ *
+ * State names and their meanings remain owned by token-architecture.ts. This
+ * contract only defines how selected composes with every other canonical state
+ * so renderers and generators cannot invent precedence rules independently.
+ */
+export declare const selectedCompoundStateGrammarV1: {
+    readonly default: {
+        readonly strategy: "selected-variant";
+        readonly semanticPath: "semantic.control.selected.default";
+        readonly meaning: "Selected resting presentation.";
+    };
+    readonly hover: {
+        readonly strategy: "selected-variant";
+        readonly semanticPath: "semantic.control.selected.hover";
+        readonly meaning: "Selected plus pointer hover when the platform supports hover.";
+    };
+    readonly pressed: {
+        readonly strategy: "selected-variant";
+        readonly semanticPath: "semantic.control.selected.pressed";
+        readonly meaning: "Selected plus transient physical pointer/key press.";
+    };
+    readonly active: {
+        readonly strategy: "domain-specific-active";
+        readonly semanticPath: null;
+        readonly meaning: "Selected may combine with active only in a registered persistent/current active domain; active is never physical press.";
+    };
+    readonly selected: {
+        readonly strategy: "selected-variant";
+        readonly semanticPath: "semantic.control.selected.default";
+        readonly meaning: "Idempotent selected state resolves to the selected baseline.";
+    };
+    readonly disabled: {
+        readonly strategy: "disabled-wins";
+        readonly semanticPath: "semantic.control.disabled";
+        readonly meaning: "Disabled suppresses transient hover/press interaction. Components may preserve selected identity with component-level selected+disabled paint.";
+    };
+    readonly focus: {
+        readonly strategy: "orthogonal-focus";
+        readonly semanticPath: "semantic.focus.ring";
+        readonly meaning: "Focus indication composes orthogonally with selection and does not replace the selected paint state.";
+    };
+};
+export type PlatformInteractionStateMapping = {
+    readonly support: 'required' | 'optional';
+    readonly signal: string;
+    readonly meaning: string;
+};
+/**
+ * Platform event/state mapping for the canonical vocabulary.
+ *
+ * React Native hover is deliberately optional: pointer-capable RN targets may
+ * expose it, but native parity never requires hover where the platform has no
+ * hover capability.
+ */
+export declare const interactionStatePlatformContractV1: {
+    readonly web: {
+        readonly default: {
+            readonly support: "required";
+            readonly signal: "rest";
+            readonly meaning: "Resting enabled presentation.";
+        };
+        readonly hover: {
+            readonly support: "required";
+            readonly signal: ":hover";
+            readonly meaning: "Pointer hover only.";
+        };
+        readonly pressed: {
+            readonly support: "required";
+            readonly signal: ":active";
+            readonly meaning: "Transient pointer/key activation while held.";
+        };
+        readonly active: {
+            readonly support: "required";
+            readonly signal: "domain-current";
+            readonly meaning: "Persistent/current domain state, never the CSS :active press.";
+        };
+        readonly selected: {
+            readonly support: "required";
+            readonly signal: ":checked-or-aria-selected";
+            readonly meaning: "Persistent chosen/checked/selected state.";
+        };
+        readonly disabled: {
+            readonly support: "required";
+            readonly signal: ":disabled-or-aria-disabled";
+            readonly meaning: "Unavailable interaction state.";
+        };
+        readonly focus: {
+            readonly support: "required";
+            readonly signal: ":focus-visible-or-focus";
+            readonly meaning: "Current input focus indication.";
+        };
+    };
+    readonly 'react-native': {
+        readonly default: {
+            readonly support: "required";
+            readonly signal: "rest";
+            readonly meaning: "Resting enabled presentation.";
+        };
+        readonly hover: {
+            readonly support: "optional";
+            readonly signal: "pointer-hover-when-capable";
+            readonly meaning: "Optional pointer hover on targets that expose hover capability.";
+        };
+        readonly pressed: {
+            readonly support: "required";
+            readonly signal: "PressableStateCallbackType.pressed";
+            readonly meaning: "Transient physical press reported by Pressable state.";
+        };
+        readonly active: {
+            readonly support: "required";
+            readonly signal: "domain-current";
+            readonly meaning: "Persistent/current domain state, never Pressable.pressed.";
+        };
+        readonly selected: {
+            readonly support: "required";
+            readonly signal: "accessibilityState.checked-or-selected";
+            readonly meaning: "Persistent chosen/checked/selected state.";
+        };
+        readonly disabled: {
+            readonly support: "required";
+            readonly signal: "disabled-and-accessibilityState.disabled";
+            readonly meaning: "Unavailable interaction state.";
+        };
+        readonly focus: {
+            readonly support: "optional";
+            readonly signal: "focus-when-capable";
+            readonly meaning: "Focus indication on keyboard/TV/pointer-capable targets; not fabricated on targets without focus presentation.";
+        };
+    };
+};
+//# sourceMappingURL=interaction-state-contract.d.ts.map

package/dist/interaction-state-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction-state-contract.d.ts","sourceRoot":"","sources":["../src/interaction-state-contract.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,QAAQ,CAAC,QAAQ,EACb,kBAAkB,GAClB,eAAe,GACf,kBAAkB,GAClB,wBAAwB,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0C1C,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG;IAC5C,QAAQ,CAAC,OAAO,EAAE,UAAU,GAAG,UAAU,CAAC;IAC1C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgF9C,CAAC"}

package/dist/interaction-state-contract.js

@@ -0,0 +1,127 @@
+/**
+ * Companion contract for Interaction State Vocabulary V1 (#882).
+ *
+ * State names and their meanings remain owned by token-architecture.ts. This
+ * contract only defines how selected composes with every other canonical state
+ * so renderers and generators cannot invent precedence rules independently.
+ */
+export const selectedCompoundStateGrammarV1 = {
+    default: {
+        strategy: 'selected-variant',
+        semanticPath: 'semantic.control.selected.default',
+        meaning: 'Selected resting presentation.',
+    },
+    hover: {
+        strategy: 'selected-variant',
+        semanticPath: 'semantic.control.selected.hover',
+        meaning: 'Selected plus pointer hover when the platform supports hover.',
+    },
+    pressed: {
+        strategy: 'selected-variant',
+        semanticPath: 'semantic.control.selected.pressed',
+        meaning: 'Selected plus transient physical pointer/key press.',
+    },
+    active: {
+        strategy: 'domain-specific-active',
+        semanticPath: null,
+        meaning: 'Selected may combine with active only in a registered persistent/current active domain; active is never physical press.',
+    },
+    selected: {
+        strategy: 'selected-variant',
+        semanticPath: 'semantic.control.selected.default',
+        meaning: 'Idempotent selected state resolves to the selected baseline.',
+    },
+    disabled: {
+        strategy: 'disabled-wins',
+        semanticPath: 'semantic.control.disabled',
+        meaning: 'Disabled suppresses transient hover/press interaction. Components may preserve selected identity with component-level selected+disabled paint.',
+    },
+    focus: {
+        strategy: 'orthogonal-focus',
+        semanticPath: 'semantic.focus.ring',
+        meaning: 'Focus indication composes orthogonally with selection and does not replace the selected paint state.',
+    },
+};
+/**
+ * Platform event/state mapping for the canonical vocabulary.
+ *
+ * React Native hover is deliberately optional: pointer-capable RN targets may
+ * expose it, but native parity never requires hover where the platform has no
+ * hover capability.
+ */
+export const interactionStatePlatformContractV1 = {
+    web: {
+        default: {
+            support: 'required',
+            signal: 'rest',
+            meaning: 'Resting enabled presentation.',
+        },
+        hover: {
+            support: 'required',
+            signal: ':hover',
+            meaning: 'Pointer hover only.',
+        },
+        pressed: {
+            support: 'required',
+            signal: ':active',
+            meaning: 'Transient pointer/key activation while held.',
+        },
+        active: {
+            support: 'required',
+            signal: 'domain-current',
+            meaning: 'Persistent/current domain state, never the CSS :active press.',
+        },
+        selected: {
+            support: 'required',
+            signal: ':checked-or-aria-selected',
+            meaning: 'Persistent chosen/checked/selected state.',
+        },
+        disabled: {
+            support: 'required',
+            signal: ':disabled-or-aria-disabled',
+            meaning: 'Unavailable interaction state.',
+        },
+        focus: {
+            support: 'required',
+            signal: ':focus-visible-or-focus',
+            meaning: 'Current input focus indication.',
+        },
+    },
+    'react-native': {
+        default: {
+            support: 'required',
+            signal: 'rest',
+            meaning: 'Resting enabled presentation.',
+        },
+        hover: {
+            support: 'optional',
+            signal: 'pointer-hover-when-capable',
+            meaning: 'Optional pointer hover on targets that expose hover capability.',
+        },
+        pressed: {
+            support: 'required',
+            signal: 'PressableStateCallbackType.pressed',
+            meaning: 'Transient physical press reported by Pressable state.',
+        },
+        active: {
+            support: 'required',
+            signal: 'domain-current',
+            meaning: 'Persistent/current domain state, never Pressable.pressed.',
+        },
+        selected: {
+            support: 'required',
+            signal: 'accessibilityState.checked-or-selected',
+            meaning: 'Persistent chosen/checked/selected state.',
+        },
+        disabled: {
+            support: 'required',
+            signal: 'disabled-and-accessibilityState.disabled',
+            meaning: 'Unavailable interaction state.',
+        },
+        focus: {
+            support: 'optional',
+            signal: 'focus-when-capable',
+            meaning: 'Focus indication on keyboard/TV/pointer-capable targets; not fabricated on targets without focus presentation.',
+        },
+    },
+};

package/dist/platform-output/component-token-boundary.d.ts

@@ -0,0 +1,7 @@
+export type ComponentTokenBoundaryFinding = {
+    path: string;
+    reason: string;
+};
+/** Shared #884 boundary check; platform intents remain atomic contracts. */
+export declare function scanCanonicalComponentTokens(value: unknown, path: string, findings: ComponentTokenBoundaryFinding[]): void;
+//# sourceMappingURL=component-token-boundary.d.ts.map

package/dist/platform-output/component-token-boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-token-boundary.d.ts","sourceRoot":"","sources":["../../src/platform-output/component-token-boundary.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AASF,4EAA4E;AAC5E,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,6BAA6B,EAAE,GACxC,IAAI,CAoCN"}

package/dist/platform-output/component-token-boundary.js

@@ -0,0 +1,37 @@
+import { isComponentPlatformIntent } from './component-token-intents.js';
+const rendererKeys = new Set([
+    'web',
+    'native',
+    'reactNative',
+    'nativeMaxHeight',
+]);
+/** Shared #884 boundary check; platform intents remain atomic contracts. */
+export function scanCanonicalComponentTokens(value, path, findings) {
+    if (isComponentPlatformIntent(value))
+        return;
+    if (Array.isArray(value)) {
+        value.forEach((entry, index) => scanCanonicalComponentTokens(entry, `${path}.${index}`, findings));
+        return;
+    }
+    if (typeof value !== 'object' || value === null) {
+        if (path.endsWith('.shadow') && typeof value === 'string') {
+            findings.push({
+                path,
+                reason: 'canonical shadow contains renderer-specific CSS syntax',
+            });
+        }
+        return;
+    }
+    for (const [key, child] of Object.entries(value)) {
+        const childPath = path ? `${path}.${key}` : key;
+        if (rendererKeys.has(key) ||
+            key.startsWith('native') ||
+            key.startsWith('reactNative')) {
+            findings.push({
+                path: childPath,
+                reason: `renderer-specific canonical key "${key}"`,
+            });
+        }
+        scanCanonicalComponentTokens(child, childPath, findings);
+    }
+}

package/dist/public-api-policy.d.ts

@@ -10,6 +10,25 @@ export declare const tokenPublicApiDeprecationPolicyV1: {
         readonly removal: "Compatibility aliases introduced or retained during Token Architecture Normalization V1 are removed at the next major boundary, Vellira 3.0.0, unless a separately reviewed policy revision supersedes this contract.";
     };
 };
+export declare const tokenPackagePublicSurfaceV1: {
+    readonly main: "./dist/index.js";
+    readonly types: "./dist/index.d.ts";
+    readonly exports: {
+        readonly '.': {
+            readonly 'react-native': {
+                readonly types: "./dist/index.d.ts";
+                readonly default: "./dist/index.js";
+            };
+            readonly 'vellira-source': "./src/index.ts";
+            readonly types: "./dist/index.d.ts";
+            readonly import: "./dist/index.js";
+        };
+        readonly './css': {
+            readonly types: "./css.d.ts";
+            readonly default: "./dist/css/tokens.css";
+        };
+    };
+};
 export declare const publicThemeContractsV1: readonly [{
     readonly exportName: "lightTheme";
     readonly themeName: "light";

package/dist/public-api-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public-api-policy.d.ts","sourceRoot":"","sources":["../src/public-api-policy.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iCAAiC;;;;;;;;;;;CAgBpC,CAAC;AAEX,eAAO,MAAM,sBAAsB;;;;;;;;;EAIzB,CAAC;AAEX,eAAO,MAAM,2BAA2B;;;;;;EAS9B,CAAC"}
+{"version":3,"file":"public-api-policy.d.ts","sourceRoot":"","sources":["../src/public-api-policy.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iCAAiC;;;;;;;;;;;CAgBpC,CAAC;AAEX,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;CAkB9B,CAAC;AAEX,eAAO,MAAM,sBAAsB;;;;;;;;;EAIzB,CAAC;AAEX,eAAO,MAAM,2BAA2B;;;;;;EAS9B,CAAC"}

package/dist/public-api-policy.js

@@ -10,6 +10,25 @@ export const tokenPublicApiDeprecationPolicyV1 = {
         removal: 'Compatibility aliases introduced or retained during Token Architecture Normalization V1 are removed at the next major boundary, Vellira 3.0.0, unless a separately reviewed policy revision supersedes this contract.',
     },
 };
+export const tokenPackagePublicSurfaceV1 = {
+    main: './dist/index.js',
+    types: './dist/index.d.ts',
+    exports: {
+        '.': {
+            'react-native': {
+                types: './dist/index.d.ts',
+                default: './dist/index.js',
+            },
+            'vellira-source': './src/index.ts',
+            types: './dist/index.d.ts',
+            import: './dist/index.js',
+        },
+        './css': {
+            types: './css.d.ts',
+            default: './dist/css/tokens.css',
+        },
+    },
+};
 export const publicThemeContractsV1 = [
     { exportName: 'lightTheme', themeName: 'light' },
     { exportName: 'darkTheme', themeName: 'dark' },

package/dist/token-architecture.d.ts

@@ -181,8 +181,8 @@ export declare const semanticVocabularyV1: {
         readonly roles: readonly ["default", "hover", "pressed", "selected", "disabled", "focus"];
     };
     readonly menu: {
-        readonly purpose: "Menu-item roles where active/current is a legitimate domain state.";
-        readonly roles: readonly ["item", "item.danger"];
+        readonly purpose: "Menu container chrome plus item roles where active/current is a legitimate domain state.";
+        readonly roles: readonly ["background", "border", "item", "item.danger"];
     };
     readonly overlay: {
         readonly purpose: "Reusable overlay surfaces named by presentation purpose, not component history.";

package/dist/token-architecture.js

@@ -380,8 +380,8 @@ export const semanticVocabularyV1 = {
         roles: ['default', 'hover', 'pressed', 'selected', 'disabled', 'focus'],
     },
     menu: {
-        purpose: 'Menu-item roles where active/current is a legitimate domain state.',
-        roles: ['item', 'item.danger'],
+        purpose: 'Menu container chrome plus item roles where active/current is a legitimate domain state.',
+        roles: ['background', 'border', 'item', 'item.danger'],
     },
     overlay: {
         purpose: 'Reusable overlay surfaces named by presentation purpose, not component history.',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellira-ui/tokens",
-  "version": "2.104.14",
+  "version": "2.104.16",
   "description": "Design tokens for Vellira Design System",
   "keywords": [
     "vellira",