@drskillissue/ganko 0.1.19 → 0.1.20

package/dist/eslint-plugin.cjs

@@ -30006,6 +30006,7 @@ function readStatefulBaseValueIndex(graph) {
 }
 
 // src/cross-file/layout/context-classification.ts
+var WHITESPACE_RE3 = /\s+/;
 var TABLE_SEMANTIC_TAGS = /* @__PURE__ */ new Set(["table", "thead", "tbody", "tfoot", "tr", "td", "th"]);
 var TABLE_DISPLAY_VALUES = /* @__PURE__ */ new Set([
   "table",
@@ -30044,6 +30045,7 @@ function createAlignmentContextForParent(parent, snapshot) {
   const classified = classifyKind(evidence);
   const contextCertainty = combineCertainty(classified.certainty, axis.certainty);
   const certainty = combineCertainty(contextCertainty, inlineDirection.certainty);
+  const baselineRelevance = computeBaselineRelevance(classified.kind, parentAlignItems, parentPlaceItems);
   const out = {
     kind: classified.kind,
     certainty,
@@ -30059,6 +30061,7 @@ function createAlignmentContextForParent(parent, snapshot) {
     parentAlignItems,
     parentPlaceItems,
     hasPositionedOffset: positionedOffset.hasPositionedOffset,
+    baselineRelevance,
     evidence
   };
   return out;
@@ -30279,6 +30282,63 @@ function combineCertainty(left, right) {
   if (left === "conditional" || right === "conditional") return "conditional";
   return "resolved";
 }
+var FLEX_GRID_GEOMETRIC_ALIGN_ITEMS = /* @__PURE__ */ new Set([
+  "center",
+  "flex-start",
+  "flex-end",
+  "start",
+  "end",
+  "stretch",
+  "self-start",
+  "self-end",
+  "normal"
+]);
+function computeBaselineRelevance(kind, parentAlignItems, parentPlaceItems) {
+  if (kind === "flex-cross-axis" || kind === "grid-cross-axis") {
+    const effective = resolveEffectiveAlignItems(parentAlignItems, parentPlaceItems);
+    if (effective === null) return "relevant";
+    return FLEX_GRID_GEOMETRIC_ALIGN_ITEMS.has(effective) ? "irrelevant" : "relevant";
+  }
+  return "relevant";
+}
+function resolveEffectiveAlignItems(alignItems, placeItems) {
+  if (alignItems !== null) return alignItems;
+  if (placeItems === null) return null;
+  const firstToken2 = placeItems.split(WHITESPACE_RE3)[0];
+  return firstToken2 ?? null;
+}
+var TABLE_CELL_GEOMETRIC_VERTICAL_ALIGN = /* @__PURE__ */ new Set([
+  "middle",
+  "top",
+  "bottom"
+]);
+function finalizeTableCellBaselineRelevance(contextByParentNode, cohortVerticalAlignConsensus) {
+  for (const [parent, consensusValue] of cohortVerticalAlignConsensus) {
+    const context = contextByParentNode.get(parent);
+    if (!context) continue;
+    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
+    });
+  }
+}
 
 // src/cross-file/layout/diagnostics.ts
 var FINDING_WEIGHT_BY_KIND = /* @__PURE__ */ new Map([
@@ -32974,7 +33034,7 @@ var UNCONDITIONAL_GUARD = {
   conditions: [],
   key: "always"
 };
-var WHITESPACE_RE3 = /\s+/g;
+var WHITESPACE_RE4 = /\s+/g;
 function resolveRuleGuard(rule) {
   const conditions = collectRuleConditions(rule);
   if (conditions.length === 0) return UNCONDITIONAL_GUARD;
@@ -33033,7 +33093,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_RE4, " ");
   if (normalized.length === 0) return null;
   return normalized;
 }
@@ -33655,12 +33715,7 @@ function resolveInlineReplacedKindDivergence(subjectFingerprint, allFingerprints
   return alignmentStrengthCalibration.compositionMixedOutlierAmongReplacedStrength;
 }
 function hasSharedBaselineAlignment(context) {
-  if (context.kind === "inline-formatting" || context.kind === "table-cell") return true;
-  if (context.kind === "flex-cross-axis" || context.kind === "grid-cross-axis") {
-    const alignItems = context.parentAlignItems;
-    return alignItems === null || alignItems === "baseline";
-  }
-  return false;
+  return context.baselineRelevance === "relevant";
 }
 function resolveMajorityClassification(allFingerprints) {
   const countByClassification = /* @__PURE__ */ new Map();
@@ -33814,6 +33869,7 @@ function estimateBlockOffsetWithDeclaredFromSources(axis, position, readNumeric)
 // src/cross-file/layout/cohort-index.ts
 function buildCohortIndex(input) {
   const statsByParentNode = /* @__PURE__ */ new Map();
+  const verticalAlignConsensusByParent = /* @__PURE__ */ new Map();
   const profileBuffers = createCohortProfileBuffers();
   let conditionalSignals = 0;
   let totalSignals = 0;
@@ -33888,12 +33944,14 @@ function buildCohortIndex(input) {
       subjectsByElementKey,
       excludedElementKeys: cohortMetricsResult.excludedElementKeys
     });
+    verticalAlignConsensusByParent.set(parent, resolveVerticalAlignConsensus(signalIndex.verticalAlign));
     conditionalSignals += counts.conditional;
     totalSignals += counts.total;
     if (!profile.unimodal) unimodalFalseCount++;
   }
   return {
     statsByParentNode,
+    verticalAlignConsensusByParent,
     conditionalSignals,
     totalSignals,
     unimodalFalseCount,
@@ -34716,6 +34774,13 @@ function swap(values, left, right) {
   values[left] = rightValue;
   values[right] = leftValue;
 }
+function resolveVerticalAlignConsensus(aggregate) {
+  if (aggregate.comparableCount === 0) return null;
+  if (aggregate.countsByValue.size !== 1) return null;
+  const firstEntry = aggregate.countsByValue.entries().next();
+  if (firstEntry.done) return null;
+  return firstEntry.value[0];
+}
 
 // src/cross-file/layout/measurement-node.ts
 var EMPTY_NODE_LIST = [];
@@ -36318,6 +36383,7 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
     snapshotByElementNode,
     snapshotHotSignalsByElementKey: factIndex.snapshotHotSignalsByElementKey
   });
+  finalizeTableCellBaselineRelevance(contextByParentNode, cohortIndex.verticalAlignConsensusByParent);
   perf.conditionalSignals = cohortIndex.conditionalSignals;
   perf.totalSignals = cohortIndex.totalSignals;
   perf.cohortUnimodalFalse = cohortIndex.unimodalFalseCount;
@@ -36658,6 +36724,12 @@ function collectAlignmentCases(context) {
       if (!subjectStats) {
         throw new Error(`missing subject cohort stats for ${measurementNode.key}`);
       }
+      const effectiveAlignmentContext = resolveEffectiveAlignmentContext(
+        alignmentContext,
+        child,
+        measurementNode,
+        context.layout.contextByParentNode
+      );
       const subjectDeclaredOffsetDeviation = computeDeviation(
         subjectStats.declaredOffset,
         subjectStats.baselineProfile.medianDeclaredOffsetPx
@@ -36673,7 +36745,7 @@ function collectAlignmentCases(context) {
       out.push(
         buildAlignmentCase(
           parent,
-          alignmentContext,
+          effectiveAlignmentContext,
           cohortStats.profile,
           subjectStats.signals,
           subjectStats.identifiability,
@@ -36822,6 +36894,31 @@ function collectCohortContentCompositions(cohortStats, children, measurementNode
   }
   return out;
 }
+function resolveEffectiveAlignmentContext(parentContext, child, measurementNode, contextByParentNode) {
+  if (child === measurementNode) return parentContext;
+  if (parentContext.baselineRelevance === "irrelevant") return parentContext;
+  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
+  };
+}
 function compareAlignmentCaseOrder(left, right) {
   if (left.subject.solidFile < right.subject.solidFile) return -1;
   if (left.subject.solidFile > right.subject.solidFile) return 1;
@@ -36854,10 +36951,11 @@ function buildConsistencyEvidence(input) {
     input.cohortProfile.lineHeightDispersionPx,
     input.cohortProfile.medianLineHeightPx
   );
-  const baselineStrength = resolveBaselineStrength(input, lineHeight);
-  const contextStrength = resolveContextStrength(input, lineHeight);
-  const replacedStrength = resolveReplacedControlStrength(input, lineHeight);
-  const compositionStrength = resolveContentCompositionStrength(input);
+  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 contextCertaintyPenalty = resolveContextCertaintyPenalty(input);
   const provenance = input.cohortProvenance;
   const atoms = buildEvidenceAtoms(
@@ -37153,6 +37251,7 @@ function toNegativeContribution(strength, maxPenalty, valueKind) {
     max: 0
   };
 }
+var ZERO_STRENGTH = { strength: 0, kind: "exact" };
 
 // src/cross-file/layout/consistency-policy.ts
 function applyConsistencyPolicy(input) {
@@ -37372,6 +37471,7 @@ function runLayoutDetector(context, detector) {
   const cases = detector.collect(context);
   const startedAt = performance.now();
   const out = [];
+  const log = context.logger;
   for (let i = 0; i < cases.length; i++) {
     const current = cases[i];
     if (!current) continue;
@@ -37384,10 +37484,20 @@ function runLayoutDetector(context, detector) {
         result.evidence.posteriorLower,
         result.evidence.posteriorUpper
       );
+      if (log.enabled) {
+        log.debug(
+          `[${detector.id}] accept case=${i} severity=${result.evidence.severity.toFixed(2)} confidence=${result.evidence.confidence.toFixed(2)} posterior=[${result.evidence.posteriorLower.toFixed(3)},${result.evidence.posteriorUpper.toFixed(3)}] evidenceMass=${result.evidence.evidenceMass.toFixed(3)} context=${result.evidence.contextKind} offset=${result.evidence.estimatedOffsetPx?.toFixed(2) ?? "null"} topFactors=[${result.evidence.topFactors.join(",")}] causes=[${result.evidence.causes.join("; ")}]`
+        );
+      }
       out.push({ caseData: current, evidence: result.evidence });
       continue;
     }
     recordPolicyMetrics(context, result.evidenceMass, result.posteriorLower, result.posteriorUpper);
+    if (log.enabled) {
+      log.debug(
+        `[${detector.id}] reject case=${i} reason=${result.reason} detail=${result.detail ?? "none"} posterior=[${result.posteriorLower.toFixed(3)},${result.posteriorUpper.toFixed(3)}] evidenceMass=${result.evidenceMass.toFixed(3)}`
+      );
+    }
     if (result.reason === "low-evidence") {
       context.layout.perf.casesRejectedLowEvidence++;
       continue;
@@ -38168,33 +38278,73 @@ var cssLayoutSiblingAlignmentOutlier = defineCrossRule({
     category: "css-layout"
   },
   check(context, emit) {
+    const log = context.logger;
     const detections = runLayoutDetector(context, siblingAlignmentDetector);
     const uniqueDetections = dedupeDetectionsBySubject(detections);
+    if (log.enabled) {
+      log.debug(
+        `[sibling-alignment] raw=${detections.length} deduped=${uniqueDetections.length}`
+      );
+    }
     for (let i = 0; i < uniqueDetections.length; i++) {
       const detection = uniqueDetections[i];
       if (!detection) continue;
-      if (detection.evidence.confidence < MIN_CONFIDENCE_THRESHOLD) continue;
+      const subjectTag = detection.caseData.subject.tag ?? "element";
+      const parentTag = detection.caseData.cohort.parentTag ?? "container";
+      const subjectFile = detection.caseData.subject.solidFile;
+      const subjectId = detection.caseData.subject.elementId;
+      const logPrefix = `[sibling-alignment] <${subjectTag}> in <${parentTag}> (${subjectFile}#${subjectId})`;
+      if (detection.evidence.confidence < MIN_CONFIDENCE_THRESHOLD) {
+        if (log.enabled) {
+          log.debug(
+            `${logPrefix} SKIP: confidence=${detection.evidence.confidence.toFixed(2)} < threshold=${MIN_CONFIDENCE_THRESHOLD}`
+          );
+        }
+        continue;
+      }
       const estimatedOffset = detection.evidence.estimatedOffsetPx;
-      if (estimatedOffset !== null && Math.abs(estimatedOffset) < MIN_OFFSET_PX_THRESHOLD && !hasNonOffsetPrimaryEvidence(detection.evidence.topFactors)) continue;
+      if (estimatedOffset !== null && Math.abs(estimatedOffset) < MIN_OFFSET_PX_THRESHOLD && !hasNonOffsetPrimaryEvidence(detection.evidence.topFactors)) {
+        if (log.enabled) {
+          log.debug(
+            `${logPrefix} SKIP: offset=${estimatedOffset.toFixed(2)}px < ${MIN_OFFSET_PX_THRESHOLD}px (no non-offset primary evidence, topFactors=[${detection.evidence.topFactors.join(",")}])`
+          );
+        }
+        continue;
+      }
       if (isInsideOutOfFlowAncestor(
         context.layout,
         detection.caseData.cohort.parentElementKey,
         detection.caseData.subject.solidFile
-      )) continue;
+      )) {
+        if (log.enabled) {
+          log.debug(`${logPrefix} SKIP: out-of-flow ancestor`);
+        }
+        continue;
+      }
       const subjectRef = readNodeRefById(
         context.layout,
         detection.caseData.subject.solidFile,
         detection.caseData.subject.elementId
       );
-      if (!subjectRef) continue;
-      const subject = detection.caseData.subject.tag ?? "element";
-      const parent = detection.caseData.cohort.parentTag ?? "container";
+      if (!subjectRef) {
+        if (log.enabled) {
+          log.debug(`${logPrefix} SKIP: no node ref`);
+        }
+        continue;
+      }
+      const subject = subjectTag;
+      const parent = parentTag;
       const severity = formatFixed(detection.evidence.severity);
       const confidence = formatFixed(detection.evidence.confidence);
       const offset = detection.evidence.estimatedOffsetPx;
       const hasOffset = offset !== null && Math.abs(offset) > 0.25;
       const offsetClause = hasOffset ? `, estimated offset ${formatFixed(offset)}px` : "";
       const causes = detection.evidence.causes.length === 0 ? "alignment signals indicate an outlier" : detection.evidence.causes.join("; ");
+      if (log.enabled) {
+        log.debug(
+          `${logPrefix} EMIT: severity=${severity} confidence=${confidence} offset=${offset?.toFixed(2) ?? "null"} posterior=[${detection.evidence.posteriorLower.toFixed(3)},${detection.evidence.posteriorUpper.toFixed(3)}] evidenceMass=${detection.evidence.evidenceMass.toFixed(3)} topFactors=[${detection.evidence.topFactors.join(",")}] causes=[${causes}]`
+        );
+      }
       emit(
         createDiagnostic(
           subjectRef.solid.file,
@@ -39732,7 +39882,8 @@ var CrossFilePlugin = {
     const context = {
       solids: solidGraphs,
       css: cssGraph,
-      layout: buildLayoutGraph(solidGraphs, cssGraph)
+      layout: buildLayoutGraph(solidGraphs, cssGraph),
+      logger: noopLogger
     };
     runCrossFileRules(context, emit);
   }
@@ -39771,7 +39922,8 @@ function buildCrossContext(context) {
   return {
     solids: [solidGraph],
     css: cssGraph,
-    layout: buildLayoutGraph([solidGraph], cssGraph)
+    layout: buildLayoutGraph([solidGraph], cssGraph),
+    logger: noopLogger
   };
 }
 var { eslintRules: eslintRules3 } = createBatchPluginAdapter(