@drskillissue/ganko 0.3.0 → 0.3.2

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   RULES,
   RULES_BY_CATEGORY,
   getRule
-} from "./chunk-TNKZGWOR.js";
+} from "./chunk-4W4KAPRH.js";
 import {
   ACCESSIBILITY_POLICIES,
   CSS_EXTENSIONS,
@@ -83,7 +83,7 @@ import {
   splitTopLevelWhitespace,
   splitWhitespaceTokens,
   toKebabCase
-} from "./chunk-2VRVUMIE.js";
+} from "./chunk-WJGGSO5O.js";
 import "./chunk-EGRHWZRV.js";
 
 // src/runner.ts
@@ -300,24 +300,26 @@ function buildTailwindValidatorFromEval(utilities, variants, logger) {
     has(className) {
       if (staticValidator.has(className)) return true;
       const cached = batchCache.get(className);
-      if (cached !== void 0) return cached;
+      if (cached !== void 0) return cached !== null;
       return false;
     },
-    resolve() {
+    resolve(className) {
+      const cached = batchCache.get(className);
+      if (cached !== void 0) return cached;
       return null;
     },
     preloadBatch(classNames, results) {
       for (let i = 0; i < classNames.length; i++) {
         const name = classNames[i];
-        const valid = results[i];
-        if (name !== void 0 && valid !== void 0) {
-          batchCache.set(name, valid);
+        const css = results[i];
+        if (name !== void 0 && css !== void 0) {
+          batchCache.set(name, css);
         }
       }
       if (logger?.isLevelEnabled(Level.Debug)) {
         let validCount = 0;
         for (let i = 0; i < results.length; i++) {
-          if (results[i]) validCount++;
+          if (results[i] !== null) validCount++;
         }
         logger.debug(`tailwind: preloaded ${classNames.length} candidates (${validCount} valid)`);
       }
@@ -513,7 +515,7 @@ function getActivePolicy() {
 }
 
 // src/compilation/symbols/class-name.ts
-function createClassNameSymbol(name, selectors, filePaths) {
+function createClassNameSymbol(name, selectors, filePaths, tailwindResolvedCSS) {
   return {
     symbolKind: "className",
     name,
@@ -522,7 +524,8 @@ function createClassNameSymbol(name, selectors, filePaths) {
       kind: "css",
       selectors,
       filePaths
-    }
+    },
+    tailwindResolvedCSS: tailwindResolvedCSS ?? null
   };
 }
 
@@ -993,7 +996,7 @@ function pushToMapArray(map, key, value) {
   if (arr !== void 0) arr.push(value);
   else map.set(key, [value]);
 }
-function buildSymbolTable(trees, tailwindValidator) {
+function buildSymbolTable(trees, tailwindValidator, solidClassTokens) {
   const classNamesMap = /* @__PURE__ */ new Map();
   const selectorsMap = /* @__PURE__ */ new Map();
   const customPropertiesMap = /* @__PURE__ */ new Map();
@@ -1020,6 +1023,7 @@ function buildSymbolTable(trees, tailwindValidator) {
   const allSelectors = [];
   const allDeclarations = [];
   const allVariables = [];
+  const referencedCustomPropertyNamesSet = /* @__PURE__ */ new Set();
   const allAtRules = [];
   const allKeyframeAtRules = [];
   const allFontFaceAtRules = [];
@@ -1130,6 +1134,11 @@ function buildSymbolTable(trees, tailwindValidator) {
         customPropertiesMap.set(entity.name, createCustomPropertySymbol(entity, filePath));
       }
     }
+    const treeVariableRefs = tree.variableRefs;
+    for (let i = 0; i < treeVariableRefs.length; i++) {
+      const ref = treeVariableRefs[i];
+      if (ref) referencedCustomPropertyNamesSet.add(ref.name);
+    }
     const treeAtRules = tree.atRules;
     for (let i = 0; i < treeAtRules.length; i++) {
       const entity = treeAtRules[i];
@@ -1183,11 +1192,32 @@ function buildSymbolTable(trees, tailwindValidator) {
       if (!placeholdersByNameMap.has(ph.name)) placeholdersByNameMap.set(ph.name, ph);
     }
   }
+  const twValidator = tailwindValidator ?? null;
   const classNameSymbols = /* @__PURE__ */ new Map();
   for (const [name, entry] of classNamesMap) {
-    classNameSymbols.set(name, createClassNameSymbol(name, entry.selectors, [...entry.filePaths]));
+    const twCSS = twValidator !== null && twValidator.has(name) ? twValidator.resolve(name) : null;
+    classNameSymbols.set(name, createClassNameSymbol(name, entry.selectors, [...entry.filePaths], twCSS));
+  }
+  if (twValidator !== null && solidClassTokens !== null && solidClassTokens !== void 0) {
+    for (const name of solidClassTokens) {
+      if (classNameSymbols.has(name)) continue;
+      if (!twValidator.has(name)) continue;
+      const resolvedCSS = twValidator.resolve(name);
+      classNameSymbols.set(name, {
+        symbolKind: "className",
+        name,
+        filePath: null,
+        source: {
+          kind: "tailwind",
+          candidate: { raw: name, variants: [], utility: name, value: null, modifier: null, important: false, negative: false },
+          resolvedCSS,
+          declarations: [],
+          diagnostics: []
+        },
+        tailwindResolvedCSS: resolvedCSS
+      });
+    }
   }
-  const twValidator = tailwindValidator ?? null;
   const knownKeyframeNames = /* @__PURE__ */ new Set();
   for (let i = 0; i < allKeyframeAtRules.length; i++) {
     const kf = allKeyframeAtRules[i];
@@ -1544,8 +1574,9 @@ function buildSymbolTable(trees, tailwindValidator) {
     unusedFunctions: unusedFunctionsArr,
     unusedPlaceholders: unusedPlaceholdersArr,
     tokenCategories: [...tokensByCategoryMap.keys()],
+    referencedCustomPropertyNames: referencedCustomPropertyNamesSet,
     hasClassName(name) {
-      return classNameSymbols.has(name) || twValidator !== null && twValidator.has(name);
+      return classNameSymbols.has(name);
     },
     getClassName(name) {
       return classNameSymbols.get(name) ?? null;
@@ -2684,7 +2715,7 @@ function buildElementNodes(solidTree, compilation) {
     const selectorDispatchKeys = buildSelectorDispatchKeys(attributes, classTokens);
     const inlineStyleValues = inlineStyleValuesByElementId.get(element.id) ?? EMPTY_INLINE_STYLE_VALUES;
     const textualContent = getTextualContentState(element, textContentMemo, compositionMetaByElementId);
-    const parentElementId = resolveComposedParentElementId(element, compositionMetaByElementId);
+    const parentElementId = resolveComposedParentElementId(element, compositionMetaByElementId, solidTree.compoundComponentParents);
     records.push({
       element,
       key: `${solidTree.filePath}::${element.id}`,
@@ -2717,12 +2748,32 @@ function buildElementNodes(solidTree, compilation) {
       byType.set(record.tagName, (byType.get(record.tagName) ?? 0) + 1);
     }
   }
+  const recordsByElementId = /* @__PURE__ */ new Map();
+  for (let i = 0; i < records.length; i++) {
+    const r = records[i];
+    if (r) recordsByElementId.set(r.element.id, r);
+  }
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  function visitRecord(r) {
+    if (visited.has(r.element.id)) return;
+    visited.add(r.element.id);
+    if (r.parentElementId !== null) {
+      const parent = recordsByElementId.get(r.parentElementId);
+      if (parent) visitRecord(parent);
+    }
+    sorted.push(r);
+  }
+  for (let i = 0; i < records.length; i++) {
+    const r = records[i];
+    if (r) visitRecord(r);
+  }
   const elements = [];
   const nodeByElementId = /* @__PURE__ */ new Map();
   const lastChildByParentId = /* @__PURE__ */ new Map();
   const siblingTypeSeenByParentId = /* @__PURE__ */ new Map();
-  for (let i = 0; i < records.length; i++) {
-    const record = records[i];
+  for (let i = 0; i < sorted.length; i++) {
+    const record = sorted[i];
     if (!record) continue;
     const parentElementId = record.parentElementId;
     const parentNode = parentElementId === null ? null : nodeByElementId.get(parentElementId) ?? null;
@@ -2886,13 +2937,19 @@ function resolveEffectiveTag(element, hostDescriptor) {
   if (!element.isDomElement) return null;
   return element.tag;
 }
-function resolveComposedParentElementId(element, compositionMetaByElementId) {
+function resolveComposedParentElementId(element, compositionMetaByElementId, compoundComponentParents) {
   let parent = element.parent;
   while (parent !== null) {
     const meta = compositionMetaByElementId.get(parent.id);
     if (meta && meta.participates) return parent.id;
     parent = parent.parent;
   }
+  let scope = element.scope;
+  while (scope !== null) {
+    const compoundParent = compoundComponentParents.get(scope.id);
+    if (compoundParent !== void 0) return compoundParent;
+    scope = scope.parent;
+  }
   return null;
 }
 function getTextualContentState(element, memo, compositionMetaByElementId, logger = noopLogger) {
@@ -4182,6 +4239,136 @@ function compareCascadePositions(posA, posB) {
   return posA.sourceOrder - posB.sourceOrder;
 }
 
+// src/compilation/analysis/layout-fact.ts
+var SCROLLABLE_VALUES = /* @__PURE__ */ new Set(["auto", "scroll"]);
+var NON_RESERVING_DIMENSION_KEYWORDS = /* @__PURE__ */ new Set(["auto", "none", "fit-content", "min-content", "max-content", "stretch", "inherit", "initial", "unset", "revert", "revert-layer"]);
+var BLOCK_LEVEL_DISPLAY_VALUES = /* @__PURE__ */ new Set(["block", "flex", "grid", "table", "list-item", "flow-root", "table-row", "table-cell", "table-caption", "table-row-group", "table-header-group", "table-footer-group", "table-column", "table-column-group"]);
+function computeReservedSpaceFact(snapshot) {
+  const reasons = [];
+  const hasHeight = hasDeclaredDimension(snapshot, "height");
+  if (hasHeight) reasons.push("height");
+  const hasBlockSize = hasDeclaredDimension(snapshot, "block-size");
+  if (hasBlockSize) reasons.push("block-size");
+  const hasMinHeight = hasDeclaredDimension(snapshot, "min-height");
+  if (hasMinHeight) reasons.push("min-height");
+  const hasMinBlockSize = hasDeclaredDimension(snapshot, "min-block-size");
+  if (hasMinBlockSize) reasons.push("min-block-size");
+  const hasContainIntrinsic = hasDeclaredDimension(snapshot, "contain-intrinsic-size");
+  if (hasContainIntrinsic) reasons.push("contain-intrinsic-size");
+  const hasAspectRatio = hasUsableAspectRatio(snapshot);
+  if (hasAspectRatio) {
+    if (hasDeclaredDimension(snapshot, "width")) reasons.push("aspect-ratio+width");
+    if (hasDeclaredDimension(snapshot, "inline-size")) reasons.push("aspect-ratio+inline-size");
+    if (hasDeclaredDimension(snapshot, "min-width")) reasons.push("aspect-ratio+min-width");
+    if (hasMinBlockSize) reasons.push("aspect-ratio+min-block-size");
+    if (hasMinHeight) reasons.push("aspect-ratio+min-height");
+  }
+  return {
+    hasReservedSpace: reasons.length > 0,
+    reasons,
+    hasContainIntrinsicSize: hasContainIntrinsic,
+    hasUsableAspectRatio: hasAspectRatio,
+    hasDeclaredBlockDimension: hasHeight || hasBlockSize || hasMinHeight || hasMinBlockSize,
+    hasDeclaredInlineDimension: hasDeclaredDimension(snapshot, "width") || hasDeclaredDimension(snapshot, "inline-size") || hasDeclaredDimension(snapshot, "min-width") || hasDeclaredDimension(snapshot, "flex-basis") || isBlockLevelDisplay(snapshot)
+  };
+}
+function hasDeclaredDimension(snapshot, property) {
+  const signal = snapshot.signals.get(property);
+  if (!signal) return false;
+  if (signal.kind === 0 /* Known */) {
+    if (signal.px !== null) return signal.px > 0;
+    if (signal.normalized.length === 0) return false;
+    return !isNonReservingDimension(signal.normalized);
+  }
+  if (signal.kind === 1 /* Unknown */) {
+    return signal.source !== null;
+  }
+  return false;
+}
+function isBlockLevelDisplay(snapshot) {
+  const signal = snapshot.signals.get("display");
+  if (!signal || signal.kind !== 0 /* Known */) return false;
+  return BLOCK_LEVEL_DISPLAY_VALUES.has(signal.normalized);
+}
+function hasUsableAspectRatio(snapshot) {
+  const signal = snapshot.signals.get("aspect-ratio");
+  if (!signal) return false;
+  if (signal.guard.kind === 1) return false;
+  if (signal.kind === 1 /* Unknown */) return false;
+  if (signal.kind !== 0 /* Known */) return false;
+  if (signal.normalized.length === 0) return false;
+  return signal.normalized !== "auto";
+}
+function isNonReservingDimension(value) {
+  if (NON_RESERVING_DIMENSION_KEYWORDS.has(value)) return true;
+  if (value.startsWith("fit-content(")) return true;
+  return false;
+}
+function computeScrollContainerFact(snapshot) {
+  const overflowSignal = snapshot.signals.get("overflow");
+  const overflowYSignal = snapshot.signals.get("overflow-y");
+  const overflow = overflowSignal && overflowSignal.kind === 0 /* Known */ ? overflowSignal.normalized : null;
+  const overflowY = overflowYSignal && overflowYSignal.kind === 0 /* Known */ ? overflowYSignal.normalized : null;
+  const shorthandAxis = parseOverflowShorthandAxis(overflow);
+  const yFromLonghand = parseSingleAxisScroll(overflowY);
+  const xScroll = shorthandAxis.x;
+  const yScroll = yFromLonghand === null ? shorthandAxis.y : yFromLonghand;
+  const hasConditionalScroll = overflowSignal?.guard.kind === 1 && (shorthandAxis.x || shorthandAxis.y) || overflowYSignal?.guard.kind === 1 && yFromLonghand === true;
+  const hasUnconditionalScroll = overflowSignal?.guard.kind === 0 && (shorthandAxis.x || shorthandAxis.y) || overflowYSignal?.guard.kind === 0 && yFromLonghand === true;
+  return {
+    isScrollContainer: xScroll || yScroll,
+    axis: toScrollAxis(xScroll, yScroll),
+    overflow,
+    overflowY,
+    hasConditionalScroll,
+    hasUnconditionalScroll
+  };
+}
+var NO_SCROLL = Object.freeze({ x: false, y: false });
+var BOTH_SCROLL = Object.freeze({ x: true, y: true });
+function parseOverflowShorthandAxis(value) {
+  if (value === null) return NO_SCROLL;
+  const trimmed = value.trim();
+  const spaceIdx = trimmed.indexOf(" ");
+  if (spaceIdx === -1) {
+    const scroll = SCROLLABLE_VALUES.has(trimmed);
+    return scroll ? BOTH_SCROLL : NO_SCROLL;
+  }
+  const first = trimmed.slice(0, spaceIdx);
+  const second = trimmed.slice(spaceIdx + 1).trimStart();
+  return {
+    x: SCROLLABLE_VALUES.has(first),
+    y: SCROLLABLE_VALUES.has(second)
+  };
+}
+function parseSingleAxisScroll(value) {
+  if (value === null) return null;
+  const trimmed = value.trim();
+  const spaceIdx = trimmed.indexOf(" ");
+  const first = spaceIdx === -1 ? trimmed : trimmed.slice(0, spaceIdx);
+  return SCROLLABLE_VALUES.has(first);
+}
+function toScrollAxis(x, y) {
+  if (x && y) return 3 /* Both */;
+  if (x) return 1 /* X */;
+  if (y) return 2 /* Y */;
+  return 0 /* None */;
+}
+function computeFlowParticipationFact(snapshot) {
+  const signal = snapshot.signals.get("position");
+  if (!signal || signal.kind !== 0 /* Known */) {
+    return { inFlow: true, position: null, hasConditionalOutOfFlow: false, hasUnconditionalOutOfFlow: false };
+  }
+  const position = signal.normalized;
+  const outOfFlow = position === "absolute" || position === "fixed";
+  return {
+    inFlow: !outOfFlow,
+    position,
+    hasConditionalOutOfFlow: signal.guard.kind === 1 && outOfFlow,
+    hasUnconditionalOutOfFlow: signal.guard.kind === 0 && outOfFlow
+  };
+}
+
 // src/compilation/binding/cascade-binder.ts
 var bindCacheBySymbolTable = /* @__PURE__ */ new WeakMap();
 function getOrBuildBindState(symbolTable) {
@@ -4643,8 +4830,6 @@ function matchesRequiredAttributes(required, actual) {
     if (constraint === void 0) continue;
     if (!actual.has(constraint.name)) return 1 /* NoMatch */;
     if (constraint.operator === "exists") {
-      const existsValue = actual.get(constraint.name);
-      if (existsValue === null) hasConditional = true;
       continue;
     }
     const actualValue = actual.get(constraint.name);
@@ -4854,10 +5039,9 @@ function augmentCascadeWithTailwindFromSymbolTable(cascade, element, symbolTable
   for (let i = 0; i < classTokens.length; i++) {
     const token = classTokens[i];
     if (token === void 0) continue;
-    const classSymbol = symbolTable.classNames.get(token);
-    if (!classSymbol) continue;
-    if (classSymbol.source.kind !== "tailwind") continue;
-    const resolvedCSS = classSymbol.source.resolvedCSS;
+    const classSymbol = symbolTable.getClassName(token);
+    if (classSymbol === null) continue;
+    const resolvedCSS = classSymbol.tailwindResolvedCSS;
     if (resolvedCSS === null) continue;
     const declarations = parseTailwindCssDeclarations(resolvedCSS);
     for (let j = 0; j < declarations.length; j++) {
@@ -4873,126 +5057,21 @@ function augmentCascadeWithTailwindFromSymbolTable(cascade, element, symbolTable
     }
   }
 }
-var SCROLLABLE_VALUES = /* @__PURE__ */ new Set(["auto", "scroll"]);
-var OUT_OF_FLOW_POSITIONS = /* @__PURE__ */ new Set(["absolute", "fixed", "sticky"]);
-function computeLayoutFact(factKind, elementId, declarations, allElements, getCascadeForElement) {
+function computeLayoutFact(factKind, elementId, snapshot, allElements, getSnapshotForElement) {
   switch (factKind) {
     case "reservedSpace":
-      return computeReservedSpaceFact(declarations);
+      return computeReservedSpaceFact(snapshot);
     case "scrollContainer":
-      return computeScrollContainerFact(declarations);
+      return computeScrollContainerFact(snapshot);
     case "flowParticipation":
-      return computeFlowParticipationFact(declarations);
+      return computeFlowParticipationFact(snapshot);
     case "containingBlock":
-      return computeContainingBlockFact(elementId, allElements, getCascadeForElement);
+      return computeContainingBlockFact(elementId, allElements, getSnapshotForElement);
     default:
       throw new Error(`Unknown layout fact kind: ${factKind}`);
   }
 }
-function getCascadeValue(declarations, property) {
-  const decl = declarations.get(property);
-  if (!decl) return null;
-  return decl.value.trim().toLowerCase();
-}
-function computeReservedSpaceFact(declarations) {
-  const reasons = [];
-  const height = getCascadeValue(declarations, "height");
-  if (height !== null && height !== "auto" && height !== "fit-content" && height !== "min-content" && height !== "max-content") {
-    reasons.push("height");
-  }
-  const blockSize = getCascadeValue(declarations, "block-size");
-  if (blockSize !== null && blockSize !== "auto" && blockSize !== "fit-content" && blockSize !== "min-content" && blockSize !== "max-content") {
-    reasons.push("block-size");
-  }
-  const minHeight = getCascadeValue(declarations, "min-height");
-  if (minHeight !== null && minHeight !== "0" && minHeight !== "0px" && minHeight !== "auto") {
-    reasons.push("min-height");
-  }
-  const minBlockSize = getCascadeValue(declarations, "min-block-size");
-  if (minBlockSize !== null && minBlockSize !== "0" && minBlockSize !== "0px" && minBlockSize !== "auto") {
-    reasons.push("min-block-size");
-  }
-  const containIntrinsicSize = getCascadeValue(declarations, "contain-intrinsic-size");
-  const hasContainIntrinsicSize = containIntrinsicSize !== null;
-  if (hasContainIntrinsicSize) {
-    reasons.push("contain-intrinsic-size");
-  }
-  const aspectRatio = getCascadeValue(declarations, "aspect-ratio");
-  const hasUsableAspectRatio = aspectRatio !== null && aspectRatio !== "auto";
-  const width = getCascadeValue(declarations, "width");
-  const inlineSize = getCascadeValue(declarations, "inline-size");
-  const hasDeclaredInlineDimension = width !== null && width !== "auto" || inlineSize !== null && inlineSize !== "auto";
-  const hasDeclaredBlockDimension = height !== null && height !== "auto";
-  if (hasUsableAspectRatio && hasDeclaredInlineDimension) {
-    if (width !== null) reasons.push("aspect-ratio+width");
-    if (inlineSize !== null) reasons.push("aspect-ratio+inline-size");
-  }
-  return {
-    hasReservedSpace: reasons.length > 0,
-    reasons,
-    hasContainIntrinsicSize,
-    hasUsableAspectRatio,
-    hasDeclaredInlineDimension,
-    hasDeclaredBlockDimension
-  };
-}
-function computeScrollContainerFact(declarations) {
-  const overflow = getCascadeValue(declarations, "overflow");
-  const overflowY = getCascadeValue(declarations, "overflow-y");
-  let axis = 0;
-  let isScrollContainer = false;
-  let hasConditionalScroll = false;
-  let hasUnconditionalScroll = false;
-  if (overflow !== null && SCROLLABLE_VALUES.has(overflow)) {
-    isScrollContainer = true;
-    axis = 3;
-    const decl = declarations.get("overflow");
-    if (decl && decl.guardProvenance.kind === 1 /* Conditional */) {
-      hasConditionalScroll = true;
-    } else {
-      hasUnconditionalScroll = true;
-    }
-  }
-  if (overflowY !== null && SCROLLABLE_VALUES.has(overflowY)) {
-    isScrollContainer = true;
-    if (axis === 0) axis = 2;
-    const decl = declarations.get("overflow-y");
-    if (decl && decl.guardProvenance.kind === 1 /* Conditional */) {
-      hasConditionalScroll = true;
-    } else {
-      hasUnconditionalScroll = true;
-    }
-  }
-  return {
-    isScrollContainer,
-    axis,
-    overflow,
-    overflowY,
-    hasConditionalScroll,
-    hasUnconditionalScroll
-  };
-}
-function computeFlowParticipationFact(declarations) {
-  const position = getCascadeValue(declarations, "position");
-  const isOutOfFlow = position !== null && OUT_OF_FLOW_POSITIONS.has(position);
-  let hasConditionalOutOfFlow = false;
-  let hasUnconditionalOutOfFlow = false;
-  if (isOutOfFlow) {
-    const decl = declarations.get("position");
-    if (decl && decl.guardProvenance.kind === 1 /* Conditional */) {
-      hasConditionalOutOfFlow = true;
-    } else {
-      hasUnconditionalOutOfFlow = true;
-    }
-  }
-  return {
-    inFlow: !isOutOfFlow,
-    position,
-    hasConditionalOutOfFlow,
-    hasUnconditionalOutOfFlow
-  };
-}
-function computeContainingBlockFact(elementId, allElements, getCascadeForElement) {
+function computeContainingBlockFact(elementId, allElements, getSnapshotForElement) {
   let current = null;
   for (let i = 0; i < allElements.length; i++) {
     const el = allElements[i];
@@ -5006,10 +5085,11 @@ function computeContainingBlockFact(elementId, allElements, getCascadeForElement
   }
   let ancestor = current.parentElementNode;
   while (ancestor !== null) {
-    const ancestorCascade = getCascadeForElement(ancestor.elementId);
-    const pos = getCascadeValue(ancestorCascade, "position");
+    const ancestorSnapshot = getSnapshotForElement(ancestor.elementId);
+    const posSignal = ancestorSnapshot.signals.get("position");
+    const pos = posSignal && posSignal.kind === 0 ? posSignal.normalized : null;
     if (pos !== null && pos !== "static") {
-      const reservedFact = computeReservedSpaceFact(ancestorCascade);
+      const reservedFact = computeReservedSpaceFact(ancestorSnapshot);
       return {
         nearestPositionedAncestorKey: ancestor.key,
         nearestPositionedAncestorHasReservedSpace: reservedFact.hasReservedSpace
@@ -5068,59 +5148,6 @@ function buildScopedSelectorIndex(scopedCSSFiles, symbolTable) {
   };
 }
 
-// src/compilation/analysis/layout-fact.ts
-var SCROLLABLE_VALUES2 = /* @__PURE__ */ new Set(["auto", "scroll"]);
-function computeScrollContainerFact2(snapshot) {
-  const overflowSignal = snapshot.signals.get("overflow");
-  const overflowYSignal = snapshot.signals.get("overflow-y");
-  const overflow = overflowSignal && overflowSignal.kind === 0 /* Known */ ? overflowSignal.normalized : null;
-  const overflowY = overflowYSignal && overflowYSignal.kind === 0 /* Known */ ? overflowYSignal.normalized : null;
-  const shorthandAxis = parseOverflowShorthandAxis(overflow);
-  const yFromLonghand = parseSingleAxisScroll(overflowY);
-  const xScroll = shorthandAxis.x;
-  const yScroll = yFromLonghand === null ? shorthandAxis.y : yFromLonghand;
-  const hasConditionalScroll = overflowSignal?.guard.kind === 1 && (shorthandAxis.x || shorthandAxis.y) || overflowYSignal?.guard.kind === 1 && yFromLonghand === true;
-  const hasUnconditionalScroll = overflowSignal?.guard.kind === 0 && (shorthandAxis.x || shorthandAxis.y) || overflowYSignal?.guard.kind === 0 && yFromLonghand === true;
-  return {
-    isScrollContainer: xScroll || yScroll,
-    axis: toScrollAxis(xScroll, yScroll),
-    overflow,
-    overflowY,
-    hasConditionalScroll,
-    hasUnconditionalScroll
-  };
-}
-var NO_SCROLL = Object.freeze({ x: false, y: false });
-var BOTH_SCROLL = Object.freeze({ x: true, y: true });
-function parseOverflowShorthandAxis(value) {
-  if (value === null) return NO_SCROLL;
-  const trimmed = value.trim();
-  const spaceIdx = trimmed.indexOf(" ");
-  if (spaceIdx === -1) {
-    const scroll = SCROLLABLE_VALUES2.has(trimmed);
-    return scroll ? BOTH_SCROLL : NO_SCROLL;
-  }
-  const first = trimmed.slice(0, spaceIdx);
-  const second = trimmed.slice(spaceIdx + 1).trimStart();
-  return {
-    x: SCROLLABLE_VALUES2.has(first),
-    y: SCROLLABLE_VALUES2.has(second)
-  };
-}
-function parseSingleAxisScroll(value) {
-  if (value === null) return null;
-  const trimmed = value.trim();
-  const spaceIdx = trimmed.indexOf(" ");
-  const first = spaceIdx === -1 ? trimmed : trimmed.slice(0, spaceIdx);
-  return SCROLLABLE_VALUES2.has(first);
-}
-function toScrollAxis(x, y) {
-  if (x && y) return 3 /* Both */;
-  if (x) return 1 /* X */;
-  if (y) return 2 /* Y */;
-  return 0 /* None */;
-}
-
 // src/compilation/analysis/alignment.ts
 var CONTROL_ELEMENT_TAGS2 = /* @__PURE__ */ new Set(["input", "select", "textarea", "button"]);
 var INTRINSIC_REPLACED_TAGS = /* @__PURE__ */ new Set(["img", "svg", "video", "canvas", "iframe", "object", "embed"]);
@@ -6545,13 +6572,13 @@ function buildConsistencyEvidence(input) {
   const lineHeight = normalizeDeviation(input.subjectLineHeightDeviation, input.cohortProfile.lineHeightDispersionPx, input.cohortProfile.medianLineHeightPx);
   const baselinesIrrelevant = input.context.baselineRelevance === "irrelevant";
   const blockAxisIsMainAxis = !input.context.crossAxisIsBlockAxis;
-  const suppressAll = blockAxisIsMainAxis;
+  const suppressAll = blockAxisIsMainAxis || baselinesIrrelevant;
   const offset = suppressAll ? ZERO_STRENGTH : offsetRaw;
   const declaredOffset = suppressAll ? ZERO_STRENGTH : declaredOffsetRaw;
-  const baselineStrength = baselinesIrrelevant || suppressAll ? ZERO_STRENGTH : resolveBaselineStrength(input, lineHeight);
-  const contextStrength = baselinesIrrelevant || suppressAll ? ZERO_STRENGTH : resolveContextStrength(input, lineHeight);
-  const replacedStrength = baselinesIrrelevant || suppressAll ? ZERO_STRENGTH : resolveReplacedControlStrength(input, lineHeight);
-  const compositionResult = baselinesIrrelevant || suppressAll ? null : resolveContentCompositionStrength(input);
+  const baselineStrength = suppressAll ? ZERO_STRENGTH : resolveBaselineStrength(input, lineHeight);
+  const contextStrength = suppressAll ? ZERO_STRENGTH : resolveContextStrength(input, lineHeight);
+  const replacedStrength = suppressAll ? ZERO_STRENGTH : resolveReplacedControlStrength(input, lineHeight);
+  const compositionResult = suppressAll ? null : resolveContentCompositionStrength(input);
   const compositionStrength = compositionResult ? compositionResult.evidence : ZERO_STRENGTH;
   const contextCertaintyPenalty = resolveContextCertaintyPenalty(input);
   const provenance = input.cohortProvenance;
@@ -6848,7 +6875,7 @@ function formatPrimaryFix(findings) {
 }
 
 // src/compilation/analysis/cascade-analyzer.ts
-var SCROLLABLE_VALUES3 = /* @__PURE__ */ new Set(["auto", "scroll"]);
+var SCROLLABLE_VALUES2 = /* @__PURE__ */ new Set(["auto", "scroll"]);
 function computeConditionalDelta(elements, cascadeByElementId, monitoredDeclarationsBySelectorId, symbolTable) {
   const deltaByElementId = /* @__PURE__ */ new Map();
   const elementsWithDeltaBySignal = /* @__PURE__ */ new Map();
@@ -7056,7 +7083,7 @@ function containsScrollToken(value) {
   for (let i = 0; i < tokens.length; i++) {
     const token = tokens[i];
     if (token === void 0) continue;
-    if (SCROLLABLE_VALUES3.has(token)) return true;
+    if (SCROLLABLE_VALUES2.has(token)) return true;
   }
   return false;
 }
@@ -7503,14 +7530,14 @@ function createFileSemanticModel(solidTree, symbolTable, dependencyGraph, compil
       return out;
     },
     getLayoutFact(elementId, factKind) {
-      const cascade = this.getElementCascade(elementId);
+      const snapshot = this.getSignalSnapshot(elementId);
       const allElements = this.getElementNodes();
       return computeLayoutFact(
         factKind,
         elementId,
-        cascade.declarations,
+        snapshot,
         allElements,
-        (id) => this.getElementCascade(id).declarations
+        (id) => this.getSignalSnapshot(id)
       );
     },
     // ── Tier 4-5: Signal + fact + alignment queries ────────────────────
@@ -7549,7 +7576,7 @@ function createFileSemanticModel(solidTree, symbolTable, dependencyGraph, compil
         if (!el) continue;
         const snapshot = snapshotIndex.get(el.elementId);
         if (!snapshot) continue;
-        const fact = computeScrollContainerFact2(snapshot);
+        const fact = computeScrollContainerFact(snapshot);
         if (fact.isScrollContainer) out.push(el);
       }
       return out;
@@ -7614,7 +7641,26 @@ function makeCompilation(solidTrees, cssTrees, tailwindConfig, packageManifest,
       if (cachedSymbolTable === null) {
         const allCssTrees = [];
         for (const tree of cssTrees.values()) allCssTrees.push(tree);
-        cachedSymbolTable = buildSymbolTable(allCssTrees, tailwindConfig?.validator ?? null);
+        let solidClassTokens = null;
+        if (tailwindConfig?.validator !== null && tailwindConfig?.validator !== void 0) {
+          const tokens = /* @__PURE__ */ new Set();
+          for (const st of solidTrees.values()) {
+            for (const [, idx] of st.staticClassTokensByElementId) {
+              for (let i = 0; i < idx.tokens.length; i++) {
+                const t = idx.tokens[i];
+                if (t) tokens.add(t);
+              }
+            }
+            for (const [, idx] of st.staticClassListKeysByElementId) {
+              for (let i = 0; i < idx.keys.length; i++) {
+                const t = idx.keys[i];
+                if (t) tokens.add(t);
+              }
+            }
+          }
+          solidClassTokens = tokens;
+        }
+        cachedSymbolTable = buildSymbolTable(allCssTrees, tailwindConfig?.validator ?? null, solidClassTokens);
       }
       return cachedSymbolTable;
     },
@@ -8518,7 +8564,7 @@ function dispatchCompilationActions(actions, compilation, symbolTable, emit) {
 }
 
 // src/css/rules/animation/layout-animation-exempt.ts
-var OUT_OF_FLOW_POSITIONS2 = /* @__PURE__ */ new Set(["fixed", "absolute"]);
+var OUT_OF_FLOW_POSITIONS = /* @__PURE__ */ new Set(["fixed", "absolute"]);
 var OVERFLOW_CONTAINMENT_VALUES = /* @__PURE__ */ new Set(["hidden", "clip"]);
 var IDENTITY_ATTRIBUTE_NAMES = /* @__PURE__ */ new Set(["data-component", "data-slot"]);
 function isLayoutAnimationExempt(declaration, layoutProperty) {
@@ -8548,7 +8594,7 @@ function hasOutOfFlowPosition(rule) {
     const decl = positionDecls[i];
     if (!decl) continue;
     const value = decl.value.trim().toLowerCase();
-    if (OUT_OF_FLOW_POSITIONS2.has(value)) return true;
+    if (OUT_OF_FLOW_POSITIONS.has(value)) return true;
   }
   return false;
 }
@@ -9233,10 +9279,7 @@ var jsxStyleNoUnusedCustomProp = defineAnalysisRule({
   requirement: { tier: 1 /* CrossSyntax */ },
   register(registry) {
     registry.registerCrossSyntaxAction((solidTree, symbolTable, emit) => {
-      const usedVarNames = /* @__PURE__ */ new Set();
-      for (const [name] of symbolTable.customProperties) {
-        usedVarNames.add(name);
-      }
+      const usedVarNames = symbolTable.referencedCustomPropertyNames;
       if (solidTree.jsxClassListAttributes.length > 0) return;
       let hasNonStaticClass = false;
       for (const [, idx] of solidTree.staticClassTokensByElementId) {
@@ -9274,7 +9317,7 @@ import ts9 from "typescript";
 var messages13 = {
   classListGeometryToggle: "classList toggles '{{className}}', and matching CSS changes layout-affecting '{{property}}', which can cause CLS."
 };
-var OUT_OF_FLOW_POSITIONS3 = /* @__PURE__ */ new Set(["fixed", "absolute"]);
+var OUT_OF_FLOW_POSITIONS2 = /* @__PURE__ */ new Set(["fixed", "absolute"]);
 var jsxLayoutClasslistGeometryToggle = defineAnalysisRule({
   id: "jsx-layout-classlist-geometry-toggle",
   severity: "warn",
@@ -9327,7 +9370,7 @@ function classEstablishesOutOfFlow(className, symbolTable) {
       const decl = positionDecls[j];
       if (!decl) continue;
       const value = decl.value.trim().toLowerCase();
-      if (OUT_OF_FLOW_POSITIONS3.has(value)) return true;
+      if (OUT_OF_FLOW_POSITIONS2.has(value)) return true;
     }
   }
   return false;
@@ -10196,7 +10239,7 @@ function normalizeStylePropertyKey(key) {
   if (key.includes("-")) return key.toLowerCase();
   return toKebabCase(key);
 }
-function isExemptFromCLS(element, flowFact, property, _semanticModel) {
+function isExemptFromCLS(element, flowFact, property, semanticModel) {
   if (!flowFact.inFlow) return true;
   if (POSITIONED_OFFSET_PROPERTIES.has(property) && flowFact.position !== null && flowFact.position !== "static") {
     return true;
@@ -10204,8 +10247,17 @@ function isExemptFromCLS(element, flowFact, property, _semanticModel) {
   if (hasLayoutContainment(element) || element.parentElementNode !== null && hasLayoutContainment(element.parentElementNode)) {
     return true;
   }
+  if (element.parentElementNode !== null && parentClipsOverflow(element.parentElementNode, semanticModel)) {
+    return true;
+  }
   return false;
 }
+var CLIPPING_OVERFLOW_VALUES = /* @__PURE__ */ new Set(["hidden", "clip"]);
+function parentClipsOverflow(parent, semanticModel) {
+  const snapshot = semanticModel.getSignalSnapshot(parent.elementId);
+  const signal = snapshot.signals.get("overflow");
+  return signal !== void 0 && signal.kind === 0 /* Known */ && CLIPPING_OVERFLOW_VALUES.has(signal.normalized);
+}
 function hasLayoutContainment(node) {
   const contain = node.inlineStyleValues.get("contain");
   if (contain === void 0) return false;
@@ -10307,7 +10359,7 @@ var messages25 = {
   noReservedBlockSize: "Interactive element `<{{tag}}>` has no declared height (minimum `{{min}}px` required by policy `{{policy}}`). The element is content-sized and may not meet the touch-target threshold.",
   noReservedInlineSize: "Interactive element `<{{tag}}>` has no declared width (minimum `{{min}}px` required by policy `{{policy}}`). The element is content-sized and may not meet the touch-target threshold."
 };
-var INTERACTIVE_HTML_TAGS2 = /* @__PURE__ */ new Set(["button", "a", "input", "select", "textarea", "label", "summary"]);
+var INTERACTIVE_HTML_TAGS2 = /* @__PURE__ */ new Set(["button", "a", "input", "select", "textarea", "summary"]);
 var INTERACTIVE_ARIA_ROLES2 = /* @__PURE__ */ new Set([
   "button",
   "link",
@@ -10468,9 +10520,12 @@ var jsxLayoutPolicyTouchTarget = defineAnalysisRule({
   }
 });
 function classifyInteractive(element, semanticModel) {
+  if (element.attributes.has("hidden")) return null;
   const tag = element.tagName;
   if (tag !== null && INTERACTIVE_HTML_TAGS2.has(tag)) {
+    if (tag === "input" && element.attributes.get("type") === "hidden") return null;
     if (tag === "input" || tag === "select" || tag === "textarea") return "input";
+    if (tag === "a" && isInlineTextLink(element)) return null;
     return "button";
   }
   const roleAttr = getJSXAttributeEntity(semanticModel.solidTree, element.jsxEntity, "role");
@@ -10500,6 +10555,14 @@ function isVisuallyHidden(element, snapshot) {
   if (widthSignal && widthSignal.kind === 0 /* Known */ && widthSignal.px === 1 && heightSignal && heightSignal.kind === 0 /* Known */ && heightSignal.px === 1) return true;
   return false;
 }
+function isInlineTextLink(element) {
+  const content = element.textualContent;
+  if (content !== 0 /* Yes */ && content !== 3 /* DynamicText */) return false;
+  const parent = element.parentElementNode;
+  if (parent === null) return false;
+  const parentContent = parent.textualContent;
+  return parentContent === 0 /* Yes */ || parentContent === 3 /* DynamicText */ || parentContent === 2 /* Unknown */;
+}
 function checkDimension(snapshot, signal, min, element, semanticModel, emit, messageId, template, tag, policyName) {
   let px = readKnownPx2(snapshot, signal);
   if (px === null) {
@@ -10510,6 +10573,7 @@ function checkDimension(snapshot, signal, min, element, semanticModel, emit, mes
   }
   if (px === null) return;
   if (px >= min) return;
+  if (px === 0 && (signal === "min-width" || signal === "min-height")) return;
   emit(createDiagnostic(
     element.solidFile,
     element.jsxEntity.node,
@@ -12628,10 +12692,8 @@ var cssPolicyTypography = defineAnalysisRule({
 var messages57 = {
   letterSpacingTooSmall: "Letter spacing `{{value}}` ({{resolved}}em) is below the minimum `{{min}}em` for policy `{{policy}}`.",
   wordSpacingTooSmall: "Word spacing `{{value}}` ({{resolved}}em) is below the minimum `{{min}}em` for policy `{{policy}}`.",
-  paragraphSpacingTooSmall: "Paragraph spacing `{{value}}` ({{resolved}}em) is below the minimum `{{min}}em` ({{minMultiplier}}\xD7 font-size) for policy `{{policy}}`.",
-  touchTargetTooSmall: "`{{property}}: {{value}}` ({{resolved}}px) is below the minimum `{{min}}px` for interactive elements in policy `{{policy}}`."
+  paragraphSpacingTooSmall: "Paragraph spacing `{{value}}` ({{resolved}}em) is below the minimum `{{min}}em` ({{minMultiplier}}\xD7 font-size) for policy `{{policy}}`."
 };
-var INTERACTIVE_SELECTORS = /button|input|select|textarea|\[role=/i;
 var cssPolicySpacing = defineAnalysisRule({
   id: "css-policy-spacing",
   severity: "warn",
@@ -12679,28 +12741,6 @@ var cssPolicySpacing = defineAnalysisRule({
           ));
         }
       }
-      for (const prop of ["height", "min-height"]) {
-        const decls = tree.declarationsByProperty.get(prop);
-        if (!decls) continue;
-        for (let i = 0; i < decls.length; i++) {
-          const d = decls[i];
-          if (!d) continue;
-          const rule = d.rule;
-          if (!rule) continue;
-          if (!INTERACTIVE_SELECTORS.test(rule.selectorText)) continue;
-          const px = parsePxValue(d.value);
-          if (px === null || px >= policy.minButtonHeight) continue;
-          emit(createCSSDiagnostic(
-            d.file.path,
-            d.startLine,
-            d.startColumn,
-            cssPolicySpacing.id,
-            "touchTargetTooSmall",
-            resolveMessage(messages57.touchTargetTooSmall, { property: prop, value: d.value.trim(), resolved: String(Math.round(px * 100) / 100), min: String(policy.minButtonHeight), policy: name }),
-            "warn"
-          ));
-        }
-      }
       for (const prop of ["margin-bottom", "margin-block-end"]) {
         const decls = tree.declarationsByProperty.get(prop);
         if (!decls) continue;