@drskillissue/ganko 0.1.22 → 0.1.24

package/dist/eslint-plugin.cjs

@@ -8559,7 +8559,7 @@ function resolveMessage(template, data) {
   }
   return result;
 }
-function createDiagnosticFromLoc(file, loc, rule, messageId, message, severity, fix) {
+function createDiagnosticFromLoc(file, loc, rule, messageId, message, severity, fix, suggest) {
   const result = {
     file,
     rule,
@@ -8569,13 +8569,14 @@ function createDiagnosticFromLoc(file, loc, rule, messageId, message, severity,
     loc: firstLine(loc)
   };
   if (fix !== void 0) result.fix = fix;
+  if (suggest !== void 0 && suggest.length > 0) result.suggest = suggest;
   return result;
 }
-function createDiagnosticFromComment(file, comment, rule, messageId, message, severity, fix) {
-  return createDiagnosticFromLoc(file, comment.loc, rule, messageId, message, severity, fix);
+function createDiagnosticFromComment(file, comment, rule, messageId, message, severity, fix, suggest) {
+  return createDiagnosticFromLoc(file, comment.loc, rule, messageId, message, severity, fix, suggest);
 }
-function createDiagnostic(file, node, rule, messageId, message, severity, fix) {
-  return createDiagnosticFromLoc(file, node.loc, rule, messageId, message, severity, fix);
+function createDiagnostic(file, node, rule, messageId, message, severity, fix, suggest) {
+  return createDiagnosticFromLoc(file, node.loc, rule, messageId, message, severity, fix, suggest);
 }
 
 // src/solid/rule.ts
@@ -11731,8 +11732,9 @@ var CONDITIONAL_MOUNT_TAGS = /* @__PURE__ */ new Set([
   "TabPanel"
 ]);
 var messages16 = {
-  loadingMismatch: "createResource '{{name}}' has no initialValue but uses manual loading checks ({{name}}.loading). Without initialValue, Suspense intercepts before your loading UI renders. Add initialValue to the options: createResource(fetcher, { initialValue: ... })",
-  conditionalSuspense: "createResource '{{name}}' has no initialValue and is rendered inside a conditional mount point ({{mountTag}}). This will trigger a distant Suspense boundary and unmount the entire subtree. Add initialValue to the options: createResource(fetcher, { initialValue: ... })"
+  loadingMismatch: "createResource '{{name}}' has no initialValue but uses {{name}}.loading for manual loading UI. Suspense intercepts before your loading UI renders \u2014 the component is unmounted before the <Show>/<Switch> evaluates. Replace createResource with onMount + createSignal to decouple from Suspense entirely.",
+  conditionalSuspense: "createResource '{{name}}' is inside a conditional mount point ({{mountTag}}) with a distant Suspense boundary. The SuspenseContext increment fires when the fetcher's Promise is pending and unmounts the entire page subtree \u2014 initialValue does NOT prevent this. Replace createResource with onMount + createSignal to avoid Suspense interaction.",
+  missingErrorBoundary: "createResource '{{name}}' has no <ErrorBoundary> between its component and the nearest <Suspense>. When the fetcher throws (network error, 401/403/503, timeout), the error propagates to Suspense which has no error handling \u2014 the boundary breaks permanently. Wrap the component in <ErrorBoundary> or replace createResource with onMount + createSignal and catch errors in the fetcher."
 };
 var options16 = {};
 function hasInitialValue(call) {
@@ -11775,35 +11777,95 @@ function hasLoadingRead(resourceVariable) {
   }
   return false;
 }
-function findConditionalMountAncestor(graph, componentName) {
+function resolveFetcherFunction(graph, call) {
+  const args = call.node.arguments;
+  if (args.length === 0) return null;
+  let fetcherNode;
+  if (args.length === 1) {
+    fetcherNode = args[0];
+  } else if (args.length === 2) {
+    const lastArg = args[1];
+    fetcherNode = lastArg && lastArg.type === "ObjectExpression" ? args[0] : args[1];
+  } else {
+    fetcherNode = args[1];
+  }
+  if (!fetcherNode) return null;
+  if (fetcherNode.type === "ArrowFunctionExpression" || fetcherNode.type === "FunctionExpression") {
+    return graph.functionsByNode.get(fetcherNode) ?? null;
+  }
+  if (fetcherNode.type === "Identifier") {
+    const fns = graph.functionsByName.get(fetcherNode.name);
+    if (fns && fns.length > 0) {
+      const fn = fns[0];
+      if (fn) return fn;
+    }
+  }
+  return null;
+}
+function fetcherCanThrow(graph, fn, visited) {
+  if (visited.has(fn.id)) return false;
+  visited.add(fn.id);
+  if (fn.async && fn.awaitRanges.length > 0) return true;
+  if (fn.hasThrowStatement) return true;
+  const callSites = fn.callSites;
+  for (let i = 0, len = callSites.length; i < len; i++) {
+    const callSite = callSites[i];
+    if (!callSite) continue;
+    if (!callSite.resolvedTarget) return true;
+    if (fetcherCanThrow(graph, callSite.resolvedTarget, visited)) return true;
+  }
+  return false;
+}
+function analyzeComponentBoundaries(graph, componentName) {
+  const result = {
+    conditionalMountTag: null,
+    suspenseDistance: 0,
+    lacksErrorBoundary: false,
+    usagesLackingErrorBoundary: []
+  };
   const usages = graph.jsxByTag.get(componentName) ?? [];
+  if (usages.length === 0) return result;
   for (let i = 0, len = usages.length; i < len; i++) {
     const usage = usages[i];
     if (!usage) continue;
     let current = usage.parent;
     let conditionalTag = null;
     let componentLevels = 0;
+    let foundErrorBoundary = false;
+    let foundSuspense = false;
     while (current) {
       const tag = current.tag;
       if (tag && !current.isDomElement) {
         componentLevels++;
-        if (tag === "Suspense") {
+        if (tag === "ErrorBoundary") {
+          foundErrorBoundary = true;
+        } else if (tag === "Suspense") {
+          foundSuspense = true;
+          if (!foundErrorBoundary) {
+            result.lacksErrorBoundary = true;
+            result.usagesLackingErrorBoundary.push(usage);
+          }
           if (conditionalTag !== null && componentLevels > 1) {
-            return { tag: conditionalTag, suspenseDistance: componentLevels };
+            result.conditionalMountTag = conditionalTag;
+            result.suspenseDistance = componentLevels;
           }
-          return null;
-        }
-        if (conditionalTag === null && CONDITIONAL_MOUNT_TAGS.has(tag)) {
+          break;
+        } else if (conditionalTag === null && CONDITIONAL_MOUNT_TAGS.has(tag)) {
           conditionalTag = tag;
         }
       }
       current = current.parent;
     }
-    if (conditionalTag !== null) {
-      return { tag: conditionalTag, suspenseDistance: componentLevels };
+    if (!foundSuspense && !foundErrorBoundary) {
+      result.lacksErrorBoundary = true;
+      result.usagesLackingErrorBoundary.push(usage);
+      if (conditionalTag !== null) {
+        result.conditionalMountTag = conditionalTag;
+        result.suspenseDistance = componentLevels;
+      }
     }
   }
-  return null;
+  return result;
 }
 function getContainingComponentName(graph, call) {
   const selfComponent = graph.componentScopes.get(call.scope);
@@ -11820,43 +11882,65 @@ function findResourceVariable(graph, name) {
   }
   return null;
 }
+function buildErrorBoundaryFix(usages, graph) {
+  if (usages.length === 0) return null;
+  const usage = usages[0];
+  if (!usage) return null;
+  const jsxNode = usage.node;
+  const startPos = jsxNode.range[0];
+  const endPos = jsxNode.range[1];
+  const ops = [
+    { range: [startPos, startPos], text: "<ErrorBoundary fallback={<div>Error</div>}>" },
+    { range: [endPos, endPos], text: "</ErrorBoundary>" }
+  ];
+  const importFix = buildSolidImportFix(graph, "ErrorBoundary");
+  if (importFix) ops.unshift(importFix);
+  return ops;
+}
 var resourceImplicitSuspense = defineSolidRule({
   id: "resource-implicit-suspense",
   severity: "warn",
   messages: messages16,
   meta: {
-    description: "Detect createResource without initialValue that implicitly triggers Suspense boundaries.",
-    fixable: false,
+    description: "Detect createResource that implicitly triggers or permanently breaks Suspense boundaries.",
+    fixable: true,
     category: "reactivity"
   },
   options: options16,
   check(graph, emit) {
     const resourceCalls = getCallsByPrimitive(graph, "createResource");
     if (resourceCalls.length === 0) return;
+    const throwVisited = /* @__PURE__ */ new Set();
+    const boundaryCache = /* @__PURE__ */ new Map();
     for (let i = 0, len = resourceCalls.length; i < len; i++) {
       const call = resourceCalls[i];
       if (!call) continue;
-      if (hasInitialValue(call)) continue;
       const resourceName = getResourceVariableName(call);
       if (!resourceName) continue;
-      const resourceVariable = findResourceVariable(graph, resourceName);
-      if (resourceVariable && hasLoadingRead(resourceVariable)) {
-        emit(
-          createDiagnostic(
-            graph.file,
-            call.node,
-            "resource-implicit-suspense",
-            "loadingMismatch",
-            resolveMessage(messages16.loadingMismatch, { name: resourceName }),
-            "warn"
-          )
-        );
-        continue;
-      }
+      const hasInitial = hasInitialValue(call);
       const componentName = getContainingComponentName(graph, call);
+      if (!hasInitial) {
+        const resourceVariable = findResourceVariable(graph, resourceName);
+        if (resourceVariable && hasLoadingRead(resourceVariable)) {
+          emit(
+            createDiagnostic(
+              graph.file,
+              call.node,
+              "resource-implicit-suspense",
+              "loadingMismatch",
+              resolveMessage(messages16.loadingMismatch, { name: resourceName }),
+              "warn"
+            )
+          );
+        }
+      }
       if (!componentName) continue;
-      const conditional = findConditionalMountAncestor(graph, componentName);
-      if (conditional) {
+      let analysis = boundaryCache.get(componentName);
+      if (!analysis) {
+        analysis = analyzeComponentBoundaries(graph, componentName);
+        boundaryCache.set(componentName, analysis);
+      }
+      if (analysis.conditionalMountTag) {
         emit(
           createDiagnostic(
             graph.file,
@@ -11865,12 +11949,32 @@ var resourceImplicitSuspense = defineSolidRule({
             "conditionalSuspense",
             resolveMessage(messages16.conditionalSuspense, {
               name: resourceName,
-              mountTag: conditional.tag
+              mountTag: analysis.conditionalMountTag
             }),
             "error"
           )
         );
       }
+      if (analysis.lacksErrorBoundary) {
+        const fetcherFn = resolveFetcherFunction(graph, call);
+        if (fetcherFn && fetcherCanThrow(graph, fetcherFn, throwVisited)) {
+          const errorBoundaryFix = buildErrorBoundaryFix(
+            analysis.usagesLackingErrorBoundary,
+            graph
+          );
+          emit(
+            createDiagnostic(
+              graph.file,
+              call.node,
+              "resource-implicit-suspense",
+              "missingErrorBoundary",
+              resolveMessage(messages16.missingErrorBoundary, { name: resourceName }),
+              "error",
+              errorBoundaryFix ?? void 0
+            )
+          );
+        }
+      }
     }
   }
 });
@@ -29369,6 +29473,11 @@ function toLayoutElementKey(solidFile, elementId) {
   return `${solidFile}::${elementId}`;
 }
 
+// src/cross-file/layout/context-model.ts
+function deriveAlignmentContext(base, overrides) {
+  return { ...base, ...overrides };
+}
+
 // src/cross-file/layout/signal-model.ts
 var layoutSignalNames = [
   "line-height",
@@ -29397,6 +29506,8 @@ var layoutSignalNames = [
   "justify-items",
   "place-items",
   "place-self",
+  "flex-direction",
+  "grid-auto-flow",
   "appearance",
   "box-sizing",
   "padding-top",
@@ -29515,13 +29626,44 @@ function expandShorthand(property, value2) {
       { name: blockTarget[1], value: parsed.end }
     ];
   }
+  if (property === "flex-flow") {
+    return expandFlexFlow(value2);
+  }
   return void 0;
 }
+var FLEX_DIRECTION_VALUES = /* @__PURE__ */ new Set(["row", "row-reverse", "column", "column-reverse"]);
+function expandFlexFlow(value2) {
+  const tokens = splitWhitespaceTokens(value2.trim().toLowerCase());
+  if (tokens.length === 0) return null;
+  if (tokens.length > 2) return null;
+  let direction = null;
+  let wrap = null;
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (!token) continue;
+    if (FLEX_DIRECTION_VALUES.has(token)) {
+      if (direction !== null) return null;
+      direction = token;
+    } else {
+      if (wrap !== null) return null;
+      wrap = token;
+    }
+  }
+  const out = [];
+  if (direction !== null) {
+    out.push({ name: "flex-direction", value: direction });
+  }
+  if (wrap !== null) {
+    out.push({ name: "flex-wrap", value: wrap });
+  }
+  return out.length > 0 ? out : null;
+}
 function getShorthandLonghandNames(property) {
   const quad = QUAD_EXPANSIONS.get(property);
   if (quad !== void 0) return [...quad];
   const block = BLOCK_EXPANSIONS.get(property);
   if (block !== void 0) return [...block];
+  if (property === "flex-flow") return ["flex-direction", "flex-wrap"];
   return null;
 }
 
@@ -29532,27 +29674,90 @@ var CONTROL_ELEMENT_TAGS = /* @__PURE__ */ new Set([
   "textarea",
   "button"
 ]);
+var INTRINSIC_REPLACED_TAGS = /* @__PURE__ */ new Set([
+  "img",
+  "svg",
+  "video",
+  "canvas",
+  "iframe",
+  "object",
+  "embed"
+]);
+var WHITESPACE_RE3 = /\s+/;
 function clamp(value2, min, max) {
   if (value2 < min) return min;
   if (value2 > max) return max;
   return value2;
 }
-function kindRank(kind) {
-  if (kind === "exact") return 0;
-  if (kind === "interval") return 1;
-  if (kind === "conditional") return 2;
-  return 3;
-}
 function mergeEvidenceKind(left, right) {
-  if (kindRank(left) >= kindRank(right)) return left;
-  return right;
+  return left > right ? left : right;
+}
+function selectKth(values, targetIndex) {
+  let left = 0;
+  let right = values.length - 1;
+  while (left <= right) {
+    if (left === right) {
+      const result = values[left];
+      if (result === void 0) return 0;
+      return result;
+    }
+    const pivotIndex = choosePivotIndex(values, left, right);
+    const partitionIndex = partitionAroundPivot(values, left, right, pivotIndex);
+    if (partitionIndex === targetIndex) {
+      const result = values[partitionIndex];
+      if (result === void 0) return 0;
+      return result;
+    }
+    if (partitionIndex < targetIndex) {
+      left = partitionIndex + 1;
+      continue;
+    }
+    right = partitionIndex - 1;
+  }
+  const fallback = values[targetIndex];
+  if (fallback === void 0) return 0;
+  return fallback;
+}
+function choosePivotIndex(values, left, right) {
+  const middle = Math.floor((left + right) / 2);
+  const leftValue = values[left] ?? 0;
+  const middleValue = values[middle] ?? 0;
+  const rightValue = values[right] ?? 0;
+  if (leftValue < middleValue) {
+    if (middleValue < rightValue) return middle;
+    if (leftValue < rightValue) return right;
+    return left;
+  }
+  if (leftValue < rightValue) return left;
+  if (middleValue < rightValue) return right;
+  return middle;
+}
+function partitionAroundPivot(values, left, right, pivotIndex) {
+  const pivotValue = values[pivotIndex] ?? 0;
+  swap(values, pivotIndex, right);
+  let storeIndex = left;
+  for (let i = left; i < right; i++) {
+    const current = values[i];
+    if (current === void 0 || current > pivotValue) continue;
+    swap(values, storeIndex, i);
+    storeIndex++;
+  }
+  swap(values, storeIndex, right);
+  return storeIndex;
+}
+function swap(values, left, right) {
+  if (left === right) return;
+  const leftValue = values[left] ?? 0;
+  const rightValue = values[right] ?? 0;
+  values[left] = rightValue;
+  values[right] = leftValue;
 }
 function toComparableExactValue(value2) {
   if (value2.value !== null) {
-    if (value2.kind !== "exact") return null;
+    if (value2.kind !== 0 /* Exact */) return null;
     return value2.value;
   }
-  if (value2.kind === "exact") return 0;
+  if (value2.kind === 0 /* Exact */) return 0;
   return null;
 }
 
@@ -29566,7 +29771,8 @@ var MONITORED_SHORTHAND_SET = /* @__PURE__ */ new Set([
   "border-width",
   "margin-block",
   "padding-block",
-  "inset-block"
+  "inset-block",
+  "flex-flow"
 ]);
 var LENGTH_SIGNAL_SET = /* @__PURE__ */ new Set([
   "font-size",
@@ -29608,13 +29814,22 @@ var KEYWORD_SIGNAL_SET = /* @__PURE__ */ new Set([
   "justify-items",
   "place-items",
   "place-self",
+  "flex-direction",
+  "grid-auto-flow",
   "appearance",
   "box-sizing",
   "position",
   "writing-mode",
   "direction"
 ]);
-var REPLACED_TAGS = /* @__PURE__ */ new Set(["input", "select", "textarea", "button", "img", "video", "canvas", "svg", "iframe"]);
+var REPLACED_ELEMENT_TAGS = /* @__PURE__ */ new Set([
+  ...CONTROL_ELEMENT_TAGS,
+  "img",
+  "video",
+  "canvas",
+  "svg",
+  "iframe"
+]);
 function isMonitoredSignal(property) {
   if (MONITORED_SIGNAL_SET.has(property)) return true;
   return MONITORED_SHORTHAND_SET.has(property);
@@ -29625,7 +29840,7 @@ function isControlTag(tag) {
 }
 function isReplacedTag(tag) {
   if (tag === null) return false;
-  return REPLACED_TAGS.has(tag.toLowerCase());
+  return REPLACED_ELEMENT_TAGS.has(tag.toLowerCase());
 }
 function normalizeSignalMapWithCounts(values) {
   const out = /* @__PURE__ */ new Map();
@@ -29636,12 +29851,11 @@ function normalizeSignalMapWithCounts(values) {
       "font-size",
       fontSizeEntry.value,
       fontSizeEntry.source,
-      fontSizeEntry.guard,
       fontSizeEntry.guardProvenance,
       null
     );
     out.set("font-size", parsedFontSize);
-    if (parsedFontSize.kind === "known" && parsedFontSize.guard === "unconditional") {
+    if (parsedFontSize.kind === "known" && parsedFontSize.guard.kind === 0 /* Unconditional */) {
       fontSizePx = parsedFontSize.px;
     }
   }
@@ -29657,7 +29871,6 @@ function normalizeSignalMapWithCounts(values) {
       name,
       declaration.value,
       declaration.source,
-      declaration.guard,
       declaration.guardProvenance,
       fontSizePx
     );
@@ -29667,7 +29880,7 @@ function normalizeSignalMapWithCounts(values) {
   let unknownSignalCount = 0;
   let conditionalSignalCount = 0;
   for (const value2 of out.values()) {
-    if (value2.guard === "conditional") {
+    if (value2.guard.kind === 1 /* Conditional */) {
       conditionalSignalCount++;
       continue;
     }
@@ -29695,7 +29908,7 @@ function applyExpandedShorthand(out, property, declaration, fontSizePx) {
       if (!longhand) continue;
       const name = MONITORED_SIGNAL_NAME_MAP.get(longhand);
       if (name === void 0) continue;
-      out.set(name, createUnknown(name, declaration.value, declaration.source, declaration.guard, declaration.guardProvenance, reason));
+      out.set(name, createUnknown(name, declaration.source, declaration.guardProvenance, reason));
     }
     return;
   }
@@ -29705,127 +29918,139 @@ function applyExpandedShorthand(out, property, declaration, fontSizePx) {
     if (!entry) continue;
     const name = MONITORED_SIGNAL_NAME_MAP.get(entry.name);
     if (name === void 0) continue;
-    out.set(name, normalizeSignal(name, entry.value, declaration.source, declaration.guard, declaration.guardProvenance, fontSizePx));
+    out.set(name, normalizeSignal(name, entry.value, declaration.source, declaration.guardProvenance, fontSizePx));
   }
 }
 function toMonitoredSignalName(property) {
   return MONITORED_SIGNAL_NAME_MAP.get(property) ?? null;
 }
-function normalizeSignal(name, raw, source, guard, guardProvenance, fontSizePx) {
+function normalizeSignal(name, raw, source, guard, fontSizePx) {
   switch (name) {
     case "line-height":
-      return parseLineHeight(name, raw, source, guard, guardProvenance, fontSizePx);
+      return parseLineHeight(name, raw, source, guard, fontSizePx);
     case "aspect-ratio":
-      return parseAspectRatio(name, raw, source, guard, guardProvenance);
+      return parseAspectRatio(name, raw, source, guard);
     case "contain-intrinsic-size":
-      return parseContainIntrinsicSize(name, raw, source, guard, guardProvenance);
+      return parseContainIntrinsicSize(name, raw, source, guard);
     case "transform":
-      return parseTransform(name, raw, source, guard, guardProvenance);
+      return parseTransform(name, raw, source, guard);
     case "translate":
-      return parseTranslateProperty(name, raw, source, guard, guardProvenance);
+      return parseTranslateProperty(name, raw, source, guard);
     default:
       break;
   }
-  if (LENGTH_SIGNAL_SET.has(name)) return parseLength(name, raw, source, guard, guardProvenance);
-  if (KEYWORD_SIGNAL_SET.has(name)) return parseKeyword(name, raw, source, guard, guardProvenance);
-  return createUnknown(name, raw, source, guard, guardProvenance, "unsupported signal");
+  if (LENGTH_SIGNAL_SET.has(name)) return parseLength(name, raw, source, guard);
+  if (KEYWORD_SIGNAL_SET.has(name)) return parseKeyword(name, raw, source, guard);
+  return createUnknown(name, source, guard, "unsupported signal");
 }
-function parseAspectRatio(name, raw, source, guard, guardProvenance) {
+function parseAspectRatio(name, raw, source, guard) {
   const trimmed = raw.trim().toLowerCase();
   if (trimmed.length === 0) {
-    return createUnknown(name, raw, source, guard, guardProvenance, "aspect-ratio value is empty");
+    return createUnknown(name, source, guard, "aspect-ratio value is empty");
   }
   if (hasDynamicExpression(trimmed)) {
-    return createUnknown(name, raw, source, guard, guardProvenance, "aspect-ratio uses runtime-dependent function");
+    return createUnknown(name, source, guard, "aspect-ratio uses runtime-dependent function");
   }
   if (trimmed === "auto") {
-    return createUnknown(name, raw, source, guard, guardProvenance, "aspect-ratio auto does not reserve ratio");
+    return createUnknown(name, source, guard, "aspect-ratio auto does not reserve ratio");
   }
   const slash = trimmed.indexOf("/");
   if (slash !== -1) {
     const left = Number(trimmed.slice(0, slash).trim());
     const right = Number(trimmed.slice(slash + 1).trim());
     if (!Number.isFinite(left) || !Number.isFinite(right) || left <= 0 || right <= 0) {
-      return createUnknown(name, raw, source, guard, guardProvenance, "aspect-ratio ratio is invalid");
+      return createUnknown(name, source, guard, "aspect-ratio ratio is invalid");
     }
-    return createKnown(name, raw, source, guard, guardProvenance, null, "unitless", "exact");
+    return createKnown(name, raw, source, guard, null, 1 /* Unitless */, "exact");
   }
   const ratio = Number(trimmed);
   if (!Number.isFinite(ratio) || ratio <= 0) {
-    return createUnknown(name, raw, source, guard, guardProvenance, "aspect-ratio is not statically parseable");
+    return createUnknown(name, source, guard, "aspect-ratio is not statically parseable");
   }
-  return createKnown(name, raw, source, guard, guardProvenance, null, "unitless", "exact");
+  return createKnown(name, raw, source, guard, null, 1 /* Unitless */, "exact");
 }
-function parseContainIntrinsicSize(name, raw, source, guard, guardProvenance) {
+function parseContainIntrinsicSize(name, raw, source, guard) {
   const trimmed = raw.trim().toLowerCase();
   if (trimmed.length === 0) {
-    return createUnknown(name, raw, source, guard, guardProvenance, "contain-intrinsic-size value is empty");
+    return createUnknown(name, source, guard, "contain-intrinsic-size value is empty");
   }
   if (hasDynamicExpression(trimmed)) {
-    return createUnknown(name, raw, source, guard, guardProvenance, "contain-intrinsic-size uses runtime-dependent function");
+    return createUnknown(name, source, guard, "contain-intrinsic-size uses runtime-dependent function");
   }
   if (trimmed === "none" || trimmed === "auto") {
-    return createUnknown(name, raw, source, guard, guardProvenance, "contain-intrinsic-size does not reserve space");
+    return createUnknown(name, source, guard, "contain-intrinsic-size does not reserve space");
   }
   const parts = splitWhitespaceTokens(trimmed);
   for (let i = 0; i < parts.length; i++) {
     const part = parts[i];
     if (!part) continue;
     const px = parseSignedPxValue(part);
-    if (px !== null) return createKnown(name, raw, source, guard, guardProvenance, px, "px", "exact");
+    if (px !== null) return createKnown(name, raw, source, guard, px, 0 /* Px */, "exact");
   }
-  return createUnknown(name, raw, source, guard, guardProvenance, "contain-intrinsic-size is not statically parseable in px");
+  return createUnknown(name, source, guard, "contain-intrinsic-size is not statically parseable in px");
 }
-function parseLineHeight(name, raw, source, guard, guardProvenance, fontSizePx) {
+function parseLineHeight(name, raw, source, guard, fontSizePx) {
   const unitless = parseUnitlessValue(raw);
   if (unitless !== null) {
     const base = fontSizePx === null ? 16 : fontSizePx;
-    return createKnown(name, raw, source, guard, guardProvenance, unitless * base, "unitless", "estimated");
+    return createKnown(name, raw, source, guard, unitless * base, 1 /* Unitless */, "estimated");
   }
   const px = parseSignedPxValue(raw);
-  if (px !== null) return createKnown(name, raw, source, guard, guardProvenance, px, "px", "exact");
-  return createUnknown(name, raw, source, guard, guardProvenance, "line-height is not statically parseable");
+  if (px !== null) return createKnown(name, raw, source, guard, px, 0 /* Px */, "exact");
+  return createUnknown(name, source, guard, "line-height is not statically parseable");
 }
-function parseLength(name, raw, source, guard, guardProvenance) {
+var DIMENSION_KEYWORD_SET = /* @__PURE__ */ new Set([
+  "auto",
+  "none",
+  "fit-content",
+  "min-content",
+  "max-content",
+  "stretch"
+]);
+function parseLength(name, raw, source, guard) {
   const px = parseSignedPxValue(raw);
-  if (px === null) {
-    return createUnknown(name, raw, source, guard, guardProvenance, "length is not statically parseable in px");
+  if (px !== null) {
+    return createKnown(name, raw, source, guard, px, 0 /* Px */, "exact");
+  }
+  const normalized = raw.trim().toLowerCase();
+  if (DIMENSION_KEYWORD_SET.has(normalized) || normalized.startsWith("fit-content(")) {
+    return createKnown(name, raw, source, guard, null, 2 /* Keyword */, "exact");
   }
-  return createKnown(name, raw, source, guard, guardProvenance, px, "px", "exact");
+  return createUnknown(name, source, guard, "length is not statically parseable in px");
 }
-function parseKeyword(name, raw, source, guard, guardProvenance) {
+function parseKeyword(name, raw, source, guard) {
   const normalized = raw.trim().toLowerCase();
   if (normalized.length === 0) {
-    return createUnknown(name, raw, source, guard, guardProvenance, "keyword value is empty");
+    return createUnknown(name, source, guard, "keyword value is empty");
   }
   if (hasDynamicExpression(normalized)) {
-    return createUnknown(name, raw, source, guard, guardProvenance, "keyword uses runtime-dependent function");
+    return createUnknown(name, source, guard, "keyword uses runtime-dependent function");
   }
-  return createKnown(name, raw, source, guard, guardProvenance, null, "keyword", "exact");
+  return createKnown(name, raw, source, guard, null, 2 /* Keyword */, "exact");
 }
-function parseTransform(name, raw, source, guard, guardProvenance) {
+function parseTransform(name, raw, source, guard) {
   const normalized = raw.trim().toLowerCase();
   if (normalized.length === 0) {
-    return createUnknown(name, raw, source, guard, guardProvenance, "transform value is empty");
+    return createUnknown(name, source, guard, "transform value is empty");
   }
   if (hasDynamicExpression(normalized)) {
-    return createUnknown(name, raw, source, guard, guardProvenance, "transform uses runtime-dependent function");
+    return createUnknown(name, source, guard, "transform uses runtime-dependent function");
   }
   const y = extractTransformYPx(normalized);
-  if (y !== null) return createKnown(name, raw, source, guard, guardProvenance, y, "px", "exact");
-  return createUnknown(name, raw, source, guard, guardProvenance, "transform has non-translational or non-px functions");
+  if (y !== null) return createKnown(name, raw, source, guard, y, 0 /* Px */, "exact");
+  return createUnknown(name, source, guard, "transform has non-translational or non-px functions");
 }
-function parseTranslateProperty(name, raw, source, guard, guardProvenance) {
+function parseTranslateProperty(name, raw, source, guard) {
   const trimmed = raw.trim().toLowerCase();
   if (trimmed.length === 0) {
-    return createUnknown(name, raw, source, guard, guardProvenance, "translate value is empty");
+    return createUnknown(name, source, guard, "translate value is empty");
   }
   if (hasDynamicExpression(trimmed)) {
-    return createUnknown(name, raw, source, guard, guardProvenance, "translate uses runtime-dependent function");
+    return createUnknown(name, source, guard, "translate uses runtime-dependent function");
   }
   const y = extractTranslatePropertyYPx(trimmed);
-  if (y !== null) return createKnown(name, raw, source, guard, guardProvenance, y, "px", "exact");
-  return createUnknown(name, raw, source, guard, guardProvenance, "translate property vertical component is not px");
+  if (y !== null) return createKnown(name, raw, source, guard, y, 0 /* Px */, "exact");
+  return createUnknown(name, source, guard, "translate property vertical component is not px");
 }
 function hasDynamicExpression(raw) {
   if (raw.includes("var(")) return true;
@@ -29837,28 +30062,24 @@ function hasDynamicExpression(raw) {
   if (raw.includes("clamp(")) return true;
   return false;
 }
-function createKnown(name, raw, source, guard, guardProvenance, px, unit, quality) {
+function createKnown(name, raw, source, guard, px, unit, quality) {
   return {
     kind: "known",
     name,
-    raw,
     normalized: raw.trim().toLowerCase(),
     source,
     guard,
-    guardProvenance,
     unit,
     px,
     quality
   };
 }
-function createUnknown(name, raw, source, guard, guardProvenance, reason) {
+function createUnknown(name, source, guard, reason) {
   return {
     kind: "unknown",
     name,
-    raw,
     source,
     guard,
-    guardProvenance,
     reason
   };
 }
@@ -29905,13 +30126,7 @@ function buildSnapshotForNode(node, cascadeByElementNode, snapshotByElementNode,
   const unknownSignalCount = normalized.unknownSignalCount + inherited.unknownDelta;
   const conditionalSignalCount = normalized.conditionalSignalCount + inherited.conditionalDelta;
   const snapshot = {
-    solidFile: node.solidFile,
-    elementId: node.elementId,
-    elementKey: node.key,
-    tag: node.tag,
-    textualContent: node.textualContent,
-    isControl: node.isControl,
-    isReplaced: node.isReplaced,
+    node,
     signals: inherited.signals,
     knownSignalCount,
     unknownSignalCount,
@@ -29942,7 +30157,7 @@ function inheritSignalsFromParent(parentSnapshot, local) {
     if (!inheritedValue) continue;
     if (out === null) out = new Map(local);
     out.set(signal, inheritedValue);
-    if (inheritedValue.guard === "conditional") {
+    if (inheritedValue.guard.kind === 1 /* Conditional */) {
       conditionalDelta++;
       continue;
     }
@@ -29986,7 +30201,7 @@ var EMPTY_LAYOUT_RESERVED_SPACE_FACT = Object.freeze({
 });
 var EMPTY_LAYOUT_SCROLL_CONTAINER_FACT = Object.freeze({
   isScrollContainer: false,
-  axis: "none",
+  axis: 0 /* None */,
   overflow: null,
   overflowY: null,
   hasConditionalScroll: false,
@@ -30019,53 +30234,28 @@ function readKnownSignalWithGuard(snapshot, name) {
   return value2;
 }
 function toEvidenceKind(value2) {
-  if (value2.guard === "conditional") return "conditional";
-  if (value2.quality === "estimated") return "interval";
-  return "exact";
-}
-function readNumericSignalEvidence(snapshot, name) {
-  const value2 = snapshot.signals.get(name);
-  if (!value2) {
-    return {
-      value: null,
-      kind: "unknown"
-    };
-  }
-  if (value2.kind !== "known") {
-    if (value2.guard === "conditional") {
-      return {
-        value: null,
-        kind: "conditional"
-      };
-    }
-    return {
-      value: null,
-      kind: "unknown"
-    };
-  }
-  return {
-    value: value2.px,
-    kind: toEvidenceKind(value2)
-  };
+  if (value2.guard.kind === 1 /* Conditional */) return 2 /* Conditional */;
+  if (value2.quality === "estimated") return 1 /* Interval */;
+  return 0 /* Exact */;
 }
 function readNormalizedSignalEvidence(snapshot, name) {
   const value2 = snapshot.signals.get(name);
   if (!value2) {
     return {
       value: null,
-      kind: "unknown"
+      kind: 3 /* Unknown */
     };
   }
   if (value2.kind !== "known") {
-    if (value2.guard === "conditional") {
+    if (value2.guard.kind === 1 /* Conditional */) {
       return {
         value: null,
-        kind: "conditional"
+        kind: 2 /* Conditional */
       };
     }
     return {
       value: null,
-      kind: "unknown"
+      kind: 3 /* Unknown */
     };
   }
   return {
@@ -30076,7 +30266,7 @@ function readNormalizedSignalEvidence(snapshot, name) {
 function readKnownSignal(snapshot, name) {
   const value2 = readKnownSignalWithGuard(snapshot, name);
   if (!value2) return null;
-  if (value2.guard !== "unconditional") return null;
+  if (value2.guard.kind !== 0 /* Unconditional */) return null;
   return value2;
 }
 function readKnownPx(snapshot, name) {
@@ -30110,19 +30300,19 @@ function hasEffectivePosition(snapshot) {
   return position !== "static";
 }
 function readReservedSpaceFact(graph, node) {
-  return graph.reservedSpaceFactsByElementKey.get(node.key) ?? EMPTY_LAYOUT_RESERVED_SPACE_FACT;
+  return graph.reservedSpaceFactsByNode.get(node) ?? EMPTY_LAYOUT_RESERVED_SPACE_FACT;
 }
 function readScrollContainerFact(graph, node) {
-  return graph.scrollContainerFactsByElementKey.get(node.key) ?? EMPTY_LAYOUT_SCROLL_CONTAINER_FACT;
+  return graph.scrollContainerFactsByNode.get(node) ?? EMPTY_LAYOUT_SCROLL_CONTAINER_FACT;
 }
 function readFlowParticipationFact(graph, node) {
-  return graph.flowParticipationFactsByElementKey.get(node.key) ?? EMPTY_LAYOUT_FLOW_PARTICIPATION_FACT;
+  return graph.flowParticipationFactsByNode.get(node) ?? EMPTY_LAYOUT_FLOW_PARTICIPATION_FACT;
 }
 function readContainingBlockFact(graph, node) {
-  return graph.containingBlockFactsByElementKey.get(node.key) ?? EMPTY_LAYOUT_CONTAINING_BLOCK_FACT;
+  return graph.containingBlockFactsByNode.get(node) ?? EMPTY_LAYOUT_CONTAINING_BLOCK_FACT;
 }
 function readConditionalSignalDeltaFact(graph, node, name) {
-  const byProperty = graph.conditionalSignalDeltaFactsByElementKey.get(node.key);
+  const byProperty = graph.conditionalSignalDeltaFactsByNode.get(node);
   if (!byProperty) return EMPTY_LAYOUT_CONDITIONAL_DELTA_FACT;
   return byProperty.get(name) ?? EMPTY_LAYOUT_CONDITIONAL_DELTA_FACT;
 }
@@ -30150,7 +30340,7 @@ function readScrollContainerElements(graph) {
   return graph.scrollContainerElements;
 }
 function readBaselineOffsetFacts(graph, node) {
-  return graph.baselineOffsetFactsByElementKey.get(node.key) ?? EMPTY_BASELINE_FACTS;
+  return graph.baselineOffsetFactsByNode.get(node) ?? EMPTY_BASELINE_FACTS;
 }
 function readElementRef(graph, node) {
   return readElementRefById(graph, node.solidFile, node.elementId);
@@ -30172,7 +30362,6 @@ function readStatefulBaseValueIndex(graph) {
 }
 
 // src/cross-file/layout/context-classification.ts
-var WHITESPACE_RE3 = /\s+/;
 var TABLE_SEMANTIC_TAGS = /* @__PURE__ */ new Set(["table", "thead", "tbody", "tfoot", "tr", "td", "th"]);
 var TABLE_DISPLAY_VALUES = /* @__PURE__ */ new Set([
   "table",
@@ -30189,7 +30378,6 @@ var TABLE_DISPLAY_VALUES = /* @__PURE__ */ new Set([
 var FLEX_DISPLAY_VALUES = /* @__PURE__ */ new Set(["flex", "inline-flex"]);
 var GRID_DISPLAY_VALUES = /* @__PURE__ */ new Set(["grid", "inline-grid"]);
 var INLINE_DISPLAY_VALUES = /* @__PURE__ */ new Set(["inline", "inline-block", "inline-list-item"]);
-var DISPLAY_TOKEN_SPLIT_RE = /\s+/;
 function createAlignmentContextForParent(parent, snapshot) {
   const axis = resolveAxis(snapshot);
   const inlineDirection = resolveInlineDirection(snapshot);
@@ -30212,6 +30400,7 @@ function createAlignmentContextForParent(parent, snapshot) {
   const contextCertainty = combineCertainty(classified.certainty, axis.certainty);
   const certainty = combineCertainty(contextCertainty, inlineDirection.certainty);
   const baselineRelevance = computeBaselineRelevance(classified.kind, parentAlignItems, parentPlaceItems);
+  const crossAxisInfo = resolveCrossAxisIsBlockAxis(classified.kind, snapshot, axis.value);
   const out = {
     kind: classified.kind,
     certainty,
@@ -30227,6 +30416,8 @@ function createAlignmentContextForParent(parent, snapshot) {
     parentAlignItems,
     parentPlaceItems,
     hasPositionedOffset: positionedOffset.hasPositionedOffset,
+    crossAxisIsBlockAxis: crossAxisInfo.value,
+    crossAxisIsBlockAxisCertainty: crossAxisInfo.certainty,
     baselineRelevance,
     evidence
   };
@@ -30236,7 +30427,7 @@ function classifyKind(evidence) {
   if (evidence.hasTableSemantics) {
     return {
       kind: "table-cell",
-      certainty: "resolved"
+      certainty: 0 /* Resolved */
     };
   }
   if (evidence.containerKind === "table") {
@@ -30323,7 +30514,7 @@ function resolveContainerKind(parentDisplay, certainty) {
       certainty
     };
   }
-  const tokens = display.split(DISPLAY_TOKEN_SPLIT_RE);
+  const tokens = display.split(WHITESPACE_RE3);
   if (tokens.length === 2) {
     const outside = tokens[0];
     const inside = tokens[1];
@@ -30373,7 +30564,7 @@ function resolveAxis(snapshot) {
   if (!snapshot.signals.has("writing-mode")) {
     return {
       value: "horizontal-tb",
-      certainty: "resolved"
+      certainty: 0 /* Resolved */
     };
   }
   const writingMode = readNormalizedSignalEvidence(snapshot, "writing-mode");
@@ -30398,7 +30589,7 @@ function resolveInlineDirection(snapshot) {
   if (!snapshot.signals.has("direction")) {
     return {
       value: "ltr",
-      certainty: "resolved"
+      certainty: 0 /* Resolved */
     };
   }
   const direction = readNormalizedSignalEvidence(snapshot, "direction");
@@ -30414,16 +30605,16 @@ function resolveInlineDirection(snapshot) {
   };
 }
 function toContextCertainty(kind) {
-  if (kind === "exact") return "resolved";
-  if (kind === "interval" || kind === "conditional") return "conditional";
-  return "unknown";
+  if (kind === 0 /* Exact */) return 0 /* Resolved */;
+  if (kind === 1 /* Interval */ || kind === 2 /* Conditional */) return 1 /* Conditional */;
+  return 2 /* Unknown */;
 }
 function resolvePositionedOffset(snapshot) {
   const position = readKnownSignalWithGuard(snapshot, "position");
   if (!position) {
     return {
       hasPositionedOffset: false,
-      certainty: "unknown"
+      certainty: 2 /* Unknown */
     };
   }
   const certainty = resolveSignalCertainty(position);
@@ -30438,15 +30629,33 @@ function resolvePositionedOffset(snapshot) {
     certainty
   };
 }
+var FLEX_ROW_VALUES = /* @__PURE__ */ new Set(["row", "row-reverse"]);
+function resolveCrossAxisIsBlockAxis(kind, snapshot, _axis) {
+  if (kind !== "flex-cross-axis" && kind !== "grid-cross-axis") {
+    return { value: true, certainty: 0 /* Resolved */ };
+  }
+  if (kind === "flex-cross-axis") {
+    const signal2 = readKnownSignalWithGuard(snapshot, "flex-direction");
+    if (!signal2) {
+      return { value: true, certainty: 0 /* Resolved */ };
+    }
+    const certainty2 = resolveSignalCertainty(signal2);
+    return { value: FLEX_ROW_VALUES.has(signal2.normalized), certainty: certainty2 };
+  }
+  const signal = readKnownSignalWithGuard(snapshot, "grid-auto-flow");
+  if (!signal) {
+    return { value: true, certainty: 0 /* Resolved */ };
+  }
+  const certainty = resolveSignalCertainty(signal);
+  return { value: !signal.normalized.startsWith("column"), certainty };
+}
 function resolveSignalCertainty(value2) {
-  if (!value2) return "unknown";
-  if (value2.guard === "conditional") return "conditional";
-  return "resolved";
+  if (!value2) return 2 /* Unknown */;
+  if (value2.guard.kind === 1 /* Conditional */) return 1 /* Conditional */;
+  return 0 /* Resolved */;
 }
 function combineCertainty(left, right) {
-  if (left === "unknown" || right === "unknown") return "unknown";
-  if (left === "conditional" || right === "conditional") return "conditional";
-  return "resolved";
+  return left > right ? left : right;
 }
 var FLEX_GRID_GEOMETRIC_ALIGN_ITEMS = /* @__PURE__ */ new Set([
   "center",
@@ -30485,24 +30694,7 @@ function finalizeTableCellBaselineRelevance(contextByParentNode, cohortVerticalA
     if (context.kind !== "table-cell") continue;
     if (consensusValue === null) continue;
     if (!TABLE_CELL_GEOMETRIC_VERTICAL_ALIGN.has(consensusValue)) continue;
-    contextByParentNode.set(parent, {
-      kind: context.kind,
-      certainty: context.certainty,
-      parentSolidFile: context.parentSolidFile,
-      parentElementId: context.parentElementId,
-      parentElementKey: context.parentElementKey,
-      parentTag: context.parentTag,
-      axis: context.axis,
-      axisCertainty: context.axisCertainty,
-      inlineDirection: context.inlineDirection,
-      inlineDirectionCertainty: context.inlineDirectionCertainty,
-      parentDisplay: context.parentDisplay,
-      parentAlignItems: context.parentAlignItems,
-      parentPlaceItems: context.parentPlaceItems,
-      hasPositionedOffset: context.hasPositionedOffset,
-      baselineRelevance: "irrelevant",
-      evidence: context.evidence
-    });
+    contextByParentNode.set(parent, deriveAlignmentContext(context, { baselineRelevance: "irrelevant" }));
   }
 }
 
@@ -31049,6 +31241,20 @@ function collectTransitiveCSSScope(entryPath, resolver, cssFilesByNormalizedPath
 }
 
 // src/cross-file/layout/perf.ts
+function createReservoir(capacity) {
+  return { buffer: [], count: 0, capacity };
+}
+function reservoirPush(r, value2) {
+  r.count++;
+  if (r.buffer.length < r.capacity) {
+    r.buffer.push(value2);
+    return;
+  }
+  const j = Math.floor(Math.random() * r.count);
+  if (j < r.capacity) {
+    r.buffer[j] = value2;
+  }
+}
 var EMPTY_STATS = {
   elementsScanned: 0,
   selectorCandidatesChecked: 0,
@@ -31105,7 +31311,7 @@ function createLayoutPerfStats() {
     cohortUnimodalFalse: 0,
     factorCoverageSum: 0,
     factorCoverageCount: 0,
-    posteriorWidths: [],
+    posteriorWidths: createReservoir(200),
     uncertaintyEscalations: 0,
     signalSnapshotsBuilt: 0,
     signalSnapshotCacheHits: 0,
@@ -31170,14 +31376,12 @@ function maybeLogLayoutPerf(stats, log) {
     `[layout] elements=${view.elementsScanned} candidates=${view.selectorCandidatesChecked} compiledSelectors=${view.compiledSelectorCount} unsupportedSelectors=${view.selectorsRejectedUnsupported} conditionalSelectors=${view.selectorsGuardedConditional} ancestryChecks=${view.ancestryChecks} edges=${view.matchEdgesCreated} collected=${view.casesCollected} cases=${view.casesScored} rejectLowEvidence=${view.casesRejectedLowEvidence} rejectThreshold=${view.casesRejectedThreshold} rejectUndecidable=${view.casesRejectedUndecidable} rejectIdentifiability=${view.casesRejectedIdentifiability} undecidableInterval=${view.undecidableInterval} conditionalSignalRatio=${Math.round(view.conditionalSignalRatio * 1e3) / 1e3} conditionalSignals=${view.conditionalSignals} totalSignals=${view.totalSignals} cohortUnimodalFalse=${view.cohortUnimodalFalse} factorCoverageMean=${Math.round(view.factorCoverageMean * 1e3) / 1e3} posteriorWidthP95=${Math.round(view.posteriorWidthP95 * 1e3) / 1e3} uncertaintyEscalations=${view.uncertaintyEscalations} snapshots=${view.signalSnapshotsBuilt} snapshotHits=${view.signalSnapshotCacheHits} measurementIndexHits=${view.measurementIndexHits} contexts=${view.contextsClassified} diagnostics=${view.diagnosticsEmitted} selectorIndexMs=${Math.round(view.selectorIndexMs * 100) / 100} selectorMatchMs=${Math.round(view.selectorMatchMs * 100) / 100} cascadeBuildMs=${Math.round(view.cascadeBuildMs * 100) / 100} caseBuildMs=${Math.round(view.caseBuildMs * 100) / 100} scoringMs=${Math.round(view.scoringMs * 100) / 100} elapsedMs=${Math.round(view.elapsedMs * 100) / 100}`
   );
 }
-function computeP95(values) {
-  if (values.length === 0) return 0;
-  const sorted = [...values];
-  sorted.sort((left, right) => left - right);
-  const index = Math.ceil(sorted.length * 0.95) - 1;
-  if (index <= 0) return sorted[0] ?? 0;
-  if (index >= sorted.length) return sorted[sorted.length - 1] ?? 0;
-  return sorted[index] ?? 0;
+function computeP95(sampler) {
+  if (sampler.buffer.length === 0) return 0;
+  const scratch = [...sampler.buffer];
+  const index = Math.ceil(scratch.length * 0.95) - 1;
+  const clamped = index <= 0 ? 0 : index >= scratch.length ? scratch.length - 1 : index;
+  return selectKth(scratch, clamped);
 }
 
 // src/cross-file/layout/component-host.ts
@@ -33196,16 +33400,16 @@ function includesAttributeWord(value2, word) {
 
 // src/cross-file/layout/guard-model.ts
 var UNCONDITIONAL_GUARD = {
-  kind: "unconditional",
+  kind: 0 /* Unconditional */,
   conditions: [],
   key: "always"
 };
-var WHITESPACE_RE4 = /\s+/g;
+var WHITESPACE_RE_GLOBAL = /\s+/g;
 function resolveRuleGuard(rule) {
   const conditions = collectRuleConditions(rule);
   if (conditions.length === 0) return UNCONDITIONAL_GUARD;
   return {
-    kind: "conditional",
+    kind: 1 /* Conditional */,
     conditions,
     key: conditions.map((condition) => condition.key).join("&")
   };
@@ -33259,7 +33463,7 @@ function buildCondition(kind, query) {
 }
 function normalizeQuery(query) {
   if (query === null) return null;
-  const normalized = query.trim().toLowerCase().replace(WHITESPACE_RE4, " ");
+  const normalized = query.trim().toLowerCase().replace(WHITESPACE_RE_GLOBAL, " ");
   if (normalized.length === 0) return null;
   return normalized;
 }
@@ -33329,7 +33533,7 @@ function summarizeSignalFacts(snapshots) {
 }
 function accumulateSnapshotFacts(snapshot, sink) {
   for (const value2 of snapshot.signals.values()) {
-    if (value2.guard === "conditional") {
+    if (value2.guard.kind === 1 /* Conditional */) {
       sink.addConditional();
       continue;
     }
@@ -33523,15 +33727,6 @@ function assertUnitInterval(name, value2) {
 }
 
 // src/cross-file/layout/content-composition.ts
-var INTRINSIC_REPLACED_TAGS = /* @__PURE__ */ new Set([
-  "img",
-  "svg",
-  "video",
-  "canvas",
-  "iframe",
-  "object",
-  "embed"
-]);
 var BLOCK_FORMATTING_CONTEXT_DISPLAYS = /* @__PURE__ */ new Set([
   "block",
   "flex",
@@ -33565,7 +33760,7 @@ var VERTICAL_ALIGN_MITIGATIONS = /* @__PURE__ */ new Set([
   "text-top",
   "text-bottom"
 ]);
-function computeContentCompositionFingerprint(elementNode, childrenByParentNode, snapshotByElementNode, snapshotHotSignalsByElementKey) {
+function computeContentCompositionFingerprint(elementNode, childrenByParentNode, snapshotByElementNode, snapshotHotSignalsByNode) {
   const state = {
     hasTextContent: false,
     hasInlineReplaced: false,
@@ -33579,10 +33774,10 @@ function computeContentCompositionFingerprint(elementNode, childrenByParentNode,
     blockChildCount: 0,
     inlineChildCount: 0
   };
-  if (elementNode.textualContent === "yes" || elementNode.textualContent === "dynamic-text") {
+  if (elementNode.textualContent === 0 /* Yes */ || elementNode.textualContent === 3 /* DynamicText */) {
     state.hasTextContent = true;
   }
-  const elementHotSignals = snapshotHotSignalsByElementKey.get(elementNode.key);
+  const elementHotSignals = snapshotHotSignalsByNode.get(elementNode);
   const elementDisplay = elementHotSignals?.display.value ?? null;
   if (elementDisplay !== null && establishesFormattingContext(elementDisplay)) {
     return {
@@ -33593,7 +33788,7 @@ function computeContentCompositionFingerprint(elementNode, childrenByParentNode,
       wrappingContextMitigates: false,
       hasVerticalAlignMitigation: false,
       mixedContentDepth: 0,
-      classification: "block-segmented",
+      classification: 4 /* BlockSegmented */,
       analyzableChildCount: 0,
       totalChildCount: 0,
       hasOnlyBlockChildren: false
@@ -33603,7 +33798,7 @@ function computeContentCompositionFingerprint(elementNode, childrenByParentNode,
     elementNode,
     childrenByParentNode,
     snapshotByElementNode,
-    snapshotHotSignalsByElementKey,
+    snapshotHotSignalsByNode,
     state,
     0
   );
@@ -33623,7 +33818,7 @@ function computeContentCompositionFingerprint(elementNode, childrenByParentNode,
     hasOnlyBlockChildren
   };
 }
-function walkInlineDescendants(node, childrenByParentNode, snapshotByElementNode, snapshotHotSignalsByElementKey, state, depth) {
+function walkInlineDescendants(node, childrenByParentNode, snapshotByElementNode, snapshotHotSignalsByNode, state, depth) {
   const children = childrenByParentNode.get(node);
   if (!children) return;
   for (let i = 0; i < children.length; i++) {
@@ -33634,7 +33829,7 @@ function walkInlineDescendants(node, childrenByParentNode, snapshotByElementNode
     if (!snapshot) continue;
     if (depth === 0) state.analyzableChildCount++;
     const childTag = child.tagName?.toLowerCase() ?? null;
-    const hotSignals = snapshotHotSignalsByElementKey.get(child.key);
+    const hotSignals = snapshotHotSignalsByNode.get(child);
     const childDisplay = hotSignals?.display.value ?? null;
     if (childTag !== null && (isIntrinsicReplacedTag(childTag) || isControlReplacedTag(childTag))) {
       state.hasInlineReplaced = true;
@@ -33656,16 +33851,16 @@ function walkInlineDescendants(node, childrenByParentNode, snapshotByElementNode
       checkVerticalAlignMitigation(snapshot, state);
       updateMixedContentDepth(state, depth);
       if (depth === 0) state.inlineChildCount++;
-      const parentHotSignals = snapshotHotSignalsByElementKey.get(node.key);
+      const parentHotSignals = snapshotHotSignalsByNode.get(node);
       const parentDisplay = parentHotSignals?.display.value ?? null;
       if (parentDisplay !== null && isAlignmentContextWithNonBaselineAlignment(parentDisplay, parentHotSignals)) {
         state.wrappingContextMitigates = true;
-      } else if (isAlignmentContextWithNonBaselineAlignment(childDisplay, hotSignals) && containsMixedContent(child, childrenByParentNode, snapshotByElementNode, snapshotHotSignalsByElementKey)) {
+      } else if (isAlignmentContextWithNonBaselineAlignment(childDisplay, hotSignals) && containsMixedContent(child, childrenByParentNode, snapshotByElementNode, snapshotHotSignalsByNode)) {
         state.wrappingContextMitigates = true;
       }
       continue;
     }
-    if (child.textualContent === "yes" || child.textualContent === "dynamic-text") {
+    if (child.textualContent === 0 /* Yes */ || child.textualContent === 3 /* DynamicText */) {
       state.hasTextContent = true;
     }
     checkHeightContributions(snapshot, state);
@@ -33675,7 +33870,7 @@ function walkInlineDescendants(node, childrenByParentNode, snapshotByElementNode
         child,
         childrenByParentNode,
         snapshotByElementNode,
-        snapshotHotSignalsByElementKey,
+        snapshotHotSignalsByNode,
         state,
         depth + 1
       );
@@ -33710,19 +33905,19 @@ function isAlignmentContextWithNonBaselineAlignment(display, hotSignals) {
   if (alignItems === null) return false;
   return alignItems !== "baseline";
 }
-function containsMixedContent(node, childrenByParentNode, snapshotByElementNode, snapshotHotSignalsByElementKey) {
-  const hasText = node.textualContent === "yes" || node.textualContent === "dynamic-text";
+function containsMixedContent(node, childrenByParentNode, snapshotByElementNode, snapshotHotSignalsByNode) {
+  const hasText = node.textualContent === 0 /* Yes */ || node.textualContent === 3 /* DynamicText */;
   const hasReplaced = false;
-  return scanMixedContent(node, childrenByParentNode, snapshotByElementNode, snapshotHotSignalsByElementKey, { hasText, hasReplaced });
+  return scanMixedContent(node, childrenByParentNode, snapshotByElementNode, snapshotHotSignalsByNode, { hasText, hasReplaced });
 }
-function scanMixedContent(node, childrenByParentNode, snapshotByElementNode, snapshotHotSignalsByElementKey, found) {
+function scanMixedContent(node, childrenByParentNode, snapshotByElementNode, snapshotHotSignalsByNode, found) {
   const children = childrenByParentNode.get(node);
   if (!children) return false;
   for (let i = 0; i < children.length; i++) {
     const child = children[i];
     if (!child) continue;
     const childTag = child.tagName?.toLowerCase() ?? null;
-    const hotSignals = snapshotHotSignalsByElementKey.get(child.key);
+    const hotSignals = snapshotHotSignalsByNode.get(child);
     const childDisplay = hotSignals?.display.value ?? null;
     if (childTag !== null && (isIntrinsicReplacedTag(childTag) || isControlReplacedTag(childTag))) {
       found.hasReplaced = true;
@@ -33737,12 +33932,12 @@ function scanMixedContent(node, childrenByParentNode, snapshotByElementNode, sna
       if (found.hasText) return true;
       continue;
     }
-    if (child.textualContent === "yes" || child.textualContent === "dynamic-text") {
+    if (child.textualContent === 0 /* Yes */ || child.textualContent === 3 /* DynamicText */) {
       found.hasText = true;
       if (found.hasReplaced) return true;
     }
     if (childDisplay === null || isInlineContinuationDisplay(childDisplay)) {
-      if (scanMixedContent(child, childrenByParentNode, snapshotByElementNode, snapshotHotSignalsByElementKey, found)) {
+      if (scanMixedContent(child, childrenByParentNode, snapshotByElementNode, snapshotHotSignalsByNode, found)) {
         return true;
       }
     }
@@ -33765,30 +33960,30 @@ function updateMixedContentDepth(state, depth) {
 }
 function classifyFromState(state, elementNode, hasOnlyBlockChildren) {
   if (hasOnlyBlockChildren) {
-    return "block-segmented";
+    return 4 /* BlockSegmented */;
   }
   if (state.totalChildCount === 0 && !state.hasTextContent) {
-    if (elementNode.textualContent === "unknown") return "unknown";
-    if (elementNode.textualContent === "yes" || elementNode.textualContent === "dynamic-text") {
-      return "text-only";
+    if (elementNode.textualContent === 2 /* Unknown */) return 5 /* Unknown */;
+    if (elementNode.textualContent === 0 /* Yes */ || elementNode.textualContent === 3 /* DynamicText */) {
+      return 0 /* TextOnly */;
     }
-    return "unknown";
+    return 5 /* Unknown */;
   }
   if (state.analyzableChildCount === 0 && state.totalChildCount > 0) {
-    return "unknown";
+    return 5 /* Unknown */;
   }
   if (state.hasTextContent && state.hasInlineReplaced) {
-    if (state.wrappingContextMitigates) return "mixed-mitigated";
-    if (state.hasVerticalAlignMitigation) return "mixed-mitigated";
-    return "mixed-unmitigated";
+    if (state.wrappingContextMitigates) return 3 /* MixedMitigated */;
+    if (state.hasVerticalAlignMitigation) return 3 /* MixedMitigated */;
+    return 2 /* MixedUnmitigated */;
   }
   if (!state.hasTextContent && state.hasInlineReplaced) {
-    return "replaced-only";
+    return 1 /* ReplacedOnly */;
   }
   if (state.hasTextContent && !state.hasInlineReplaced) {
-    return "text-only";
+    return 0 /* TextOnly */;
   }
-  return "unknown";
+  return 5 /* Unknown */;
 }
 function isIntrinsicReplacedTag(tag) {
   return INTRINSIC_REPLACED_TAGS.has(tag);
@@ -33808,10 +34003,14 @@ function isInlineReplacedDisplay(display) {
 function isInlineContinuationDisplay(display) {
   return INLINE_CONTINUATION_DISPLAYS.has(display);
 }
-function resolveCompositionDivergenceStrength(subjectFingerprint, allFingerprints, parentContext) {
-  if (allFingerprints.length < 2) return 0;
+var NO_DIVERGENCE = Object.freeze({
+  strength: 0,
+  majorityClassification: 5 /* Unknown */
+});
+function resolveCompositionDivergence(subjectFingerprint, allFingerprints, parentContext) {
+  if (allFingerprints.length < 2) return NO_DIVERGENCE;
   if (parentContext !== null && !hasSharedBaselineAlignment(parentContext)) {
-    return 0;
+    return NO_DIVERGENCE;
   }
   const countByClassification = /* @__PURE__ */ new Map();
   for (let i = 0; i < allFingerprints.length; i++) {
@@ -33823,10 +34022,7 @@ function resolveCompositionDivergenceStrength(subjectFingerprint, allFingerprint
   }
   const subjectNormalized = normalizeClassificationForComparison(subjectFingerprint.classification);
   const subjectCount = countByClassification.get(subjectNormalized) ?? 0;
-  if (subjectCount === allFingerprints.length) {
-    return resolveInlineReplacedKindDivergence(subjectFingerprint, allFingerprints);
-  }
-  let majorityClassification = "unknown";
+  let majorityClassification = 5 /* Unknown */;
   let majorityCount = 0;
   for (const [classification, count] of countByClassification) {
     if (count > majorityCount) {
@@ -33834,35 +34030,38 @@ function resolveCompositionDivergenceStrength(subjectFingerprint, allFingerprint
       majorityClassification = classification;
     }
   }
+  if (subjectCount === allFingerprints.length) {
+    return { strength: resolveInlineReplacedKindDivergence(subjectFingerprint, allFingerprints), majorityClassification };
+  }
   if (subjectNormalized === majorityClassification) {
-    return resolveInlineReplacedKindDivergence(subjectFingerprint, allFingerprints);
+    return { strength: resolveInlineReplacedKindDivergence(subjectFingerprint, allFingerprints), majorityClassification };
   }
-  if (subjectNormalized === "unknown") {
-    return 0;
+  if (subjectNormalized === 5 /* Unknown */) {
+    return { strength: 0, majorityClassification };
   }
   const cal = alignmentStrengthCalibration;
-  if (majorityClassification === "text-only" && subjectNormalized === "mixed-unmitigated") {
-    return cal.compositionMixedUnmitigatedOutlierStrength;
+  if (majorityClassification === 0 /* TextOnly */ && subjectNormalized === 2 /* MixedUnmitigated */) {
+    return { strength: cal.compositionMixedUnmitigatedOutlierStrength, majorityClassification };
   }
-  if (majorityClassification === "replaced-only" && subjectNormalized === "mixed-unmitigated") {
-    return cal.compositionMixedOutlierAmongReplacedStrength;
+  if (majorityClassification === 1 /* ReplacedOnly */ && subjectNormalized === 2 /* MixedUnmitigated */) {
+    return { strength: cal.compositionMixedOutlierAmongReplacedStrength, majorityClassification };
   }
-  if (majorityClassification === "mixed-unmitigated" && subjectNormalized === "text-only") {
-    return cal.compositionTextOutlierAmongMixedStrength;
+  if (majorityClassification === 2 /* MixedUnmitigated */ && subjectNormalized === 0 /* TextOnly */) {
+    return { strength: cal.compositionTextOutlierAmongMixedStrength, majorityClassification };
   }
-  if (majorityClassification === "mixed-unmitigated" && subjectNormalized === "replaced-only") {
-    return cal.compositionTextOutlierAmongMixedStrength;
+  if (majorityClassification === 2 /* MixedUnmitigated */ && subjectNormalized === 1 /* ReplacedOnly */) {
+    return { strength: cal.compositionTextOutlierAmongMixedStrength, majorityClassification };
   }
-  if (majorityClassification === "text-only" && subjectNormalized === "replaced-only") {
-    return cal.compositionMixedOutlierAmongReplacedStrength;
+  if (majorityClassification === 0 /* TextOnly */ && subjectNormalized === 1 /* ReplacedOnly */) {
+    return { strength: cal.compositionMixedOutlierAmongReplacedStrength, majorityClassification };
   }
-  if (majorityClassification === "replaced-only" && subjectNormalized === "text-only") {
-    return cal.compositionTextOutlierAmongMixedStrength;
+  if (majorityClassification === 1 /* ReplacedOnly */ && subjectNormalized === 0 /* TextOnly */) {
+    return { strength: cal.compositionTextOutlierAmongMixedStrength, majorityClassification };
   }
-  if (majorityClassification === "unknown") {
-    return 0;
+  if (majorityClassification === 5 /* Unknown */) {
+    return { strength: 0, majorityClassification };
   }
-  return cal.compositionUnknownPenalty;
+  return { strength: cal.compositionUnknownPenalty, majorityClassification };
 }
 function resolveInlineReplacedKindDivergence(subjectFingerprint, allFingerprints) {
   if (subjectFingerprint.inlineReplacedKind === null) return 0;
@@ -33883,28 +34082,9 @@ function resolveInlineReplacedKindDivergence(subjectFingerprint, allFingerprints
 function hasSharedBaselineAlignment(context) {
   return context.baselineRelevance === "relevant";
 }
-function resolveMajorityClassification(allFingerprints) {
-  const countByClassification = /* @__PURE__ */ new Map();
-  for (let i = 0; i < allFingerprints.length; i++) {
-    const fp = allFingerprints[i];
-    if (!fp) continue;
-    const normalized = normalizeClassificationForComparison(fp.classification);
-    const existing = countByClassification.get(normalized) ?? 0;
-    countByClassification.set(normalized, existing + 1);
-  }
-  let majorityClassification = "unknown";
-  let majorityCount = 0;
-  for (const [classification, count] of countByClassification) {
-    if (count > majorityCount) {
-      majorityCount = count;
-      majorityClassification = classification;
-    }
-  }
-  return majorityClassification;
-}
 function normalizeClassificationForComparison(classification) {
-  if (classification === "mixed-mitigated") return "text-only";
-  if (classification === "block-segmented") return "text-only";
+  if (classification === 3 /* MixedMitigated */) return 0 /* TextOnly */;
+  if (classification === 4 /* BlockSegmented */) return 0 /* TextOnly */;
   return classification;
 }
 function resolveCompositionCoverage(subjectFingerprint, allFingerprints) {
@@ -33912,12 +34092,12 @@ function resolveCompositionCoverage(subjectFingerprint, allFingerprints) {
   let analyzableCount = 0;
   for (let i = 0; i < allFingerprints.length; i++) {
     const fp = allFingerprints[i];
-    if (fp && fp.classification !== "unknown") {
+    if (fp && fp.classification !== 5 /* Unknown */) {
       analyzableCount++;
     }
   }
   const analyzableShare = analyzableCount / allFingerprints.length;
-  if (subjectFingerprint.classification === "unknown") {
+  if (subjectFingerprint.classification === 5 /* Unknown */) {
     return analyzableShare * 0.3;
   }
   if (subjectFingerprint.totalChildCount > 0 && subjectFingerprint.analyzableChildCount === 0) {
@@ -33925,24 +34105,19 @@ function resolveCompositionCoverage(subjectFingerprint, allFingerprints) {
   }
   return analyzableShare;
 }
+var COMPOSITION_LABELS = {
+  [0 /* TextOnly */]: "text-only",
+  [1 /* ReplacedOnly */]: "inline-replaced-only",
+  [2 /* MixedUnmitigated */]: "mixed text + inline-replaced",
+  [3 /* MixedMitigated */]: "mixed (alignment mitigated)",
+  [4 /* BlockSegmented */]: "block-segmented",
+  [5 /* Unknown */]: "unknown"
+};
 function formatCompositionClassification(classification) {
-  switch (classification) {
-    case "text-only":
-      return "text-only";
-    case "replaced-only":
-      return "inline-replaced-only";
-    case "mixed-unmitigated":
-      return "mixed text + inline-replaced";
-    case "mixed-mitigated":
-      return "mixed (alignment mitigated)";
-    case "block-segmented":
-      return "block-segmented";
-    case "unknown":
-      return "unknown";
-  }
+  return COMPOSITION_LABELS[classification];
 }
 function formatCompositionFixSuggestion(subjectFingerprint) {
-  if (subjectFingerprint.classification === "mixed-unmitigated") {
+  if (subjectFingerprint.classification === 2 /* MixedUnmitigated */) {
     if (subjectFingerprint.hasVerticalAlignMitigation) {
       return "verify vertical-align resolves the baseline shift";
     }
@@ -33977,12 +34152,12 @@ function estimateBlockOffsetWithDeclaredFromHotSignals(hot, axis) {
 function estimateBlockOffsetWithDeclaredFromSources(axis, position, readNumeric) {
   let declaredTotal = 0;
   let declaredCount = 0;
-  let declaredKind = "exact";
-  let declaredMissingKind = "exact";
+  let declaredKind = 0 /* Exact */;
+  let declaredMissingKind = 0 /* Exact */;
   let effectiveTotal = 0;
   let effectiveCount = 0;
-  let effectiveKind = "exact";
-  let effectiveMissingKind = "exact";
+  let effectiveKind = 0 /* Exact */;
+  let effectiveMissingKind = 0 /* Exact */;
   const positioned = position.value !== null && position.value !== "static";
   const add = (name, sign, requiresPositioning) => {
     const v = readNumeric(name);
@@ -34053,7 +34228,7 @@ function buildCohortIndex(input) {
       axisCertainty: context.axisCertainty,
       measurementNodeByRootKey: input.measurementNodeByRootKey,
       snapshotByElementNode: input.snapshotByElementNode,
-      snapshotHotSignalsByElementKey: input.snapshotHotSignalsByElementKey
+      snapshotHotSignalsByNode: input.snapshotHotSignalsByNode
     });
     measurementIndexHits += cohortMetricsResult.measurementHits;
     const metrics = cohortMetricsResult.metrics;
@@ -34087,7 +34262,7 @@ function buildCohortIndex(input) {
         subjectMetrics.rootNode,
         input.childrenByParentNode,
         input.snapshotByElementNode,
-        input.snapshotHotSignalsByElementKey
+        input.snapshotHotSignalsByNode
       );
       subjectsByElementKey.set(subjectMetrics.key, {
         element: subjectMetrics.element,
@@ -34153,7 +34328,7 @@ function collectCohortMetrics(input) {
     if (!snapshot) {
       throw new Error(`missing snapshot for measurement node ${measurementNode.key}`);
     }
-    const hotSignals = input.snapshotHotSignalsByElementKey.get(measurementNode.key);
+    const hotSignals = input.snapshotHotSignalsByNode.get(measurementNode);
     if (!hotSignals) {
       throw new Error(`missing hot signals for measurement node ${measurementNode.key}`);
     }
@@ -34478,9 +34653,9 @@ function buildCohortSignalIndex(metrics) {
   const verticalAlignCounts = /* @__PURE__ */ new Map();
   const alignSelfCounts = /* @__PURE__ */ new Map();
   const placeSelfCounts = /* @__PURE__ */ new Map();
-  let verticalAlignMergedKind = "exact";
-  let alignSelfMergedKind = "exact";
-  let placeSelfMergedKind = "exact";
+  let verticalAlignMergedKind = 0 /* Exact */;
+  let alignSelfMergedKind = 0 /* Exact */;
+  let placeSelfMergedKind = 0 /* Exact */;
   let verticalAlignComparableCount = 0;
   let alignSelfComparableCount = 0;
   let placeSelfComparableCount = 0;
@@ -34494,12 +34669,12 @@ function buildCohortSignalIndex(metrics) {
     const snapshot = metric.element.snapshot;
     const alignSelf = metric.hotSignals.alignSelf;
     const placeSelf = metric.hotSignals.placeSelf;
-    const isControlOrReplaced = snapshot.isControl || snapshot.isReplaced;
+    const isControlOrReplaced = snapshot.node.isControl || snapshot.node.isReplaced;
     const verticalAlign = resolveComparableVerticalAlign(metric.hotSignals.verticalAlign, isControlOrReplaced);
     if (isControlOrReplaced) controlOrReplacedCount++;
-    if (snapshot.textualContent === "yes" || snapshot.textualContent === "dynamic-text") textYesCount++;
-    if (snapshot.textualContent === "no") textNoCount++;
-    if (snapshot.textualContent === "unknown") textUnknownCount++;
+    if (snapshot.node.textualContent === 0 /* Yes */ || snapshot.node.textualContent === 3 /* DynamicText */) textYesCount++;
+    if (snapshot.node.textualContent === 1 /* No */) textNoCount++;
+    if (snapshot.node.textualContent === 2 /* Unknown */) textUnknownCount++;
     if (verticalAlign.value !== null) {
       verticalAlignMergedKind = mergeEvidenceKind(verticalAlignMergedKind, verticalAlign.kind);
       verticalAlignComparableCount++;
@@ -34519,24 +34694,24 @@ function buildCohortSignalIndex(metrics) {
       verticalAlign,
       alignSelf,
       placeSelf,
-      textualContent: snapshot.textualContent,
+      textualContent: snapshot.node.textualContent,
       isControlOrReplaced
     });
   }
   return {
     byKey,
     verticalAlign: {
-      mergedKind: verticalAlignComparableCount === 0 ? "unknown" : verticalAlignMergedKind,
+      mergedKind: verticalAlignComparableCount === 0 ? 3 /* Unknown */ : verticalAlignMergedKind,
       comparableCount: verticalAlignComparableCount,
       countsByValue: verticalAlignCounts
     },
     alignSelf: {
-      mergedKind: alignSelfComparableCount === 0 ? "unknown" : alignSelfMergedKind,
+      mergedKind: alignSelfComparableCount === 0 ? 3 /* Unknown */ : alignSelfMergedKind,
       comparableCount: alignSelfComparableCount,
       countsByValue: alignSelfCounts
     },
     placeSelf: {
-      mergedKind: placeSelfComparableCount === 0 ? "unknown" : placeSelfMergedKind,
+      mergedKind: placeSelfComparableCount === 0 ? 3 /* Unknown */ : placeSelfMergedKind,
       comparableCount: placeSelfComparableCount,
       countsByValue: placeSelfCounts
     },
@@ -34573,9 +34748,9 @@ function collectSubjectCohortSignals(index, subjectMetrics, context) {
     sawComparableVerticalAlign,
     sawVerticalAlignConflict
   );
-  const tableCellControlFallback = context.kind === "table-cell" && subject.isControlOrReplaced && verticalAlign.value === "unknown" && index.byKey.size > index.controlOrReplacedCount;
+  const tableCellControlFallback = context.kind === "table-cell" && subject.isControlOrReplaced && verticalAlign.value === 2 /* Unknown */ && index.byKey.size > index.controlOrReplacedCount;
   const normalizedVerticalAlign = tableCellControlFallback ? {
-    value: "conflict",
+    value: 0 /* Conflict */,
     kind: verticalAlignKind
   } : verticalAlign;
   const textContrastWithPeers = resolveIndexedTextContrastWithPeers(
@@ -34608,7 +34783,7 @@ function resolveComparableVerticalAlign(verticalAlign, isControlOrReplaced) {
   return {
     present: verticalAlign.present,
     value: "baseline",
-    kind: "exact"
+    kind: 0 /* Exact */
   };
 }
 function hasComparablePeer(aggregate, subjectValue) {
@@ -34625,37 +34800,37 @@ function hasConflictPeer(aggregate, subjectValue) {
 function finalizeConflictEvidence(subjectValue, kind, sawComparablePeer, sawConflict) {
   if (subjectValue === null) {
     return {
-      value: "unknown",
+      value: 2 /* Unknown */,
       kind
     };
   }
   if (!sawComparablePeer) {
     return {
-      value: "unknown",
+      value: 2 /* Unknown */,
       kind
     };
   }
   return {
-    value: sawConflict ? "conflict" : "aligned",
+    value: sawConflict ? 0 /* Conflict */ : 1 /* Aligned */,
     kind
   };
 }
 function resolveIndexedTextContrastWithPeers(index, subjectTextualContent, subjectIsControlOrReplaced, tableCellControlFallback) {
-  if (subjectTextualContent === "unknown") return "unknown";
+  if (subjectTextualContent === 2 /* Unknown */) return 2 /* Unknown */;
   const unknownPeers = index.textUnknownCount;
   const cohortSize = index.byKey.size;
-  if (subjectTextualContent === "yes" || subjectTextualContent === "dynamic-text") {
-    if (index.textNoCount > 0) return "different";
-    if (unknownPeers > 0) return "unknown";
-    return "same";
+  if (subjectTextualContent === 0 /* Yes */ || subjectTextualContent === 3 /* DynamicText */) {
+    if (index.textNoCount > 0) return 0 /* Different */;
+    if (unknownPeers > 0) return 2 /* Unknown */;
+    return 1 /* Same */;
   }
-  if (index.textYesCount > 0) return "different";
-  if (tableCellControlFallback) return "different";
+  if (index.textYesCount > 0) return 0 /* Different */;
+  if (tableCellControlFallback) return 0 /* Different */;
   if (subjectIsControlOrReplaced && index.controlOrReplacedCount === 1 && cohortSize >= 3 && unknownPeers > 0) {
-    return "different";
+    return 0 /* Different */;
   }
-  if (unknownPeers > 0) return "unknown";
-  return "same";
+  if (unknownPeers > 0) return 2 /* Unknown */;
+  return 1 /* Same */;
 }
 function resolveSubjectIdentifiability(subjectMetrics, profile, subjectBaselineProfile, clusterSummary, signalIndex, cohortKind, cohortSize) {
   const subjectClusterKey = toComparableClusterKey(subjectMetrics);
@@ -34671,7 +34846,7 @@ function resolveSubjectIdentifiability(subjectMetrics, profile, subjectBaselineP
     return {
       dominantShare: profile.dominantClusterShare,
       subjectExcludedDominantShare: subjectBaselineProfile.dominantClusterShare,
-      subjectMembership: "insufficient",
+      subjectMembership: 3 /* Insufficient */,
       ambiguous: true,
       kind
     };
@@ -34680,7 +34855,7 @@ function resolveSubjectIdentifiability(subjectMetrics, profile, subjectBaselineP
     return {
       dominantShare: profile.dominantClusterShare,
       subjectExcludedDominantShare: subjectBaselineProfile.dominantClusterShare,
-      subjectMembership: "dominant",
+      subjectMembership: 0 /* Dominant */,
       ambiguous: false,
       kind
     };
@@ -34689,7 +34864,7 @@ function resolveSubjectIdentifiability(subjectMetrics, profile, subjectBaselineP
     return {
       dominantShare: profile.dominantClusterShare,
       subjectExcludedDominantShare: subjectBaselineProfile.dominantClusterShare,
-      subjectMembership: "insufficient",
+      subjectMembership: 3 /* Insufficient */,
       ambiguous: true,
       kind
     };
@@ -34699,7 +34874,7 @@ function resolveSubjectIdentifiability(subjectMetrics, profile, subjectBaselineP
     return {
       dominantShare: profile.dominantClusterShare,
       subjectExcludedDominantShare: subjectBaselineProfile.dominantClusterShare,
-      subjectMembership: "insufficient",
+      subjectMembership: 3 /* Insufficient */,
       ambiguous: true,
       kind
     };
@@ -34709,7 +34884,7 @@ function resolveSubjectIdentifiability(subjectMetrics, profile, subjectBaselineP
     return {
       dominantShare: profile.dominantClusterShare,
       subjectExcludedDominantShare: subjectBaselineProfile.dominantClusterShare,
-      subjectMembership: "ambiguous",
+      subjectMembership: 2 /* Ambiguous */,
       ambiguous: true,
       kind
     };
@@ -34718,7 +34893,7 @@ function resolveSubjectIdentifiability(subjectMetrics, profile, subjectBaselineP
     return {
       dominantShare: profile.dominantClusterShare,
       subjectExcludedDominantShare: subjectBaselineProfile.dominantClusterShare,
-      subjectMembership: "dominant",
+      subjectMembership: 0 /* Dominant */,
       ambiguous: false,
       kind
     };
@@ -34726,13 +34901,13 @@ function resolveSubjectIdentifiability(subjectMetrics, profile, subjectBaselineP
   return {
     dominantShare: profile.dominantClusterShare,
     subjectExcludedDominantShare: subjectBaselineProfile.dominantClusterShare,
-    subjectMembership: "nondominant",
+    subjectMembership: 1 /* Nondominant */,
     ambiguous: false,
     kind
   };
 }
 function resolveControlRoleIdentifiability(subjectMetrics, signalIndex, kind, cohortSize) {
-  const subjectIsControlOrReplaced = subjectMetrics.element.snapshot.isControl || subjectMetrics.element.snapshot.isReplaced;
+  const subjectIsControlOrReplaced = subjectMetrics.element.snapshot.node.isControl || subjectMetrics.element.snapshot.node.isReplaced;
   const controlCount = signalIndex.controlOrReplacedCount;
   const nonControlCount = cohortSize - controlCount;
   if (controlCount <= 0 || nonControlCount <= 0) return null;
@@ -34747,12 +34922,12 @@ function resolveControlRoleIdentifiability(subjectMetrics, signalIndex, kind, co
     return {
       dominantShare,
       subjectExcludedDominantShare: excludedDominantShare,
-      subjectMembership: subjectMembership === "ambiguous" ? "dominant" : subjectMembership,
+      subjectMembership: subjectMembership === 2 /* Ambiguous */ ? 0 /* Dominant */ : subjectMembership,
       ambiguous: false,
       kind
     };
   }
-  if (subjectMembership === "ambiguous") {
+  if (subjectMembership === 2 /* Ambiguous */) {
     return {
       dominantShare,
       subjectExcludedDominantShare: excludedDominantShare,
@@ -34770,9 +34945,9 @@ function resolveControlRoleIdentifiability(subjectMetrics, signalIndex, kind, co
   };
 }
 function resolveRoleMembership(controlCount, nonControlCount, subjectIsControlOrReplaced) {
-  if (controlCount === nonControlCount) return "ambiguous";
+  if (controlCount === nonControlCount) return 2 /* Ambiguous */;
   const dominantRoleIsControl = controlCount > nonControlCount;
-  return dominantRoleIsControl === subjectIsControlOrReplaced ? "dominant" : "nondominant";
+  return dominantRoleIsControl === subjectIsControlOrReplaced ? 0 /* Dominant */ : 1 /* Nondominant */;
 }
 function resolveExcludedRoleDominantShare(controlCount, nonControlCount, subjectIsControlOrReplaced) {
   const controlAfterExclusion = controlCount - (subjectIsControlOrReplaced ? 1 : 0);
@@ -34810,8 +34985,8 @@ function collectCohortProvenanceFromSnapshots(snapshots) {
     const snapshot = snapshots[i];
     if (!snapshot) continue;
     for (const signal of snapshot.signals.values()) {
-      for (let j = 0; j < signal.guardProvenance.conditions.length; j++) {
-        const guard = signal.guardProvenance.conditions[j];
+      for (let j = 0; j < signal.guard.conditions.length; j++) {
+        const guard = signal.guard.conditions[j];
         if (!guard) continue;
         if (!byKey.has(guard.key)) byKey.set(guard.key, guard);
       }
@@ -34841,7 +35016,7 @@ function buildGuardKey(guards) {
   return keys.join("&");
 }
 function resolveCohortEvidenceKind(metrics) {
-  let kind = "exact";
+  let kind = 0 /* Exact */;
   for (let i = 0; i < metrics.length; i++) {
     const metric = metrics[i];
     if (!metric) continue;
@@ -34858,9 +35033,9 @@ function incrementCount(counts, key) {
   counts.set(key, existing + 1);
 }
 function toEvidenceKind2(certainty) {
-  if (certainty === "resolved") return "exact";
-  if (certainty === "conditional") return "conditional";
-  return "unknown";
+  if (certainty === 0 /* Resolved */) return 0 /* Exact */;
+  if (certainty === 1 /* Conditional */) return 2 /* Conditional */;
+  return 3 /* Unknown */;
 }
 function computeMedian(values) {
   if (values.length === 0) return null;
@@ -34880,66 +35055,6 @@ function computeMedianAbsoluteDeviation(values, median, scratch) {
   }
   return computeMedian(scratch);
 }
-function selectKth(values, targetIndex) {
-  let left = 0;
-  let right = values.length - 1;
-  while (left <= right) {
-    if (left === right) {
-      const result = values[left];
-      if (result === void 0) return 0;
-      return result;
-    }
-    const pivotIndex = choosePivotIndex(values, left, right);
-    const partitionIndex = partitionAroundPivot(values, left, right, pivotIndex);
-    if (partitionIndex === targetIndex) {
-      const result = values[partitionIndex];
-      if (result === void 0) return 0;
-      return result;
-    }
-    if (partitionIndex < targetIndex) {
-      left = partitionIndex + 1;
-      continue;
-    }
-    right = partitionIndex - 1;
-  }
-  const fallback = values[targetIndex];
-  if (fallback === void 0) return 0;
-  return fallback;
-}
-function choosePivotIndex(values, left, right) {
-  const middle = Math.floor((left + right) / 2);
-  const leftValue = values[left] ?? 0;
-  const middleValue = values[middle] ?? 0;
-  const rightValue = values[right] ?? 0;
-  if (leftValue < middleValue) {
-    if (middleValue < rightValue) return middle;
-    if (leftValue < rightValue) return right;
-    return left;
-  }
-  if (leftValue < rightValue) return left;
-  if (middleValue < rightValue) return right;
-  return middle;
-}
-function partitionAroundPivot(values, left, right, pivotIndex) {
-  const pivotValue = values[pivotIndex] ?? 0;
-  swap(values, pivotIndex, right);
-  let storeIndex = left;
-  for (let i = left; i < right; i++) {
-    const current = values[i];
-    if (current === void 0 || current > pivotValue) continue;
-    swap(values, storeIndex, i);
-    storeIndex++;
-  }
-  swap(values, storeIndex, right);
-  return storeIndex;
-}
-function swap(values, left, right) {
-  if (left === right) return;
-  const leftValue = values[left] ?? 0;
-  const rightValue = values[right] ?? 0;
-  values[left] = rightValue;
-  values[right] = leftValue;
-}
 function resolveVerticalAlignConsensus(aggregate) {
   if (aggregate.comparableCount === 0) return null;
   if (aggregate.countsByValue.size !== 1) return null;
@@ -35038,7 +35153,7 @@ function resolveMeasurementCandidates(root, childrenByParentNode, snapshotByElem
     if (firstControlOrReplacedDescendant === null && (child.isControl || child.isReplaced)) {
       firstControlOrReplacedDescendant = child;
     }
-    if (firstTextualDescendant === null && child.textualContent === "yes") {
+    if (firstTextualDescendant === null && child.textualContent === 0 /* Yes */) {
       firstTextualDescendant = child;
     }
     if (firstControlOrReplacedDescendant !== null && firstTextualDescendant !== null) break;
@@ -35064,7 +35179,7 @@ function resolveMeasurementNode(root, candidates) {
   if (candidates.firstControlOrReplacedDescendant !== null) return candidates.firstControlOrReplacedDescendant;
   if (root.isControl || root.isReplaced) return root;
   if (candidates.firstTextualDescendant !== null) return candidates.firstTextualDescendant;
-  if (root.textualContent === "yes") return root;
+  if (root.textualContent === 0 /* Yes */) return root;
   return root;
 }
 
@@ -35111,7 +35226,7 @@ function buildScopedSelectorIndexBySolidFile(cssScopeBySolidFile, css, selectorM
         seenSelectorIds.add(selector.id);
         const metadata = selectorMetadataById.get(selector.id);
         if (!metadata) continue;
-        if (metadata.guard.kind === "conditional") {
+        if (metadata.guard.kind === 1 /* Conditional */) {
           if (!conditionalSelectorIds.has(selector.id)) {
             conditionalSelectorIds.add(selector.id);
             perf.selectorsGuardedConditional++;
@@ -35153,7 +35268,7 @@ function buildScopedSelectorIndexBySolidFile(cssScopeBySolidFile, css, selectorM
   }
   return out;
 }
-function buildSelectorCandidatesByElementKey(elements, scopedSelectorsBySolidFile, perf) {
+function buildSelectorCandidatesByNode(elements, scopedSelectorsBySolidFile, perf) {
   const out = /* @__PURE__ */ new Map();
   for (let i = 0; i < elements.length; i++) {
     const node = elements[i];
@@ -35163,7 +35278,7 @@ function buildSelectorCandidatesByElementKey(elements, scopedSelectorsBySolidFil
     const byTag = node.tagName !== null ? collectSelectorCandidates(scoped.bySubjectTag.get(node.tagName), node.selectorDispatchKeys) : EMPTY_SELECTOR_LIST;
     const withoutTag = collectSelectorCandidates(scoped.withoutSubjectTag, node.selectorDispatchKeys);
     const merged = mergeSelectorCandidateIds(byTag, withoutTag);
-    out.set(node.key, merged);
+    out.set(node, merged);
     perf.elementsScanned++;
     perf.selectorCandidatesChecked += merged.length;
   }
@@ -35622,12 +35737,6 @@ var EMPTY_EXPANSION_RESULT = [];
 function collectMonitoredDeclarations(selector, layerOrder, guard) {
   const out = [];
   const declarations = selector.rule.declarations;
-  const signalGuard = guard.kind === "conditional" ? "conditional" : "unconditional";
-  const guardProvenance = {
-    kind: signalGuard,
-    conditions: guard.conditions,
-    key: guard.key
-  };
   for (let i = 0; i < declarations.length; i++) {
     const declaration = declarations[i];
     if (!declaration) continue;
@@ -35638,8 +35747,7 @@ function collectMonitoredDeclarations(selector, layerOrder, guard) {
     out.push({
       property: monitored,
       value: declaration.value,
-      guard: signalGuard,
-      guardProvenance,
+      guardProvenance: guard,
       position: {
         layer: declaration.cascadePosition.layer,
         layerOrder,
@@ -35661,6 +35769,7 @@ function toMonitoredSignalKey(property) {
     case "margin-block":
     case "padding-block":
     case "inset-block":
+    case "flex-flow":
       return property;
     default:
       return null;
@@ -35684,30 +35793,27 @@ function expandMonitoredDeclarationForDelta(declaration) {
   if (signalName === void 0) return EMPTY_EXPANSION_RESULT;
   return [{ name: signalName, value: value2 }];
 }
-function appendMatchingEdgesFromSelectorIds(selectorIds, node, selectorMetadataById, selectorsById, applies, appliesByElementNodeMutable, perf, rootElementsByFile, logger) {
-  const fileRoots = rootElementsByFile.get(node.solidFile) ?? null;
+function appendMatchingEdgesFromSelectorIds(ctx, selectorIds, node, applies, appliesByElementNodeMutable) {
+  const fileRoots = ctx.rootElementsByFile.get(node.solidFile) ?? null;
   for (let i = 0; i < selectorIds.length; i++) {
     const selectorId = selectorIds[i];
     if (selectorId === void 0) continue;
-    const metadata = selectorMetadataById.get(selectorId);
+    const metadata = ctx.selectorMetadataById.get(selectorId);
     if (!metadata || !metadata.matcher) {
       throw new Error(`missing compiled selector matcher for selector ${selectorId}`);
     }
-    const selector = selectorsById.get(selectorId);
+    const selector = ctx.selectorsById.get(selectorId);
     if (!selector) {
       throw new Error(`missing selector ${selectorId}`);
     }
-    if (!selectorMatchesLayoutElement(metadata.matcher, node, perf, fileRoots, logger)) continue;
+    if (!selectorMatchesLayoutElement(metadata.matcher, node, ctx.perf, fileRoots, ctx.logger)) continue;
     const edge = {
-      solidFile: node.solidFile,
-      elementId: node.elementId,
-      elementKey: node.key,
       selectorId: selector.id,
       specificityScore: selector.specificityScore,
       sourceOrder: selector.rule.sourceOrder
     };
     applies.push(edge);
-    perf.matchEdgesCreated++;
+    ctx.perf.matchEdgesCreated++;
     const existing = appliesByElementNodeMutable.get(node);
     if (existing) {
       existing.push(edge);
@@ -35733,7 +35839,7 @@ function augmentCascadeWithTailwind(cascade, node, tailwind) {
   const classTokens = node.classTokens;
   if (classTokens.length === 0) return;
   const guardProvenance = {
-    kind: "unconditional",
+    kind: 0 /* Unconditional */,
     conditions: [],
     key: "always"
   };
@@ -35750,8 +35856,7 @@ function augmentCascadeWithTailwind(cascade, node, tailwind) {
       if (cascade.has(property)) continue;
       cascade.set(property, {
         value: value2,
-        source: "selector",
-        guard: "unconditional",
+        source: 0 /* Selector */,
         guardProvenance
       });
     }
@@ -35771,8 +35876,7 @@ function buildCascadeMapForElement(node, edges, monitoredDeclarationsBySelectorI
       const property = declaration.property;
       const newDeclaration = {
         value: declaration.value,
-        source: "selector",
-        guard: declaration.guard,
+        source: 0 /* Selector */,
         guardProvenance: declaration.guardProvenance
       };
       const existingPosition = positions.get(property);
@@ -35791,33 +35895,26 @@ function buildCascadeMapForElement(node, edges, monitoredDeclarationsBySelectorI
       positions.set(property, declaration.position);
     }
   }
-  const inlinePosition = createInlineCascadePosition();
-  const inlineGuardProvenance = {
-    kind: "unconditional",
-    conditions: [],
-    key: "always"
-  };
   for (const [property, value2] of node.inlineStyleValues) {
     const newDeclaration = {
       value: value2,
-      source: "inline-style",
-      guard: "unconditional",
-      guardProvenance: inlineGuardProvenance
+      source: 1 /* InlineStyle */,
+      guardProvenance: INLINE_GUARD_PROVENANCE
     };
     const existingPosition = positions.get(property);
     if (existingPosition === void 0) {
       out.set(property, newDeclaration);
-      positions.set(property, inlinePosition);
+      positions.set(property, INLINE_CASCADE_POSITION);
       continue;
     }
     const existingDeclaration = out.get(property);
     if (existingDeclaration === void 0) continue;
     if (!doesCandidateOverride(
       { declaration: existingDeclaration, position: existingPosition },
-      { declaration: newDeclaration, position: inlinePosition }
+      { declaration: newDeclaration, position: INLINE_CASCADE_POSITION }
     )) continue;
     out.set(property, newDeclaration);
-    positions.set(property, inlinePosition);
+    positions.set(property, INLINE_CASCADE_POSITION);
   }
   if (tailwind !== null) {
     augmentCascadeWithTailwind(out, node, tailwind);
@@ -35834,7 +35931,7 @@ function doesCandidateOverride(existing, incoming) {
   const existingSource = existing.declaration.source;
   const incomingSource = incoming.declaration.source;
   if (existingSource !== incomingSource) {
-    if (incomingSource === "inline-style") {
+    if (incomingSource === 1 /* InlineStyle */) {
       if (existing.position.isImportant && !incoming.position.isImportant) return false;
       return true;
     }
@@ -35842,16 +35939,19 @@ function doesCandidateOverride(existing, incoming) {
   }
   return compareCascadePositions(incoming.position, existing.position) > 0;
 }
-function createInlineCascadePosition() {
-  return {
-    layer: null,
-    layerOrder: Number.MAX_SAFE_INTEGER,
-    sourceOrder: Number.MAX_SAFE_INTEGER,
-    specificity: [1, 0, 0, 0],
-    specificityScore: Number.MAX_SAFE_INTEGER,
-    isImportant: false
-  };
-}
+var INLINE_CASCADE_POSITION = Object.freeze({
+  layer: null,
+  layerOrder: Number.MAX_SAFE_INTEGER,
+  sourceOrder: Number.MAX_SAFE_INTEGER,
+  specificity: [1, 0, 0, 0],
+  specificityScore: Number.MAX_SAFE_INTEGER,
+  isImportant: false
+});
+var INLINE_GUARD_PROVENANCE = Object.freeze({
+  kind: 0 /* Unconditional */,
+  conditions: [],
+  key: "always"
+});
 function resolveRuleLayerOrder(rule, css) {
   const layer = rule.containingLayer;
   if (!layer) return 0;
@@ -35859,14 +35959,14 @@ function resolveRuleLayerOrder(rule, css) {
   if (!name) return 0;
   return css.layerOrder.get(name) ?? 0;
 }
-function buildConditionalDeltaIndex(elements, appliesByElementKey, monitoredDeclarationsBySelectorId) {
-  const conditionalSignalDeltaFactsByElementKey = /* @__PURE__ */ new Map();
+function buildConditionalDeltaIndex(elements, appliesByNode, monitoredDeclarationsBySelectorId) {
+  const conditionalSignalDeltaFactsByNode = /* @__PURE__ */ new Map();
   const elementsWithConditionalDeltaBySignal = /* @__PURE__ */ new Map();
-  const baselineOffsetFactsByElementKey = /* @__PURE__ */ new Map();
+  const baselineOffsetFactsByNode = /* @__PURE__ */ new Map();
   for (let i = 0; i < elements.length; i++) {
     const node = elements[i];
     if (!node) continue;
-    const edges = appliesByElementKey.get(node.key);
+    const edges = appliesByNode.get(node);
     let factByProperty = null;
     if (edges !== void 0 && edges.length > 0) {
       const byProperty = /* @__PURE__ */ new Map();
@@ -35891,7 +35991,7 @@ function buildConditionalDeltaIndex(elements, appliesByElementKey, monitoredDecl
               };
               byProperty.set(property, bucket);
             }
-            if (declaration.guard === "conditional") {
+            if (declaration.guardProvenance.kind === 1 /* Conditional */) {
               bucket.conditional.add(expandedEntry.value);
               continue;
             }
@@ -35931,7 +36031,7 @@ function buildConditionalDeltaIndex(elements, appliesByElementKey, monitoredDecl
         }
         if (facts.size > 0) {
           factByProperty = facts;
-          conditionalSignalDeltaFactsByElementKey.set(node.key, facts);
+          conditionalSignalDeltaFactsByNode.set(node, facts);
           for (const [signal, fact] of facts) {
             if (!fact.hasConditional) continue;
             const existing = elementsWithConditionalDeltaBySignal.get(signal);
@@ -35968,13 +36068,13 @@ function buildConditionalDeltaIndex(elements, appliesByElementKey, monitoredDecl
       baselineBySignal.set(signal, [...values]);
     }
     if (baselineBySignal.size > 0) {
-      baselineOffsetFactsByElementKey.set(node.key, baselineBySignal);
+      baselineOffsetFactsByNode.set(node, baselineBySignal);
     }
   }
   return {
-    conditionalSignalDeltaFactsByElementKey,
+    conditionalSignalDeltaFactsByNode,
     elementsWithConditionalDeltaBySignal,
-    baselineOffsetFactsByElementKey
+    baselineOffsetFactsByNode
   };
 }
 var EMPTY_NODE_LIST2 = [];
@@ -36101,8 +36201,8 @@ function getTextualContentState(element, memo, compositionMetaByElementId, logge
     if (child.kind === "expression") {
       if (isStructuralExpression(child.node)) {
         if (logger.enabled) logger.trace(`[textual-content] element=${element.tagName ?? element.tag}#${element.id} \u2192 unknown (structural expression child)`);
-        memo.set(element.id, "unknown");
-        return "unknown";
+        memo.set(element.id, 2 /* Unknown */);
+        return 2 /* Unknown */;
       }
       hasTextOnlyExpression = true;
       continue;
@@ -36110,8 +36210,8 @@ function getTextualContentState(element, memo, compositionMetaByElementId, logge
     if (child.kind !== "text") continue;
     if (child.node.type !== "JSXText") continue;
     if (isBlank(child.node.value)) continue;
-    memo.set(element.id, "yes");
-    return "yes";
+    memo.set(element.id, 0 /* Yes */);
+    return 0 /* Yes */;
   }
   let childHasUnknown = false;
   let childHasDynamicText = false;
@@ -36125,31 +36225,31 @@ function getTextualContentState(element, memo, compositionMetaByElementId, logge
         if (logger.enabled) logger.trace(`[textual-content] element=${element.tagName ?? element.tag}#${element.id}: non-DOM child ${child.tag}#${child.id} resolves to control tag=${childMeta.tagName}, skipping`);
         continue;
       }
-      if (childState !== "no") {
+      if (childState !== 1 /* No */) {
         if (logger.enabled) logger.trace(`[textual-content] element=${element.tagName ?? element.tag}#${element.id}: non-DOM child ${child.tag ?? child.id}#${child.id} has state=${childState} \u2192 childHasUnknown`);
         childHasUnknown = true;
       }
       continue;
     }
-    if (childState === "yes") {
-      memo.set(element.id, "yes");
-      return "yes";
+    if (childState === 0 /* Yes */) {
+      memo.set(element.id, 0 /* Yes */);
+      return 0 /* Yes */;
     }
-    if (childState === "unknown") childHasUnknown = true;
-    if (childState === "dynamic-text") childHasDynamicText = true;
+    if (childState === 2 /* Unknown */) childHasUnknown = true;
+    if (childState === 3 /* DynamicText */) childHasDynamicText = true;
   }
   if (childHasUnknown) {
     if (logger.enabled) logger.trace(`[textual-content] element=${element.tagName ?? element.tag}#${element.id} \u2192 unknown (child has unknown)`);
-    memo.set(element.id, "unknown");
-    return "unknown";
+    memo.set(element.id, 2 /* Unknown */);
+    return 2 /* Unknown */;
   }
   if (hasTextOnlyExpression || childHasDynamicText) {
     if (logger.enabled) logger.trace(`[textual-content] element=${element.tagName ?? element.tag}#${element.id} \u2192 dynamic-text`);
-    memo.set(element.id, "dynamic-text");
-    return "dynamic-text";
+    memo.set(element.id, 3 /* DynamicText */);
+    return 3 /* DynamicText */;
   }
-  memo.set(element.id, "no");
-  return "no";
+  memo.set(element.id, 1 /* No */);
+  return 1 /* No */;
 }
 function isStructuralExpression(node) {
   if (node.type !== "JSXExpressionContainer") return false;
@@ -36448,8 +36548,6 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
         classTokens: record.classTokens,
         classTokenSet: record.classTokenSet,
         inlineStyleKeys: record.inlineStyleKeys,
-        parentElementId,
-        parentElementKey: parentNode ? parentNode.key : parentElementId === null ? null : toLayoutElementKey(solid.file, parentElementId),
         parentElementNode: parentNode,
         previousSiblingNode,
         siblingIndex,
@@ -36490,22 +36588,25 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
       logger.debug(`[build] rootElementsByFile file=${file} count=${roots.length}: ${descs.join(", ")}`);
     }
   }
-  const selectorCandidatesByElementKey = buildSelectorCandidatesByElementKey(elements, scopedSelectorsBySolidFile, perf);
+  const selectorCandidatesByNode = buildSelectorCandidatesByNode(elements, scopedSelectorsBySolidFile, perf);
+  const selectorMatchCtx = {
+    selectorMetadataById,
+    selectorsById,
+    rootElementsByFile,
+    perf,
+    logger
+  };
   for (let i = 0; i < elements.length; i++) {
     const node = elements[i];
     if (!node) continue;
-    const selectorIds = selectorCandidatesByElementKey.get(node.key) ?? EMPTY_NUMBER_LIST2;
+    const selectorIds = selectorCandidatesByNode.get(node) ?? EMPTY_NUMBER_LIST2;
     if (selectorIds.length === 0) continue;
     appendMatchingEdgesFromSelectorIds(
+      selectorMatchCtx,
       selectorIds,
       node,
-      selectorMetadataById,
-      selectorsById,
       applies,
-      appliesByElementNodeMutable,
-      perf,
-      rootElementsByFile,
-      logger
+      appliesByElementNodeMutable
     );
   }
   perf.selectorMatchMs = performance.now() - selectorMatchStartedAt;
@@ -36513,7 +36614,7 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
   for (const edges of appliesByElementNodeMutable.values()) {
     edges.sort(compareLayoutEdge);
   }
-  const appliesByElementKey = /* @__PURE__ */ new Map();
+  const appliesByNode = /* @__PURE__ */ new Map();
   const tailwind = css.tailwind;
   for (let i = 0; i < elements.length; i++) {
     const node = elements[i];
@@ -36521,7 +36622,7 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
     const edges = appliesByElementNodeMutable.get(node) ?? [];
     const cascade = buildCascadeMapForElement(node, edges, monitoredDeclarationsBySelectorId, tailwind);
     cascadeByElementNode.set(node, cascade);
-    appliesByElementKey.set(node.key, edges);
+    appliesByNode.set(node, edges);
   }
   perf.cascadeBuildMs = performance.now() - cascadeStartedAt;
   const snapshotByElementNode = buildSignalSnapshotIndex(elements, cascadeByElementNode, perf);
@@ -36529,7 +36630,7 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
   const factIndex = buildElementFactIndex(elements, snapshotByElementNode);
   const conditionalDeltaIndex = buildConditionalDeltaIndex(
     elements,
-    appliesByElementKey,
+    appliesByNode,
     monitoredDeclarationsBySelectorId
   );
   const elementsWithConditionalOverflowDelta = buildConditionalDeltaSignalGroupElements(
@@ -36547,7 +36648,7 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
     contextByParentNode,
     measurementNodeByRootKey,
     snapshotByElementNode,
-    snapshotHotSignalsByElementKey: factIndex.snapshotHotSignalsByElementKey
+    snapshotHotSignalsByNode: factIndex.snapshotHotSignalsByNode
   });
   finalizeTableCellBaselineRelevance(contextByParentNode, cohortIndex.verticalAlignConsensusByParent);
   perf.conditionalSignals = cohortIndex.conditionalSignals;
@@ -36563,11 +36664,11 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
     childrenByParentNode: childrenByParentNodeMutable,
     elementBySolidFileAndId: elementBySolidFileAndIdMutable,
     elementRefsBySolidFileAndId: elementRefsBySolidFileAndIdMutable,
-    appliesByElementKey,
-    selectorCandidatesByElementKey,
+    appliesByNode,
+    selectorCandidatesByNode,
     selectorsById,
     measurementNodeByRootKey,
-    snapshotHotSignalsByElementKey: factIndex.snapshotHotSignalsByElementKey,
+    snapshotHotSignalsByNode: factIndex.snapshotHotSignalsByNode,
     elementsByTagName: factIndex.elementsByTagName,
     elementsWithConditionalDeltaBySignal: conditionalDeltaIndex.elementsWithConditionalDeltaBySignal,
     elementsWithConditionalOverflowDelta,
@@ -36575,12 +36676,12 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
     elementsByKnownSignalValue: factIndex.elementsByKnownSignalValue,
     dynamicSlotCandidateElements: factIndex.dynamicSlotCandidateElements,
     scrollContainerElements: factIndex.scrollContainerElements,
-    reservedSpaceFactsByElementKey: factIndex.reservedSpaceFactsByElementKey,
-    scrollContainerFactsByElementKey: factIndex.scrollContainerFactsByElementKey,
-    flowParticipationFactsByElementKey: factIndex.flowParticipationFactsByElementKey,
-    containingBlockFactsByElementKey: factIndex.containingBlockFactsByElementKey,
-    conditionalSignalDeltaFactsByElementKey: conditionalDeltaIndex.conditionalSignalDeltaFactsByElementKey,
-    baselineOffsetFactsByElementKey: conditionalDeltaIndex.baselineOffsetFactsByElementKey,
+    reservedSpaceFactsByNode: factIndex.reservedSpaceFactsByNode,
+    scrollContainerFactsByNode: factIndex.scrollContainerFactsByNode,
+    flowParticipationFactsByNode: factIndex.flowParticipationFactsByNode,
+    containingBlockFactsByNode: factIndex.containingBlockFactsByNode,
+    conditionalSignalDeltaFactsByNode: conditionalDeltaIndex.conditionalSignalDeltaFactsByNode,
+    baselineOffsetFactsByNode: conditionalDeltaIndex.baselineOffsetFactsByNode,
     statefulSelectorEntriesByRuleId: statefulRuleIndexes.selectorEntriesByRuleId,
     statefulNormalizedDeclarationsByRuleId: statefulRuleIndexes.normalizedDeclarationsByRuleId,
     statefulBaseValueIndex: statefulRuleIndexes.baseValueIndex,
@@ -36592,11 +36693,11 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
   };
 }
 function buildElementFactIndex(elements, snapshotByElementNode) {
-  const reservedSpaceFactsByElementKey = /* @__PURE__ */ new Map();
-  const scrollContainerFactsByElementKey = /* @__PURE__ */ new Map();
-  const flowParticipationFactsByElementKey = /* @__PURE__ */ new Map();
-  const containingBlockFactsByElementKey = /* @__PURE__ */ new Map();
-  const snapshotHotSignalsByElementKey = /* @__PURE__ */ new Map();
+  const reservedSpaceFactsByNode = /* @__PURE__ */ new Map();
+  const scrollContainerFactsByNode = /* @__PURE__ */ new Map();
+  const flowParticipationFactsByNode = /* @__PURE__ */ new Map();
+  const containingBlockFactsByNode = /* @__PURE__ */ new Map();
+  const snapshotHotSignalsByNode = /* @__PURE__ */ new Map();
   const elementsByTagName = /* @__PURE__ */ new Map();
   const elementsByKnownSignalValue = /* @__PURE__ */ new Map();
   const dynamicSlotCandidateElements = [];
@@ -36606,7 +36707,7 @@ function buildElementFactIndex(elements, snapshotByElementNode) {
     const node = elements[i];
     if (!node) continue;
     const snapshot = snapshotByElementNode.get(node);
-    if (node.textualContent === "unknown" && node.siblingCount >= 2) {
+    if (node.textualContent === 2 /* Unknown */ && node.siblingCount >= 2) {
       dynamicSlotCandidateElements.push(node);
     }
     if (node.tagName) {
@@ -36627,18 +36728,18 @@ function buildElementFactIndex(elements, snapshotByElementNode) {
         nearestPositionedAncestorHasReservedSpace = parentPositioned.hasReservedSpace;
       }
     }
-    containingBlockFactsByElementKey.set(node.key, {
+    containingBlockFactsByNode.set(node, {
       nearestPositionedAncestorKey,
       nearestPositionedAncestorHasReservedSpace
     });
     if (!snapshot) continue;
     const reservedSpaceFact = computeReservedSpaceFact(snapshot);
-    reservedSpaceFactsByElementKey.set(node.key, reservedSpaceFact);
+    reservedSpaceFactsByNode.set(node, reservedSpaceFact);
     const scrollFact = computeScrollContainerFact(snapshot);
-    scrollContainerFactsByElementKey.set(node.key, scrollFact);
+    scrollContainerFactsByNode.set(node, scrollFact);
     if (scrollFact.isScrollContainer) scrollContainerElements.push(node);
-    flowParticipationFactsByElementKey.set(node.key, computeFlowParticipationFact(snapshot));
-    snapshotHotSignalsByElementKey.set(node.key, computeHotSignals(snapshot));
+    flowParticipationFactsByNode.set(node, computeFlowParticipationFact(snapshot));
+    snapshotHotSignalsByNode.set(node, computeHotSignals(snapshot));
     const positionSignal = snapshot.signals.get("position");
     const isPositioned = positionSignal !== void 0 && positionSignal.kind === "known" && positionSignal.normalized !== "static";
     if (isPositioned) {
@@ -36669,49 +36770,163 @@ function buildElementFactIndex(elements, snapshotByElementNode) {
     }
   }
   return {
-    reservedSpaceFactsByElementKey,
-    scrollContainerFactsByElementKey,
+    reservedSpaceFactsByNode,
+    scrollContainerFactsByNode,
     scrollContainerElements,
-    flowParticipationFactsByElementKey,
-    containingBlockFactsByElementKey,
-    snapshotHotSignalsByElementKey,
+    flowParticipationFactsByNode,
+    containingBlockFactsByNode,
+    snapshotHotSignalsByNode,
     elementsByTagName,
     elementsByKnownSignalValue,
     dynamicSlotCandidateElements
   };
 }
-function computeHotSignals(snapshot) {
+var ABSENT_NUMERIC = Object.freeze({
+  present: false,
+  value: null,
+  kind: 3 /* Unknown */
+});
+var ABSENT_NORMALIZED = Object.freeze({
+  present: false,
+  value: null,
+  kind: 3 /* Unknown */
+});
+function toHotNumeric(signal) {
+  if (signal.kind !== "known") {
+    return {
+      present: true,
+      value: null,
+      kind: signal.guard.kind === 1 /* Conditional */ ? 2 /* Conditional */ : 3 /* Unknown */
+    };
+  }
   return {
-    lineHeight: computeHotNumeric(snapshot, "line-height"),
-    verticalAlign: computeHotNormalized(snapshot, "vertical-align"),
-    alignSelf: computeHotNormalized(snapshot, "align-self"),
-    placeSelf: computeHotNormalized(snapshot, "place-self"),
-    writingMode: computeHotNormalized(snapshot, "writing-mode"),
-    direction: computeHotNormalized(snapshot, "direction"),
-    display: computeHotNormalized(snapshot, "display"),
-    alignItems: computeHotNormalized(snapshot, "align-items"),
-    placeItems: computeHotNormalized(snapshot, "place-items"),
-    position: computeHotNormalized(snapshot, "position"),
-    insetBlockStart: computeHotNumeric(snapshot, "inset-block-start"),
-    insetBlockEnd: computeHotNumeric(snapshot, "inset-block-end"),
-    transform: computeHotNumeric(snapshot, "transform"),
-    translate: computeHotNumeric(snapshot, "translate"),
-    top: computeHotNumeric(snapshot, "top"),
-    bottom: computeHotNumeric(snapshot, "bottom"),
-    marginTop: computeHotNumeric(snapshot, "margin-top"),
-    marginBottom: computeHotNumeric(snapshot, "margin-bottom")
+    present: true,
+    value: signal.px,
+    kind: signal.guard.kind === 1 /* Conditional */ ? 2 /* Conditional */ : signal.quality === "estimated" ? 1 /* Interval */ : 0 /* Exact */
   };
 }
-function computeHotNumeric(snapshot, name) {
+function toHotNormalized(signal) {
+  if (signal.kind !== "known") {
+    return {
+      present: true,
+      value: null,
+      kind: signal.guard.kind === 1 /* Conditional */ ? 2 /* Conditional */ : 3 /* Unknown */
+    };
+  }
   return {
-    present: snapshot.signals.has(name),
-    ...readNumericSignalEvidence(snapshot, name)
+    present: true,
+    value: signal.normalized,
+    kind: signal.guard.kind === 1 /* Conditional */ ? 2 /* Conditional */ : signal.quality === "estimated" ? 1 /* Interval */ : 0 /* Exact */
   };
 }
-function computeHotNormalized(snapshot, name) {
+function computeHotSignals(snapshot) {
+  let lineHeight = ABSENT_NUMERIC;
+  let verticalAlign = ABSENT_NORMALIZED;
+  let alignSelf = ABSENT_NORMALIZED;
+  let placeSelf = ABSENT_NORMALIZED;
+  let flexDirection = ABSENT_NORMALIZED;
+  let gridAutoFlow = ABSENT_NORMALIZED;
+  let writingMode = ABSENT_NORMALIZED;
+  let direction = ABSENT_NORMALIZED;
+  let display = ABSENT_NORMALIZED;
+  let alignItems = ABSENT_NORMALIZED;
+  let placeItems = ABSENT_NORMALIZED;
+  let position = ABSENT_NORMALIZED;
+  let insetBlockStart = ABSENT_NUMERIC;
+  let insetBlockEnd = ABSENT_NUMERIC;
+  let transform = ABSENT_NUMERIC;
+  let translate = ABSENT_NUMERIC;
+  let top = ABSENT_NUMERIC;
+  let bottom = ABSENT_NUMERIC;
+  let marginTop = ABSENT_NUMERIC;
+  let marginBottom = ABSENT_NUMERIC;
+  for (const [name, value2] of snapshot.signals) {
+    switch (name) {
+      case "line-height":
+        lineHeight = toHotNumeric(value2);
+        break;
+      case "vertical-align":
+        verticalAlign = toHotNormalized(value2);
+        break;
+      case "align-self":
+        alignSelf = toHotNormalized(value2);
+        break;
+      case "place-self":
+        placeSelf = toHotNormalized(value2);
+        break;
+      case "flex-direction":
+        flexDirection = toHotNormalized(value2);
+        break;
+      case "grid-auto-flow":
+        gridAutoFlow = toHotNormalized(value2);
+        break;
+      case "writing-mode":
+        writingMode = toHotNormalized(value2);
+        break;
+      case "direction":
+        direction = toHotNormalized(value2);
+        break;
+      case "display":
+        display = toHotNormalized(value2);
+        break;
+      case "align-items":
+        alignItems = toHotNormalized(value2);
+        break;
+      case "place-items":
+        placeItems = toHotNormalized(value2);
+        break;
+      case "position":
+        position = toHotNormalized(value2);
+        break;
+      case "inset-block-start":
+        insetBlockStart = toHotNumeric(value2);
+        break;
+      case "inset-block-end":
+        insetBlockEnd = toHotNumeric(value2);
+        break;
+      case "transform":
+        transform = toHotNumeric(value2);
+        break;
+      case "translate":
+        translate = toHotNumeric(value2);
+        break;
+      case "top":
+        top = toHotNumeric(value2);
+        break;
+      case "bottom":
+        bottom = toHotNumeric(value2);
+        break;
+      case "margin-top":
+        marginTop = toHotNumeric(value2);
+        break;
+      case "margin-bottom":
+        marginBottom = toHotNumeric(value2);
+        break;
+      default:
+        break;
+    }
+  }
   return {
-    present: snapshot.signals.has(name),
-    ...readNormalizedSignalEvidence(snapshot, name)
+    lineHeight,
+    verticalAlign,
+    alignSelf,
+    placeSelf,
+    flexDirection,
+    gridAutoFlow,
+    writingMode,
+    direction,
+    display,
+    alignItems,
+    placeItems,
+    position,
+    insetBlockStart,
+    insetBlockEnd,
+    transform,
+    translate,
+    top,
+    bottom,
+    marginTop,
+    marginBottom
   };
 }
 function computeReservedSpaceFact(snapshot) {
@@ -36746,15 +36961,14 @@ function computeReservedSpaceFact(snapshot) {
 function hasPositiveOrDeclaredDimension(snapshot, property) {
   const signal = snapshot.signals.get(property);
   if (!signal) return false;
-  if (signal.guard !== "unconditional") return false;
+  if (signal.guard.kind !== 0 /* Unconditional */) return false;
   let normalized = "";
   if (signal.kind === "known") {
     if (signal.px !== null) return signal.px > 0;
     normalized = signal.normalized.trim().toLowerCase();
   }
   if (signal.kind === "unknown") {
-    if (signal.raw === null) return false;
-    normalized = signal.raw.trim().toLowerCase();
+    return signal.source !== null;
   }
   if (normalized.length === 0) return false;
   if (isNonReservingDimension(normalized)) return false;
@@ -36763,15 +36977,14 @@ function hasPositiveOrDeclaredDimension(snapshot, property) {
 function hasUsableAspectRatio(snapshot) {
   const signal = snapshot.signals.get("aspect-ratio");
   if (!signal) return false;
-  if (signal.guard !== "unconditional") return false;
+  if (signal.guard.kind !== 0 /* Unconditional */) return false;
+  if (signal.kind === "unknown") {
+    return false;
+  }
   let normalized = "";
   if (signal.kind === "known") {
     normalized = signal.normalized.trim().toLowerCase();
   }
-  if (signal.kind === "unknown") {
-    if (signal.raw === null) return false;
-    normalized = signal.raw.trim().toLowerCase();
-  }
   if (normalized.length === 0) return false;
   return normalized !== "auto";
 }
@@ -36789,8 +37002,8 @@ function computeScrollContainerFact(snapshot) {
   const yFromLonghand = parseSingleAxisScroll(overflowY);
   const xScroll = shorthandAxis.x;
   const yScroll = yFromLonghand === null ? shorthandAxis.y : yFromLonghand;
-  const hasConditionalScroll = overflowSignal?.guard === "conditional" && (shorthandAxis.x || shorthandAxis.y) || overflowYSignal?.guard === "conditional" && yFromLonghand === true;
-  const hasUnconditionalScroll = overflowSignal?.guard === "unconditional" && (shorthandAxis.x || shorthandAxis.y) || overflowYSignal?.guard === "unconditional" && yFromLonghand === true;
+  const hasConditionalScroll = overflowSignal?.guard.kind === 1 /* Conditional */ && (shorthandAxis.x || shorthandAxis.y) || overflowYSignal?.guard.kind === 1 /* Conditional */ && yFromLonghand === true;
+  const hasUnconditionalScroll = overflowSignal?.guard.kind === 0 /* Unconditional */ && (shorthandAxis.x || shorthandAxis.y) || overflowYSignal?.guard.kind === 0 /* Unconditional */ && yFromLonghand === true;
   return {
     isScrollContainer: xScroll || yScroll,
     axis: toScrollAxis(xScroll, yScroll),
@@ -36800,18 +37013,18 @@ function computeScrollContainerFact(snapshot) {
     hasUnconditionalScroll
   };
 }
+var NO_SCROLL = Object.freeze({ x: false, y: false });
+var BOTH_SCROLL = Object.freeze({ x: true, y: true });
 function parseOverflowShorthandAxis(value2) {
-  if (value2 === null) return { x: false, y: false };
-  const tokens = splitWhitespaceTokens(value2);
-  if (tokens.length === 0) return { x: false, y: false };
-  const first = tokens[0];
-  if (!first) return { x: false, y: false };
-  if (tokens.length === 1) {
-    const scroll = SCROLLABLE_VALUES.has(first);
-    return { x: scroll, y: scroll };
-  }
-  const second = tokens[1];
-  if (!second) return { x: SCROLLABLE_VALUES.has(first), y: false };
+  if (value2 === null) return NO_SCROLL;
+  const trimmed = value2.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)
@@ -36819,16 +37032,16 @@ function parseOverflowShorthandAxis(value2) {
 }
 function parseSingleAxisScroll(value2) {
   if (value2 === null) return null;
-  const tokens = splitWhitespaceTokens(value2);
-  const first = tokens[0];
-  if (!first) return null;
+  const trimmed = value2.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 "both";
-  if (x) return "x";
-  if (y) return "y";
-  return "none";
+  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");
@@ -36845,8 +37058,8 @@ function computeFlowParticipationFact(snapshot) {
   return {
     inFlow: !outOfFlow,
     position,
-    hasConditionalOutOfFlow: signal.guard === "conditional" && outOfFlow,
-    hasUnconditionalOutOfFlow: signal.guard === "unconditional" && outOfFlow
+    hasConditionalOutOfFlow: signal.guard.kind === 1 /* Conditional */ && outOfFlow,
+    hasUnconditionalOutOfFlow: signal.guard.kind === 0 /* Unconditional */ && outOfFlow
   };
 }
 function buildContextIndex(childrenByParentNode, snapshotByElementNode, perf) {
@@ -36921,7 +37134,7 @@ function collectAlignmentCases(context) {
           subjectDeclaredOffsetDeviation,
           subjectEffectiveOffsetDeviation,
           subjectLineHeightDeviation,
-          subjectStats.element.snapshot.textualContent,
+          subjectStats.element.snapshot.node.textualContent,
           subjectStats.element,
           subjectStats.contentComposition,
           cohortContentCompositions
@@ -37014,26 +37227,26 @@ function coverageFromNumeric(value2) {
 }
 function coverageFromConflict(value2) {
   const certainty = coverageFromKind(value2.kind);
-  if (value2.value === "unknown") return certainty * 0.4;
+  if (value2.value === 2 /* Unknown */) return certainty * 0.4;
   return certainty;
 }
 function coverageFromTextContrast(value2) {
-  if (value2 === "unknown") return 0.35;
+  if (value2 === 2 /* Unknown */) return 0.35;
   return 1;
 }
 function coverageFromSubjectText(subjectTextualContent) {
-  if (subjectTextualContent === "unknown") return 0.35;
+  if (subjectTextualContent === 2 /* Unknown */) return 0.35;
   return 1;
 }
 function coverageFromContextCertainty(certainty) {
-  if (certainty === "resolved") return 1;
-  if (certainty === "conditional") return 0.55;
+  if (certainty === 0 /* Resolved */) return 1;
+  if (certainty === 1 /* Conditional */) return 0.55;
   return 0.25;
 }
 function coverageFromKind(kind) {
-  if (kind === "exact") return 1;
-  if (kind === "interval") return 0.78;
-  if (kind === "conditional") return 0.5;
+  if (kind === 0 /* Exact */) return 1;
+  if (kind === 1 /* Interval */) return 0.78;
+  if (kind === 2 /* Conditional */) return 0.5;
   return 0.2;
 }
 function averageCoverage(...values) {
@@ -37066,24 +37279,7 @@ function resolveEffectiveAlignmentContext(parentContext, child, measurementNode,
   const childContext = contextByParentNode.get(child);
   if (!childContext) return parentContext;
   if (childContext.baselineRelevance !== "irrelevant") return parentContext;
-  return {
-    kind: parentContext.kind,
-    certainty: parentContext.certainty,
-    parentSolidFile: parentContext.parentSolidFile,
-    parentElementId: parentContext.parentElementId,
-    parentElementKey: parentContext.parentElementKey,
-    parentTag: parentContext.parentTag,
-    axis: parentContext.axis,
-    axisCertainty: parentContext.axisCertainty,
-    inlineDirection: parentContext.inlineDirection,
-    inlineDirectionCertainty: parentContext.inlineDirectionCertainty,
-    parentDisplay: parentContext.parentDisplay,
-    parentAlignItems: parentContext.parentAlignItems,
-    parentPlaceItems: parentContext.parentPlaceItems,
-    hasPositionedOffset: parentContext.hasPositionedOffset,
-    baselineRelevance: "irrelevant",
-    evidence: parentContext.evidence
-  };
+  return deriveAlignmentContext(parentContext, { baselineRelevance: "irrelevant" });
 }
 function compareAlignmentCaseOrder(left, right) {
   if (left.subject.solidFile < right.subject.solidFile) return -1;
@@ -37102,12 +37298,12 @@ function buildConsistencyEvidence(input) {
     input.cohortProfile.medianLineHeightPx,
     input.cohortProfile.medianDeclaredOffsetPx
   );
-  const offset = normalizeDeviation(
+  const offsetRaw = normalizeDeviation(
     input.subjectEffectiveOffsetDeviation,
     input.cohortProfile.effectiveOffsetDispersionPx,
     effectiveOffsetScaleReference
   );
-  const declaredOffset = normalizeDeviation(
+  const declaredOffsetRaw = normalizeDeviation(
     input.subjectDeclaredOffsetDeviation,
     input.cohortProfile.declaredOffsetDispersionPx,
     declaredOffsetScaleReference
@@ -37118,10 +37314,15 @@ function buildConsistencyEvidence(input) {
     input.cohortProfile.medianLineHeightPx
   );
   const baselinesIrrelevant = input.context.baselineRelevance === "irrelevant";
-  const baselineStrength = baselinesIrrelevant ? ZERO_STRENGTH : resolveBaselineStrength(input, lineHeight);
-  const contextStrength = baselinesIrrelevant ? ZERO_STRENGTH : resolveContextStrength(input, lineHeight);
-  const replacedStrength = baselinesIrrelevant ? ZERO_STRENGTH : resolveReplacedControlStrength(input, lineHeight);
-  const compositionStrength = baselinesIrrelevant ? ZERO_STRENGTH : resolveContentCompositionStrength(input);
+  const blockAxisIsMainAxis = !input.context.crossAxisIsBlockAxis;
+  const suppressAll = blockAxisIsMainAxis;
+  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 compositionStrength = compositionResult ? compositionResult.evidence : ZERO_STRENGTH;
   const contextCertaintyPenalty = resolveContextCertaintyPenalty(input);
   const provenance = input.cohortProvenance;
   const atoms = buildEvidenceAtoms(
@@ -37142,6 +37343,7 @@ function buildConsistencyEvidence(input) {
     contextStrength: contextStrength.strength,
     replacedStrength: replacedStrength.strength,
     compositionStrength: compositionStrength.strength,
+    majorityClassification: compositionResult ? compositionResult.divergence.majorityClassification : 5 /* Unknown */,
     identifiability: input.subjectIdentifiability,
     factSummary,
     atoms
@@ -37177,7 +37379,7 @@ function resolveOffsetScaleReference(medianLineHeightPx, fallbackMedianOffsetPx)
 }
 function resolveBaselineStrength(input, lineHeight) {
   const verticalAlign = input.cohortSignals.verticalAlign;
-  const hasConflict = verticalAlign.value === "conflict";
+  const hasConflict = verticalAlign.value === 0 /* Conflict */;
   const conflict = hasConflict ? alignmentStrengthCalibration.baselineConflictBoost : 0;
   const kind = resolveBaselineEvidenceKind(lineHeight.kind, verticalAlign.kind, hasConflict);
   return {
@@ -37187,7 +37389,7 @@ function resolveBaselineStrength(input, lineHeight) {
 }
 function resolveBaselineEvidenceKind(lineHeightKind, verticalAlignKind, hasConflict) {
   if (!hasConflict) return mergeEvidenceKind(lineHeightKind, verticalAlignKind);
-  if (lineHeightKind === "unknown") return verticalAlignKind;
+  if (lineHeightKind === 3 /* Unknown */) return verticalAlignKind;
   return mergeEvidenceKind(lineHeightKind, verticalAlignKind);
 }
 function resolveContextStrength(input, lineHeight) {
@@ -37215,7 +37417,7 @@ function resolveContextConflictEvidence(input) {
   const alignSelf = input.cohortSignals.alignSelf;
   const placeSelf = input.cohortSignals.placeSelf;
   const kind = mergeEvidenceKind(alignSelf.kind, placeSelf.kind);
-  const hasConflict = alignSelf.value === "conflict" || placeSelf.value === "conflict";
+  const hasConflict = alignSelf.value === 0 /* Conflict */ || placeSelf.value === 0 /* Conflict */;
   if (!hasConflict) {
     return {
       strength: 0,
@@ -37229,23 +37431,23 @@ function resolveContextConflictEvidence(input) {
 }
 function resolveReplacedControlStrength(input, lineHeight) {
   const subject = input.subject.snapshot;
-  const hasReplacedPair = subject.isControl || subject.isReplaced || input.cohortSignals.hasControlOrReplacedPeer;
+  const hasReplacedPair = subject.node.isControl || subject.node.isReplaced || input.cohortSignals.hasControlOrReplacedPeer;
   if (!hasReplacedPair) {
     return {
       strength: 0,
       kind: lineHeight.kind
     };
   }
-  if (input.cohortSignals.textContrastWithPeers === "different") {
+  if (input.cohortSignals.textContrastWithPeers === 0 /* Different */) {
     return {
       strength: alignmentStrengthCalibration.replacedDifferentTextBoost,
-      kind: "exact"
+      kind: 0 /* Exact */
     };
   }
-  if (input.cohortSignals.textContrastWithPeers === "unknown") {
+  if (input.cohortSignals.textContrastWithPeers === 2 /* Unknown */) {
     return {
       strength: alignmentStrengthCalibration.replacedUnknownTextBoost,
-      kind: "conditional"
+      kind: 2 /* Conditional */
     };
   }
   return {
@@ -37254,22 +37456,28 @@ function resolveReplacedControlStrength(input, lineHeight) {
   };
 }
 function resolveContentCompositionStrength(input) {
-  const divergenceStrength = resolveCompositionDivergenceStrength(
+  const divergence = resolveCompositionDivergence(
     input.subjectContentComposition,
     input.cohortContentCompositions,
     input.context
   );
-  if (divergenceStrength <= 0) {
+  if (divergence.strength <= 0) {
     return {
-      strength: 0,
-      kind: "exact"
+      evidence: {
+        strength: 0,
+        kind: 0 /* Exact */
+      },
+      divergence
     };
   }
   const subjectClassification = input.subjectContentComposition.classification;
-  const kind = subjectClassification === "unknown" ? "conditional" : "exact";
+  const kind = subjectClassification === 5 /* Unknown */ ? 2 /* Conditional */ : 0 /* Exact */;
   return {
-    strength: clamp(divergenceStrength, 0, 1),
-    kind
+    evidence: {
+      strength: clamp(divergence.strength, 0, 1),
+      kind
+    },
+    divergence
   };
 }
 function resolveContextCertaintyPenalty(input) {
@@ -37341,9 +37549,9 @@ function buildEvidenceAtoms(input, offset, declaredOffset, baselineStrength, con
   return out;
 }
 function mapContextCertaintyToEvidenceKind(certainty) {
-  if (certainty === "resolved") return "exact";
-  if (certainty === "conditional") return "conditional";
-  return "unknown";
+  if (certainty === 0 /* Resolved */) return 0 /* Exact */;
+  if (certainty === 1 /* Conditional */) return 2 /* Conditional */;
+  return 3 /* Unknown */;
 }
 function pushSupportAtom(out, factorId, valueKind, strength, coverage, provenance) {
   pushAtom(out, factorId, valueKind, strength, coverage, provenance, "support");
@@ -37369,19 +37577,19 @@ function pushAtom(out, factorId, valueKind, strength, coverage, provenance, expe
 }
 function toPositiveContribution(strength, maxWeight, valueKind) {
   const contribution = clamp(strength, 0, 2) * maxWeight;
-  if (valueKind === "exact") {
+  if (valueKind === 0 /* Exact */) {
     return {
       min: contribution,
       max: contribution
     };
   }
-  if (valueKind === "interval") {
+  if (valueKind === 1 /* Interval */) {
     return {
       min: contribution * evidenceContributionCalibration.supportIntervalLowerScale,
       max: contribution
     };
   }
-  if (valueKind === "conditional") {
+  if (valueKind === 2 /* Conditional */) {
     return {
       min: 0,
       max: contribution * evidenceContributionCalibration.supportConditionalUpperScale
@@ -37394,19 +37602,19 @@ function toPositiveContribution(strength, maxWeight, valueKind) {
 }
 function toNegativeContribution(strength, maxPenalty, valueKind) {
   const penalty = clamp(strength, 0, 1) * maxPenalty;
-  if (valueKind === "exact") {
+  if (valueKind === 0 /* Exact */) {
     return {
       min: -penalty,
       max: -penalty
     };
   }
-  if (valueKind === "interval") {
+  if (valueKind === 1 /* Interval */) {
     return {
       min: -penalty,
       max: -penalty * evidenceContributionCalibration.penaltyIntervalUpperScale
     };
   }
-  if (valueKind === "conditional") {
+  if (valueKind === 2 /* Conditional */) {
     return {
       min: -penalty,
       max: 0
@@ -37417,7 +37625,7 @@ function toNegativeContribution(strength, maxPenalty, valueKind) {
     max: 0
   };
 }
-var ZERO_STRENGTH = { strength: 0, kind: "exact" };
+var ZERO_STRENGTH = { strength: 0, kind: 0 /* Exact */ };
 
 // src/cross-file/layout/consistency-policy.ts
 function applyConsistencyPolicy(input) {
@@ -37501,23 +37709,38 @@ function resolveConfidence(posterior, evidenceMass) {
   const confidence = posterior.lower * weightedMass * (1 - intervalWidth * alignmentPolicyCalibration.confidenceIntervalPenalty);
   return clamp(confidence, 0, 1);
 }
+var EMPTY_FACTOR_LIST = Object.freeze([]);
 function selectTopFactors(evidence) {
-  const sorted = [...evidence.atoms];
-  sorted.sort((left, right) => {
-    const leftMagnitude = Math.abs((left.contribution.min + left.contribution.max) / 2);
-    const rightMagnitude = Math.abs((right.contribution.min + right.contribution.max) / 2);
-    if (leftMagnitude !== rightMagnitude) return rightMagnitude - leftMagnitude;
-    if (left.factorId < right.factorId) return -1;
-    if (left.factorId > right.factorId) return 1;
+  const atoms = evidence.atoms;
+  if (atoms.length === 0) return EMPTY_FACTOR_LIST;
+  const top = [];
+  for (let i = 0; i < atoms.length; i++) {
+    const atom = atoms[i];
+    if (!atom) continue;
+    const mag = Math.abs((atom.contribution.min + atom.contribution.max) / 2);
+    if (mag <= 0) continue;
+    if (top.length < 4) {
+      top.push({ id: atom.factorId, mag });
+      continue;
+    }
+    let minIdx = 0;
+    for (let j = 1; j < top.length; j++) {
+      const curr = top[j];
+      const best = top[minIdx];
+      if (curr && best && curr.mag < best.mag) minIdx = j;
+    }
+    const minEntry = top[minIdx];
+    if (minEntry && mag > minEntry.mag) {
+      top[minIdx] = { id: atom.factorId, mag };
+    }
+  }
+  top.sort((a, b) => {
+    if (a.mag !== b.mag) return b.mag - a.mag;
+    if (a.id < b.id) return -1;
+    if (a.id > b.id) return 1;
     return 0;
   });
-  const out = [];
-  for (let i = 0; i < sorted.length && i < 4; i++) {
-    const item = sorted[i];
-    if (!item) continue;
-    out.push(item.factorId);
-  }
-  return out;
+  return top.map((t) => t.id);
 }
 function logistic(value2) {
   if (value2 > 30) return 1;
@@ -37538,7 +37761,7 @@ function evaluateAlignmentCase(input) {
       evidenceMass: policy.evidenceMass
     };
   }
-  const signalFindings = buildFindingsFromAtoms(evidence.atoms, input);
+  const signalFindings = buildFindingsFromAtoms(evidence.atoms, input, evidence);
   return {
     kind: "accept",
     evaluation: {
@@ -37558,12 +37781,12 @@ function evaluateAlignmentCase(input) {
     }
   };
 }
-function buildFindingsFromAtoms(atoms, input) {
+function buildFindingsFromAtoms(atoms, input, evidence) {
   const byKind = /* @__PURE__ */ new Map();
   for (let i = 0; i < atoms.length; i++) {
     const atom = atoms[i];
     if (!atom) continue;
-    const factor = toFindingFactor(atom.factorId, input);
+    const factor = toFindingFactor(atom.factorId, input, evidence);
     if (factor === null) continue;
     const meanContribution = (atom.contribution.min + atom.contribution.max) / 2;
     if (meanContribution <= 0) continue;
@@ -37584,7 +37807,7 @@ function buildFindingsFromAtoms(atoms, input) {
   }
   return [...byKind.values()];
 }
-function toFindingFactor(factorId, input) {
+function toFindingFactor(factorId, input, evidence) {
   switch (factorId) {
     case "offset-delta":
       return {
@@ -37614,17 +37837,15 @@ function toFindingFactor(factorId, input) {
     case "content-composition-conflict":
       return {
         kind: "content-composition-conflict",
-        message: formatContentCompositionFinding(input)
+        message: formatContentCompositionFinding(input, evidence)
       };
     default:
       return null;
   }
 }
-function formatContentCompositionFinding(input) {
+function formatContentCompositionFinding(input, evidence) {
   const subjectClassification = formatCompositionClassification(input.subjectContentComposition.classification);
-  const majorityClassification = formatCompositionClassification(
-    resolveMajorityClassification(input.cohortContentCompositions)
-  );
+  const majorityClassification = formatCompositionClassification(evidence.majorityClassification);
   const fixSuggestion = formatCompositionFixSuggestion(input.subjectContentComposition);
   return `siblings have identical CSS but different content composition (subject: ${subjectClassification}, majority: ${majorityClassification}; fix: ${fixSuggestion})`;
 }
@@ -37683,7 +37904,7 @@ function recordPolicyMetrics(context, evidenceMass, posteriorLower, posteriorUpp
   context.layout.perf.factorCoverageSum += clamp(evidenceMass, 0, 1);
   context.layout.perf.factorCoverageCount++;
   const width = clamp(posteriorUpper - posteriorLower, 0, 1);
-  context.layout.perf.posteriorWidths.push(width);
+  reservoirPush(context.layout.perf.posteriorWidths, width);
   if (width > 1e-3) context.layout.perf.uncertaintyEscalations++;
 }
 
@@ -37796,16 +38017,16 @@ function readNodeRefById(layout, solidFile, elementId) {
 }
 function isFlowRelevantBySiblingsOrText(node, textualContent) {
   if (node.siblingCount >= 2) return true;
-  return textualContent === "yes" || textualContent === "unknown" || textualContent === "dynamic-text";
+  return textualContent === 0 /* Yes */ || textualContent === 2 /* Unknown */ || textualContent === 3 /* DynamicText */;
 }
 function isDeferredContainerLike(node, textualContent) {
   if (node.siblingCount >= 2) return true;
-  if (textualContent === "unknown") return true;
+  if (textualContent === 2 /* Unknown */) return true;
   if (node.tagName !== null && SECTIONING_CONTAINER_TAGS.has(node.tagName)) return true;
   return false;
 }
 function isDynamicContainerLike(node) {
-  return node.textualContent === "unknown" && node.siblingCount >= 2;
+  return node.textualContent === 2 /* Unknown */ && node.siblingCount >= 2;
 }
 function isLikelyViewportAffectingContainer(node) {
   if (node.siblingCount >= 2) return true;
@@ -39045,7 +39266,7 @@ var cssLayoutScrollbarGutterInstability = defineCrossRule({
       const snapshot = collectSignalSnapshot(context, node);
       const scroll = readScrollContainerFact(context.layout, node);
       if (!scroll.isScrollContainer) continue;
-      if (scroll.axis !== "y" && scroll.axis !== "both") continue;
+      if (scroll.axis !== 2 /* Y */ && scroll.axis !== 3 /* Both */) continue;
       const scrollbarWidth = readKnownNormalized(snapshot, "scrollbar-width");
       if (scrollbarWidth === "none") continue;
       const gutter = readKnownNormalized(snapshot, "scrollbar-gutter");
@@ -39175,10 +39396,10 @@ var cssLayoutConditionalDisplayCollapse = defineCrossRule({
       const display = readKnownNormalizedWithGuard(snapshot, "display");
       if (!display || !COLLAPSING_DISPLAYS.has(display)) continue;
       const displaySignal = snapshot.signals.get("display");
-      if (!displaySignal || displaySignal.guard !== "conditional") continue;
+      if (!displaySignal || displaySignal.guard.kind !== 1 /* Conditional */) continue;
       const flow = readFlowParticipationFact(context.layout, node);
       if (!flow.inFlow) continue;
-      if (!isFlowRelevantBySiblingsOrText(node, snapshot.textualContent)) continue;
+      if (!isFlowRelevantBySiblingsOrText(node, snapshot.node.textualContent)) continue;
       const reservedSpace = readReservedSpaceFact(context.layout, node);
       if (reservedSpace.hasReservedSpace) continue;
       if (!emitLayoutDiagnostic(context.layout, node, emit, cssLayoutConditionalDisplayCollapse.id, "conditionalDisplayCollapse", messages152.conditionalDisplayCollapse, cssLayoutConditionalDisplayCollapse.severity, { display })) continue;
@@ -39214,10 +39435,10 @@ var cssLayoutConditionalWhiteSpaceWrapShift = defineCrossRule({
       if (!hasWrapShiftDelta(whiteSpaceDelta)) continue;
       if (!whiteSpace) continue;
       const whiteSpaceSignal = snapshot.signals.get("white-space");
-      if (!whiteSpaceSignal || whiteSpaceSignal.guard !== "conditional") continue;
+      if (!whiteSpaceSignal || whiteSpaceSignal.guard.kind !== 1 /* Conditional */) continue;
       const flow = readFlowParticipationFact(context.layout, node);
       if (!flow.inFlow) continue;
-      if (!isFlowRelevantBySiblingsOrText(node, snapshot.textualContent)) continue;
+      if (!isFlowRelevantBySiblingsOrText(node, snapshot.node.textualContent)) continue;
       if (hasStableTextShell(snapshot)) continue;
       if (!emitLayoutDiagnostic(context.layout, node, emit, cssLayoutConditionalWhiteSpaceWrapShift.id, "conditionalWhiteSpaceShift", messages153.conditionalWhiteSpaceShift, cssLayoutConditionalWhiteSpaceWrapShift.severity, { whiteSpace })) continue;
     }
@@ -39354,7 +39575,7 @@ var cssLayoutContentVisibilityNoIntrinsicSize = defineCrossRule({
       const node = candidates[i];
       if (!node) continue;
       const snapshot = collectSignalSnapshot(context, node);
-      if (!isDeferredContainerLike(node, snapshot.textualContent)) continue;
+      if (!isDeferredContainerLike(node, snapshot.node.textualContent)) continue;
       const reservedSpace = readReservedSpaceFact(context.layout, node);
       if (reservedSpace.hasReservedSpace) continue;
       if (!emitLayoutDiagnostic(context.layout, node, emit, cssLayoutContentVisibilityNoIntrinsicSize.id, "missingIntrinsicSize", messages156.missingIntrinsicSize, cssLayoutContentVisibilityNoIntrinsicSize.severity)) continue;
@@ -39413,11 +39634,11 @@ function collectConditionalOffsets(layout, node, snapshot) {
     if (!delta.hasConditional || !delta.hasDelta) continue;
     const signal = snapshot.signals.get(name);
     if (!signal) continue;
-    if (signal.guard !== "conditional") continue;
+    if (signal.guard.kind !== 1 /* Conditional */) continue;
     if (signal.kind !== "known") continue;
     if (signal.px === null) continue;
     if (Math.abs(signal.px) <= 0.25) continue;
-    out.push({ property: name, value: signal.px, guardKey: signal.guardProvenance.key });
+    out.push({ property: name, value: signal.px, guardKey: signal.guard.key });
   }
   return out;
 }
@@ -39438,8 +39659,8 @@ function hasEffectivePositionForConditionalOffset(snapshot, guardKey) {
   const position = snapshot.signals.get("position");
   if (!position) return false;
   if (position.kind !== "known") return false;
-  if (position.guard !== "conditional") return false;
-  if (position.guardProvenance.key !== guardKey) return false;
+  if (position.guard.kind !== 1 /* Conditional */) return false;
+  if (position.guard.key !== guardKey) return false;
   return position.normalized !== "static";
 }
 function hasStableBaseline(baselineBySignal, property, expectedPx) {