code-auditor-mcp 3.4.2 → 3.4.3

package/dist/styles/tailwindUtilityExpander.js

@@ -1,755 +1,139 @@
 /**
- * Tailwind Utility Class Expander — Spec 22 R1
+ * Tailwind Utility Class Expander — Spec 22 R1.2 (compile-probe)
  *
- * Generates the full set of valid Tailwind utility classes from default theme
- * scales plus arbitrary-value grammar, variant prefix stripping, and project
- * config resolution. Replaces the hand-curated ~30-class Set previously in
- * UniversalStylesAnalyzer.detectUndefinedClasses.
+ * Validates Tailwind class names against the project's own installed
+ * `tailwindcss` package as the oracle. Zero hand-curated dictionaries —
+ * the project's compiler IS the authority on what classes exist.
  *
- * Fail-open rule (per Spec 22 R1.3): if project Tailwind config resolution
- * fails, the undefined-class detector disables for that project with one
- * visible warning naming the failure. A claim that a class "does not exist"
- * may not ship on a known-incomplete dictionary.
- */
-import { loadTailwindConfig } from './tailwindConfigLoader.js';
-// ─── Variant Prefixes ──────────────────────────────────────────────────────
-/**
- * Tailwind variant prefixes that modify utilities.
- * When stripped, the underlying class should match a known utility or
- * arbitrary-value pattern.
- */
-const VARIANT_PREFIXES = [
-    // Responsive
-    'sm', 'md', 'lg', 'xl', '2xl',
-    // State
-    'hover', 'focus', 'active', 'disabled', 'visited',
-    'focus-visible', 'focus-within', 'focus-visible',
-    // Form
-    'checked', 'indeterminate', 'required', 'valid', 'invalid',
-    'in-range', 'out-of-range', 'placeholder-shown', 'autofill', 'read-only',
-    // Structure
-    'first', 'last', 'only', 'odd', 'even', 'first-of-type', 'last-of-type', 'only-of-type',
-    'empty',
-    // Mode
-    'dark', 'light',
-    // Group
-    'group-hover', 'group-focus', 'group-focus-visible', 'group-focus-within',
-    'group-active', 'group-disabled', 'group-visited', 'group-checked',
-    // Peer
-    'peer-hover', 'peer-focus', 'peer-focus-visible', 'peer-active',
-    'peer-disabled', 'peer-checked', 'peer-invalid', 'peer-required',
-    // Motion
-    'motion-safe', 'motion-reduce',
-    // Other
-    'before', 'after', 'first-letter', 'first-line',
-    'marker', 'selection', 'target', 'file', 'placeholder',
-    'rtl', 'ltr',
-    'open', 'closed',
-    'portrait', 'landscape',
-    'print',
-    // Aria
-    'aria-checked', 'aria-disabled',
-    'has-[:checked]', 'has-[:disabled]',
-    // Redundant but safe: already covered by individual state modifiers
-];
-// ─── Utility Prefixes (for arbitrary-value grammar) ─────────────────────────
-/**
- * Known Tailwind utility prefixes that can accept arbitrary values via
- * the `prefix-[...]` syntax. Covers spacing, color, sizing, and other
- * commonly-arbitrary-value'd families.
+ * **Primary (v4):** Uses `compile()` with `@apply` probe stylesheets.
+ * **Fallback (v3):** Uses `resolveConfig()` + theme generation.
+ * **Structural parsing:** Arbitrary values, variant prefixes, opacity
+ *   modifiers, and negative utilities are parsed via structural regex
+ *   patterns — never enumerated.
+ *
+ * **Fail-open rule:** If the probe can't initialize (no tailwindcss found,
+ *   compile fails), `configFailed` is true. The caller MUST emit a visible
+ *   warning and disable the undefined-class detector.
  */
-const ARBITRARY_VALUE_PREFIXES = new Set([
-    // Spacing-based
-    'p', 'px', 'py', 'pt', 'pr', 'pb', 'pl',
-    'm', 'mx', 'my', 'mt', 'mr', 'mb', 'ml',
-    'gap', 'gap-x', 'gap-y',
-    'w', 'min-w', 'max-w', 'h', 'min-h', 'max-h',
-    'top', 'right', 'bottom', 'left', 'inset',
-    'inset-x', 'inset-y',
-    'translate-x', 'translate-y', 'translate',
-    'skew-x', 'skew-y', 'skew',
-    'rotate',
-    'scale', 'scale-x', 'scale-y',
-    'space-x', 'space-y',
-    'leading', 'tracking', 'indent',
-    'scroll-m', 'scroll-mx', 'scroll-my', 'scroll-mt', 'scroll-mr', 'scroll-mb', 'scroll-ml',
-    'scroll-p', 'scroll-px', 'scroll-py', 'scroll-pt', 'scroll-pr', 'scroll-pb', 'scroll-pl',
-    // Color-based
-    'bg', 'text', 'border', 'ring', 'ring-offset', 'shadow',
-    'fill', 'stroke', 'outline', 'accent', 'caret',
-    'placeholder', 'divide',
-    'from', 'via', 'to', // gradient stops
-    'decoration',
-    // Sizing
-    'basis', 'grow', 'shrink',
-    'order',
-    'z', // z-index
-    // Border
-    'rounded', 'rounded-t', 'rounded-r', 'rounded-b', 'rounded-l',
-    'rounded-tl', 'rounded-tr', 'rounded-br', 'rounded-bl',
-    'rounded-s', 'rounded-e', 'rounded-ss', 'rounded-se', 'rounded-es', 'rounded-ee',
-    'border', 'border-t', 'border-r', 'border-b', 'border-l',
-    'border-x', 'border-y',
-    'outline',
-    'outline-offset',
-    // Text
-    'text', 'text-wrap',
-    'underline-offset',
-    // Opacity
-    'opacity',
-    'bg-opacity', 'text-opacity', 'border-opacity', 'ring-opacity',
-    'divide-opacity', 'placeholder-opacity',
-    // Shadow
-    'shadow',
-    // Duration / timing
-    'duration', 'delay', 'easing',
-    // Animation
-    'animate',
-    // Grid
-    'grid-cols', 'grid-rows', 'auto-cols', 'auto-rows',
-    'col', 'col-start', 'col-end', 'col-span',
-    'row', 'row-start', 'row-end', 'row-span',
-    // Columns
-    'columns',
-    // Filter
-    'blur', 'brightness', 'contrast', 'grayscale', 'hue-rotate',
-    'invert', 'saturate', 'sepia', 'drop-shadow',
-    'backdrop-blur', 'backdrop-brightness', 'backdrop-contrast',
-    'backdrop-grayscale', 'backdrop-hue-rotate', 'backdrop-invert',
-    'backdrop-opacity', 'backdrop-saturate', 'backdrop-sepia',
-    // Aspect ratio
-    'aspect',
-    // Break
-    'break',
-    // Container queries
-    '@',
-]);
+import { TailwindProbe } from './tailwindProbe.js';
+// ---------------------------------------------------------------------------
+// Structural patterns (regex — NOT enumeration)
+// ---------------------------------------------------------------------------
 /**
- * Prefixes that allow a negative sign to be prepended to the utility.
- * e.g., -mt-1 (negative margin-top), -top-2 (negative position).
+ * Regex matching Tailwind variant prefix syntax.
+ * Covers: responsive (sm/md/lg/xl/2xl), state (hover/focus/active/...),
+ * group/peer modifiers, dark/light, motion, aria, has, supports, etc.
+ *
+ * Pattern: `word` or `word-word` or `[...]` followed by `:`.
+ * This is a structural check — it does not enumerate valid variant names.
  */
-const NEGATIVE_ALLOWED_PREFIXES = new Set([
-    // Margin — negative margins pull elements closer / overlap
-    'm', 'mx', 'my', 'mt', 'mr', 'mb', 'ml',
-    // Position — negative offsets move element beyond container edge
-    'top', 'right', 'bottom', 'left',
-    // Inset
-    'inset', 'inset-x', 'inset-y',
-    // Z-index
-    'z',
-    // Transform
-    'translate-x', 'translate-y',
-    'rotate',
-    'scale', 'scale-x', 'scale-y',
-    'skew-x', 'skew-y',
-    // Indent (negative text indent)
-    'indent',
-]);
-// ─── Static Utility Classes ─────────────────────────────────────────────────
+const VARIANT_PREFIX_RE = /^(?:[a-z][a-z0-9]*(?:-[a-z][a-z0-9]*)*|\[.+?\]):/;
 /**
- * Standard Tailwind utility classes that don't depend on a theme scale.
- * These are the fixed-name classes: display, flex, grid, alignment, etc.
+ * Regex matching arbitrary-value syntax: `prefix-[...]`.
+ * Any word followed by `-[...]` is structurally a valid Tailwind
+ * arbitrary value. The brackets DO need to be balanced.
  */
-function getStaticUtilityClasses() {
-    return [
-        // Display
-        'block', 'inline-block', 'inline', 'flex', 'inline-flex', 'grid',
-        'inline-grid', 'hidden', 'flow-root', 'contents', 'table', 'table-row',
-        'table-cell', 'table-caption', 'table-column', 'table-column-group',
-        'table-footer-group', 'table-header-group', 'table-row-group', 'list-item',
-        // Position
-        'static', 'fixed', 'absolute', 'relative', 'sticky',
-        // Flex direction
-        'flex-row', 'flex-row-reverse', 'flex-col', 'flex-col-reverse',
-        'flex-wrap', 'flex-nowrap', 'flex-wrap-reverse',
-        'flex-1', 'flex-auto', 'flex-initial', 'flex-none',
-        'grow', 'grow-0', 'shrink', 'shrink-0',
-        'flex-grow', 'flex-grow-0', 'flex-shrink', 'flex-shrink-0',
-        'group',
-        // Grid
-        'grid-cols-1', 'grid-cols-2', 'grid-cols-3', 'grid-cols-4',
-        'grid-cols-5', 'grid-cols-6', 'grid-cols-7', 'grid-cols-8',
-        'grid-cols-9', 'grid-cols-10', 'grid-cols-11', 'grid-cols-12',
-        'grid-cols-none', 'grid-cols-subgrid',
-        'grid-rows-1', 'grid-rows-2', 'grid-rows-3', 'grid-rows-4',
-        'grid-rows-5', 'grid-rows-6', 'grid-rows-none', 'grid-rows-subgrid',
-        'grid-flow-row', 'grid-flow-col', 'grid-flow-dense', 'grid-flow-row-dense', 'grid-flow-col-dense',
-        'auto-cols-auto', 'auto-cols-min', 'auto-cols-max', 'auto-cols-fr',
-        'auto-rows-auto', 'auto-rows-min', 'auto-rows-max', 'auto-rows-fr',
-        // Alignment
-        'items-start', 'items-end', 'items-center', 'items-baseline', 'items-stretch',
-        'justify-start', 'justify-end', 'justify-center', 'justify-between',
-        'justify-around', 'justify-evenly', 'justify-stretch', 'justify-normal',
-        'justify-items-start', 'justify-items-end', 'justify-items-center', 'justify-items-stretch',
-        'content-center', 'content-start', 'content-end', 'content-between',
-        'content-around', 'content-evenly', 'content-baseline', 'content-normal', 'content-stretch',
-        'place-content-center', 'place-content-start', 'place-content-end',
-        'place-content-between', 'place-content-around', 'place-content-evenly',
-        'place-items-center', 'place-items-start', 'place-items-end', 'place-items-stretch',
-        'self-auto', 'self-start', 'self-end', 'self-center', 'self-stretch', 'self-baseline',
-        'place-self-auto', 'place-self-start', 'place-self-end', 'place-self-center', 'place-self-stretch',
-        // Text alignment
-        'text-left', 'text-center', 'text-right', 'text-justify', 'text-start', 'text-end',
-        // Text decoration
-        'underline', 'line-through', 'no-underline', 'overline',
-        'decoration-solid', 'decoration-double', 'decoration-dotted', 'decoration-dashed', 'decoration-wavy',
-        // Text transform
-        'uppercase', 'lowercase', 'capitalize', 'normal-case',
-        // Text overflow
-        'truncate', 'text-ellipsis', 'text-clip',
-        // Whitespace
-        'whitespace-normal', 'whitespace-nowrap', 'whitespace-pre', 'whitespace-pre-line', 'whitespace-pre-wrap',
-        'whitespace-break-spaces',
-        // Word break
-        'break-normal', 'break-words', 'break-all', 'break-keep', 'hyphens-none', 'hyphens-manual', 'hyphens-auto',
-        // Font weight
-        'font-thin', 'font-extralight', 'font-light', 'font-normal', 'font-medium',
-        'font-semibold', 'font-bold', 'font-extrabold', 'font-black',
-        // Font style
-        'italic', 'not-italic',
-        // Font variant
-        'ordinal', 'slashed-zero', 'lining-nums', 'oldstyle-nums', 'proportional-nums',
-        'tabular-nums', 'diagonal-fractions', 'stacked-fractions',
-        // Width
-        'w-auto', 'w-full', 'w-screen', 'w-svw', 'w-dvw', 'w-lvw', 'w-min', 'w-max', 'w-fit',
-        'w-0', 'w-px', 'w-0.5', 'w-1', 'w-2', 'w-3', 'w-4', 'w-5', 'w-6', 'w-7', 'w-8',
-        'w-9', 'w-10', 'w-11', 'w-12', 'w-14', 'w-16', 'w-20', 'w-24', 'w-28', 'w-32',
-        'w-36', 'w-40', 'w-44', 'w-48', 'w-52', 'w-56', 'w-60', 'w-64', 'w-72', 'w-80', 'w-96',
-        'w-1/2', 'w-1/3', 'w-2/3', 'w-1/4', 'w-2/4', 'w-3/4', 'w-1/5', 'w-2/5', 'w-3/5', 'w-4/5',
-        'w-1/6', 'w-2/6', 'w-3/6', 'w-4/6', 'w-5/6',
-        // Height
-        'h-auto', 'h-full', 'h-screen', 'h-svh', 'h-dvh', 'h-lvh', 'h-min', 'h-max', 'h-fit',
-        'h-0', 'h-px', 'h-0.5', 'h-1', 'h-2', 'h-3', 'h-4', 'h-5', 'h-6', 'h-7', 'h-8',
-        'h-9', 'h-10', 'h-11', 'h-12', 'h-14', 'h-16', 'h-20', 'h-24', 'h-28', 'h-32',
-        'h-36', 'h-40', 'h-44', 'h-48', 'h-52', 'h-56', 'h-60', 'h-64', 'h-72', 'h-80', 'h-96',
-        'h-1/2', 'h-1/3', 'h-2/3', 'h-1/4', 'h-2/4', 'h-3/4', 'h-1/5', 'h-2/5', 'h-3/5', 'h-4/5',
-        'h-1/6', 'h-2/6', 'h-3/6', 'h-4/6', 'h-5/6',
-        // Min/max sizing
-        'min-w-0', 'min-w-full', 'min-w-min', 'min-w-max', 'min-w-fit',
-        'max-w-0', 'max-w-none', 'max-w-xs', 'max-w-sm', 'max-w-md', 'max-w-lg', 'max-w-xl',
-        'max-w-2xl', 'max-w-3xl', 'max-w-4xl', 'max-w-5xl', 'max-w-6xl', 'max-w-7xl',
-        'max-w-full', 'max-w-min', 'max-w-max', 'max-w-fit', 'max-w-prose',
-        'max-w-screen-sm', 'max-w-screen-md', 'max-w-screen-lg', 'max-w-screen-xl', 'max-w-screen-2xl',
-        'min-h-0', 'min-h-full', 'min-h-screen', 'min-h-min', 'min-h-max', 'min-h-fit',
-        'max-h-0', 'max-h-full', 'max-h-screen', 'max-h-min', 'max-h-max', 'max-h-fit',
-        // Size (both w and h)
-        'size-auto', 'size-full', 'size-min', 'size-max', 'size-fit',
-        // Overflow
-        'overflow-auto', 'overflow-hidden', 'overflow-visible', 'overflow-scroll',
-        'overflow-x-auto', 'overflow-x-hidden', 'overflow-x-visible', 'overflow-x-scroll',
-        'overflow-y-auto', 'overflow-y-hidden', 'overflow-y-visible', 'overflow-y-scroll',
-        // Cursor
-        'cursor-auto', 'cursor-default', 'cursor-pointer', 'cursor-wait', 'cursor-text',
-        'cursor-move', 'cursor-help', 'cursor-not-allowed', 'cursor-none',
-        'cursor-context-menu', 'cursor-progress', 'cursor-cell', 'cursor-crosshair',
-        'cursor-vertical-text', 'cursor-alias', 'cursor-copy', 'cursor-grab', 'cursor-grabbing',
-        'cursor-no-drop', 'cursor-zoom-in', 'cursor-zoom-out',
-        // Visibility
-        'visible', 'invisible', 'collapse',
-        // Border
-        'border', 'border-0', 'border-2', 'border-4', 'border-8',
-        'border-t', 'border-r', 'border-b', 'border-l',
-        'border-t-0', 'border-r-0', 'border-b-0', 'border-l-0',
-        'border-x', 'border-y',
-        'border-solid', 'border-dashed', 'border-dotted', 'border-double', 'border-hidden', 'border-none',
-        // Shadow
-        'shadow', 'shadow-sm', 'shadow-md', 'shadow-lg', 'shadow-xl', 'shadow-2xl',
-        'shadow-inner', 'shadow-none',
-        // Ring
-        'ring', 'ring-0', 'ring-1', 'ring-2', 'ring-4', 'ring-8', 'ring-inset',
-        'ring-offset-0', 'ring-offset-1', 'ring-offset-2', 'ring-offset-4', 'ring-offset-8',
-        // Opacity
-        'opacity-0', 'opacity-5', 'opacity-10', 'opacity-20', 'opacity-25', 'opacity-30',
-        'opacity-40', 'opacity-50', 'opacity-60', 'opacity-70', 'opacity-75', 'opacity-80',
-        'opacity-90', 'opacity-95', 'opacity-100',
-        // Z-index
-        'z-0', 'z-10', 'z-20', 'z-30', 'z-40', 'z-50', 'z-auto',
-        // Object fit
-        'object-contain', 'object-cover', 'object-fill', 'object-none', 'object-scale-down',
-        // Object position
-        'object-bottom', 'object-center', 'object-left', 'object-left-bottom',
-        'object-left-top', 'object-right', 'object-right-bottom', 'object-right-top', 'object-top',
-        // Transition
-        'transition-none', 'transition-all', 'transition', 'transition-colors',
-        'transition-opacity', 'transition-shadow', 'transition-transform',
-        // Duration
-        'duration-0', 'duration-75', 'duration-100', 'duration-150', 'duration-200',
-        'duration-300', 'duration-500', 'duration-700', 'duration-1000',
-        // Delay
-        'delay-0', 'delay-75', 'delay-100', 'delay-150', 'delay-200', 'delay-300',
-        'delay-500', 'delay-700', 'delay-1000',
-        // Timing
-        'ease-linear', 'ease-in', 'ease-out', 'ease-in-out',
-        // Transform
-        'transform', 'transform-gpu', 'transform-none',
-        'scale-0', 'scale-50', 'scale-75', 'scale-90', 'scale-95', 'scale-100',
-        'scale-105', 'scale-110', 'scale-125', 'scale-150',
-        'scale-x-0', 'scale-x-50', 'scale-x-75', 'scale-x-90', 'scale-x-95', 'scale-x-100',
-        'scale-x-105', 'scale-x-110', 'scale-x-125', 'scale-x-150',
-        'scale-y-0', 'scale-y-50', 'scale-y-75', 'scale-y-90', 'scale-y-95', 'scale-y-100',
-        'scale-y-105', 'scale-y-110', 'scale-y-125', 'scale-y-150',
-        'rotate-0', 'rotate-1', 'rotate-2', 'rotate-3', 'rotate-6', 'rotate-12',
-        'rotate-45', 'rotate-90', 'rotate-180',
-        'origin-center', 'origin-top', 'origin-top-right', 'origin-right',
-        'origin-bottom-right', 'origin-bottom', 'origin-bottom-left', 'origin-left', 'origin-top-left',
-        // Box sizing
-        'box-border', 'box-content',
-        // Container
-        'container',
-        // Pointer events
-        'pointer-events-none', 'pointer-events-auto',
-        // Resize
-        'resize-none', 'resize', 'resize-y', 'resize-x',
-        // User select
-        'select-none', 'select-text', 'select-all', 'select-auto',
-        // Screen readers
-        'sr-only', 'not-sr-only',
-        // Background
-        'bg-auto', 'bg-cover', 'bg-contain',
-        'bg-bottom', 'bg-center', 'bg-left', 'bg-left-bottom', 'bg-left-top',
-        'bg-right', 'bg-right-bottom', 'bg-right-top', 'bg-top',
-        'bg-fixed', 'bg-local', 'bg-scroll',
-        'bg-no-repeat', 'bg-repeat', 'bg-repeat-x', 'bg-repeat-y', 'bg-repeat-round', 'bg-repeat-space',
-        'bg-none', 'bg-origin-border', 'bg-origin-padding', 'bg-origin-content',
-        'bg-clip-border', 'bg-clip-padding', 'bg-clip-content', 'bg-clip-text',
-        // Gradient
-        'bg-gradient-to-t', 'bg-gradient-to-tr', 'bg-gradient-to-r', 'bg-gradient-to-br',
-        'bg-gradient-to-b', 'bg-gradient-to-bl', 'bg-gradient-to-l', 'bg-gradient-to-tl',
-        'bg-none',
-        // List style
-        'list-none', 'list-disc', 'list-decimal', 'list-image-none',
-        'list-inside', 'list-outside',
-        // Table
-        'table-auto', 'table-fixed',
-        'border-collapse', 'border-separate',
-        'border-spacing-0', 'border-spacing-1', 'border-spacing-2',
-        'border-spacing-x-0', 'border-spacing-y-0',
-        'table-layout-auto', 'table-layout-fixed',
-        'caption-top', 'caption-bottom',
-        // Vertical align
-        'align-baseline', 'align-top', 'align-middle', 'align-bottom',
-        'align-text-top', 'align-text-bottom', 'align-sub', 'align-super',
-        // Aspect ratio
-        'aspect-auto', 'aspect-square', 'aspect-video',
-        // Columns
-        'columns-1', 'columns-2', 'columns-3', 'columns-4', 'columns-5', 'columns-6',
-        'columns-7', 'columns-8', 'columns-9', 'columns-10', 'columns-11', 'columns-12',
-        'columns-auto', 'columns-3xs', 'columns-2xs', 'columns-xs', 'columns-sm',
-        'columns-md', 'columns-lg', 'columns-xl', 'columns-2xl', 'columns-3xl',
-        'columns-4xl', 'columns-5xl', 'columns-6xl', 'columns-7xl',
-        'break-before-auto', 'break-before-avoid', 'break-before-all', 'break-before-avoid-page', 'break-before-page',
-        'break-before-left', 'break-before-right', 'break-before-column',
-        'break-after-auto', 'break-after-avoid', 'break-after-all', 'break-after-avoid-page', 'break-after-page',
-        'break-after-left', 'break-after-right', 'break-after-column',
-        'break-inside-auto', 'break-inside-avoid', 'break-inside-avoid-page', 'break-inside-avoid-column',
-        // Float
-        'float-right', 'float-left', 'float-none', 'float-start', 'float-end',
-        'clear-left', 'clear-right', 'clear-both', 'clear-none', 'clear-start', 'clear-end',
-        // Box decoration
-        'decoration-slice', 'decoration-clone',
-        'box-decoration-slice', 'box-decoration-clone',
-        // Isolation
-        'isolate', 'isolation-auto',
-        // Overscroll
-        'overscroll-auto', 'overscroll-contain', 'overscroll-none',
-        'overscroll-x-auto', 'overscroll-x-contain', 'overscroll-x-none',
-        'overscroll-y-auto', 'overscroll-y-contain', 'overscroll-y-none',
-        'overscroll-behavior-auto', 'overscroll-behavior-contain', 'overscroll-behavior-none',
-        // Scroll snap
-        'snap-none', 'snap-x', 'snap-y', 'snap-both', 'snap-mandatory', 'snap-proximity',
-        'snap-start', 'snap-end', 'snap-center', 'snap-align-none', 'snap-normal', 'snap-always',
-        // Scroll behavior
-        'scroll-auto', 'scroll-smooth',
-        // Appearance
-        'appearance-none', 'appearance-auto',
-        // Touch
-        'touch-auto', 'touch-none', 'touch-pan-x', 'touch-pan-left', 'touch-pan-right',
-        'touch-pan-y', 'touch-pan-up', 'touch-pan-down', 'touch-pinch-zoom',
-        'touch-manipulation',
-        // Will change
-        'will-change-auto', 'will-change-scroll', 'will-change-contents', 'will-change-transform',
-        // Content
-        'content-none',
-        // Blend mode
-        'mix-blend-normal', 'mix-blend-multiply', 'mix-blend-screen', 'mix-blend-overlay',
-        'mix-blend-darken', 'mix-blend-lighten', 'mix-blend-color-dodge', 'mix-blend-color-burn',
-        'mix-blend-hard-light', 'mix-blend-soft-light', 'mix-blend-difference',
-        'mix-blend-exclusion', 'mix-blend-hue', 'mix-blend-saturation', 'mix-blend-color', 'mix-blend-luminosity',
-        'mix-blend-plus-darker', 'mix-blend-plus-lighter',
-        'bg-blend-normal', 'bg-blend-multiply', 'bg-blend-screen', 'bg-blend-overlay',
-        'bg-blend-darken', 'bg-blend-lighten', 'bg-blend-color-dodge', 'bg-blend-color-burn',
-        // Gap
-        'gap-0', 'gap-px', 'gap-0.5', 'gap-1', 'gap-2', 'gap-3', 'gap-4', 'gap-5',
-        'gap-6', 'gap-7', 'gap-8', 'gap-9', 'gap-10', 'gap-11', 'gap-12',
-        'gap-14', 'gap-16', 'gap-20', 'gap-24', 'gap-28', 'gap-32', 'gap-36', 'gap-40',
-        'gap-44', 'gap-48', 'gap-52', 'gap-56', 'gap-60', 'gap-64', 'gap-72', 'gap-80', 'gap-96',
-        'gap-x-0', 'gap-y-0',
-        // Space
-        'space-x-0', 'space-y-0',
-        // Divide
-        'divide-x', 'divide-y',
-        'divide-x-0', 'divide-y-0',
-        'divide-solid', 'divide-dashed', 'divide-dotted', 'divide-double', 'divide-none',
-        'divide-x-reverse', 'divide-y-reverse',
-        // Ring
-        'ring-inset',
-        // Line clamp
-        'line-clamp-1', 'line-clamp-2', 'line-clamp-3', 'line-clamp-4', 'line-clamp-5', 'line-clamp-6', 'line-clamp-none',
-        // Animation
-        'animate-none', 'animate-spin', 'animate-ping', 'animate-pulse', 'animate-bounce',
-        // Font family
-        'font-sans', 'font-serif', 'font-mono',
-        // Letter spacing (tracking)
-        'tracking-tighter', 'tracking-tight', 'tracking-normal',
-        'tracking-wide', 'tracking-wider', 'tracking-widest',
-        // Backdrop filters
-        'backdrop-blur', 'backdrop-blur-sm', 'backdrop-blur-md', 'backdrop-blur-lg',
-        'backdrop-blur-xl', 'backdrop-blur-2xl', 'backdrop-blur-3xl', 'backdrop-blur-none',
-        'backdrop-opacity-0', 'backdrop-opacity-50', 'backdrop-opacity-100',
-    ];
-}
-// ─── Generated Utility Classes (from theme scales) ──────────────────────────
+const ARBITRARY_VALUE_RE = /^[a-z][a-z0-9]*(?:-[a-z][a-z0-9]*)*-\[.+\]$/;
 /**
- * Generate all valid Tailwind utility classes by combining known prefixes with
- * default theme scales + common string values for non-scale prefixes.
+ * Regex matching opacity-modifier syntax: `utility/opacity`.
+ * e.g., `bg-red-500/50`, `text-blue-100/75`.
+ * The part before the last `/` should be a valid utility,
+ * and the suffix should be a numeric opacity (0-100).
  */
-function generateScaleBasedClasses() {
-    const classes = [];
-    // Color prefixes — generate bg-{color}, text-{color}, etc.
-    const colorPrefixes = [
-        'bg', 'text', 'border', 'ring', 'shadow', 'fill', 'stroke',
-        'accent', 'caret', 'outline', 'placeholder', 'divide', 'from', 'via', 'to',
-        'decoration',
-    ];
-    // Color names from the default Tailwind palette
-    const colorNames = [
-        'inherit', 'current', 'transparent',
-        'white', 'black',
-        // Slate
-        'slate-50', 'slate-100', 'slate-200', 'slate-300', 'slate-400', 'slate-500',
-        'slate-600', 'slate-700', 'slate-800', 'slate-900', 'slate-950',
-        // Gray
-        'gray-50', 'gray-100', 'gray-200', 'gray-300', 'gray-400', 'gray-500',
-        'gray-600', 'gray-700', 'gray-800', 'gray-900', 'gray-950',
-        // Zinc
-        'zinc-50', 'zinc-100', 'zinc-200', 'zinc-300', 'zinc-400', 'zinc-500',
-        'zinc-600', 'zinc-700', 'zinc-800', 'zinc-900', 'zinc-950',
-        // Neutral
-        'neutral-50', 'neutral-100', 'neutral-200', 'neutral-300', 'neutral-400', 'neutral-500',
-        'neutral-600', 'neutral-700', 'neutral-800', 'neutral-900', 'neutral-950',
-        // Stone
-        'stone-50', 'stone-100', 'stone-200', 'stone-300', 'stone-400', 'stone-500',
-        'stone-600', 'stone-700', 'stone-800', 'stone-900', 'stone-950',
-        // Red
-        'red-50', 'red-100', 'red-200', 'red-300', 'red-400', 'red-500',
-        'red-600', 'red-700', 'red-800', 'red-900', 'red-950',
-        // Orange
-        'orange-50', 'orange-100', 'orange-200', 'orange-300', 'orange-400', 'orange-500',
-        'orange-600', 'orange-700', 'orange-800', 'orange-900', 'orange-950',
-        // Amber
-        'amber-50', 'amber-100', 'amber-200', 'amber-300', 'amber-400', 'amber-500',
-        'amber-600', 'amber-700', 'amber-800', 'amber-900', 'amber-950',
-        // Yellow
-        'yellow-50', 'yellow-100', 'yellow-200', 'yellow-300', 'yellow-400', 'yellow-500',
-        'yellow-600', 'yellow-700', 'yellow-800', 'yellow-900', 'yellow-950',
-        // Lime
-        'lime-50', 'lime-100', 'lime-200', 'lime-300', 'lime-400', 'lime-500',
-        'lime-600', 'lime-700', 'lime-800', 'lime-900', 'lime-950',
-        // Green
-        'green-50', 'green-100', 'green-200', 'green-300', 'green-400', 'green-500',
-        'green-600', 'green-700', 'green-800', 'green-900', 'green-950',
-        // Emerald
-        'emerald-50', 'emerald-100', 'emerald-200', 'emerald-300', 'emerald-400', 'emerald-500',
-        'emerald-600', 'emerald-700', 'emerald-800', 'emerald-900', 'emerald-950',
-        // Teal
-        'teal-50', 'teal-100', 'teal-200', 'teal-300', 'teal-400', 'teal-500',
-        'teal-600', 'teal-700', 'teal-800', 'teal-900', 'teal-950',
-        // Cyan
-        'cyan-50', 'cyan-100', 'cyan-200', 'cyan-300', 'cyan-400', 'cyan-500',
-        'cyan-600', 'cyan-700', 'cyan-800', 'cyan-900', 'cyan-950',
-        // Sky
-        'sky-50', 'sky-100', 'sky-200', 'sky-300', 'sky-400', 'sky-500',
-        'sky-600', 'sky-700', 'sky-800', 'sky-900', 'sky-950',
-        // Blue
-        'blue-50', 'blue-100', 'blue-200', 'blue-300', 'blue-400', 'blue-500',
-        'blue-600', 'blue-700', 'blue-800', 'blue-900', 'blue-950',
-        // Indigo
-        'indigo-50', 'indigo-100', 'indigo-200', 'indigo-300', 'indigo-400', 'indigo-500',
-        'indigo-600', 'indigo-700', 'indigo-800', 'indigo-900', 'indigo-950',
-        // Violet
-        'violet-50', 'violet-100', 'violet-200', 'violet-300', 'violet-400', 'violet-500',
-        'violet-600', 'violet-700', 'violet-800', 'violet-900', 'violet-950',
-        // Purple
-        'purple-50', 'purple-100', 'purple-200', 'purple-300', 'purple-400', 'purple-500',
-        'purple-600', 'purple-700', 'purple-800', 'purple-900', 'purple-950',
-        // Fuchsia
-        'fuchsia-50', 'fuchsia-100', 'fuchsia-200', 'fuchsia-300', 'fuchsia-400', 'fuchsia-500',
-        'fuchsia-600', 'fuchsia-700', 'fuchsia-800', 'fuchsia-900', 'fuchsia-950',
-        // Pink
-        'pink-50', 'pink-100', 'pink-200', 'pink-300', 'pink-400', 'pink-500',
-        'pink-600', 'pink-700', 'pink-800', 'pink-900', 'pink-950',
-        // Rose
-        'rose-50', 'rose-100', 'rose-200', 'rose-300', 'rose-400', 'rose-500',
-        'rose-600', 'rose-700', 'rose-800', 'rose-900', 'rose-950',
-    ];
-    // Special opacity variants for color prefixes that support it
-    const dividerColors = new Set(['divide', 'border', 'ring', 'placeholder', 'text']);
-    const opacityNumbers = ['0', '5', '10', '20', '25', '30', '40', '50', '60', '70', '75', '80', '90', '95', '100'];
-    for (const prefix of colorPrefixes) {
-        for (const colorName of colorNames) {
-            classes.push(`${prefix}-${colorName}`);
-            // Opacity modifiers for supported prefixes
-            if (dividerColors.has(prefix)) {
-                for (const opacity of opacityNumbers) {
-                    classes.push(`${prefix}-${colorName}/${opacity}`);
-                }
-            }
-        }
-    }
-    // Font size prefixes
-    const fontSizePrefixes = ['text'];
-    const fontSizeNames = [
-        'xs', 'sm', 'base', 'lg', 'xl', '2xl', '3xl', '4xl', '5xl', '6xl', '7xl', '8xl', '9xl',
-    ];
-    for (const prefix of fontSizePrefixes) {
-        for (const sizeName of fontSizeNames) {
-            classes.push(`${prefix}-${sizeName}`);
-        }
-    }
-    // Border radius prefixes
-    const radiusPrefixes = [
-        'rounded', 'rounded-t', 'rounded-r', 'rounded-b', 'rounded-l',
-        'rounded-tl', 'rounded-tr', 'rounded-br', 'rounded-bl',
-        'rounded-s', 'rounded-e', 'rounded-ss', 'rounded-se', 'rounded-es', 'rounded-ee',
-    ];
-    const radiusNames = ['none', 'sm', '', 'md', 'lg', 'xl', '2xl', '3xl', 'full'];
-    for (const prefix of radiusPrefixes) {
-        for (const radiusName of radiusNames) {
-            if (radiusName === '') {
-                classes.push(prefix); // "rounded" alone
-            }
-            else {
-                classes.push(`${prefix}-${radiusName}`);
-            }
-        }
-    }
-    // ── Spacing-scale utilities ─────────────────────────────────────────
-    // Padding, margin, position, inset, gap-x, gap-y, space-x, space-y,
-    // size, leading, indent, scroll-margin/padding — all accept the default
-    // spacing scale as values.
-    const spacingScaleValues = [
-        '0', 'px', '0.5', '1', '1.5', '2', '2.5', '3', '3.5', '4', '5', '6', '7',
-        '8', '9', '10', '11', '12', '14', '16', '20', '24', '28', '32', '36', '40',
-        '44', '48', '52', '56', '60', '64', '72', '80', '96',
-    ];
-    // Spacing-based prefixes — utilities that accept spacing scale values
-    const spacingPrefixes = [
-        // Padding
-        'p', 'px', 'py', 'pt', 'pr', 'pb', 'pl',
-        // Margin
-        'm', 'mx', 'my', 'mt', 'mr', 'mb', 'ml',
-        // Position
-        'top', 'right', 'bottom', 'left',
-        // Inset
-        'inset', 'inset-x', 'inset-y',
-        // Gap (gap-{x,y} — full scale; gap base already in static)
-        'gap-x', 'gap-y',
-        // Space (space-{x,y} — full scale)
-        'space-x', 'space-y',
-        // Size (both width and height)
-        'size',
-        // Scroll margin / padding
-        'scroll-m', 'scroll-mx', 'scroll-my', 'scroll-mt', 'scroll-mr', 'scroll-mb', 'scroll-ml',
-        'scroll-p', 'scroll-px', 'scroll-py', 'scroll-pt', 'scroll-pr', 'scroll-pb', 'scroll-pl',
-    ];
-    for (const prefix of spacingPrefixes) {
-        for (const value of spacingScaleValues) {
-            classes.push(`${prefix}-${value}`);
-        }
-    }
-    // Special non-scale values for margin: auto
-    for (const prefix of ['m', 'mx', 'my', 'mt', 'mr', 'mb', 'ml']) {
-        classes.push(`${prefix}-auto`);
-    }
-    // Special non-scale values for position: auto, fractions, full
-    for (const prefix of ['top', 'right', 'bottom', 'left']) {
-        classes.push(`${prefix}-auto`);
-        classes.push(`${prefix}-full`);
-        for (const frac of ['1/2', '1/3', '2/3', '1/4', '3/4']) {
-            classes.push(`${prefix}-${frac}`);
-        }
-    }
-    // Special non-scale values for inset: auto, full, fractions
-    for (const prefix of ['inset', 'inset-x', 'inset-y']) {
-        classes.push(`${prefix}-auto`);
-        classes.push(`${prefix}-full`);
-        for (const frac of ['1/2', '1/3', '2/3', '1/4', '3/4']) {
-            classes.push(`${prefix}-${frac}`);
-        }
-    }
-    // Leading (line-height) — spacing values + text keywords
-    for (const value of spacingScaleValues) {
-        classes.push(`leading-${value}`);
-    }
-    for (const kw of ['none', 'tight', 'snug', 'normal', 'relaxed', 'loose']) {
-        classes.push(`leading-${kw}`);
-    }
-    // Indent — spacing scale values
-    for (const value of spacingScaleValues) {
-        classes.push(`indent-${value}`);
-    }
-    // Border-width directional — only major widths for border-{side}-{width}
-    for (const side of ['t', 'r', 'b', 'l', 'x', 'y']) {
-        for (const w of ['0', '2', '4', '8']) {
-            classes.push(`border-${side}-${w}`);
-        }
-    }
-    // Opacity modifiers for bg/text/shadow/ring (non-divider color prefixes)
-    // — divider colors (border/ring/placeholder/divide/text) already generated
-    const nonDividerOpacityPrefixes = ['bg', 'shadow'];
-    const opacityValues = ['0', '5', '10', '20', '25', '30', '40', '50', '60', '70', '75', '80', '90', '95', '100'];
-    for (const prefix of nonDividerOpacityPrefixes) {
-        for (const op of opacityValues) {
-            classes.push(`${prefix}-opacity-${op}`);
-        }
-    }
-    // Translate — fractions and full
-    for (const prefix of ['translate-x', 'translate-y']) {
-        for (const frac of ['1/2', '1/3', '2/3', '1/4', '3/4', 'full']) {
-            classes.push(`${prefix}-${frac}`);
-        }
-    }
-    // Grid column spans — col-span-{1..12}, col-start-{1..13}, col-end-{1..13}
-    for (let i = 1; i <= 12; i++)
-        classes.push(`col-span-${i}`);
-    for (let i = 1; i <= 13; i++) {
-        classes.push(`col-start-${i}`);
-        classes.push(`col-end-${i}`);
-    }
-    // Grid row spans — row-span-{1..6}, row-start-{1..7}, row-end-{1..7}
-    for (let i = 1; i <= 6; i++)
-        classes.push(`row-span-${i}`);
-    for (let i = 1; i <= 7; i++) {
-        classes.push(`row-start-${i}`);
-        classes.push(`row-end-${i}`);
-    }
-    // Outline utilities
-    classes.push('outline-none', 'outline', 'outline-dashed', 'outline-dotted', 'outline-double');
-    return classes;
-}
-// ─── Main Expander API ──────────────────────────────────────────────────────
-/** Cached bundled utility classes. */
-let _bundledClasses = null;
+const OPACITY_MODIFIER_RE = /^(.+)\/(\d{1,3})$/;
 /**
- * Get the full set of bundled Tailwind utility classes.
- * Generated from the default theme scales plus static utilities.
- * Cached after first call — callers get the same Set instance.
+ * Regex matching negative-utility syntax: `-utility`.
+ * Any utility prefixed with a leading `-` is structurally a negative
+ * Tailwind utility. We strip the `-` and check the positive utility.
  */
-export function getBundledUtilityClasses() {
-    if (_bundledClasses)
-        return _bundledClasses;
-    _bundledClasses = new Set();
-    // Static utilities
-    for (const cls of getStaticUtilityClasses()) {
-        _bundledClasses.add(cls);
-    }
-    // Scale-generated utilities
-    for (const cls of generateScaleBasedClasses()) {
-        _bundledClasses.add(cls);
-    }
-    return _bundledClasses;
-}
+const NEGATIVE_UTILITY_RE = /^-(.+)$/;
+// ---------------------------------------------------------------------------
+// TailwindUtilityExpander
+// ---------------------------------------------------------------------------
 /**
- * Tailwind utility class expander.
+ * Tailwind utility class expander backed by compile-probe.
  *
- * Validates a class name against the full expansion path:
- * 1. Bundled default theme dictionary
- * 2. Project config custom classes (if resolved)
- * 3. Arbitrary-value grammar (`prefix-[...]`)
- * 4. Variant prefix stripping + retry against all of the above
+ * Validation pipeline:
+ * 1. Probe cache (compile-probe or config-generation validated classes)
+ * 2. User-supplied custom classes
+ * 3. Opacity-modifier syntax (`utility/opacity`)
+ * 4. Arbitrary-value grammar (`prefix-[...]`)
+ * 5. Negative-utility syntax (`-utility`)
+ * 6. Variant prefix stripping + retry against all of the above
  *
- * Fail-open: if project config resolution is requested but fails, the
- * expander enters fail-open mode where project-config tier is silently
- * empty. The CALLER is responsible for emitting the visible warning and
+ * Fail-open: if the probe fails to initialize, configFailed is true.
+ * The caller is responsible for emitting a visible warning and
  * potentially disabling the undefined-class detector.
  */
 export class TailwindUtilityExpander {
-    bundled = null;
-    projectClasses = null;
+    probe = null;
+    customClasses = null;
     _configFailed = false;
     _configFailureReason = null;
     /**
      * Initialize the expander with optional project config.
-     * Call once at the start of a project audit.
+     * Call once per audit. Async because it may compile-probe Tailwind.
      */
-    init(config = {}) {
-        this.bundled = getBundledUtilityClasses();
-        if (config.customClasses) {
-            this.projectClasses = new Set(config.customClasses);
-            return;
-        }
+    async init(config = {}) {
+        this.customClasses = config.customClasses ?? null;
         if (config.useProjectConfig && config.projectRoot) {
-            try {
-                const result = loadTailwindConfig(config.projectRoot);
-                if (result && result.tokens) {
-                    this.projectClasses = new Set();
-                    // Generate utility classes from project-specific theme tokens
-                    const colorPrefixes = ['bg', 'text', 'border', 'ring', 'shadow', 'fill', 'stroke', 'accent', 'caret'];
-                    for (const colorName of Object.keys(result.tokens.colors)) {
-                        for (const prefix of colorPrefixes) {
-                            this.projectClasses.add(`${prefix}-${colorName}`);
-                        }
-                    }
-                    for (const spaceName of Object.keys(result.tokens.spacing)) {
-                        for (const prefix of [
-                            'p', 'px', 'py', 'pt', 'pr', 'pb', 'pl',
-                            'm', 'mx', 'my', 'mt', 'mr', 'mb', 'ml',
-                            'w', 'h', 'min-w', 'min-h', 'max-w', 'max-h',
-                            'gap', 'gap-x', 'gap-y', 'space-x', 'space-y',
-                            'top', 'right', 'bottom', 'left', 'inset',
-                            'inset-x', 'inset-y',
-                            'leading', 'indent',
-                        ]) {
-                            this.projectClasses.add(`${prefix}-${spaceName}`);
-                        }
-                    }
-                    for (const sizeName of Object.keys(result.tokens.fontSize)) {
-                        this.projectClasses.add(`text-${sizeName}`);
-                    }
-                    for (const radiusName of Object.keys(result.tokens.borderRadius)) {
-                        this.projectClasses.add(`rounded-${radiusName}`);
-                    }
-                }
-            }
-            catch (err) {
+            this.probe = new TailwindProbe();
+            const result = await this.probe.init(config.projectRoot);
+            if (!result.ok) {
                 this._configFailed = true;
-                this._configFailureReason = err instanceof Error ? err.message : String(err);
+                this._configFailureReason = result.error ?? 'Unknown probe init failure';
+                this.probe = null;
             }
         }
     }
-    /** Did the project config resolution fail? */
+    /** Did the probe initialization fail? */
     get configFailed() {
         return this._configFailed;
     }
-    /** Why did project config resolution fail? */
+    /** Why did probe initialization fail? */
     get configFailureReason() {
         return this._configFailureReason;
     }
+    /** Whether the probe is ready (initialized successfully). */
+    get probeReady() {
+        return this.probe?.ready ?? false;
+    }
+    /** Human-readable source of validation data. */
+    get probeSource() {
+        return this.probe?.source ?? null;
+    }
     /**
-     * Resolve a single class name against the expansion path.
-     * Returns the highest-priority matching tier, or 'none'.
+     * Validate a batch of unknown class names against the compile-probe.
+     * Call this BEFORE resolve() to pre-populate the validation cache.
+     *
+     * Classes that pass validation are cached internally; resolve() will
+     * find them on subsequent calls.
+     *
+     * Returns the full set of all validated classes (including previously
+     * cached ones).
+     */
+    async validateBatch(candidates) {
+        if (!this.probe?.ready) {
+            // No probe — use custom classes only
+            return this.customClasses ?? new Set();
+        }
+        return this.probe.validateBatch(candidates);
+    }
+    /**
+     * Resolve a single class name against the validation pipeline.
+     * Synchronous — only checks cached data + structural patterns.
+     * Call validateBatch() first to populate the cache for unknown classes.
      */
     resolve(className) {
-        const bundled = this.bundled ?? getBundledUtilityClasses();
-        // 1. Check raw class against bundled dictionary
-        if (bundled.has(className)) {
-            return { valid: true, tier: 'bundled' };
+        // 1. Check probe cache
+        if (this.probe?.isCached(className)) {
+            return { valid: true, tier: 'probe' };
         }
-        // 2. Check raw class against project config
-        if (this.projectClasses?.has(className)) {
-            return { valid: true, tier: 'project-config' };
+        // 2. Check custom (user-supplied) classes
+        if (this.customClasses?.has(className)) {
+            return { valid: true, tier: 'probe' };
         }
-        // 3. Check opacity-modifier syntax: {color-utility}/{opacity}
+        // 3. Check opacity-modifier syntax: {utility}/{opacity}
         if (className.includes('/')) {
             const result = this.checkOpacityModifier(className);
             if (result)
@@ -759,79 +143,70 @@ export class TailwindUtilityExpander {
         if (this.matchesArbitraryValue(className)) {
             return { valid: true, tier: 'arbitrary-value' };
         }
-        // 5. Check negative-value utility: -{prefix}-{value}
+        // 5. Check negative-utility syntax: -{utility}
         const negResult = this.checkNegativeUtility(className);
         if (negResult)
             return negResult;
         // 6. Strip variant prefix and retry
         const stripped = this.stripVariantPrefix(className);
         if (stripped !== className) {
-            return this.resolve(stripped); // Recurse once with the stripped class
+            return this.resolve(stripped);
         }
         return { valid: false, tier: 'none' };
     }
     /**
      * Check whether a class matches the arbitrary-value grammar:
-     * `{known-prefix}-[...]`
+     * `{prefix}-[...]` — any word prefix followed by `-[...]`.
+     *
+     * Structural check only — does not enumerate valid prefixes.
+     * The Tailwind compiler is the authority on whether a prefix
+     * actually accepts arbitrary values; our job is to not false-positive
+     * on obviously-arbitrary syntax.
      */
     matchesArbitraryValue(className) {
-        const bracketIdx = className.indexOf('[');
-        if (bracketIdx <= 0)
-            return false;
-        // Extract the prefix before the [
-        const prefix = className.substring(0, bracketIdx);
-        // Handle prefix-[value] where prefix ends with '-'
-        if (prefix.endsWith('-')) {
-            const normalizedPrefix = prefix.slice(0, -1);
-            return ARBITRARY_VALUE_PREFIXES.has(normalizedPrefix);
-        }
-        return false;
+        return ARBITRARY_VALUE_RE.test(className);
     }
     /**
-     * Check the opacity-modifier syntax: `{utility}/{opacity}`.
-     * e.g., `bg-red-500/50` → `bg-red-500` must be a valid utility AND
-     * `50` must be a valid opacity value.
+     * Check opacity-modifier syntax: `{utility}/{opacity}`.
      *
-     * We split on the LAST `/` to avoid confusing fractional widths
-     * (e.g. `w-1/2`) — those are in the dictionary directly and won't
-     * reach this check.
+     * Split on the LAST `/` to avoid confusing fractional widths
+     * (e.g. `w-1/2`). The prefix must be a known utility, suffix
+     * must be a numeric opacity (0-100).
      */
     checkOpacityModifier(className) {
-        const lastSlash = className.lastIndexOf('/');
-        if (lastSlash <= 0)
-            return null;
-        const prefix = className.substring(0, lastSlash);
-        const suffix = className.substring(lastSlash + 1);
-        // Suffix must be a numeric opacity value (0-100)
-        if (!/^\d{1,3}$/.test(suffix))
+        const m = OPACITY_MODIFIER_RE.exec(className);
+        if (!m)
             return null;
+        const prefix = m[1];
+        const suffix = m[2];
         const opacity = parseInt(suffix, 10);
         if (opacity < 0 || opacity > 100)
             return null;
-        // Prefix must be a known utility
-        const bundled = this.bundled ?? getBundledUtilityClasses();
-        if (bundled.has(prefix) || this.projectClasses?.has(prefix)) {
-            return { valid: true, tier: 'project-config' };
+        // Prefix must be a known utility — check against probe cache
+        // and custom classes (structural check isn't enough here because
+        // "foo-bar/50" should not match unless "foo-bar" is valid).
+        if (this.probe?.isCached(prefix) || this.customClasses?.has(prefix)) {
+            return { valid: true, tier: 'probe' };
+        }
+        // Also check if the prefix itself resolves (handles variant-prefixed
+        // utilities with opacity: hover:bg-red-500/50)
+        const prefixResolution = this.resolve(prefix);
+        if (prefixResolution.valid) {
+            return { valid: true, tier: prefixResolution.tier };
         }
         return null;
     }
     /**
-     * Check a negative utility: `-{prefix}-{value}`.
-     * e.g., `-mt-1`, `-top-2`, `-translate-x-1/2`, `-z-10`.
+     * Check negative-utility syntax: `-{utility}`.
      *
-     * Strips the leading `-` and checks whether the remainder is a valid
-     * utility whose prefix is in the negative-allowed set.
+     * Structural check — strips the leading `-` and verifies the positive
+     * utility itself is valid. No hand-curated allowed-prefixes list.
      */
     checkNegativeUtility(className) {
-        if (!className.startsWith('-'))
-            return null;
-        const positive = className.slice(1); // strip leading '-'
-        // Determine the prefix of the positive utility
-        // e.g., "top-2" → prefix="top", "translate-x-1/2" → prefix="translate-x"
-        const lastDash = positive.lastIndexOf('-');
-        const prefix = lastDash > 0 ? positive.substring(0, lastDash) : positive;
-        if (!NEGATIVE_ALLOWED_PREFIXES.has(prefix))
+        const m = NEGATIVE_UTILITY_RE.exec(className);
+        if (!m)
             return null;
+        const positive = m[1];
         // Recurse: is the positive utility itself valid?
         const result = this.resolve(positive);
         if (result.valid) {
@@ -841,14 +216,19 @@ export class TailwindUtilityExpander {
     }
     /**
      * Strip a Tailwind variant prefix from a class name.
+     * Uses structural regex — matches any `word:` or `word-word:` prefix.
+     *
      * E.g., "hover:bg-blue-500" → "bg-blue-500"
+     *       "md:w-full" → "w-full"
+     *       "group-hover:text-red" → "text-red"
+     *       "[&_>_a]:text-blue" → "text-blue" (arbitrary variant)
+     *
      * Returns the original if no variant prefix is matched.
      */
     stripVariantPrefix(className) {
-        for (const prefix of VARIANT_PREFIXES) {
-            if (className.startsWith(prefix + ':')) {
-                return className.slice(prefix.length + 1);
-            }
+        const m = VARIANT_PREFIX_RE.exec(className);
+        if (m) {
+            return className.slice(m[0].length);
         }
         return className;
     }
@@ -856,17 +236,19 @@ export class TailwindUtilityExpander {
      * Check if a class has a variant prefix at all.
      */
     hasVariantPrefix(className) {
-        return className.includes(':') && this.stripVariantPrefix(className) !== className;
+        return VARIANT_PREFIX_RE.test(className);
     }
     /** Reset state (useful for testing). */
     reset() {
-        this.bundled = null;
-        this.projectClasses = null;
+        this.probe = null;
+        this.customClasses = null;
         this._configFailed = false;
         this._configFailureReason = null;
     }
 }
-/** Singleton instance for the analyzer layer. */
+// ---------------------------------------------------------------------------
+// Singleton
+// ---------------------------------------------------------------------------
 let _instance = null;
 export function getTailwindExpander() {
     if (!_instance) {