@drskillissue/ganko 0.1.23 → 0.1.25

package/dist/{chunk-V6U7TQCD.js → chunk-64TMAKYI.js}

@@ -2696,7 +2696,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,
@@ -2706,13 +2706,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
@@ -7565,9 +7566,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}}' is rendered inside a conditional mount point ({{mountTag}}) with a distant Suspense boundary. When the fetcher's Promise is pending, the SuspenseContext increment fires and unmounts the entire subtree. initialValue does NOT prevent this \u2014 it only prevents the accessor from returning undefined.",
-  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 absorbs it and stays in its fallback state permanently. Wrap the component in <ErrorBoundary fallback={...}> or catch errors inside the fetcher."
+  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) {
@@ -7653,7 +7654,8 @@ function analyzeComponentBoundaries(graph, componentName) {
   const result = {
     conditionalMountTag: null,
     suspenseDistance: 0,
-    lacksErrorBoundary: false
+    lacksErrorBoundary: false,
+    usagesLackingErrorBoundary: []
   };
   const usages = graph.jsxByTag.get(componentName) ?? [];
   if (usages.length === 0) return result;
@@ -7675,6 +7677,7 @@ function analyzeComponentBoundaries(graph, componentName) {
           foundSuspense = true;
           if (!foundErrorBoundary) {
             result.lacksErrorBoundary = true;
+            result.usagesLackingErrorBoundary.push(usage);
           }
           if (conditionalTag !== null && componentLevels > 1) {
             result.conditionalMountTag = conditionalTag;
@@ -7689,6 +7692,7 @@ function analyzeComponentBoundaries(graph, componentName) {
     }
     if (!foundSuspense && !foundErrorBoundary) {
       result.lacksErrorBoundary = true;
+      result.usagesLackingErrorBoundary.push(usage);
       if (conditionalTag !== null) {
         result.conditionalMountTag = conditionalTag;
         result.suspenseDistance = componentLevels;
@@ -7712,13 +7716,28 @@ 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 that implicitly triggers or permanently breaks Suspense boundaries.",
-    fixable: false,
+    fixable: true,
     category: "reactivity"
   },
   options: options16,
@@ -7773,6 +7792,10 @@ var resourceImplicitSuspense = defineSolidRule({
       if (analysis.lacksErrorBoundary) {
         const fetcherFn = resolveFetcherFunction(graph, call);
         if (fetcherFn && fetcherCanThrow(graph, fetcherFn, throwVisited)) {
+          const errorBoundaryFix = buildErrorBoundaryFix(
+            analysis.usagesLackingErrorBoundary,
+            graph
+          );
           emit(
             createDiagnostic(
               graph.file,
@@ -7780,7 +7803,8 @@ var resourceImplicitSuspense = defineSolidRule({
               "resource-implicit-suspense",
               "missingErrorBoundary",
               resolveMessage(messages16.missingErrorBoundary, { name: resourceName }),
-              "error"
+              "error",
+              errorBoundaryFix ?? void 0
             )
           );
         }
@@ -30281,7 +30305,168 @@ function collectTransitiveCSSScope(entryPath, resolver, cssFilesByNormalizedPath
   return out;
 }
 
+// src/cross-file/layout/signal-model.ts
+var layoutSignalNames = [
+  "line-height",
+  "font-size",
+  "width",
+  "inline-size",
+  "height",
+  "block-size",
+  "min-width",
+  "min-block-size",
+  "min-height",
+  "aspect-ratio",
+  "vertical-align",
+  "display",
+  "white-space",
+  "object-fit",
+  "overflow",
+  "overflow-y",
+  "overflow-anchor",
+  "scrollbar-gutter",
+  "scrollbar-width",
+  "contain-intrinsic-size",
+  "content-visibility",
+  "align-items",
+  "align-self",
+  "justify-items",
+  "place-items",
+  "place-self",
+  "flex-direction",
+  "grid-auto-flow",
+  "appearance",
+  "box-sizing",
+  "padding-top",
+  "padding-left",
+  "padding-right",
+  "padding-bottom",
+  "border-top-width",
+  "border-left-width",
+  "border-right-width",
+  "border-bottom-width",
+  "position",
+  "top",
+  "bottom",
+  "margin-top",
+  "margin-bottom",
+  "transform",
+  "translate",
+  "inset-block-start",
+  "inset-block-end",
+  "writing-mode",
+  "direction"
+];
+
+// src/cross-file/layout/util.ts
+var CONTROL_ELEMENT_TAGS = /* @__PURE__ */ new Set([
+  "input",
+  "select",
+  "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 mergeEvidenceKind(left, 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 !== 0 /* Exact */) return null;
+    return value2.value;
+  }
+  if (value2.kind === 0 /* Exact */) return 0;
+  return null;
+}
+
 // 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,
@@ -30338,7 +30523,7 @@ function createLayoutPerfStats() {
     cohortUnimodalFalse: 0,
     factorCoverageSum: 0,
     factorCoverageCount: 0,
-    posteriorWidths: [],
+    posteriorWidths: createReservoir(200),
     uncertaintyEscalations: 0,
     signalSnapshotsBuilt: 0,
     signalSnapshotCacheHits: 0,
@@ -30403,14 +30588,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
@@ -31519,98 +31702,47 @@ 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;
 }
 
-// src/cross-file/layout/util.ts
-var CONTROL_ELEMENT_TAGS = /* @__PURE__ */ new Set([
-  "input",
-  "select",
-  "textarea",
-  "button"
-]);
-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;
-}
-function toComparableExactValue(value2) {
-  if (value2.value !== null) {
-    if (value2.kind !== "exact") return null;
-    return value2.value;
-  }
-  if (value2.kind === "exact") return 0;
-  return null;
-}
-
-// src/cross-file/layout/signal-model.ts
-var layoutSignalNames = [
-  "line-height",
-  "font-size",
-  "width",
-  "inline-size",
-  "height",
-  "block-size",
-  "min-width",
-  "min-block-size",
-  "min-height",
-  "aspect-ratio",
-  "vertical-align",
-  "display",
-  "white-space",
-  "object-fit",
-  "overflow",
-  "overflow-y",
-  "overflow-anchor",
-  "scrollbar-gutter",
-  "scrollbar-width",
-  "contain-intrinsic-size",
-  "content-visibility",
-  "align-items",
-  "align-self",
-  "justify-items",
-  "place-items",
-  "place-self",
-  "appearance",
-  "box-sizing",
-  "padding-top",
-  "padding-left",
-  "padding-right",
-  "padding-bottom",
-  "border-top-width",
-  "border-left-width",
-  "border-right-width",
-  "border-bottom-width",
-  "position",
-  "top",
-  "bottom",
-  "margin-top",
-  "margin-bottom",
-  "transform",
-  "translate",
-  "inset-block-start",
-  "inset-block-end",
-  "writing-mode",
-  "direction"
-];
-
 // src/cross-file/layout/signal-normalization.ts
 var MONITORED_SIGNAL_SET = new Set(layoutSignalNames);
 var MONITORED_SIGNAL_NAME_MAP = new Map(
@@ -31621,7 +31753,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",
@@ -31663,13 +31796,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);
@@ -31680,7 +31822,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();
@@ -31691,12 +31833,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;
     }
   }
@@ -31712,7 +31853,6 @@ function normalizeSignalMapWithCounts(values) {
       name,
       declaration.value,
       declaration.source,
-      declaration.guard,
       declaration.guardProvenance,
       fontSizePx
     );
@@ -31722,7 +31862,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;
     }
@@ -31750,7 +31890,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;
   }
@@ -31760,127 +31900,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");
   }
-  return createKnown(name, raw, source, guard, guardProvenance, px, "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 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;
@@ -31892,28 +32044,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
   };
 }
@@ -32874,16 +33022,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_RE3 = /\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("&")
   };
@@ -32937,7 +33085,7 @@ function buildCondition(kind, query) {
 }
 function normalizeQuery(query) {
   if (query === null) return null;
-  const normalized = query.trim().toLowerCase().replace(WHITESPACE_RE3, " ");
+  const normalized = query.trim().toLowerCase().replace(WHITESPACE_RE_GLOBAL, " ");
   if (normalized.length === 0) return null;
   return normalized;
 }
@@ -32989,13 +33137,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,
@@ -33026,7 +33168,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;
     }
@@ -33052,6 +33194,11 @@ function inheritSignalsFromParent(parentSnapshot, local) {
   };
 }
 
+// src/cross-file/layout/context-model.ts
+function deriveAlignmentContext(base, overrides) {
+  return { ...base, ...overrides };
+}
+
 // src/cross-file/layout/signal-access.ts
 var EMPTY_STRING_LIST = Object.freeze([]);
 var EMPTY_LAYOUT_NODE_LIST = Object.freeze([]);
@@ -33070,7 +33217,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,
@@ -33103,53 +33250,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 {
@@ -33160,7 +33282,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) {
@@ -33194,19 +33316,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;
 }
@@ -33234,7 +33356,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);
@@ -33256,7 +33378,6 @@ function readStatefulBaseValueIndex(graph) {
 }
 
 // src/cross-file/layout/context-classification.ts
-var WHITESPACE_RE4 = /\s+/;
 var TABLE_SEMANTIC_TAGS = /* @__PURE__ */ new Set(["table", "thead", "tbody", "tfoot", "tr", "td", "th"]);
 var TABLE_DISPLAY_VALUES = /* @__PURE__ */ new Set([
   "table",
@@ -33273,7 +33394,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);
@@ -33296,6 +33416,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,
@@ -33311,6 +33432,8 @@ function createAlignmentContextForParent(parent, snapshot) {
     parentAlignItems,
     parentPlaceItems,
     hasPositionedOffset: positionedOffset.hasPositionedOffset,
+    crossAxisIsBlockAxis: crossAxisInfo.value,
+    crossAxisIsBlockAxisCertainty: crossAxisInfo.certainty,
     baselineRelevance,
     evidence
   };
@@ -33320,7 +33443,7 @@ function classifyKind(evidence) {
   if (evidence.hasTableSemantics) {
     return {
       kind: "table-cell",
-      certainty: "resolved"
+      certainty: 0 /* Resolved */
     };
   }
   if (evidence.containerKind === "table") {
@@ -33407,7 +33530,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];
@@ -33457,7 +33580,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");
@@ -33482,7 +33605,7 @@ function resolveInlineDirection(snapshot) {
   if (!snapshot.signals.has("direction")) {
     return {
       value: "ltr",
-      certainty: "resolved"
+      certainty: 0 /* Resolved */
     };
   }
   const direction = readNormalizedSignalEvidence(snapshot, "direction");
@@ -33498,16 +33621,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);
@@ -33522,15 +33645,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",
@@ -33554,7 +33695,7 @@ function computeBaselineRelevance(kind, parentAlignItems, parentPlaceItems) {
 function resolveEffectiveAlignItems(alignItems, placeItems) {
   if (alignItems !== null) return alignItems;
   if (placeItems === null) return null;
-  const firstToken2 = placeItems.split(WHITESPACE_RE4)[0];
+  const firstToken2 = placeItems.split(WHITESPACE_RE3)[0];
   return firstToken2 ?? null;
 }
 var TABLE_CELL_GEOMETRIC_VERTICAL_ALIGN = /* @__PURE__ */ new Set([
@@ -33569,24 +33710,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" }));
   }
 }
 
@@ -33650,7 +33774,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;
     }
@@ -33844,15 +33968,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",
@@ -33886,7 +34001,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,
@@ -33900,10 +34015,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 {
@@ -33914,7 +34029,7 @@ function computeContentCompositionFingerprint(elementNode, childrenByParentNode,
       wrappingContextMitigates: false,
       hasVerticalAlignMitigation: false,
       mixedContentDepth: 0,
-      classification: "block-segmented",
+      classification: 4 /* BlockSegmented */,
       analyzableChildCount: 0,
       totalChildCount: 0,
       hasOnlyBlockChildren: false
@@ -33924,7 +34039,7 @@ function computeContentCompositionFingerprint(elementNode, childrenByParentNode,
     elementNode,
     childrenByParentNode,
     snapshotByElementNode,
-    snapshotHotSignalsByElementKey,
+    snapshotHotSignalsByNode,
     state,
     0
   );
@@ -33944,7 +34059,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++) {
@@ -33955,7 +34070,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;
@@ -33977,16 +34092,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);
@@ -33996,7 +34111,7 @@ function walkInlineDescendants(node, childrenByParentNode, snapshotByElementNode
         child,
         childrenByParentNode,
         snapshotByElementNode,
-        snapshotHotSignalsByElementKey,
+        snapshotHotSignalsByNode,
         state,
         depth + 1
       );
@@ -34031,19 +34146,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;
@@ -34058,12 +34173,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;
       }
     }
@@ -34086,30 +34201,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);
@@ -34129,10 +34244,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++) {
@@ -34144,10 +34263,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) {
@@ -34155,35 +34271,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;
@@ -34204,28 +34323,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) {
@@ -34233,12 +34333,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) {
@@ -34246,24 +34346,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";
     }
@@ -34298,12 +34393,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);
@@ -34374,7 +34469,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;
@@ -34408,7 +34503,7 @@ function buildCohortIndex(input) {
         subjectMetrics.rootNode,
         input.childrenByParentNode,
         input.snapshotByElementNode,
-        input.snapshotHotSignalsByElementKey
+        input.snapshotHotSignalsByNode
       );
       subjectsByElementKey.set(subjectMetrics.key, {
         element: subjectMetrics.element,
@@ -34474,7 +34569,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}`);
     }
@@ -34799,9 +34894,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;
@@ -34815,12 +34910,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++;
@@ -34840,24 +34935,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
     },
@@ -34894,9 +34989,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(
@@ -34929,7 +35024,7 @@ function resolveComparableVerticalAlign(verticalAlign, isControlOrReplaced) {
   return {
     present: verticalAlign.present,
     value: "baseline",
-    kind: "exact"
+    kind: 0 /* Exact */
   };
 }
 function hasComparablePeer(aggregate, subjectValue) {
@@ -34946,37 +35041,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);
@@ -34992,7 +35087,7 @@ function resolveSubjectIdentifiability(subjectMetrics, profile, subjectBaselineP
     return {
       dominantShare: profile.dominantClusterShare,
       subjectExcludedDominantShare: subjectBaselineProfile.dominantClusterShare,
-      subjectMembership: "insufficient",
+      subjectMembership: 3 /* Insufficient */,
       ambiguous: true,
       kind
     };
@@ -35001,7 +35096,7 @@ function resolveSubjectIdentifiability(subjectMetrics, profile, subjectBaselineP
     return {
       dominantShare: profile.dominantClusterShare,
       subjectExcludedDominantShare: subjectBaselineProfile.dominantClusterShare,
-      subjectMembership: "dominant",
+      subjectMembership: 0 /* Dominant */,
       ambiguous: false,
       kind
     };
@@ -35010,7 +35105,7 @@ function resolveSubjectIdentifiability(subjectMetrics, profile, subjectBaselineP
     return {
       dominantShare: profile.dominantClusterShare,
       subjectExcludedDominantShare: subjectBaselineProfile.dominantClusterShare,
-      subjectMembership: "insufficient",
+      subjectMembership: 3 /* Insufficient */,
       ambiguous: true,
       kind
     };
@@ -35020,7 +35115,7 @@ function resolveSubjectIdentifiability(subjectMetrics, profile, subjectBaselineP
     return {
       dominantShare: profile.dominantClusterShare,
       subjectExcludedDominantShare: subjectBaselineProfile.dominantClusterShare,
-      subjectMembership: "insufficient",
+      subjectMembership: 3 /* Insufficient */,
       ambiguous: true,
       kind
     };
@@ -35030,7 +35125,7 @@ function resolveSubjectIdentifiability(subjectMetrics, profile, subjectBaselineP
     return {
       dominantShare: profile.dominantClusterShare,
       subjectExcludedDominantShare: subjectBaselineProfile.dominantClusterShare,
-      subjectMembership: "ambiguous",
+      subjectMembership: 2 /* Ambiguous */,
       ambiguous: true,
       kind
     };
@@ -35039,7 +35134,7 @@ function resolveSubjectIdentifiability(subjectMetrics, profile, subjectBaselineP
     return {
       dominantShare: profile.dominantClusterShare,
       subjectExcludedDominantShare: subjectBaselineProfile.dominantClusterShare,
-      subjectMembership: "dominant",
+      subjectMembership: 0 /* Dominant */,
       ambiguous: false,
       kind
     };
@@ -35047,13 +35142,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;
@@ -35068,12 +35163,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,
@@ -35091,9 +35186,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);
@@ -35131,8 +35226,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);
       }
@@ -35162,7 +35257,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;
@@ -35179,9 +35274,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;
@@ -35201,66 +35296,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;
@@ -35359,7 +35394,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;
@@ -35385,7 +35420,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;
 }
 
@@ -35432,7 +35467,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++;
@@ -35474,7 +35509,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];
@@ -35484,7 +35519,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;
   }
@@ -35943,12 +35978,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;
@@ -35959,8 +35988,7 @@ function collectMonitoredDeclarations(selector, layerOrder, guard) {
     out.push({
       property: monitored,
       value: declaration.value,
-      guard: signalGuard,
-      guardProvenance,
+      guardProvenance: guard,
       position: {
         layer: declaration.cascadePosition.layer,
         layerOrder,
@@ -35982,6 +36010,7 @@ function toMonitoredSignalKey(property) {
     case "margin-block":
     case "padding-block":
     case "inset-block":
+    case "flex-flow":
       return property;
     default:
       return null;
@@ -36005,30 +36034,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);
@@ -36054,7 +36080,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"
   };
@@ -36071,8 +36097,7 @@ function augmentCascadeWithTailwind(cascade, node, tailwind) {
       if (cascade.has(property)) continue;
       cascade.set(property, {
         value: value2,
-        source: "selector",
-        guard: "unconditional",
+        source: 0 /* Selector */,
         guardProvenance
       });
     }
@@ -36092,8 +36117,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);
@@ -36112,33 +36136,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);
@@ -36155,7 +36172,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;
     }
@@ -36163,16 +36180,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;
@@ -36180,14 +36200,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();
@@ -36212,7 +36232,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;
             }
@@ -36252,7 +36272,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);
@@ -36289,13 +36309,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 = [];
@@ -36422,8 +36442,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;
@@ -36431,8 +36451,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;
@@ -36446,31 +36466,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;
@@ -36769,8 +36789,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,
@@ -36811,22 +36829,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;
@@ -36834,7 +36855,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];
@@ -36842,7 +36863,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);
@@ -36850,7 +36871,7 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
   const factIndex = buildElementFactIndex(elements, snapshotByElementNode);
   const conditionalDeltaIndex = buildConditionalDeltaIndex(
     elements,
-    appliesByElementKey,
+    appliesByNode,
     monitoredDeclarationsBySelectorId
   );
   const elementsWithConditionalOverflowDelta = buildConditionalDeltaSignalGroupElements(
@@ -36868,7 +36889,7 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
     contextByParentNode,
     measurementNodeByRootKey,
     snapshotByElementNode,
-    snapshotHotSignalsByElementKey: factIndex.snapshotHotSignalsByElementKey
+    snapshotHotSignalsByNode: factIndex.snapshotHotSignalsByNode
   });
   finalizeTableCellBaselineRelevance(contextByParentNode, cohortIndex.verticalAlignConsensusByParent);
   perf.conditionalSignals = cohortIndex.conditionalSignals;
@@ -36884,11 +36905,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,
@@ -36896,12 +36917,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,
@@ -36913,11 +36934,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 = [];
@@ -36927,7 +36948,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) {
@@ -36948,18 +36969,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) {
@@ -36990,49 +37011,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) {
@@ -37067,15 +37202,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;
@@ -37084,15 +37218,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";
 }
@@ -37110,8 +37243,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),
@@ -37121,18 +37254,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)
@@ -37140,16 +37273,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");
@@ -37166,8 +37299,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) {
@@ -37280,7 +37413,7 @@ function collectAlignmentCases(context) {
           subjectDeclaredOffsetDeviation,
           subjectEffectiveOffsetDeviation,
           subjectLineHeightDeviation,
-          subjectStats.element.snapshot.textualContent,
+          subjectStats.element.snapshot.node.textualContent,
           subjectStats.element,
           subjectStats.contentComposition,
           cohortContentCompositions
@@ -37373,26 +37506,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) {
@@ -37425,24 +37558,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;
@@ -37461,12 +37577,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
@@ -37477,10 +37593,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(
@@ -37501,6 +37622,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
@@ -37536,7 +37658,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 {
@@ -37546,7 +37668,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) {
@@ -37574,7 +37696,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,
@@ -37588,23 +37710,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 {
@@ -37613,22 +37735,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) {
@@ -37700,9 +37828,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");
@@ -37728,19 +37856,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
@@ -37753,19 +37881,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
@@ -37776,7 +37904,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) {
@@ -37860,23 +37988,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;
@@ -37897,7 +38040,7 @@ function evaluateAlignmentCase(input) {
       evidenceMass: policy.evidenceMass
     };
   }
-  const signalFindings = buildFindingsFromAtoms(evidence.atoms, input);
+  const signalFindings = buildFindingsFromAtoms(evidence.atoms, input, evidence);
   return {
     kind: "accept",
     evaluation: {
@@ -37917,12 +38060,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;
@@ -37943,7 +38086,7 @@ function buildFindingsFromAtoms(atoms, input) {
   }
   return [...byKind.values()];
 }
-function toFindingFactor(factorId, input) {
+function toFindingFactor(factorId, input, evidence) {
   switch (factorId) {
     case "offset-delta":
       return {
@@ -37973,17 +38116,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})`;
 }
@@ -38042,7 +38183,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++;
 }
 
@@ -38148,16 +38289,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;
@@ -39397,7 +39538,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");
@@ -39527,10 +39668,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;
@@ -39566,10 +39707,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;
     }
@@ -39706,7 +39847,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;
@@ -39765,11 +39906,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;
 }
@@ -39790,8 +39931,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) {
@@ -40307,4 +40448,4 @@ export {
   rules3,
   runCrossFileRules
 };
-//# sourceMappingURL=chunk-V6U7TQCD.js.map
+//# sourceMappingURL=chunk-64TMAKYI.js.map