@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/chunk-XTQM2IP3.js

@@ -0,0 +1,2863 @@
+import {
+  ASTEngine
+} from "./chunk-3ZTOHHSW.js";
+
+// src/ast/real-css-analyzer.ts
+import { existsSync, statSync } from "fs";
+import * as path from "path";
+var JS_WHITESPACE = /* @__PURE__ */ new Set([
+  " ",
+  "	",
+  "\n",
+  "\v",
+  "\f",
+  "\r",
+  "\xA0",
+  "\u1680",
+  "\u2002",
+  "\u2003",
+  "\u2002",
+  "\u2003",
+  "\u2004",
+  "\u2005",
+  "\u2006",
+  "\u2007",
+  "\u2008",
+  "\u2009",
+  "\u200A",
+  "\u2028",
+  "\u2029",
+  "\u202F",
+  "\u205F",
+  "\u3000",
+  "\uFEFF"
+]);
+function isWhitespaceChar(c) {
+  return JS_WHITESPACE.has(c);
+}
+function firstCustomFunctionName(prelude) {
+  const trimmed = prelude.trim();
+  if (!trimmed.startsWith("--")) return "";
+  let end = 2;
+  while (end < trimmed.length) {
+    const c = trimmed.charAt(end);
+    if (!(c === "-" || c === "_" || c >= "0" && c <= "9" || c >= "a" && c <= "z" || c >= "A" && c <= "Z")) break;
+    end++;
+  }
+  return end > 2 ? trimmed.slice(0, end) : "";
+}
+function hasCssFileExtension(specifier) {
+  const lower = specifier.toLowerCase();
+  let at = lower.indexOf(".css");
+  while (at >= 0) {
+    const next = lower.charAt(at + 4);
+    if (next === "" || next === "?" || next === "#") return true;
+    at = lower.indexOf(".css", at + 4);
+  }
+  return false;
+}
+function stripAllQuotes(text) {
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (c !== '"' && c !== "'") out += c;
+  }
+  return out;
+}
+function unwrapUrl(text) {
+  if (text.startsWith("url(") && text.endsWith(")")) {
+    return stripAllQuotes(text.slice(4, -1).trim());
+  }
+  return stripAllQuotes(text);
+}
+function replaceAll(text, needle, replacement) {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    if (text.startsWith(needle, i)) {
+      out += replacement;
+      i += needle.length;
+    } else {
+      out += text[i];
+      i++;
+    }
+  }
+  return out;
+}
+function leadingCustomIdent(prelude) {
+  const t = prelude.trim();
+  if (t.length < 2 || t.charAt(0) !== "-" || t.charAt(1) !== "-") return "";
+  let i = 2;
+  while (i < t.length && isCustomIdentChar(t.charAt(i))) i++;
+  return t.slice(0, i);
+}
+function isCustomIdentChar(c) {
+  return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c >= "0" && c <= "9" || c === "-" || c === "_";
+}
+function stripOccurrenceSuffix(name) {
+  let i = name.length;
+  while (i > 0) {
+    const c = name.charAt(i - 1);
+    if (c < "0" || c > "9") break;
+    i--;
+  }
+  if (i === name.length) return name;
+  if (i === 0 || name.charAt(i - 1) !== ":") return name;
+  return name.slice(0, i - 1);
+}
+function lastPathSegment(p) {
+  let cut = -1;
+  for (let i = 0; i < p.length; i++) {
+    const c = p.charAt(i);
+    if (c === "/" || c === "\\") cut = i;
+  }
+  return cut >= 0 ? p.slice(cut + 1) : p;
+}
+var CSS_PROJECT_ROOT_CACHE = /* @__PURE__ */ new Map();
+function cssProjectRootOf(filePath) {
+  const start = path.dirname(path.resolve(filePath));
+  const seen = [];
+  let dir = start;
+  for (let i = 0; i < 64; i++) {
+    const cached = CSS_PROJECT_ROOT_CACHE.get(dir);
+    if (cached !== void 0) {
+      for (const d of seen) CSS_PROJECT_ROOT_CACHE.set(d, cached);
+      return cached;
+    }
+    seen.push(dir);
+    if (existsSync(path.join(dir, ".git"))) {
+      if (CSS_PROJECT_ROOT_CACHE.size > 2e4) CSS_PROJECT_ROOT_CACHE.clear();
+      for (const d of seen) CSS_PROJECT_ROOT_CACHE.set(d, dir);
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  if (CSS_PROJECT_ROOT_CACHE.size > 2e4) CSS_PROJECT_ROOT_CACHE.clear();
+  for (const d of seen) CSS_PROJECT_ROOT_CACHE.set(d, null);
+  return null;
+}
+function cssFileScopeOf(filePath) {
+  if (!filePath || filePath.length === 0) return "";
+  const abs = path.resolve(filePath);
+  const root = cssProjectRootOf(abs);
+  let rel = root === null ? abs : path.relative(root, abs);
+  if (rel.length === 0) rel = abs;
+  const dot = rel.lastIndexOf(".");
+  const slash = Math.max(rel.lastIndexOf("/"), rel.lastIndexOf("\\"));
+  const withoutExt = dot > slash ? rel.slice(0, dot) : rel;
+  let out = "";
+  for (const ch of withoutExt.split(path.sep).join("/")) out += ch === "." || ch === ":" ? "_" : ch;
+  return out;
+}
+function firstToken(text) {
+  let i = 0;
+  while (i < text.length && isWhitespaceChar(text.charAt(i))) i++;
+  const start = i;
+  while (i < text.length && !isWhitespaceChar(text.charAt(i))) i++;
+  return text.slice(start, i);
+}
+function looksLikeSelectorText(text) {
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (c === ";") return false;
+    if (c === "{" && text.charAt(i - 1) !== "#") return false;
+  }
+  return text.trim().length > 0;
+}
+function collapseWhitespace(text) {
+  let out = "";
+  let pendingSpace = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    const isWs = c === " " || c === "	" || c === "\n" || c === "\r" || c === "\f";
+    if (isWs) {
+      if (out.length > 0) pendingSpace = true;
+      continue;
+    }
+    if (pendingSpace) {
+      out += " ";
+      pendingSpace = false;
+    }
+    out += c;
+  }
+  return out;
+}
+function fnNameNameIsVar(fnNameNode) {
+  return fnNameNode.text.trim() === "var";
+}
+function hasNestingAmp(text) {
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] !== "&") continue;
+    let bs = 0;
+    for (let k = i - 1; k >= 0 && text[k] === "\\"; k--) bs++;
+    if (bs % 2 === 0) return true;
+  }
+  return false;
+}
+function isResetSelector(text) {
+  if (text === "*") return true;
+  if (text.startsWith("*::")) {
+    const rest = text.slice(3);
+    if (rest.length === 0) return false;
+    for (let i = 0; i < rest.length; i++) {
+      const c = rest[i];
+      if (!(c >= "a" && c <= "z" || c === "-")) return false;
+    }
+    return true;
+  }
+  return false;
+}
+function isTailwindClass(cls) {
+  if (cls.startsWith("tw-")) return true;
+  for (const p of ["sm:", "md:", "lg:", "xl:", "2xl:", "hover:", "focus:", "dark:"]) {
+    if (cls.startsWith(p)) return true;
+  }
+  return false;
+}
+function isBootstrapClass(cls) {
+  if (cls === "container" || cls === "btn-primary" || cls === "navbar-expand") return true;
+  for (const size of ["sm-", "md-", "lg-", "xl-"]) {
+    if (cls.startsWith(`col-${size}`)) {
+      const rest = cls.slice(`col-${size}`.length);
+      if (rest.length > 0) {
+        let allDigits = true;
+        for (let i = 0; i < rest.length; i++) {
+          const c = rest[i];
+          if (!(c >= "0" && c <= "9")) {
+            allDigits = false;
+            break;
+          }
+        }
+        if (allDigits) return true;
+      }
+    }
+  }
+  return false;
+}
+function isBulmaClass(cls) {
+  for (const p of ["is-", "has-"]) {
+    if (cls.startsWith(p)) {
+      const rest = cls.slice(p.length);
+      if (rest === "primary" || rest === "info" || rest === "success" || rest === "warning" || rest === "danger" || rest === "text-centered") return true;
+    }
+  }
+  return false;
+}
+function isFoundationClass(cls) {
+  if (cls === "foundation") return true;
+  for (const p of ["small-", "medium-", "large-"]) {
+    if (cls.startsWith(p)) {
+      const rest = cls.slice(p.length);
+      if (rest.length === 0) return false;
+      let allDigits = true;
+      for (let i = 0; i < rest.length; i++) {
+        const c = rest[i];
+        if (!(c >= "0" && c <= "9")) {
+          allDigits = false;
+          break;
+        }
+      }
+      if (allDigits) return true;
+    }
+  }
+  return false;
+}
+var RECOVERY_CHILD_CAP = 1e4;
+var STRUCTURAL_SCOPE_AT_RULES = /* @__PURE__ */ new Set(["@layer", "@container", "@scope"]);
+var RealCssAnalyzer = class _RealCssAnalyzer {
+  analyze(rootNode, content, filePath, context) {
+    const lastSegment = lastPathSegment(filePath);
+    this.importerName = lastSegment || filePath || "stylesheet";
+    this.claimProjectRoot = typeof context?.projectRoot === "string" ? context.projectRoot : "";
+    this.hasRealModuleName = lastSegment.length > 0;
+    this.fileScope = cssFileScopeOf(filePath);
+    this.fileDir = filePath.length > 0 ? path.dirname(filePath) : "";
+    {
+      const dot = lastSegment.lastIndexOf(".");
+      const ext = dot >= 0 ? lastSegment.slice(dot + 1).toLowerCase() : "";
+      this.cssFamilyHost = ext === "css" || ext === "less" || ext === "sass";
+    }
+    const ctx = {
+      symbols: [],
+      relationships: [],
+      imports: [],
+      exports: [],
+      errors: [],
+      content,
+      keyframeNames: {},
+      fontFaceNames: {},
+      counterStyleNames: {},
+      customMediaNames: {},
+      cssFunctionNames: {},
+      fontFeatureValuesNames: {},
+      layerNames: {},
+      namespacePrefixes: {},
+      layerOrder: [],
+      mixinNames: {},
+      keyframeLive: {},
+      propertyLive: {},
+      customPropInBlock: {},
+      customPropBlockKey: "",
+      overrideEdges: {},
+      frameworks: {},
+      patterns: {},
+      fileHasParseError: rootNode.hasError === true,
+      declaredProperties: {},
+      mediaScopes: {},
+      scopeSymbol: {},
+      deferredChainEdges: [],
+      selectorChains: {},
+      fileSelectorComplexity: 0,
+      fileNestingDepth: 0,
+      fileMaxSelectorComplexity: 0
+    };
+    this.collectKeyframeNames(rootNode, ctx);
+    this.collectFontFaceNames(rootNode, ctx);
+    this.collectCustomDefinitionNames(rootNode, ctx);
+    this.collectNamespacePrefixes(rootNode, ctx);
+    if (this.hasRealModuleName) {
+      ctx.symbols.unshift({
+        name: this.importerName,
+        kind: ASTEngine.SymbolKind.Module,
+        range: this.nodeToRange(rootNode),
+        scope: "",
+        visibility: "public",
+        complexity: 1,
+        metadata: {
+          cssSpecific: true,
+          isStylesheet: true,
+          stylesheetPath: filePath
+        }
+      });
+    }
+    const stack = [{ node: rootNode, media: "", supports: "", layer: "", container: "", scope: "", currentSelector: "", keyframeScope: "" }];
+    while (stack.length > 0) {
+      const { node, media, supports, layer, container, scope, currentSelector, keyframeScope } = stack.pop();
+      if (this.isErrorNode(node)) {
+        ctx.errors.push({
+          message: `Syntax ERROR: the grammar could not read this token.`,
+          range: this.nodeToRange(node),
+          severity: `warning`
+        });
+      } else if (node.hasError) {
+        ctx.errors.push({
+          message: `Syntax ERROR detected inside this rule; the rule itself is extracted.`,
+          range: this.nodeToRange(node),
+          severity: `warning`
+        });
+      }
+      let nextMedia = media;
+      let nextSupports = supports;
+      let nextLayer = layer;
+      let nextContainer = container;
+      let nextScope = scope;
+      let nextSelector = currentSelector;
+      let nextKeyframeScope = keyframeScope;
+      switch (node.type) {
+        case "rule_set":
+          nextSelector = this.processRuleSet(node, media, supports, layer, container, scope, currentSelector, ctx) || nextSelector;
+          break;
+        case "import_statement":
+          this.processImport(node, ctx);
+          break;
+        case "media_statement": {
+          const newMedia = this.processMedia(node, ctx);
+          if (newMedia) {
+            nextMedia = media ? `${media} and ${newMedia.replace("@media ", "")}` : newMedia;
+          }
+          break;
+        }
+        case "keyframes_statement": {
+          const kfName = this.processKeyframes(node, ctx);
+          nextKeyframeScope = kfName;
+          break;
+        }
+        case "supports_statement": {
+          const newSupports = this.processSupports(node, ctx);
+          if (newSupports) nextSupports = newSupports;
+          break;
+        }
+        case "at_rule":
+        case "postcss_statement":
+        case "namespace_statement":
+        case "scope_statement":
+        case "charset_statement": {
+          const scopeUpdate = this.processAtRule(node, currentSelector, ctx);
+          if (scopeUpdate.layer) nextLayer = scopeUpdate.layer;
+          if (scopeUpdate.container) nextContainer = scopeUpdate.container;
+          if (scopeUpdate.scope) nextScope = scopeUpdate.scope;
+          break;
+        }
+        case "declaration": {
+          this.processDeclaration(node, currentSelector, ctx);
+          break;
+        }
+        case "call_expression":
+          this.processCallExpression(node, currentSelector, keyframeScope, ctx);
+          break;
+      }
+      const wide = node.namedChildCount > RECOVERY_CHILD_CAP;
+      const first = wide ? RECOVERY_CHILD_CAP : node.namedChildCount;
+      if (wide) {
+        const tally = ctx.recoveryCap ??= { cap: RECOVERY_CHILD_CAP, errorNodes: 0, errorChildren: 0, visited: 0, skipped: 0 };
+        tally.errorNodes++;
+        tally.errorChildren += node.namedChildCount;
+        tally.visited += RECOVERY_CHILD_CAP;
+        tally.skipped += node.namedChildCount - RECOVERY_CHILD_CAP;
+      }
+      for (let i = first - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) {
+          stack.push({
+            node: child,
+            media: nextMedia,
+            supports: nextSupports,
+            layer: nextLayer,
+            container: nextContainer,
+            scope: nextScope,
+            currentSelector: nextSelector,
+            keyframeScope: nextKeyframeScope
+          });
+        }
+      }
+    }
+    if (ctx.recoveryCap && ctx.relationships.length > 0) {
+      ctx.relationships[0].metadata = { ...ctx.relationships[0].metadata ?? {}, cssRecoveryCap: ctx.recoveryCap };
+    }
+    {
+      const names = /* @__PURE__ */ new Set();
+      for (const sym of ctx.symbols) {
+        names.add(sym.name);
+        if (sym.scope) names.add(`${sym.scope}.${sym.name}`);
+      }
+      const chainTermKind = (n) => {
+        if (n.length === 0) return "";
+        const c = n.charAt(0);
+        if (c === ".") return "class";
+        if (c === "#") return "id";
+        if (c === ":") return "pseudo";
+        if (c === "*") return "universal";
+        return "bare";
+      };
+      const leafOf = (n) => {
+        const segs = stripOccurrenceSuffix(n).split(":").filter((x) => x.length > 0);
+        const last = segs[segs.length - 1] ?? "";
+        const dots = last.split(".");
+        return dots[dots.length - 1];
+      };
+      const resolves = (n) => {
+        if (!n) return false;
+        if (names.has(n)) return true;
+        const kind = chainTermKind(n);
+        const l = leafOf(n);
+        if (l !== n && chainTermKind(l) === kind && names.has(l)) return true;
+        for (let i = 0; i < n.length; i++) {
+          const c = n[i];
+          if (c !== ":" && c !== ".") continue;
+          const tail = n.slice(i + 1);
+          if (tail.length > 0 && chainTermKind(tail) === kind && names.has(tail)) return true;
+        }
+        return false;
+      };
+      let emitted = 0;
+      let withheld = 0;
+      const seen = /* @__PURE__ */ new Set();
+      for (const e of ctx.deferredChainEdges) {
+        const key = `${e.from}${e.to}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        if (resolves(e.from) && resolves(e.to)) {
+          emitted++;
+          ctx.relationships.push({
+            source: e.from,
+            target: e.to,
+            type: ASTEngine.RelationshipType.Contains,
+            line_number: e.line,
+            metadata: { cssSpecific: true, isSelectorChain: true }
+          });
+        } else {
+          withheld++;
+        }
+      }
+      ctx.chainEdgeTally = { emitted, withheld };
+    }
+    const attachDeclared = (sym) => {
+      const direct = ctx.declaredProperties[sym.name];
+      const parts = sym.name.split(",").map((x) => x.trim()).filter(Boolean);
+      const merged = [];
+      const push = (list) => {
+        if (!list) return;
+        for (const p of list) if (merged.indexOf(p) === -1) merged.push(p);
+      };
+      push(direct);
+      for (const part of parts) push(ctx.declaredProperties[part]);
+      if (merged.length === 0) return;
+      if (!sym.metadata) sym.metadata = {};
+      sym.metadata.declaresProperties = merged;
+      sym.metadata.declaredPropertyCount = merged.length;
+    };
+    const attachChain = (sym) => {
+      const direct = ctx.selectorChains[sym.name];
+      const parts = sym.name.split(",").map((x) => x.trim()).filter(Boolean);
+      const merged = [];
+      const push = (list) => {
+        if (!list) return;
+        for (const p of list) if (merged.indexOf(p) === -1) merged.push(p);
+      };
+      push(direct);
+      for (const part of parts) push(ctx.selectorChains[part]);
+      if (merged.length < 2) return;
+      if (!sym.metadata) sym.metadata = {};
+      sym.metadata.selectorChain = merged;
+    };
+    {
+      const byIdentity = /* @__PURE__ */ new Map();
+      const merged = [];
+      for (const sym of ctx.symbols) {
+        const key = `${sym.kind}\0${sym.name}`;
+        const first = byIdentity.get(key);
+        if (!first) {
+          byIdentity.set(key, sym);
+          merged.push(sym);
+          continue;
+        }
+        const a = first.metadata ?? {};
+        const b = sym.metadata ?? {};
+        const out = { ...a };
+        for (const [k, v] of Object.entries(b)) {
+          const cur = out[k];
+          if (Array.isArray(v) && Array.isArray(cur)) {
+            for (const item of v) if (!cur.includes(item)) cur.push(item);
+          } else if (typeof v === "boolean" && typeof cur === "boolean") {
+            out[k] = cur || v;
+          } else if (typeof v === "number" && typeof cur === "number" && (k.includes("specificity") || k.includes("omplexity"))) {
+            out[k] = Math.max(cur, v);
+          } else if (cur === void 0) {
+            out[k] = v;
+          }
+        }
+        first.metadata = out;
+        const firstLine = first.range?.startLine ?? 0;
+        const lastLine = sym.range?.endLine ?? firstLine;
+        if (lastLine > (first.range?.endLine ?? 0)) {
+          first.range = { ...first.range, endLine: lastLine };
+        }
+        const occ = first.metadata.occurrences ?? 1;
+        first.metadata.occurrences = occ + 1;
+        const prevScopes = first.metadata.scopes ?? (first.scope ? [first.scope] : []);
+        if (sym.scope && !prevScopes.includes(sym.scope)) prevScopes.push(sym.scope);
+        if (prevScopes.length > 1) first.metadata.scopes = prevScopes;
+        if (firstLine > 0) first.metadata.firstLine = Math.min(first.metadata.firstLine ?? firstLine, firstLine);
+      }
+      ctx.symbols = merged;
+    }
+    for (const s2 of ctx.symbols) attachChain(s2);
+    for (const s of ctx.symbols) attachDeclared(s);
+    for (const s of ctx.symbols) {
+      if (!s.scope || s.scope === "") {
+        ctx.exports.push({ name: s.name, kind: s.kind, range: s.range, visibility: s.visibility || "public" });
+      }
+    }
+    this.detectFrameworksFromClasses(ctx);
+    const frameworks = [];
+    for (const f in ctx.frameworks) frameworks.push(f);
+    const patterns = [];
+    for (const p in ctx.patterns) patterns.push(p);
+    const metrics = this.calculateMetrics(ctx);
+    const frameworkPatterns = [];
+    for (let i = 0; i < frameworks.length; i++) {
+      frameworkPatterns.push({
+        framework: frameworks[i],
+        patterns: [{ type: "usage", detected: true, description: `${frameworks[i]} usage detected` }]
+      });
+    }
+    const evidenceClassFor = (type) => {
+      if (type === ASTEngine.RelationshipType.Imports || type === ASTEngine.RelationshipType.References) return "import_based";
+      if (type === ASTEngine.RelationshipType.Uses) return "usage_contextual";
+      return "structural";
+    };
+    let unrankable = 0;
+    for (const rel of ctx.relationships) {
+      const md = rel.metadata ?? {};
+      if (typeof md.evidenceClass === "string" && md.evidenceClass.length > 0) continue;
+      if (rel.type == null) {
+        unrankable++;
+        continue;
+      }
+      rel.metadata = { evidenceClass: evidenceClassFor(rel.type), ...md };
+    }
+    this.publishFileScopedIdentities(ctx);
+    return {
+      language: "css",
+      symbols: ctx.symbols,
+      relationships: ctx.relationships,
+      imports: ctx.imports,
+      exports: ctx.exports,
+      errors: ctx.errors,
+      metadata: {
+        complexity: ctx.symbols.length,
+        linesOfCode: content.split("\n").length,
+        // NB: the cascade order is NOT recorded here. `parseFile` rebuilds file
+        // metadata as a fresh literal of specific keys (engine.ts:1572 — its own
+        // comment says an omitted key is "computed and DISCARDED — silently"), so a
+        // key added at the analyzer would never reach a consumer, and a key that
+        // looks present but is always dropped is worse than an absent one. The order
+        // rides each layer SYMBOL as `layerIndex`, which is passed through.
+        // 0 on every real corpus file; present so a non-zero value is a number
+        // someone can go and look at rather than a branch nobody can observe.
+        cssUnrankedRelationships: unrankable,
+        // M60 R6 / CC1. This was a literal 1, and because
+        // `pool-worker.ts` computes `complexity: s.complexity ||
+        // s.metadata?.complexity || 1`, every CSS symbol in the store claimed a
+        // complexity of exactly 1 — measured 9,338 of 9,338, 100%. A CC1 check
+        // that asserts `complexity >= 1` is therefore satisfied vacuously for
+        // this lane: it cannot distinguish a one-line reset from a deeply nested
+        // selector, because both answer 1.
+        //
+        // The number is now MEASURED, and it is the thing a CSS author actually
+        // finds hard: how much selector machinery a single rule carries. See
+        // `selectorComplexity` for the terms and why each is there.
+        cyclomaticComplexity: metrics.complexity,
+        framework: frameworks[0] || "Standard CSS",
+        patterns,
+        detectedFrameworks: frameworks,
+        frameworkPatterns,
+        architecturalInsights: this.generateInsights(ctx, frameworks),
+        architecturalScore: metrics.score,
+        codeQuality: metrics.quality,
+        hasTypeInference: false,
+        hasFrameworkIntelligence: true,
+        maintainabilityScore: metrics.maintainability,
+        performanceScore: metrics.performance,
+        analysisVersion: "8.0.0-infallible-brain-math-strict"
+      }
+    };
+  }
+  /**
+   * CSS-D15 — publish a project-unique identity per declaration, and respell the edges whose
+   * declaration is in the edge's own file. See the FILE SCOPE note above `cssFileScopeOf` for
+   * the measurement this answers and why the spelling is `<dotless-scope>::<name>`.
+   *
+   * TWO RULES, and both are deliberate:
+   *
+   *  1. A target is respelled ONLY when this file publishes exactly one symbol with that name.
+   *     Then the edge's own file is the whole answer and the spelling is exact. The fallback is
+   *     the bare name, which is what the lane emitted before this change — so this pass can only
+   *     ADD resolution, never remove it (the `json` lane's rule for the same fix).
+   *
+   *  2. Where this file publishes the name 2+ times (the gate's `IN-FILE-MULTI`) the edge does
+   *     not say which site it means, so the target is left BARE and stays visibly ambiguous. The
+   *     occurrence discriminator exists only to keep those two symbols' `qualifiedName`s
+   *     distinct, so a direct reference to one of them is still resolvable.
+   *
+   * NO TARGET IS REWRITTEN ON AN IMPORT: an `imports` edge names ANOTHER file's module, and this
+   * file's module symbol happens to share its spelling with that file's basename — respelling it
+   * would point the import at the importing file itself.
+   */
+  publishFileScopedIdentities(ctx) {
+    const byName = /* @__PURE__ */ new Map();
+    for (const sym of ctx.symbols) {
+      const name = String(sym.name ?? "");
+      if (name.length === 0) continue;
+      const existing = byName.get(name);
+      const occurrence = existing === void 0 ? 0 : existing.length;
+      const prefix = this.fileScope;
+      const qname = occurrence === 0 ? prefix === "" ? name : `${prefix}::${name}` : `${prefix}#${occurrence + 1}::${name}`;
+      sym.qualifiedName = qname;
+      if (existing === void 0) byName.set(name, [{ sym, qname }]);
+      else existing.push({ sym, qname });
+    }
+    if (this.fileScope === "") return;
+    const REWRITABLE = /* @__PURE__ */ new Set([
+      ASTEngine.RelationshipType.Contains,
+      ASTEngine.RelationshipType.References,
+      ASTEngine.RelationshipType.Uses,
+      ASTEngine.RelationshipType.Overrides
+    ]);
+    for (const rel of ctx.relationships) {
+      const type = String(rel.type ?? "");
+      if (!REWRITABLE.has(type)) continue;
+      const target = String(rel.target ?? "");
+      if (target.length === 0) continue;
+      const candidates = byName.get(target);
+      if (candidates === void 0 || candidates.length === 0) continue;
+      let pick = candidates[0];
+      if (candidates.length > 1) {
+        const md = rel.metadata ?? {};
+        if (md.isAnimationRef === true) {
+          const keyframes = candidates.filter((c) => c.sym.metadata?.isKeyframes === true);
+          if (keyframes.length !== 1) continue;
+          pick = keyframes[0];
+        } else {
+          const line = typeof rel.line_number === "number" ? rel.line_number : null;
+          if (line === null) continue;
+          const covering = candidates.filter((c) => {
+            const r = c.sym.range;
+            return r !== void 0 && line >= r.startLine && line <= r.endLine;
+          });
+          if (covering.length !== 1) continue;
+          pick = covering[0];
+        }
+      }
+      rel.target = pick.qname;
+    }
+    let marked = 0;
+    for (const rel of ctx.relationships) {
+      if (String(rel.type ?? "") !== ASTEngine.RelationshipType.References) continue;
+      const target = String(rel.target ?? "");
+      if (!target.startsWith("--") || target.includes(".")) continue;
+      if (byName.has(target)) continue;
+      rel.metadata = { ...rel.metadata ?? {}, isExternalTarget: true };
+      marked++;
+    }
+    ctx.externalCustomPropertyReads = marked;
+  }
+  /**
+   * True when the node IS the parse failure, rather than merely containing one.
+   *
+   * `Node.hasError` is true for a node with a broken descendant too, so using it
+   * as a suppression test would discard declarations that are well formed. A
+   * MISSING node is a token the parser inserted where the source had none,
+   * which is equally not a declaration.
+   */
+  /**
+   * The 1-based line of a node — the convention, matching the symbol
+   * `line_start` base the LSP reads with `line - 1`.
+   *
+   * / #825. The rule this lane follows is one sentence: **the line belongs
+   * to the NAME, never to the construct that contains it.** Every call site below
+   * passes the node the NAME is written on, not the node that encloses it:
+   *
+   *   a `contains` scope edge      -> the rule's `selectors` node, not the
+   *                                   `rule_set` (which opens on the same line
+   *                                   here, but not for a nested rule under a
+   *                                   multi-line selector)
+   *   a custom-property `contains` -> the `property_name` node, not the
+   *                                   `declaration` (a declaration can carry a
+   *                                   leading comment or a newline before the
+   *                                   name)
+   *   an `animation` reference     -> the VALUE node naming the keyframes, not
+   *                                   the `animation` property (the referenced
+   *                                   name is written on the value's line, and a
+   *                                   shorthand puts several there)
+   *   a `var()` reference          -> the ARGUMENT node, not the
+   *                                   `call_expression` (whose start is the
+   *                                   receiver's position)
+   *   a `composes` edge            -> the composed name's value node
+   *   an `imports` edge            -> the module NAME node, not the `@import`
+   *                                   keyword (the target is written after it,
+   *                                   and can be on a later line)
+   *   a mixin reference            -> the `@include` at-rule's own line
+   *   a selector-chain edge        -> the `selectors` node the chain is read
+   *                                   from
+   *
+   * Where a line genuinely cannot be derived the field is ABSENT, never 0 and
+   * never the enclosing symbol's line: `absent` is the honest value and 0 is a
+   * lie a reader cannot detect. There are no such cases in this lane — every
+   * relationship CSS emits is between two names that are written in the file —
+   * and the exceptions list in docs/analyzers/css.md records that
+   * as a measured fact rather than an assumption.
+   */
+  lineOf(node) {
+    if (!node) return void 0;
+    return node.startPosition.row + 1;
+  }
+  isErrorNode(node) {
+    return node.type === "ERROR" || node.isMissing === true;
+  }
+  /**
+   * True when a `selectors` node can only be error-recovery debris.
+   *
+   * A stylesheet-level selector is never a bare string. The one way a `rule_set`
+   * gets a `string_value` in selector position is the grammar abandoning a
+   * construct's head (emitting an ERROR for it) and re-parsing the remainder as
+   * a sibling rule — measured on `@keyframes "fade" { … }`, whose fabricated
+   * output was three symbols whose names carried literal quote characters.
+   *
+   * The `selectors` node is examined for ANY real selector form; if it has one,
+   * this is a genuine rule and nothing is suppressed. A genuine CSS selector can
+   * contain a string only inside `[attr="value"]`, and there the string sits
+   * under an `attribute_selector`, never as a selector of its own.
+   */
+  /**
+   * The leading `@keyword` of an at-rule's own text, or `""`.
+   *
+   * Pure-String, bounded to the characters CSS actually allows in an at-keyword
+   * (`@`, then letters/digits/`-`/`_`), so it cannot run past the keyword into a
+   * prelude. Returns `""` when the text does not start with `@`, which is the
+   * honest answer for a node that is not an at-rule at all.
+   */
+  leadingAtKeyword(text) {
+    if (text.charAt(0) !== "@") return "";
+    let i = 1;
+    while (i < text.length) {
+      const c = text[i];
+      const ok = c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c >= "0" && c <= "9" || c === "-" || c === "_";
+      if (!ok) break;
+      i++;
+    }
+    return i > 1 ? text.slice(0, i) : "";
+  }
+  /** First descendant satisfying `predicate`, breadth-first. */
+  findDescendant(node, predicate) {
+    const queue = [node];
+    while (queue.length > 0) {
+      const n = queue.shift();
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (!c) continue;
+        if (predicate(c)) return c;
+        queue.push(c);
+      }
+    }
+    return null;
+  }
+  isKeyframeStepSelector(selectorsNode) {
+    const t = selectorsNode.text.trim();
+    return t === "from" || t === "to";
+  }
+  isRecoveryDebris(selectorsNode) {
+    let hasString = false;
+    let hasRealSelector = false;
+    for (let i = 0; i < selectorsNode.namedChildCount; i++) {
+      const c = selectorsNode.namedChild(i);
+      if (!c) continue;
+      const t = c.type;
+      if (t === "string_value") {
+        hasString = true;
+        continue;
+      }
+      if (t === "class_selector" || t === "id_selector" || t === "tag_name" || t === "universal_selector" || t === "pseudo_class_selector" || t === "pseudo_element_selector" || t === "attribute_selector" || t === "nesting_selector" || t === "namespace_selector" || t === "child_selector" || t === "descendant_selector" || t === "sibling_selector" || t === "adjacent_sibling_selector") {
+        hasRealSelector = true;
+        continue;
+      }
+      hasRealSelector = true;
+    }
+    return hasString && !hasRealSelector;
+  }
+  /** The importing stylesheet's name; set per `analyze` run. */
+  importerName = "stylesheet";
+  /** Whether `importerName` is a real basename rather than the fallback literal. */
+  hasRealModuleName = false;
+  /** The project-unique scope prefix for the file being analyzed; set per `analyze` run. */
+  fileScope = "";
+  /** The directory of the file being analyzed, for resolving a RELATIVE import specifier. */
+  fileDir = "";
+  /**
+   * The CALLER's project root, or `""`. Set per `analyze` run from `context.projectRoot`.
+   *
+   * Used for exactly one thing: turning the sibling file an `@import` resolves to into the
+   * PROJECT-RELATIVE path an `importProjectFile` claim carries. Empty (the fixture runner's
+   * case) means the claim is not stated — see the note at the assignment in `analyze`.
+   */
+  claimProjectRoot = "";
+  // THE HOST-EXTENSION GATE: `part_of` is enabled only for the extensions this lane admits
+  // (`css,less,sass`). scss delegates its walk here and relabels the Sass form ITSELF, and html
+  // delegates with an extensionless module name — so the relabel must be decided by the file this
+  // run is analyzing, not by a flag a caller could forget. Computed once in analyze().
+  cssFamilyHost = false;
+  determineSelectorKind(hasId, hasClass, hasTag, hasPseudoClass, hasPseudoElement, hasAttribute, isComplex) {
+    if (hasPseudoElement && !hasClass && !hasId && !hasTag) return ASTEngine.SymbolKind.Property;
+    if (hasPseudoClass && !hasClass && !hasId && !hasTag && !hasAttribute) return ASTEngine.SymbolKind.Property;
+    if (hasId && !hasClass && !hasTag && !hasPseudoClass && !hasPseudoElement && !hasAttribute)
+      return ASTEngine.SymbolKind.Interface;
+    if (hasTag && !hasClass && !hasId && !hasPseudoClass && !hasPseudoElement && !hasAttribute)
+      return ASTEngine.SymbolKind.Type;
+    if (hasAttribute && !hasClass && !hasId && !hasTag && !hasPseudoClass && !hasPseudoElement)
+      return ASTEngine.SymbolKind.Property;
+    if (hasClass && !hasId && !hasTag && !hasPseudoClass && !hasPseudoElement && !hasAttribute && !isComplex)
+      return ASTEngine.SymbolKind.Class;
+    return ASTEngine.SymbolKind.Class;
+  }
+  /**
+   * Exactly the code points JS `\s` matches, as a set.
+   *
+   * This exists so the whitespace tests in `queryComplexity` are not regexes. The
+   * M12 regex census drives that count DOWN, and five of the nine regexes this lane
+   * carried were added by the complexity work two commits ago — `queryComplexity`
+   * testing `/\s/` once per CHARACTER of every query, which is both a census
+   * regression and slower than a set lookup. The full set is listed rather than the
+   * ASCII five so the replacement is not a NARROWING: `\s` also matches \v, NBSP,
+   * the U+2000 block, the line/paragraph separators and the BOM, and a predicate
+   * that quietly stops matching a code point is a behaviour change wearing a
+   * cleanup's commit message.
+   */
+  static JS_SPACE = JS_WHITESPACE;
+  isSpace(c) {
+    return c !== void 0 && _RealCssAnalyzer.JS_SPACE.has(c);
+  }
+  /**
+   * Complexity of a media/supports/container QUERY, in the same spirit as the
+   * selector metric: 1, plus one for each boolean operator that joins or negates a
+   * condition. `@media print` is 1 (no decision), while
+   * `@supports (a:1) and (b:2) and (c:3)` is 3 and `not (a)` is 2.
+   *
+   * WHY THIS EXISTS. Complexity was measured for SELECTOR symbols only, and
+   * `pool-worker.ts` computes `complexity: s.complexity || s.metadata?.complexity
+   * || 1` — so every other kind's absent value became a FABRICATED 1 in the store.
+   * Measured on the corpus, that was 6,486 of 27,322 css symbols (24%): 4,664
+   * `variable`, 1,378 `interface` (@supports), 350 `module` (@media/@layer/
+   * @container) and 94 `function` (keyframes). A `@supports` scope with a
+   * 20-condition query read identically to `.plain { color: red }`, which is the
+   * same defect as the hardcoded 1, one level narrower and therefore easier to
+   * miss.
+   */
+  queryComplexity(text) {
+    if (!text) return 1;
+    let depth = 0;
+    let ops = 0;
+    const src = text;
+    for (let i = 0; i < src.length; i++) {
+      const c = src[i];
+      if (c === "(") {
+        depth++;
+        continue;
+      }
+      if (c === ")") {
+        depth--;
+        continue;
+      }
+      if (depth !== 0) continue;
+      if (c === "a" && src.startsWith("and", i) && this.isSpace(src[i - 1])) {
+        ops++;
+        i += 2;
+        continue;
+      }
+      if (c === "o" && src.startsWith("or", i) && this.isSpace(src[i - 1])) {
+        ops++;
+        i += 1;
+        continue;
+      }
+      if (c === "n" && src.startsWith("not", i) && this.isSpace(src[i - 1])) {
+        ops++;
+        i += 2;
+        continue;
+      }
+    }
+    return 1 + ops;
+  }
+  /** `keyframe_block` children of a `keyframes_statement` — one per animation stop. */
+  countKeyframeStops(node) {
+    let n = 0;
+    const walk = (x) => {
+      if (x.type === "keyframe_block") n++;
+      for (let i = 0; i < x.childCount; i++) {
+        const c = x.child(i);
+        if (c) walk(c);
+      }
+    };
+    walk(node);
+    return n;
+  }
+  /**
+   * A custom property's complexity: 1, plus one for each `var(--other)` it reads.
+   * A `--brand: #06c` is 1; a theming token composing five others is 6, and that
+   * composition chain is the review cost. This is the last css symbol kind that
+   * had no measured value — with it, all 27,322 corpus symbols carry one, and the
+   * `|| 1` fallback in `pool-worker.ts` stops fabricating a quarter of the lane.
+   */
+  customPropertyComplexity(decl) {
+    let reads = 0;
+    for (let i = 0; i < decl.childCount; i++) {
+      const child = decl.child(i);
+      if (!child) continue;
+      for (let j = 0; j < child.childCount; j++) {
+        const leaf = child.child(j);
+        if (leaf && this.countsVarRead(leaf.text)) reads++;
+      }
+    }
+    return 1 + reads;
+  }
+  /**
+   * Does this text contain a `var(` immediately followed by a custom-property name?
+   * Replaces `/var\(\s*--/` with a scan rather than narrowing it: the whitespace
+   * between `(` and `--` is skipped with the same `\s` set, so `var( --x)` still
+   * counts exactly as it did.
+   */
+  countsVarRead(text) {
+    for (let i = 0; i + 3 < text.length; i++) {
+      if (text[i] !== "v" || text[i + 1] !== "a" || text[i + 2] !== "r" || text[i + 3] !== "(") continue;
+      let k = i + 4;
+      while (k < text.length && this.isSpace(text[k])) k++;
+      if (text[k] === "-" && text[k + 1] === "-") return true;
+    }
+    return false;
+  }
+  /**
+   * The at-rule's OWN descriptors: `declaration` children of its DIRECT block, one
+   * level only.
+   *
+   * One level, deliberately. The first version walked the whole subtree and
+   * produced complexity 2,917 for Tailwind's `@layer utilities`, which wraps
+   * essentially the whole stylesheet — so the number was "declarations in
+   * everything nested under here", which is a file size, not a complexity, and it
+   * double-counted every selector that already carries its own. `@layer utilities`
+   * is honestly 1: its contents are accounted by the rules inside it.
+   *
+   * This is what makes the descriptor reading correct where it applies:
+   * `@property --x` with `syntax`/`inherits`/`initial-value` is 4, `@font-face`
+   * with a descriptor set is its count + 1, and `@mixin` with one declaration is 2.
+   */
+  countDescriptors(node) {
+    let n = 0;
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child || child.type !== "block") continue;
+      for (let j = 0; j < child.childCount; j++) {
+        const d = child.child(j);
+        if (d && d.type === "declaration") n++;
+      }
+      break;
+    }
+    return n;
+  }
+  findChild(node, predicate) {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child && predicate(child)) return child;
+    }
+    return null;
+  }
+  filterChildren(node, predicate) {
+    const res = [];
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child && predicate(child)) res.push(child);
+    }
+    return res;
+  }
+  processRuleSet(node, media, supports, layer, container, scope, parentSelector, ctx) {
+    const selectorsNode = this.findChild(node, (c) => c?.type === "selectors");
+    if (!selectorsNode) return null;
+    if (this.isRecoveryDebris(selectorsNode)) {
+      ctx.errors.push({
+        message: `Syntax ERROR: this selector is not a valid CSS rule (the grammar could not read the construct it belongs to), so nothing is extracted from it.`,
+        range: this.nodeToRange(node),
+        severity: `warning`
+      });
+      return null;
+    }
+    if (ctx.fileHasParseError && this.isKeyframeStepSelector(selectorsNode)) {
+      ctx.errors.push({
+        message: `Syntax ERROR: a keyframe step was re-parsed as a rule by error recovery, so it is not extracted as a selector.`,
+        range: this.nodeToRange(node),
+        severity: `warning`
+      });
+      return null;
+    }
+    if (!looksLikeSelectorText(selectorsNode.text)) return null;
+    const rawParts = selectorsNode.text.split(",");
+    const rawSelectors = [];
+    for (let i = 0; i < rawParts.length; i++) {
+      rawSelectors.push(rawParts[i].trim());
+    }
+    const keptSelectors = [];
+    for (let i = 0; i < rawSelectors.length; i++) {
+      if (!isResetSelector(rawSelectors[i])) keptSelectors.push(rawSelectors[i]);
+    }
+    if (keptSelectors.length === 0) {
+      return null;
+    }
+    if (keptSelectors.length !== rawSelectors.length) {
+      rawSelectors.length = 0;
+      for (let i = 0; i < keptSelectors.length; i++) rawSelectors.push(keptSelectors[i]);
+    }
+    let parentSelectors = [""];
+    if (parentSelector) {
+      const pParts = parentSelector.split(",");
+      parentSelectors = [];
+      for (let i = 0; i < pParts.length; i++) {
+        parentSelectors.push(pParts[i].trim());
+      }
+    }
+    for (const r of rawSelectors) {
+      if (!parentSelector && hasNestingAmp(r)) return null;
+    }
+    const resolvedSelectors = [];
+    for (let i = 0; i < parentSelectors.length; i++) {
+      const p = parentSelectors[i];
+      for (let j = 0; j < rawSelectors.length; j++) {
+        const r = rawSelectors[j];
+        if (p) {
+          if (hasNestingAmp(r)) {
+            resolvedSelectors.push(replaceAll(r, "&", p));
+          } else {
+            resolvedSelectors.push(`${p} ${r}`);
+          }
+        } else {
+          resolvedSelectors.push(r);
+        }
+      }
+    }
+    const selectorText = resolvedSelectors.join(", ");
+    let isComplex = false;
+    let hasPseudoClass = false;
+    let hasPseudoElement = false;
+    let isUtility = true;
+    let isCssModule = false;
+    const classNames = [];
+    let hasIdSelector = false;
+    let hasTagSelector = false;
+    let hasAttributeSelector = false;
+    let maxSpecificity = [0, 0, 0];
+    let groupComplexity = 0;
+    const selectorNodes = selectorsNode.namedChildren;
+    for (let j = 0; j < selectorNodes.length; j++) {
+      const selNode = selectorNodes[j];
+      let specId = 0;
+      let specClass = 0;
+      let specTag = 0;
+      const chain = [];
+      let selectorComplexity = 1;
+      let nestingDepth = 0;
+      const chainLines = {};
+      const selStack = [selNode];
+      while (selStack.length > 0) {
+        const n = selStack.pop();
+        if (n.type === "child_selector" || n.type === "sibling_selector" || n.type === "adjacent_sibling_selector" || n.type === "descendant_selector") {
+          isComplex = true;
+          isUtility = false;
+          selectorComplexity += 1;
+        }
+        if (n.type === "pseudo_class_selector") {
+          hasPseudoClass = true;
+          specClass += 1;
+          isUtility = false;
+          selectorComplexity += 1;
+          if (this.findChild(n, (c) => c?.type === "arguments") !== null) selectorComplexity += 1;
+        }
+        if (n.type === "pseudo_element_selector") {
+          hasPseudoElement = true;
+          specTag += 1;
+          isUtility = false;
+          selectorComplexity += 1;
+        }
+        if (n.type === "attribute_selector") {
+          hasAttributeSelector = true;
+          specClass += 1;
+          isUtility = false;
+          selectorComplexity += 1;
+          const attrName = this.findChild(n, (c) => c?.type === "attribute_name");
+          const attrKey = attrName ? attrName.text : n.text;
+          chain.push(attrKey);
+          chainLines[attrKey] = this.lineOf(n) ?? chainLines[attrKey];
+        }
+        if (n.type === "id_selector") {
+          hasIdSelector = true;
+          specId += 1;
+          isUtility = false;
+          chain.push(n.text);
+          chainLines[n.text] = this.lineOf(n) ?? chainLines[n.text];
+        }
+        if (n.type === "tag_name") {
+          hasTagSelector = true;
+          specTag += 1;
+          if (n.text !== "*") isUtility = false;
+          chain.push(n.text);
+          chainLines[n.text] = this.lineOf(n) ?? chainLines[n.text];
+        }
+        if (n.type === "class_name") {
+          specClass += 1;
+          classNames.push(n.text);
+          chain.push(`.${n.text}`);
+          chainLines[`.${n.text}`] = this.lineOf(n) ?? chainLines[`.${n.text}`];
+        }
+        if (n.type === "universal_selector") {
+          specTag += 1;
+          chain.push(n.text);
+          chainLines[n.text] = this.lineOf(n) ?? chainLines[n.text];
+        }
+        if (n.text.indexOf(":local") !== -1 || n.text.indexOf(":global") !== -1) {
+          isCssModule = true;
+        }
+        for (let i = n.namedChildCount - 1; i >= 0; i--) {
+          const child = n.namedChild(i);
+          if (child) selStack.push(child);
+        }
+      }
+      if (parentSelector) nestingDepth += 1;
+      if (selectorComplexity > groupComplexity) groupComplexity = selectorComplexity;
+      if (selectorComplexity > 0) ctx.fileSelectorComplexity = (ctx.fileSelectorComplexity ?? 0) + selectorComplexity;
+      if (nestingDepth > 0) ctx.fileNestingDepth = Math.max(ctx.fileNestingDepth ?? 0, nestingDepth);
+      if (selectorComplexity > nestingDepth) ctx.fileMaxSelectorComplexity = Math.max(ctx.fileMaxSelectorComplexity ?? 0, selectorComplexity);
+      if (specId > maxSpecificity[0]) maxSpecificity = [specId, specClass, specTag];
+      else if (specId === maxSpecificity[0] && specClass > maxSpecificity[1])
+        maxSpecificity = [specId, specClass, specTag];
+      else if (specId === maxSpecificity[0] && specClass === maxSpecificity[1] && specTag > maxSpecificity[2])
+        maxSpecificity = [specId, specClass, specTag];
+      if (selectorText) {
+        const bar = selectorText.indexOf("|");
+        if (bar > 0) {
+          const prefix = selectorText.slice(0, bar).trim();
+          const declared = ctx.namespacePrefixes[prefix];
+          if (declared) {
+            ctx.relationships.push({
+              source: selectorText,
+              target: declared,
+              type: ASTEngine.RelationshipType.References,
+              // the name on this edge is the DECLARATION, which is written on the
+              // `@namespace` line — not the selector's own line
+              line_number: this.lineOf(selectorsNode),
+              metadata: { cssSpecific: true, isNamespaceRef: true }
+            });
+          }
+        }
+      }
+      if (isComplex && chain.length >= 2) {
+        for (let i = 0; i < chain.length - 1; i++) {
+          ctx.deferredChainEdges.push({
+            from: chain[i],
+            to: chain[i + 1],
+            rule: rawSelectors.join(", "),
+            line: chainLines[chain[i + 1]] ?? this.lineOf(selectorsNode)
+          });
+        }
+        for (let i = 0; i < chain.length; i++) {
+          if (chain[i].length === 0) continue;
+          ctx.selectorChains[rawSelectors.join(", ")] = ctx.selectorChains[rawSelectors.join(", ")] ?? [];
+          const list = ctx.selectorChains[rawSelectors.join(", ")];
+          if (list.indexOf(chain[i]) === -1) list.push(chain[i]);
+        }
+      }
+    }
+    if (classNames.length !== 1 || isComplex || hasPseudoClass || hasPseudoElement || parentSelector) {
+      isUtility = false;
+    }
+    const selectorKind = this.determineSelectorKind(
+      hasIdSelector,
+      classNames.length > 0,
+      hasTagSelector,
+      hasPseudoClass,
+      hasPseudoElement,
+      hasAttributeSelector,
+      isComplex
+    );
+    if (parentSelector && selectorText === parentSelector) {
+      return null;
+    }
+    ctx.symbols.push({
+      name: selectorText,
+      kind: selectorKind,
+      range: this.nodeToRange(node),
+      scope: parentSelector,
+      visibility: "public",
+      // `complexity` is a REQUIRED field of the Symbol contract (engine.ts:389) and
+      // the store reads it directly (`complexity: meta.complexity || 0`, engine.ts
+      // :1573). CSS carried the number in `metadata` only, so the contract field was
+      // never populated and both the store and pool-worker's `||` fallbacks invented
+      // a value. One number, one field.
+      complexity: groupComplexity + (parentSelector ? ctx.fileNestingDepth ?? 0 : 0),
+      metadata: {
+        isSelector: true,
+        isUtility,
+        isComplex,
+        hasPseudoClass,
+        hasPseudoElement,
+        isCssModule,
+        classNames,
+        specificity: maxSpecificity,
+        cssSpecific: true,
+        // Nesting depth is added to the selector's own complexity (set on the
+        // symbol above) rather than inside the walk, because `nestingDepth` is a
+        // property of the RULE, and the walk counts complexity per selector within
+        // the group.
+        selectorComposition: {
+          hasId: hasIdSelector,
+          hasClass: classNames.length > 0,
+          hasTag: hasTagSelector,
+          hasPseudoClass,
+          hasPseudoElement,
+          hasAttribute: hasAttributeSelector
+        }
+      }
+    });
+    if (isComplex) ctx.patterns["Complex Selectors"] = true;
+    if (isUtility) ctx.patterns["Utility-First Classes"] = true;
+    if (hasPseudoClass) ctx.patterns["Pseudo-classes"] = true;
+    if (hasPseudoElement) ctx.patterns["Pseudo-elements"] = true;
+    if (isCssModule) {
+      ctx.patterns["CSS Modules (:local/:global)"] = true;
+      ctx.frameworks["CSS Modules"] = true;
+    }
+    const selectorLine = this.lineOf(selectorsNode);
+    const asWritten = selectorsNode.text.trim();
+    const composedName = collapseWhitespace(asWritten) !== selectorText;
+    const nameLine = { line_number: selectorLine };
+    const nameProvenance = composedName ? { isSynthesizedName: true, asWrittenSelector: asWritten } : {};
+    if (media) {
+      ctx.relationships.push({
+        source: media,
+        target: selectorText,
+        type: ASTEngine.RelationshipType.Contains,
+        ...nameLine,
+        metadata: { cssSpecific: true, isMediaScope: true, ...nameProvenance }
+      });
+    }
+    if (supports) {
+      ctx.relationships.push({
+        source: supports,
+        target: selectorText,
+        type: ASTEngine.RelationshipType.Contains,
+        ...nameLine,
+        metadata: { cssSpecific: true, isSupportsScope: true, ...nameProvenance }
+      });
+    }
+    if (layer) {
+      ctx.relationships.push({
+        source: layer,
+        target: selectorText,
+        type: ASTEngine.RelationshipType.Contains,
+        ...nameLine,
+        metadata: { cssSpecific: true, isLayerScope: true, ...nameProvenance }
+      });
+    }
+    if (container) {
+      ctx.relationships.push({
+        source: container,
+        target: selectorText,
+        type: ASTEngine.RelationshipType.Contains,
+        ...nameLine,
+        metadata: { cssSpecific: true, isContainerScope: true, ...nameProvenance }
+      });
+    }
+    if (scope) {
+      ctx.relationships.push({
+        source: scope,
+        target: selectorText,
+        type: ASTEngine.RelationshipType.Contains,
+        ...nameLine,
+        metadata: { cssSpecific: true, isScopeScope: true, ...nameProvenance }
+      });
+    }
+    if (parentSelector) {
+      ctx.relationships.push({
+        source: parentSelector,
+        target: selectorText,
+        type: ASTEngine.RelationshipType.Contains,
+        ...nameLine,
+        metadata: {
+          cssSpecific: true,
+          isNestedSelector: true,
+          ...nameProvenance
+        }
+      });
+    }
+    return selectorText;
+  }
+  /**
+   * The node that NAMES the module an `@import` pulls in, or `null` when the statement
+   * carries none.
+   *
+   * A DIRECT `string_value` / `call_expression` child is the shape the grammar produces for
+   * a well-formed `@import`, and it stays the first thing tried so the 243 edges that were
+   * already published are untouched.
+   *
+   * The DESCENDANT pass exists because pass 10 measured a 7-edge gap on the admitted corpus:
+   * 250 `import_statement` nodes, 243 published `imports` edges
+   * (`validation/m14/census/css-import-coverage.ts`). The 7 are indented-Sass `.sass`
+   * partials, which this pinned CSS grammar cannot parse, and it recovers them into an
+   * ERROR shape — `;+@import+ERROR+binary_expression`, `;+@import+ERROR+ERROR+float_value+
+   * keyword_query` and four siblings — where the quoted specifier is still a real
+   * `string_value` node but sits under the ERROR rather than directly under the statement.
+   * `@import "../utilities/mixins"` is a genuine fetch the user agent performs; publishing
+   * nothing for it is a silent miss, not a ruling.
+   *
+   * **The line guard is what makes the descendant pass safe, and it is not optional.** The
+   * ERROR recovery SWALLOWS the rest of the file into the `import_statement` node:
+   * `Documenter.jl/.../bulma/elements/button.sass` spans L2..L50 and carries ELEVEN
+   * `string_value` descendants — one at L2 (`"../utilities/mixins"`, the module) and ten at
+   * L47 (the `$breakpoints` map's `"mobile"`, `"small"`, `"normal"`, … ). Taking the first
+   * descendant in document order happens to pick the right one there, and would pick the
+   * WRONG one for any statement whose own specifier is not a node. Restricting the search to
+   * the `@import` KEYWORD's own row rejects the L47 ten by construction, so the name is
+   * always the specifier written on the `@import` line and never a string the recovery
+   * swept up from a later line.
+   *
+   * Node-type and position tests only. No pattern over raw text, so a quoted word in a
+   * comment, in a `content:` value or in a class name cannot become a module name.
+   */
+  findImportNameNode(node) {
+    const isNameNode = (n) => n.type === "string_value" || n.type === "call_expression";
+    const direct = this.findChild(node, isNameNode);
+    if (direct) return direct;
+    const keyword = this.findChild(node, (c) => c?.type === "@import");
+    const keywordRow = (keyword ?? node).startPosition.row;
+    let found = null;
+    const walk = (n) => {
+      if (found) return;
+      if (n.startPosition.row === keywordRow && isNameNode(n)) {
+        found = n;
+        return;
+      }
+      for (let i = 0; i < n.childCount; i++) {
+        const child = n.child(i);
+        if (child) walk(child);
+      }
+    };
+    walk(node);
+    return found;
+  }
+  /**
+   * The name an `imports` TARGET is published under, which is the same rule the SOURCE half
+   * already uses: a stylesheet is named by its LAST PATH SEGMENT.
+   *
+   * ## The defect this fixes
+   *
+   * One edge had its two ends spelled by two different rules. The source is
+   * `this.importerName` = `lastPathSegment(filePath)` = `layout.css`. The target was the
+   * specifier verbatim = `styles/layout.css`. So the store could never join them, and
+   * MEASURED over the 600-file window (`css-import-specifier-names.json`, 58 import edges):
+   * 11 edges named a file that exists under the basename with that basename UNIQUE in its own
+   * repo, and all 11 were unreachable.
+   *
+   * ## Why only stylesheet-extension specifiers
+   *
+   * A specifier's last segment is only a stylesheet's name when it is a stylesheet. Three
+   * cases in the same 58-edge population are NOT, and reducing them would FABRICATE a
+   * resolution:
+   *
+   *   `https://fonts.googleapis.com/css?family=Lato:400,400i` (10 edges) — the last segment
+   *   names no file anywhere; it would bind to whatever unrelated file shares its basename.
+   *   `tailwindcss`, `tw-animate-css` (24 edges) — package names, resolved by a package
+   *   manager or a PostCSS plugin. `tailwindcss` DOES collide with a real file in this
+   *   corpus, so recovering it resolves to the wrong thing.
+   *   `@fontsource-variable/figtree/index.css` (1 edge) — a package SUBPATH. The `index.css`
+   *   last segment is the package's internal file, not this repo's.
+   *
+   * The discriminator is a final segment carrying a stylesheet extension, checked by
+   * `charCodeAt` and `startsWith` — no pattern over text. `_variables.less` (9 edges, no
+   * slash) is the case that proves the discriminator has to be the EXTENSION and not the
+   * slash: it is a sibling file, and a slash test files it as a package.
+   *
+   * ## What this does NOT claim
+   *
+   * A basename held by more than one stylesheet in the same repo USED to be published under the
+   * bare basename and stay ambiguous, on the ground that any disambiguator would be an invented
+   * naming convention. That is now falsified and fixed: a relative specifier whose sibling exists
+   * on disk targets the SIBLING's own published module name (`siblingImportTarget` above), which
+   * is the file's existing identity rather than a new convention. Measured over the whole
+   * `css,less` population: 51 ambiguous edges resolved, 0 currently-resolving edges put at risk.
+   */
+  /**
+   * CSS-D18-FALSIFIER. A RELATIVE specifier names the file BESIDE the importing stylesheet, and
+   * when that file exists on disk the target is that sibling's OWN project-unique module name —
+   * `<its file scope>::<its basename>` — which is not an invented convention but the identity
+   * `publishFileScopedIdentities` already publishes for every file in this lane.
+   *
+   * WHY THIS REPLACES THE LANE'S EARLIER RULING. The paragraph below used to say that a basename
+   * held by more than one stylesheet in a repo "stays AMBIGUOUS, because ... a disambiguator
+   * invented here would be a second, invented naming convention". The falsifier was measured
+   * (`validation/m14/fixtures/css/imports-sibling-falsifier.ts`, whole `css,less` population):
+   * of 106 basename-specifier imports, the 51 whose basename TWO OR MORE admitted files publish
+   * have an ADMITTED SIBLING in **51 of 51** cases, and of the 55 unique-basename ones the 32
+   * with no admitted sibling **do not exist on disk at all** (dangling imports). So an
+   * existence-gated resolution fixes every ambiguous edge and puts NONE of the currently
+   * resolving ones at risk — the risk is measured at ZERO, not assumed.
+   *
+   * `existsSync` is a filesystem read in an analyzer, and that is stated rather than hidden: it
+   * makes the target depend on which sibling is on disk, and a sibling that exists but is NOT
+   * admitted would name a declaration the population does not contain (an unresolved edge where
+   * the bare basename used to resolve). MEASURED on this population: 0 such cases in either
+   * bucket. The alternative — naming a same-basename file in another directory — is what the
+   * bare spelling already does, and it is right only by luck.
+   */
+  siblingImportFile(specifier) {
+    if (this.fileDir === "" || specifier.length === 0) return null;
+    if (specifier.startsWith("/")) return null;
+    const sibling = path.resolve(this.fileDir, specifier);
+    if (!existsSync(sibling)) return null;
+    return sibling;
+  }
+  siblingImportTarget(specifier) {
+    const sibling = this.siblingImportFile(specifier);
+    if (sibling === null) return null;
+    const base = lastPathSegment(sibling);
+    if (base.length === 0) return null;
+    const scope = cssFileScopeOf(sibling);
+    if (scope === "") return null;
+    return `${scope}::${base}`;
+  }
+  /**
+   * THE CLAIM AN `@import` TARGET CAN CARRY — the reason the edge names something this run cannot
+   * resolve, published on a key the ARBITER reads rather than in a comment.
+   *
+   * THE DEFECT THIS CLOSES, in this lane's own measurement. The gate's residual for `css` over the
+   * 400-file stride is **85 edges = 70 ambiguous + 15 unresolved**; the 15 are ALL `@import`
+   * specifiers that name no declaration in the sampled key space, and they carried NO claim of any
+   * kind — the marker table showed `imports  importSource+importSpecifier+isCssImport` with
+   * `extClaim 0`. This is the fleet-wide finding (`RESIDUAL-CLASSIFICATION-41-LANES.md:18-34`) in
+   * its earlier form: not a truthful marker on an unread spelling, but no marker at all, on a
+   * construct whose reason the analyzer ALREADY computes — `importTargetName` above branches on
+   * network URL vs project path vs package name.
+   *
+   * THE TWO SHAPES THE CENSUS FOUND, and each one's claim:
+   *
+   *   A NETWORK URL (`https://fonts.googleapis.com/css?family=…`, 7 of the 15) is outside every
+   *   admitted file list BY CONSTRUCTION, so the edge carries `sourcePathClaim`. Its polarity is
+   *   inverted on purpose (`incoming-rule.ts`, `SOURCE_PATH_CLAIM_KEY`): the project REFUTES the
+   *   claim the moment a candidate IS an admitted file, which is what stops this from becoming a
+   *   laundering channel. MEASURED, with the arbiter's own `classifyEdge` and its own admitted
+   *   file facts: **7 of 7 verify, 0 refuted** — and the spelling cannot produce a refutation,
+   *   since no admitted path answers a URL.
+   *
+   *   A RELATIVE SPECIFIER THAT RESOLVES TO A FILE BESIDE THIS ONE (`styles/layout.css`,
+   *   `MavenPro.css`; 8 of the 15) is a dependency the project plainly HAS — it is on disk, and it
+   *   is an admitted file — but the sampler did not draw the file that declares it, so the target
+   *   (`<scope>::<basename>`) answers nothing in the key space. The honest claim is
+   *   `importProjectFile`: the project's own admitted list CONFIRMS the file, which is evidence the
+   *   analyzer never saw. MEASURED the same way: **8 of 8 verify, 0 refuted** — the candidate is
+   *   the sibling's real repo-relative path (`plugins/org.jkiss.dbeaver.ui.ai/web/styles/layout.css`,
+   *   …) and every one of the eight is in the admitted file list. This is the yaml `!include`
+   *   claim's law (`incoming-rule.ts`, `FILE_CLAIM_KEY`): a miss would REFUTE, so existence is
+   *   checked before the claim is published — never the other way round.
+   *
+   * WHAT IS DELIBERATELY LEFT UNMARKED, which is the half that keeps this from being a blanket
+   * excuse. A BARE PACKAGE NAME (`tailwindcss`, `tw-animate-css`) gets NOTHING: the source-path
+   * claim is defined only for a target containing `/` or a scheme, and a bare name is exactly the
+   * spelling that can also name a DECLARATION. An `@`-SCOPED PACKAGE SUBPATH
+   * (`@fontsource-variable/figtree/index.css`) gets nothing either: it is not in this population,
+   * and its claim's CANDIDATES include the bare basename (`index.css`), which a repo that admits a
+   * root-level `index.css` would refute. A claim that has not been measured is not published.
+   *
+   * EVERY KEY HERE IS ADDITIVE. The target is untouched — no rebasing, no basename stripping — so
+   * `resolved`, `collRes` and the binding-intent table cannot move; the claim is read by the
+   * arbiter only where the key space declares nothing by that target (`classifyEdge`'s
+   * `decls === 0` branch), so no existing resolution can be relabelled either.
+   */
+  importClaimMetadata(specifier) {
+    if (this.claimProjectRoot.length === 0) return {};
+    if (specifier.startsWith("http:") || specifier.startsWith("https:") || specifier.startsWith("//")) {
+      return { sourcePathClaim: [specifier] };
+    }
+    if (specifier.startsWith("@") || specifier.startsWith("~")) return {};
+    const sibling = this.siblingImportFile(specifier);
+    if (sibling === null) return {};
+    try {
+      if (!statSync(sibling).isFile()) return {};
+    } catch {
+      return {};
+    }
+    const rel = path.relative(this.claimProjectRoot, sibling);
+    if (rel.length === 0 || rel.startsWith("..")) return {};
+    return { importProjectFile: [rel.split(path.sep).join("/")] };
+  }
+  importTargetName(specifier) {
+    if (specifier.startsWith("http:") || specifier.startsWith("https:") || specifier.startsWith("//")) return specifier;
+    if (specifier.startsWith("@") || specifier.startsWith("~")) return specifier;
+    const sibling = this.siblingImportTarget(specifier);
+    if (sibling !== null) return sibling;
+    const slash = specifier.lastIndexOf("/");
+    if (slash < 0) return specifier;
+    const segment = specifier.slice(slash + 1);
+    const dot = segment.lastIndexOf(".");
+    if (dot <= 0) return specifier;
+    const ext = segment.slice(dot).toLowerCase();
+    for (const known of [".css", ".scss", ".sass", ".less"]) {
+      if (ext === known) return segment;
+    }
+    return specifier;
+  }
+  /**
+   * Is this `@import` the PLAIN FILE FORM — the one that names a stylesheet to fold in?
+   *
+   * Sass and Less inline a non-CSS import at compile time, so that form is an inclusion of one
+   * source file into another, not a stylesheet load. The grammar answers the question as a SHAPE,
+   * which is why this reads the tree rather than matching spellings:
+   *   `@import url("x")`      → one named child, type `call_expression`   (stylesheet load)
+   *   `@import "x" screen`    → a second named child (the media query)    (stylesheet load)
+   *   `@import "x.css";`      → one `string_value` whose text is a CSS file (stylesheet load)
+   * so the plain-file form is: exactly ONE named child, type `string_value`, and a specifier that
+   * is not a `.css` file, not a protocol URL, not a `sass:` built-in module and not `data:`.
+   * Error-recovered statements fail the shape test and stay `imports`.
+   */
+  isPlainFileFormImport(node) {
+    const named = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c) named.push(c);
+    }
+    if (named.length !== 1 || named[0].type !== "string_value") return false;
+    const spec = stripAllQuotes(named[0].text).trim();
+    if (spec.length === 0) return false;
+    if (hasCssFileExtension(spec)) return false;
+    const lower = spec.toLowerCase();
+    if (lower.startsWith("//") || lower.startsWith("http://") || lower.startsWith("https://")) return false;
+    if (lower.startsWith("sass:") || lower.startsWith("data:")) return false;
+    return true;
+  }
+  processImport(node, ctx) {
+    const stringNode = this.findImportNameNode(node);
+    if (stringNode) {
+      const moduleName = unwrapUrl(stringNode.text);
+      const targetName = this.importTargetName(moduleName);
+      ctx.imports.push({
+        module: moduleName,
+        source: moduleName,
+        imported: ["*"],
+        isTypeOnly: false,
+        range: this.nodeToRange(node)
+      });
+      const isPart = this.cssFamilyHost && this.isPlainFileFormImport(node);
+      ctx.relationships.push({
+        source: this.importerName,
+        target: targetName,
+        type: isPart ? ASTEngine.RelationshipType.PartOf : ASTEngine.RelationshipType.Imports,
+        // the name on this edge is the MODULE, so the line is the
+        // `string_value` / `call_expression` node — which can be on a LATER line
+        // than the `@import` keyword, and is for the multi-line form where the
+        // url() wraps its argument. Taking the statement's line would be the
+        // enclosing construct, not the name.
+        line_number: this.lineOf(stringNode),
+        confidence: 1,
+        metadata: {
+          isCssImport: true,
+          importSource: this.importerName,
+          importSpecifier: moduleName,
+          ...isPart ? { partRole: "library", isCssPartImport: true } : {},
+          // THE REASON, on the channel the arbiter reads. `imports` was the only residual type of
+          // this lane that published NO claim at all (gate marker table: `extClaim 0`), while the
+          // analyzer already knew which specifiers are network URLs and which name a project file.
+          // Additive: the target is untouched, so no resolution can move — see
+          // `importClaimMetadata` for the measured 15 of 15 verifications and what is NOT marked.
+          ...this.importClaimMetadata(moduleName)
+        }
+      });
+      if (moduleName.indexOf("tailwind") !== -1) ctx.frameworks["Tailwind CSS"] = true;
+      if (moduleName.indexOf("bootstrap") !== -1) ctx.frameworks["Bootstrap"] = true;
+      if (moduleName.indexOf("bulma") !== -1) ctx.frameworks["Bulma"] = true;
+      if (moduleName.indexOf("foundation") !== -1) ctx.frameworks["Foundation"] = true;
+    }
+  }
+  /**
+   * Every custom-media name a media query REFERENCES, in source order.
+   *
+   * Custom Media Queries L1: `@media (--narrow)` evaluates a `@custom-media`
+   * declaration, wherever in the query list it appears and however the query is
+   * composed. The grammar marks the reference exactly — a `keyword_query` directly
+   * under a `parenthesized_query`, spelled `--name` — so this reads that shape rather
+   * than recognising a spelling, which is why `@media screen and (--narrow)`,
+   * `@media not (--c)` and `@media (--a), (--b)` are all covered.
+   *
+   * The discriminator is the `--` prefix and NOT the node type alone, because
+   * `keyword_query` is the grammar's node for a bare media type too: `screen` in
+   * `@media screen` and `print` in `@media print and (color)` are the same node type
+   * and neither is a custom-media reference.
+   *
+   * A `parenthesized_query` holding a `feature_query` — `(min-width: 400px)` — has no
+   * `keyword_query` child at all, so it contributes nothing, which is the correct
+   * answer without a special case.
+   */
+  customMediaRefsIn(queryNode) {
+    const out = [];
+    const stack = [queryNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      const isRefSite = n.type === "parenthesized_query" || n === queryNode;
+      if (isRefSite) {
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (!c || c.type !== "keyword_query") continue;
+          const name = leadingCustomIdent(c.text);
+          if (name.length > 0 && out.indexOf(name) === -1) out.push(name);
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return out;
+  }
+  /**
+   * The `@custom-media` references of a whole comma-separated query LIST.
+   *
+   * `customMediaRefsIn` walks ONE node's subtree. A comma list is not inside one
+   * node — the grammar leaves the terms as SIBLING query children of the statement —
+   * so the single-term walk cannot see past the first comma. This unions the walk
+   * over the statement's own DIRECT query children, which is what makes
+   * `@media (--a), (--b)` depend on both `--a` and `--b`.
+   *
+   * Direct children only, so the walk cannot descend into the block and read a
+   * declaration value as a reference. For a single-term query there is exactly one
+   * such child, so the result is identical to `customMediaRefsIn(queryNode)` — which
+   * is why this is a widening and not a rewrite.
+   */
+  customMediaRefsInList(statement) {
+    const out = [];
+    for (let i = 0; i < statement.childCount; i++) {
+      const c = statement.child(i);
+      if (!c) continue;
+      if (c.type !== "keyword_query" && c.type !== "binary_query" && c.type !== "feature_query" && c.type !== "parenthesized_query" && c.type !== "unary_query" && c.type !== "selector_query") {
+        continue;
+      }
+      for (const name of this.customMediaRefsIn(c)) if (out.indexOf(name) === -1) out.push(name);
+    }
+    return out;
+  }
+  processMedia(node, ctx) {
+    const queryNode = this.findChild(
+      node,
+      (c) => c && (c.type === "keyword_query" || c.type === "binary_query" || c.type === "feature_query" || c.type === "parenthesized_query" || c.type === "unary_query" || c.type === "selector_query")
+    );
+    if (queryNode) {
+      const mediaName = `@media ${collapseWhitespace(this.atRulePrelude(node, "@media"))}`;
+      ctx.patterns["Responsive Design (Media Queries)"] = true;
+      if (!ctx.mediaScopes[mediaName]) {
+        ctx.mediaScopes[mediaName] = true;
+        const published = {
+          name: mediaName,
+          kind: ASTEngine.SymbolKind.Module,
+          range: this.nodeToRange(node),
+          scope: "",
+          visibility: "public",
+          complexity: this.queryComplexity(collapseWhitespace(queryNode.text)),
+          metadata: {
+            isMediaScope: true,
+            mediaCondition: collapseWhitespace(queryNode.text),
+            scopeBlocks: 1
+          }
+        };
+        ctx.symbols.push(published);
+        ctx.scopeSymbol[mediaName] = published;
+        for (const declared of this.customMediaRefsInList(node)) {
+          if (!ctx.customMediaNames[declared]) continue;
+          ctx.relationships.push({
+            source: mediaName,
+            target: declared,
+            type: ASTEngine.RelationshipType.References,
+            // the NAME is the condition's own line, the same rule as the
+            // font-family edge: the reference is the condition, not the statement
+            line_number: this.lineOf(queryNode),
+            metadata: { cssSpecific: true, isCustomMediaRef: true }
+          });
+        }
+      } else {
+        this.widenScopeSymbol(ctx.scopeSymbol[mediaName], node);
+      }
+      return mediaName;
+    }
+    return null;
+  }
+  /**
+   * Extend an already-published at-rule SCOPE symbol so its recorded extent covers a
+   * further block of the same scope.
+   *
+   * ## What was wrong, and how it was found
+   *
+   * `@media` and `@layer` publish ONE symbol per name, at the FIRST block, and the
+   * identity merge at the end of `analyze` never sees a second copy to fold. So a file
+   * with `@media (min-width: 576px)` three times has one symbol for it, recorded at the
+   * first block, and every rule of the second and third blocks receives a `contains`
+   * edge pointing at that first block. The edge is TRUE — the rule is inside a block of
+   * that query — and its endpoint is somewhere the rule is not.
+   *
+   * Measured over the whole admitted corpus: 7,257 of 25,181 `isMediaScope` edges
+   * (28.8%) and 40 of 505 `isLayerScope` edges (7.9%) carried a contained rule outside
+   * the source symbol's line range. Worked example, `bootstrap-grid.css`: the edge for
+   * `.col-sm` is at L284 and the symbol is recorded at L22-L26.
+   *
+   * A pass-1 probe reported this as 0 violations. That number was VACUOUS — the probe
+   * read the extent as `symbol.range.start.line`, and `parseFile` returns no `range`
+   * object at all (it flattens to top-level `startLine` / `endLine`), so every lookup
+   * missed. The non-zero figure is from the corrected probe, and the correction is
+   * recorded in `validation/m14/census/css-boundary-probe.ts` because a broken probe
+   * reporting zero is indistinguishable from a correct probe reporting zero.
+   *
+   * ## Why widening is the right repair and not publishing a second symbol
+   *
+   * Two symbols with one name is the identity collision this dedup exists to prevent —
+   * an edge naming one of them is ambiguous, and an ambiguous endpoint is the failure
+   * the export invariant convicts. And the NAME is the only identity a consumer has
+   * here: `pool-worker.ts` forwards a narrow allowlist of `metadata` keys and
+   * `isMediaScope` / `mediaCondition` are not on it, so 2,804 of 3,084 at-rule scope
+   * symbols arrive from `parseFile` with NO metadata at all (measured, same probe). A
+   * consumer cannot tell two `@media` nodes apart except by the name, so the name's
+   * extent has to be the union of its blocks. `@supports` and `@container` already get
+   * exactly this from the identity merge.
+   *
+   * ## Only `endLine` moves, and the gap it leaves is stated
+   *
+   * The identity merge widens `endLine` only, and this does the same, so the byte span
+   * (`startIndex`/`endIndex`) still describes the FIRST block while the line extent
+   * describes all of them. A range is therefore not contiguous for a scope with
+   * several blocks. That is the lane's existing convention rather than a new one, and
+   * it is recorded here because a consumer that assumes contiguity will be wrong for
+   * exactly the multi-block scopes this method exists to describe. `scopeBlocks` counts
+   * the blocks — and is itself dropped at the production boundary, for the reason above,
+   * so it is available to a fixture and not to a store consumer.
+   */
+  widenScopeSymbol(sym, block) {
+    if (!sym || !sym.range) return;
+    const r = this.nodeToRange(block);
+    if (r.endLine <= (sym.range.endLine ?? 0)) return;
+    sym.range = { ...sym.range, endLine: r.endLine };
+    const md = sym.metadata ?? {};
+    const n = typeof md.scopeBlocks === "number" ? md.scopeBlocks : 1;
+    sym.metadata = { ...md, scopeBlocks: n + 1 };
+  }
+  /**
+   * Every `@keyframes` name in the file, collected before the main walk so that
+   * an `animation:` reference resolves regardless of where the block sits.
+   */
+  /**
+   * The published name of an `@font-face` declaration. Used by BOTH the symbol push
+   * and the `uses` edge, because when they were written separately the edge named
+   * the bare family while the symbol carried the keyword — a dangling endpoint, the
+   * same defect fixed for `@property` one commit earlier, in the other direction.
+   * One expression is the only way two names cannot drift apart.
+   */
+  /**
+   * The leading `--ident` of an at-rule prelude, or `""`.
+   *
+   * Written against the DECLARED name rather than a node type on purpose: the
+   * grammar has no `custom_media` node at all (all three of these at-rules are a
+   * bare `at_rule`), so there is nothing type-shaped to key on, and CSS itself says
+   * a custom media query name is a `<custom-ident>` followed by a condition.
+   */
+  atRulePrelude(node, keyword) {
+    const kwNode = this.findChild(node, (c) => c?.type === "at_keyword") ?? // `@namespace` and `@media` carry their keyword as an ANONYMOUS child whose type
+    // IS the keyword text, so the named-node lookup misses them.
+    this.findChild(node, (c) => c?.type === keyword);
+    const block = this.findChild(node, (c) => c?.type === "block");
+    const semi = this.findChild(node, (c) => c?.type === ";");
+    const start = kwNode ? kwNode.endIndex - node.startIndex : keyword.length;
+    const terminator = block ?? semi;
+    const end = terminator ? terminator.startIndex - node.startIndex : node.text.length;
+    if (end <= start) return "";
+    return collapseWhitespace(node.text.slice(start, end));
+  }
+  /**
+   * The family of the `@font-face` block a declaration sits in, or `undefined`.
+   *
+   * Walks UP from the declaration to its enclosing `@font-face` and reads that
+   * block's own `font-family` declaration — the same two-step the symbol push does,
+   * and deliberately so: CSS binds a `font-feature-settings` value to the family of
+   * the `@font-face` it appears in, so the edge target cannot be derived from the
+   * value alone.
+   */
+  fontFamilyOf(decl) {
+    let n = decl;
+    while (n) {
+      if (n.type === "at_rule") {
+        const kw = this.findChild(n, (c) => c?.type === "at_keyword");
+        if (kw && kw.text.trim().toLowerCase() === "@font-face") {
+          const block = this.findChild(n, (c) => c?.type === "block");
+          const family = block ? this.findDescendant(block, (d) => {
+            if (d.type !== "declaration") return false;
+            const prop = this.findChild(d, (g) => g?.type === "property_name");
+            return prop !== null && prop.text === "font-family";
+          }) : null;
+          if (family) {
+            const value = this.findChild(family, (c) => c?.type === "plain_value" || c?.type === "string_value");
+            if (value) return stripAllQuotes(value.text);
+          }
+          return void 0;
+        }
+      }
+      n = n.parent;
+    }
+    return void 0;
+  }
+  fontFaceSymbolName(family) {
+    return `@font-face ${family}`;
+  }
+  /**
+   * Namespace prefixes declared by `@namespace`, collected before the walk for the
+   * same order-independence reason as keyframes and font faces: a selector may use a
+   * prefix before the `@namespace` that declares it, and CSS does not care.
+   *
+   * The value is the PUBLISHED symbol name, so the edge and the symbol cannot name
+   * different things — the same single-expression discipline as `@font-face`.
+   */
+  collectNamespacePrefixes(root, ctx) {
+    const stack = [root];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (this.isErrorNode(n)) continue;
+      if (n.type === "namespace_statement") {
+        const nameNode = this.findChild(n, (c) => c?.type === "namespace_name");
+        if (nameNode) {
+          const prefix = nameNode.text.trim();
+          const kwNode = this.findChild(n, (c) => c?.type === "@namespace");
+          const semi = this.findChild(n, (c) => c?.type === ";");
+          const start = kwNode ? kwNode.endIndex - n.startIndex : "@namespace".length;
+          const end = semi ? semi.startIndex - n.startIndex : n.text.length;
+          const prelude = end <= start ? "" : collapseWhitespace(n.text.slice(start, end));
+          if (prefix && prelude) ctx.namespacePrefixes[prefix] = `@namespace ${prelude}`;
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+  }
+  collectKeyframeNames(root, ctx) {
+    const stack = [root];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (this.isErrorNode(n)) continue;
+      if (n.type === "keyframes_statement") {
+        const nameNode = this.findChild(
+          n,
+          (c) => c && (c.type === "keyframes_name" || c.type === "identifier" || c.type === "string_value")
+        );
+        if (nameNode) ctx.keyframeNames[stripAllQuotes(nameNode.text)] = true;
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+  }
+  /**
+   * Families declared by an `@font-face` in this file, collected BEFORE the walk for
+   * the same reason `collectKeyframeNames` runs first: a rule may use a family
+   * before the `@font-face` that declares it, and CSS does not care about order, so
+   * an edge that resolved during the walk would depend on where the author happened
+   * to put the declaration.
+   */
+  /**
+   * `@counter-style`, `@custom-media` and `@font-feature-values` are the last three
+   * at-rules that DECLARE a named, referable thing, and until now all three were
+   * dropped on the floor: the analyzer published no symbol for them, so a
+   * `list-style: thumbs` had nothing to point at and a `@media (--narrow)` named
+   * itself by raw text. That is the `@font-face` / `@property` defect class a
+   * second time — and it survived because NO CORPUS FILE USES ANY OF THE THREE, so
+   * they were classified NO OCCURRENCE and recorded as "not a defect". That is the
+   * cost of that label: it means the corpus cannot speak about them, not that they
+   * work. Three of three turned out to be broken.
+   *
+   * Pre-collected for the same order-independence reason as keyframes and font
+   * faces: CSS does not care whether a use precedes its declaration.
+   */
+  collectCustomDefinitionNames(root, ctx) {
+    const stack = [root];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (this.isErrorNode(n)) continue;
+      if (n.type === "at_rule") {
+        const kwNode = this.findChild(n, (c) => c?.type === "at_keyword");
+        const keyword = kwNode ? kwNode.text.trim().toLowerCase() : "";
+        const prelude = this.atRulePrelude(n, keyword);
+        if (keyword === "@counter-style" && prelude) ctx.counterStyleNames[prelude] = true;
+        else if (keyword === "@custom-media") {
+          const name = leadingCustomIdent(prelude);
+          if (name) ctx.customMediaNames[name] = true;
+        } else if (keyword === "@font-feature-values" && prelude) {
+          ctx.fontFeatureValuesNames[prelude] = true;
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+  }
+  collectFontFaceNames(root, ctx) {
+    const stack = [root];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (this.isErrorNode(n)) continue;
+      if (n.type === "at_rule") {
+        const kw = this.findChild(n, (c) => c?.type === "at_keyword");
+        if (kw && kw.text.trim() === "@font-face") {
+          const block = this.findChild(n, (c) => c?.type === "block");
+          const decl = block ? this.findDescendant(block, (d) => {
+            if (d.type !== "declaration") return false;
+            const prop = this.findChild(d, (g) => g?.type === "property_name");
+            return prop !== null && prop.text.trim().toLowerCase() === "font-family";
+          }) : null;
+          if (decl) {
+            const value = this.findChild(decl, (c) => c?.type === "string_value" || c?.type === "plain_value" || c?.type === "identifier");
+            if (value) ctx.fontFaceNames[stripAllQuotes(value.text.trim())] = true;
+          }
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+  }
+  /**
+   * Publishes a `@keyframes` declaration as a symbol and returns the name it published, or
+   * `""` when it published none.
+   *
+   * The RETURN is load-bearing and is new: the caller stores it as the owning scope for the
+   * declarations inside, which is what lets a `var()` inside a `keyframe_block` be emitted
+   * as a `references` edge from the animation instead of being dropped. See
+   * `StackFrame.keyframeScope`. It returns the name rather than `void` so the two can never
+   * disagree — a symbol published under a name the caller has to re-derive is the shape that
+   * produced the bare-`@container` identity collision this lane already had to undo.
+   */
+  processKeyframes(node, ctx) {
+    const nameNode = this.findChild(
+      node,
+      (c) => c && (c.type === "keyframes_name" || c.type === "identifier" || c.type === "string_value")
+    );
+    if (!nameNode) return "";
+    const name = stripAllQuotes(nameNode.text);
+    ctx.symbols.push({
+      name,
+      kind: ASTEngine.SymbolKind.Function,
+      range: this.nodeToRange(node),
+      scope: "",
+      visibility: "public",
+      complexity: 1 + this.countKeyframeStops(node),
+      metadata: {
+        isKeyframes: true
+        // (the stop-count complexity is set on the symbol above)
+      }
+    });
+    ctx.keyframeNames[name] = true;
+    ctx.patterns["CSS Animations"] = true;
+    const keywordNode = this.findChild(node, (c) => c?.type === "at_keyword");
+    const keyword = keywordNode ? keywordNode.text.trim().toLowerCase() : "@keyframes";
+    this.recordKeyframesOverride(ctx, name, keyword, this.lineOf(node));
+    return name;
+  }
+  /**
+   * M14 ONTOLOGY, `overrides` — CSS's only inheritance-like construct, and the one the
+   * lane was silently omitting.
+   *
+   * ## What the construct is
+   *
+   * CSS Animations L1 : "If multiple `@keyframes` rules with the same name are
+   * declared, the last one wins." The Properties & Values API says the same for a
+   * re-registered `@property --x`. So a second declaration of a name REPLACES the
+   * first, wholly — the earlier block becomes dead code. This is the same shape the
+   * gate's own header records for bash's 174 redefinition events, and the reason the
+   * differential could not find it here: `deriveCssEdges` derives `contains`, `uses`,
+   * `references` and `imports`, and both walkers said nothing about `overrides`.
+   *
+   * ## What the corpus says, and the number that changed the design
+   *
+   * `validation/m14/census/css-overrides-split.ts` over the whole admitted corpus
+   * (1,114 files, 61 repos) found **146 second declarations of an already-declared
+   * `@keyframes` name in one file** — and **142 of them are a vendor-prefixed pair**,
+   * overwhelmingly Font Awesome's `@-webkit-keyframes fa-spin` / `@keyframes fa-spin`.
+   * A prefixed pair is not a redeclaration: two animations, selected by support. An
+   * `overrides` edge for each would have been a fabrication over 97.3% of the type, on
+   * the strength of an aggregate count.
+   *
+   * The remaining **4** are the real thing: `hasura-engine/frontend/libs/console/
+   * legacy-ce/src/lib/components/Services/ApiExplorer/GraphiQLWrapper/GraphiQL.css`
+   * (`@keyframes rotation` at L1534 and again at L2214) and three in
+   * `vue-element-admin/src/assets/custom-theme/index.css` (`v-modal-in`, `v-modal-out`,
+   * `progress`). Four occurrences in 1,114 files is a thin census and it is reported as
+   * one — but "four" is not "none", and a ruling of `overrides` that said the construct
+   * does not occur would be false by exactly those four.
+   *
+   * THE AGGREGATE ALSO NEEDS A CORRECTION, and the correction is about the instrument
+   * rather than the language. The first version of the split probe bucketed a whole
+   * NAME-GROUP by whether the group mentioned more than one keyword, so `v-modal-in`
+   * — spelled three times, once prefixed and twice not — was filed under
+   * "cross-keyword" on the strength of its first pair and its genuine redefinition was
+   * never counted. It reported 1 where the truth is 4. The rule that decides this is
+   * adjacency, because CSS Animations L1  makes the LAST declaration the live one, so
+   * a declaration is compared against the one it replaces and not against its whole
+   * group. `validation/m14/census/css-overrides-split.ts` now counts adjacent pairs and
+   * agrees with the production census at 4.
+   *
+   * `@property` re-registration is counted at **0** occurrences, because the corpus
+   * cannot speak about it. It is implemented anyway and pinned by a fixture, which is
+   * this lane's standing answer to a construct the corpus does not exercise (see the
+   * `@counter-style` / `@custom-media` / `@font-feature-values` note in
+   * `collectCustomDefinitionNames`): a measured zero means the corpus is silent, not
+   * that the branch is wrong.
+   *
+   * ## Why `source === target`, stated rather than hidden
+   *
+   * The overriding declaration and the overridden one have the SAME NAME, and this
+   * lane publishes ONE symbol per name — the merge at the end of `analyze` is keyed
+   * `(kind, name)` and deliberately so, because "a selector is a MATCH PATTERN, not a
+   * declaration" and the same reasoning makes two `@keyframes spin` blocks two
+   * occurrences of one node. So the edge's two ends are the same string, and what
+   * distinguishes them is the SITE: `line_number` is the superseding declaration's
+   * line and `metadata.supersedesLine` is the declaration it kills.
+   *
+   * That is the shape `real-markdown-analyzer.ts:142` already guards for rather than
+   * forbids — `if (source === target && !distinctSites) return`, whose own comment is
+   * "The two ends name DIFFERENT sites even when they spell the same string". The two
+   * declarations here are two blocks of source text on two lines, so they are two
+   * sites by any reading, and `distinctSites: true` is recorded in the metadata
+   * rather than left for a reader to infer.
+   *
+   * The line is also load-bearing for STORAGE, not only for meaning: a relationship's
+   * store key is (source, type, target, line) — #822, which markdown's own
+   * comment records — so an edge without the superseding line would collide with any
+   * other `spin -> spin` edge in the file and `INSERT OR IGNORE` would keep one.
+   *
+   * ## Confidence
+   *
+   * 1.0. This is not a name-match guess: both ends are read from two `@keyframes`
+   * nodes, the equality test is on the tree's own keyframes-name node, and the
+   * keyword discriminator is the tree's own `at_keyword`. There is no inference in it
+   * to be uncertain about.
+   */
+  recordKeyframesOverride(ctx, name, keyword, line) {
+    if (!name || !line) return;
+    const live = ctx.keyframeLive[name];
+    if (live === void 0) {
+      ctx.keyframeLive[name] = { keyword, line };
+      return;
+    }
+    if (live.keyword === keyword) {
+      this.emitOverride(ctx, name, line, live.line, {
+        isKeyframesRedefinition: true,
+        atKeyword: keyword
+      });
+    }
+    ctx.keyframeLive[name] = { keyword, line };
+  }
+  /**
+   * `@property --x` written twice is the same last-wins replacement
+   * (`recordKeyframesOverride`'s rule, from the Properties & Values API rather than
+   * from CSS Animations). Measured at 0 occurrences over 1,114 corpus files, which is
+   * a fact about the corpus and not about the construct — so it is pinned by a fixture
+   * instead of being dropped for want of evidence.
+   */
+  recordPropertyOverride(ctx, name, line) {
+    if (!name || !line) return;
+    const prior = ctx.propertyLive[name];
+    if (prior !== void 0) {
+      this.emitOverride(ctx, name, line, prior, { isPropertyReregistration: true });
+    }
+    ctx.propertyLive[name] = line;
+  }
+  /**
+   * M14 ONTOLOGY PASS 2, `overrides` — a `--custom-property` assigned TWICE inside ONE
+   * declaration block. Found by the pass-2 adversarial probe, not by reading: see
+   * `validation/m14/census/css-boundary-probe.ts` (Q3), which counts the shape on the
+   * parse tree of the whole admitted corpus.
+   *
+   * ## Why this is the same construct `@keyframes` already gets
+   *
+   * Two declarations of one property inside one block share origin, context, layer,
+   * specificity and importance, so nothing about them distinguishes them except their
+   * position, and CSS Cascade 5  resolves that: "The last declaration in document
+   * order wins." CSS Variables 1  adds that custom properties are not special here —
+   * "Custom properties are ordinary properties, so they can be declared on any element,
+   * are resolved with the normal inheritance and cascade rules." So the second
+   * assignment REPLACES the first outright and the first is dead, which is exactly what
+   * `recordKeyframesOverride` asserts for a second `@keyframes` of one name.
+   *
+   * The corpus shape is Bulma's minified bundles, where `:root { --bulma-light-l: 90%;
+   * … ; --bulma-light-l: 96%; … }` writes the same token twice inside one block.
+   *
+   * ## The block boundary is load-bearing, and narrower than it looks
+   *
+   * Only declarations in the SAME block produce an edge. `:root { --x: 1 }` followed by
+   * `.dark { --x: 2 }` assigns `--x` twice in one FILE and is NOT an override: the two
+   * apply to different elements and the cascade chooses between them per element, so an
+   * edge claiming the second kills the first would be false. The block is therefore the
+   * unit, tracked by `customPropBlockKey`, and the corpus's much larger
+   * cross-block-assignment shape (which the same probe counts) is deliberately not
+   * emitted. The rule is stated here because the boundary is the whole content of the
+   * claim: "the last one wins" is only unconditional inside one block.
+   *
+   * ## `!important` is respected
+   *
+   * `--x: 1 !important; --x: 2;` does NOT replace — the important declaration wins and
+   * the later one loses. Cascade 5  sorts importance above document order, so the
+   * two are not interchangeable and an edge between them would be backwards. Only a pair
+   * of EQUAL importance is emitted, which is the only case where "later wins" is the
+   * whole rule. Measured on the corpus: every occurrence is an equal-importance pair, so
+   * this guard costs nothing there and is recorded because a guard that costs nothing is
+   * indistinguishable from a guard that was never needed.
+   */
+  recordCustomPropertyOverride(node, name, ctx) {
+    const line = this.lineOf(node);
+    if (!name || !line) return;
+    let block = node.parent;
+    let key = `decl@${node.startIndex}`;
+    while (block) {
+      if (block.type === "rule_set" || block.type === "keyframe_block") {
+        key = `${block.type}@${block.startIndex}`;
+        break;
+      }
+      block = block.parent;
+    }
+    if (ctx.customPropBlockKey !== key) {
+      ctx.customPropBlockKey = key;
+      ctx.customPropInBlock = {};
+    }
+    const important = node.text.indexOf("!important") !== -1;
+    const prior = ctx.customPropInBlock[name];
+    if (prior && prior.important === important) {
+      this.emitOverride(ctx, name, line, prior.line, {
+        isCustomPropertyRedefinition: true,
+        blockSelector: key
+      });
+    }
+    ctx.customPropInBlock[name] = { line, important };
+  }
+  emitOverride(ctx, name, laterLine, priorLine, extra) {
+    const key = `${name}\0${laterLine}`;
+    if (ctx.overrideEdges[key]) return;
+    ctx.overrideEdges[key] = true;
+    ctx.relationships.push({
+      source: name,
+      target: name,
+      type: ASTEngine.RelationshipType.Overrides,
+      // the name on this edge is the `@keyframes` name, and it is written on
+      // BOTH lines — the superseding one first, because that is the declaration the
+      // edge is about and the one a reader navigates to.
+      line_number: laterLine,
+      confidence: 1,
+      metadata: {
+        cssSpecific: true,
+        isOverride: true,
+        redefinition: true,
+        // The declaration this one kills. Carried explicitly so a consumer does not
+        // have to diff the file to find out WHICH earlier block died.
+        supersedesLine: priorLine,
+        // See the header: the two ends are two SITES, not one name twice.
+        distinctSites: true,
+        ...extra
+      }
+    });
+  }
+  processSupports(node, ctx) {
+    const queryNode = this.findChild(
+      node,
+      (c) => c && c.type !== "block" && c.type !== "at_keyword" && c.type !== "@supports" && c.text.trim() !== "@supports"
+    );
+    if (queryNode) {
+      const condition = queryNode.text.trim();
+      ctx.symbols.push({
+        name: `@supports ${condition}`,
+        kind: ASTEngine.SymbolKind.Interface,
+        range: this.nodeToRange(node),
+        scope: "",
+        visibility: "public",
+        complexity: this.queryComplexity(condition),
+        metadata: {
+          isSupports: true,
+          supportsCondition: condition
+        }
+      });
+      ctx.patterns["Feature Queries (@supports)"] = true;
+      return `@supports ${condition}`;
+    }
+    return null;
+  }
+  processAtRule(node, currentSelector, ctx) {
+    const atKeywordNode = this.findChild(node, (c) => c?.type === "at_keyword");
+    let keyword = atKeywordNode ? atKeywordNode.text : "";
+    if (!keyword) keyword = this.leadingAtKeyword(node.text);
+    if (!keyword) return {};
+    let namePart = "";
+    const DECLARING = /* @__PURE__ */ new Set([
+      "@layer",
+      "@container",
+      "@scope",
+      "@font-face",
+      "@property",
+      "@namespace",
+      "@mixin",
+      // CSS Functions and Mixins Level 1: `@function --name(a, b) { … }` DECLARES a
+      // callable that `--name(1, 2)` invokes. Measured on the corpus: 10 `@function`
+      // at-rules (all in .sass utility files under Documenter.jl), so the construct is
+      // real in this lane's population and arrives as a generic `at_rule`.
+      "@function",
+      // the three that were silently dropped: each DECLARES a named, referable
+      // thing, so each belongs here. Measured, not assumed — a probe of all three
+      // returned zero symbols before this line and the fixtures pin them now.
+      "@counter-style",
+      "@custom-media",
+      "@font-feature-values"
+    ]);
+    const CONSUMING = /* @__PURE__ */ new Set(["@tailwind", "@apply", "@theme", "@config", "@include", "@use", "@forward"]);
+    if (DECLARING.has(keyword) || CONSUMING.has(keyword)) {
+      let namePartOverride = "";
+      if (keyword === "@font-face") {
+        const block = this.findChild(node, (c) => c?.type === "block");
+        const family = block ? this.findDescendant(block, (n) => {
+          if (n.type !== "declaration") return false;
+          const prop = this.findChild(n, (g) => g?.type === "property_name");
+          return prop !== null && prop.text === "font-family";
+        }) : null;
+        if (family) {
+          const value = this.findChild(family, (c) => c?.type === "plain_value" || c?.type === "string_value");
+          if (value) namePartOverride = collapseWhitespace(stripAllQuotes(value.text));
+          void namePartOverride;
+        }
+      }
+      const afterKeyword = node.text.slice(keyword.length);
+      const braceAt = afterKeyword.indexOf("{");
+      const semiAt = afterKeyword.indexOf(";");
+      let cut = afterKeyword.length;
+      if (braceAt !== -1) cut = braceAt;
+      if (semiAt !== -1 && semiAt < cut) cut = semiAt;
+      const namePart2 = namePartOverride || stripAllQuotes(collapseWhitespace(afterKeyword.slice(0, cut)));
+      const ruleName = keyword === "@font-face" && namePart2 ? this.fontFaceSymbolName(namePart2) : `${keyword}${namePart2 ? " " + namePart2 : ""}`;
+      if (keyword === "@layer" && !this.findChild(node, (c) => c?.type === "block")) {
+        const names = namePart2.split(",").map((x) => x.trim()).filter((x) => x.length > 0);
+        for (const nm of names) {
+          ctx.layerOrder.push(nm);
+          if (ctx.layerNames[nm]) continue;
+          ctx.layerNames[nm] = true;
+          ctx.symbols.push({
+            name: `${keyword} ${nm}`,
+            kind: ASTEngine.SymbolKind.Module,
+            range: this.nodeToRange(node),
+            scope: "",
+            visibility: "public",
+            complexity: 1,
+            metadata: {
+              isAtRule: true,
+              atKeyword: keyword,
+              isLayerOrdering: true,
+              // The cascade position this statement gives the layer. Per-SYMBOL
+              // rather than per-file, and that is not a style choice: `parseFile`
+              // rebuilds the file metadata as a fresh literal listing specific keys
+              // (engine.ts:1572, whose own comment records that anything it omits is
+              // "computed and DISCARDED — silently"), so a file-level key added here
+              // would never reach a consumer. Symbol metadata is passed through, and
+              // the position is a property of the LAYER anyway.
+              layerIndex: ctx.layerOrder.length - 1
+            }
+          });
+        }
+        return {};
+      }
+      if (DECLARING.has(keyword)) {
+        const publishedName = keyword === "@property" ? namePart2 || ruleName : keyword === "@custom-media" ? (
+          // `namePart` is the PRELUDE; `ruleName` is the keyword plus the
+          // prelude, so slicing the latter matches nothing and the first
+          // version published `@custom-media --narrow (max-width: 400px)` —
+          // a name the `@media (--narrow)` can never resolve against.
+          leadingCustomIdent(namePart2) || ruleName
+        ) : ruleName;
+        if (keyword === "@layer" && namePart2) {
+          if (ctx.layerNames[namePart2]) {
+            const existing = ctx.symbols.find((sy) => sy.name === `${keyword} ${namePart2}`);
+            if (existing) {
+              const em = existing.metadata ?? {};
+              const blockRange = this.nodeToRange(node);
+              if (em.hasLayerBlock !== true) {
+                existing.range = blockRange;
+                existing.metadata = { ...em, hasLayerBlock: true, scopeBlocks: 1 };
+              } else {
+                existing.range = {
+                  ...existing.range,
+                  endLine: Math.max(existing.range?.endLine ?? 0, blockRange.endLine)
+                };
+                const n = typeof em.scopeBlocks === "number" ? em.scopeBlocks : 1;
+                existing.metadata = { ...em, scopeBlocks: n + 1 };
+              }
+              ctx.scopeSymbol[`${keyword} ${namePart2}`] = existing;
+            }
+            return { layer: `${keyword} ${namePart2}` };
+          }
+          ctx.layerNames[namePart2] = true;
+        }
+        const atRuleSymbol = {
+          name: publishedName,
+          // A declared `@font-face` and a registered `@property` are both
+          // declarations of a named thing, which is what `variable` means in this
+          // ontology; `@mixin` is a callable, so `function`; the rest are
+          // structural scopes, which is `module`.
+          kind: keyword === "@mixin" ? ASTEngine.SymbolKind.Function : keyword === "@font-face" || keyword === "@property" || keyword === "@counter-style" || keyword === "@custom-media" || keyword === "@font-feature-values" ? ASTEngine.SymbolKind.Variable : ASTEngine.SymbolKind.Module,
+          range: this.nodeToRange(node),
+          scope: "",
+          visibility: "public",
+          complexity: 1 + this.countDescriptors(node),
+          metadata: {
+            isAtRule: true,
+            atKeyword: keyword,
+            // the keyword is dropped from a `@property` symbol's NAME, so it is
+            // recorded here — the declaration is still identifiable as a
+            // registration rather than a rule-level declaration
+            ...keyword === "@property" ? { isPropertyRegistration: true } : {},
+            // the three late additions carry which construct declared them, because
+            // a `@custom-media` symbol is a BARE `--x` name — identical in shape to
+            // a registered `@property` symbol and to a rule-level custom property,
+            // so without this the three declarations are indistinguishable in the
+            // graph
+            ...keyword === "@counter-style" ? { isCounterStyleDeclaration: true } : {},
+            ...keyword === "@custom-media" ? { isCustomMediaDeclaration: true } : {},
+            ...keyword === "@font-feature-values" ? { isFontFeatureValuesDeclaration: true } : {}
+            // (the descriptor-count complexity is set on the symbol above)
+          }
+        };
+        ctx.symbols.push(atRuleSymbol);
+        if (STRUCTURAL_SCOPE_AT_RULES.has(keyword)) ctx.scopeSymbol[publishedName] = atRuleSymbol;
+        if (keyword === "@property") {
+          this.recordPropertyOverride(ctx, publishedName, this.lineOf(node));
+        }
+      }
+      if (keyword === "@layer") ctx.patterns["Cascade Layers (@layer)"] = true;
+      if (keyword === "@container") ctx.patterns["Container Queries (@container)"] = true;
+      if (keyword === "@tailwind" || keyword === "@apply" || keyword === "@theme" || keyword === "@config")
+        ctx.frameworks["Tailwind CSS"] = true;
+      if (keyword === "@mixin" || keyword === "@include" || keyword === "@forward" || keyword === "@use") {
+        ctx.frameworks["SCSS/SASS"] = true;
+        ctx.patterns["CSS Preprocessor Macros"] = true;
+      }
+      if (keyword === "@mixin" && namePart2) ctx.mixinNames[namePart2] = true;
+      if (keyword === "@function" && namePart2) {
+        const callable = firstCustomFunctionName(namePart2);
+        if (callable) ctx.cssFunctionNames[callable] = `${keyword} ${namePart2}`;
+      }
+      if (keyword === "@include" && currentSelector && namePart2) {
+        ctx.relationships.push({
+          source: currentSelector,
+          target: `@mixin ${namePart2}`,
+          type: ASTEngine.RelationshipType.Uses,
+          // the referenced mixin name is written in the `@include`
+          // prelude, on the at-rule's own line. (The relation stays `uses` — a
+          // mixin reference is a USE. An edit here briefly changed it to
+          // `contains` on the theory that the mixin is "contained" in the rule;
+          // that is a different claim and a wrong one, and it is reverted.)
+          line_number: this.lineOf(node),
+          metadata: { cssSpecific: true, isMixinRef: true, isDeclaredLocally: ctx.mixinNames[namePart2] === true }
+        });
+      }
+      if ((keyword === "@use" || keyword === "@forward") && namePart2) {
+        ctx.relationships.push({
+          source: this.importerName,
+          target: stripAllQuotes(firstToken(namePart2)),
+          type: ASTEngine.RelationshipType.Imports,
+          // the module name is the at-rule's prelude, on its own line.
+          line_number: this.lineOf(node),
+          confidence: 1,
+          metadata: { isCssImport: true, isSassModuleImport: true, importSource: this.importerName }
+        });
+      }
+      return {
+        layer: keyword === "@layer" ? ruleName : void 0,
+        container: keyword === "@container" ? ruleName : void 0,
+        // A `@scope` prelude is a SELECTOR (`(.a) to (.b)`), not a condition, so
+        // it cannot reuse the media field's name. It is reported as its own
+        // scope so a rule inside it is attributable to the scope that contains
+        // it, which is the whole point of the construct.
+        scope: keyword === "@scope" ? ruleName : void 0
+      };
+    }
+    return {};
+  }
+  /**
+   * Every property a selector declares, recorded on the SELECTOR SYMBOL rather
+   * than emitted as a relationship to the property name.
+   *
+   * RULING . This used to emit `uses <selector> -> <property>` for
+   * every declaration, and the class table says what that cost:
+   *
+   *   uses   34,727 edges   2,073 resolve at both ends    6.0%
+   *          of which 32,654 have a RESOLVABLE SOURCE and an unresolvable target,
+   *          and 0 have an unresolvable source
+   *
+   * The class is homogeneous: the source is always a selector (always a
+   * published symbol) and the target is always a CSS property name — `color`,
+   * `margin`, `font-family` — which the analyzer never publishes as a symbol and
+   * never will, because a property name is a token in a declaration, not an
+   * entity a stylesheet defines. So 32,654 of 59,940 relationships (54%) were
+   * edges to a name that exists nowhere in the graph: stored as
+   * `target_external`, unjoinable at query, and then discarded outright by
+   * pool-worker's CSS branch of `filterNoiseRelationships`, which keeps
+   * `contains` only. The information was paid for twice and delivered neither
+   * time.
+   *
+   * A relationship is a claim about two graph nodes. `declaresProperties` is the
+   * right shape for "this rule sets these properties" — it rides the symbol
+   * payload, which M60 P1 treats as a first-class channel (produced by the
+   * analyzer, preserved by the store, reachable at query, truthful at the tool).
+   *
+   * The relationships that DO survive in this handler are the ones whose target
+   * is a real node: a custom property, a `@keyframes` name, a `@mixin`. Those
+   * are untouched.
+   */
+  recordDeclaredProperty(currentSelector, property, ctx) {
+    if (!currentSelector) return;
+    ctx.declaredProperties[currentSelector] = ctx.declaredProperties[currentSelector] ?? [];
+    const list = ctx.declaredProperties[currentSelector];
+    if (list.indexOf(property) === -1) list.push(property);
+  }
+  /**
+   * CSS MODULES `export` SURFACE — `:export { name: value; }`.
+   *
+   * CSS Modules writes a cross-file export surface with no export syntax: a rule whose
+   * selector is `:export` holds the names the module publishes to its importers. The
+   * construct EXISTS in the language family and occurs 0 times in this lane's .css
+   * population, so the type is implemented and counted once as corpus-unexercised —
+   * a zero-sites ruling would otherwise sit in the denominator claiming nothing.
+   *
+   * Each declaration inside the block publishes a SYMBOL for the exported name and an
+   * `exports` edge from the file's own module symbol to it, so the target is a symbol
+   * this file really declares rather than a string a reader cannot join against.
+   */
+  processCssModulesExport(node, entry, currentSelector, ctx) {
+    if (currentSelector.trim() !== ":export") return false;
+    const propNode = this.findChild(entry, (c) => c?.type === "property_name");
+    if (!propNode) return false;
+    const exported = stripAllQuotes(propNode.text).trim();
+    if (exported.length === 0) return false;
+    const range = this.nodeToRange(propNode);
+    ctx.symbols.push({
+      name: exported,
+      kind: ASTEngine.SymbolKind.Variable,
+      range,
+      scope: "",
+      visibility: "public",
+      complexity: 1,
+      metadata: { isCssModulesExport: true, exportedName: exported }
+    });
+    ctx.relationships.push({
+      source: this.importerName,
+      target: exported,
+      type: ASTEngine.RelationshipType.Exports,
+      line_number: this.lineOf(propNode),
+      confidence: 1,
+      metadata: {
+        cssSpecific: true,
+        exportForm: "css_modules_export_block",
+        isModuleSurface: true,
+        evidenceClass: "structural"
+      }
+    });
+    return true;
+  }
+  processDeclaration(node, currentSelector, ctx) {
+    if (this.processCssModulesExport(node, node, currentSelector, ctx)) return;
+    const declPropNode = this.findChild(node, (c) => c.type === "property_name");
+    if (declPropNode) this.recordDeclaredProperty(currentSelector, declPropNode.text, ctx);
+    const propNode = this.findChild(node, (c) => c?.type === "property_name");
+    if (!propNode) return;
+    const propName = propNode.text;
+    if (propName === "composes") {
+      ctx.patterns["CSS Modules (composes)"] = true;
+      ctx.frameworks["CSS Modules"] = true;
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const val = node.namedChild(i);
+        if (!val || val.type === "property_name") continue;
+        const target = collapseWhitespace(val.text);
+        if (!target) continue;
+        ctx.relationships.push({
+          source: currentSelector,
+          target,
+          type: ASTEngine.RelationshipType.Uses,
+          // the name is the composed class, so the line is the VALUE
+          // node it is written on — not the `composes` property, which is a
+          // different name on the same declaration.
+          line_number: this.lineOf(val),
+          metadata: { cssSpecific: true, isComposition: true }
+        });
+      }
+    }
+    if (propName.startsWith("--")) {
+      ctx.symbols.push({
+        name: propName,
+        kind: ASTEngine.SymbolKind.Variable,
+        range: this.nodeToRange(node),
+        scope: currentSelector,
+        visibility: "public",
+        complexity: this.customPropertyComplexity(node),
+        metadata: {
+          isCustomProperty: true
+          // (the var()-read complexity is set on the symbol above)
+        }
+      });
+      if (currentSelector) {
+        ctx.relationships.push({
+          source: currentSelector,
+          target: propName,
+          type: ASTEngine.RelationshipType.Contains,
+          // the name is the custom property, so the line is its
+          // `property_name` node — NOT the `declaration`, which can open on
+          // an earlier line (a leading comment inside the block, or a declaration
+          // written across lines).
+          line_number: this.lineOf(propNode),
+          confidence: 1,
+          metadata: { cssSpecific: true, isCustomPropertyScope: true }
+        });
+      }
+      this.recordCustomPropertyOverride(node, propName, ctx);
+      ctx.patterns["CSS Custom Properties"] = true;
+    }
+    if ((propName === "list-style" || propName === "list-style-type") && currentSelector) {
+      const nameStack = [node];
+      while (nameStack.length > 0) {
+        const n = nameStack.pop();
+        if (n.type === "plain_value" || n.type === "identifier" || n.type === "string_value") {
+          const style = n.text.trim();
+          if (style.length > 0 && ctx.counterStyleNames[style]) {
+            ctx.relationships.push({
+              source: currentSelector,
+              target: `@counter-style ${style}`,
+              type: ASTEngine.RelationshipType.Uses,
+              line_number: this.lineOf(n),
+              metadata: { cssSpecific: true, isCounterStyleRef: true }
+            });
+          }
+        }
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) nameStack.push(c);
+        }
+      }
+    }
+    if (propName === "font-feature-settings") {
+      const enclosing = this.fontFamilyOf(node);
+      if (enclosing && ctx.fontFeatureValuesNames[enclosing]) {
+        const valueStack = [node];
+        while (valueStack.length > 0) {
+          const n = valueStack.pop();
+          if (n.type === "string_value" || n.type === "plain_value") {
+            ctx.relationships.push({
+              source: this.fontFaceSymbolName(enclosing),
+              target: `@font-feature-values ${enclosing}`,
+              type: ASTEngine.RelationshipType.Uses,
+              line_number: this.lineOf(n),
+              metadata: { cssSpecific: true, isFontFeatureValuesRef: true }
+            });
+          }
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (c) valueStack.push(c);
+          }
+        }
+      }
+    }
+    if (propName === "font-family" && currentSelector) {
+      const famStack = [node];
+      while (famStack.length > 0) {
+        const n = famStack.pop();
+        if (n.type === "plain_value" || n.type === "identifier" || n.type === "string_value") {
+          const family = stripAllQuotes(n.text.trim());
+          if (family.length > 0 && ctx.fontFaceNames[family]) {
+            ctx.relationships.push({
+              source: currentSelector,
+              // The edge names the DECLARATION, which is the published symbol — not
+              // the bare family, which nothing publishes. A resolvable endpoint, and
+              // the same both-ends-must-resolve rule the chain edges follow.
+              target: this.fontFaceSymbolName(family),
+              type: ASTEngine.RelationshipType.Uses,
+              // , the same rule as the animation edge: the name is the FAMILY
+              // as written in the value, so the line is the value's line — not the
+              // `font-family` property's, and for a fallback list
+              // (`"Inter", sans-serif`) the specific family that matched rather
+              // than the first token on the line.
+              line_number: this.lineOf(n),
+              metadata: { cssSpecific: true, isFontFamilyRef: true }
+            });
+          }
+        }
+        for (let i = n.namedChildCount - 1; i >= 0; i--) {
+          const child = n.namedChild(i);
+          if (child) famStack.push(child);
+        }
+      }
+    }
+    if ((propName === "animation" || propName === "animation-name") && currentSelector) {
+      const valStack = [node];
+      while (valStack.length > 0) {
+        const n = valStack.pop();
+        if (n.type === "plain_value" || n.type === "identifier" || n.type === "string_value") {
+          const text = stripAllQuotes(n.text.trim());
+          if (ctx.keyframeNames[text]) {
+            ctx.relationships.push({
+              source: currentSelector,
+              target: text,
+              type: ASTEngine.RelationshipType.Uses,
+              // the name is the KEYFRAMES name, which is written in the
+              // VALUE — not the `animation` property, which is a different name
+              // and, for the shorthand, shares its line with the duration and
+              // easing. Taking the value node is what makes the edge point at the
+              // line a reader would call the reference.
+              line_number: this.lineOf(n),
+              metadata: { cssSpecific: true, isAnimationRef: true }
+            });
+          }
+        }
+        for (let i = n.namedChildCount - 1; i >= 0; i--) {
+          const child = n.namedChild(i);
+          if (child) valStack.push(child);
+        }
+      }
+    }
+    if (node.text.indexOf("!important") !== -1) {
+      ctx.patterns["Uses !important"] = true;
+    }
+  }
+  /**
+   * `keyframeScope` is the nearest enclosing `@keyframes` name, or `""`. A `var()` whose
+   * owner is a keyframe block rather than a rule is emitted from THAT name; see
+   * `StackFrame.keyframeScope` for the measurement that made it necessary.
+   */
+  processCallExpression(node, currentSelector, keyframeScope, ctx) {
+    const fnNameNode = this.findChild(node, (c) => c?.type === "function_name" || c?.type === "identifier");
+    if (!fnNameNode) return;
+    {
+      const callee = fnNameNode.text.trim();
+      const declared = ctx.cssFunctionNames[callee];
+      if (declared) {
+        const owner = currentSelector || keyframeScope || declared;
+        ctx.relationships.push({
+          source: owner,
+          target: declared,
+          type: ASTEngine.RelationshipType.Calls,
+          // the CALLEE node's line: the name is what the edge names, and a wrapped call's
+          // statement line is a different line.
+          line_number: this.lineOf(fnNameNode),
+          confidence: 1,
+          metadata: {
+            cssSpecific: true,
+            isUserDefinedFunctionCall: true,
+            callableName: callee,
+            evidenceClass: "structural"
+          }
+        });
+      }
+    }
+    if (fnNameNameIsVar(fnNameNode) && (currentSelector || keyframeScope)) {
+      const argsNode = this.findChild(node, (c) => c?.type === "arguments");
+      if (argsNode) {
+        const owner = currentSelector || keyframeScope;
+        const ownedByKeyframes = currentSelector === "" && keyframeScope !== "";
+        const argStack = [argsNode];
+        while (argStack.length > 0) {
+          const n = argStack.pop();
+          if (n.namedChildCount === 0 && n.text.trim().startsWith("--")) {
+            ctx.relationships.push({
+              source: owner,
+              target: n.text.trim(),
+              type: ASTEngine.RelationshipType.References,
+              // the name is the custom property INSIDE `var()`, so the
+              // line is that argument node. The `call_expression` starts at its
+              // receiver's position, which for `calc(var(--x) * 2)` is the
+              // `calc` — a different line whenever the value wraps.
+              line_number: this.lineOf(n),
+              // A parse fact, written explicitly rather than left absent: the owner is a
+              // node this walk published and the target is an argument node of a `var()`
+              // whose callee node reads `var`. Nothing here is matched by name against a
+              // declared target — that is what `uses` does, and it is why those edges are
+              // the ones that need a lower confidence. `isVariableRef`'s 161,768 siblings
+              // write no confidence at all, which the lane's own census counts as a
+              // distinct claim; this branch states its own instead of inheriting the
+              // absence.
+              ...ownedByKeyframes ? { confidence: 1 } : {},
+              metadata: {
+                cssSpecific: true,
+                isVariableRef: true,
+                ...ownedByKeyframes ? { isKeyframeScopeRef: true } : {}
+              }
+            });
+            ctx.patterns["CSS Custom Properties"] = true;
+          }
+          for (let i = n.namedChildCount - 1; i >= 0; i--) {
+            const child = n.namedChild(i);
+            if (child) argStack.push(child);
+          }
+        }
+      }
+    }
+  }
+  detectFrameworksFromClasses(ctx) {
+    const selectors = [];
+    for (let i = 0; i < ctx.symbols.length; i++) {
+      if (ctx.symbols[i].metadata?.isSelector) selectors.push(ctx.symbols[i]);
+    }
+    let tailwindScore = 0;
+    let bootstrapScore = 0;
+    let muiScore = 0;
+    let vuetifyScore = 0;
+    let bulmaScore = 0;
+    let foundationScore = 0;
+    for (let i = 0; i < selectors.length; i++) {
+      const s = selectors[i];
+      const classNames = s.metadata?.classNames || [];
+      for (let j = 0; j < classNames.length; j++) {
+        const cls = classNames[j];
+        if (isTailwindClass(cls)) tailwindScore += 5;
+        if (isBootstrapClass(cls)) bootstrapScore += 5;
+        if (cls.startsWith("Mui")) muiScore += 5;
+        if (cls.startsWith("v-btn") || cls.startsWith("v-card") || cls.startsWith("v-col")) vuetifyScore += 5;
+        if (isBulmaClass(cls)) bulmaScore += 5;
+        if (isFoundationClass(cls)) foundationScore += 5;
+      }
+    }
+    if (tailwindScore > 10) ctx.frameworks["Tailwind CSS"] = true;
+    if (bootstrapScore > 0) ctx.frameworks["Bootstrap / Grid System"] = true;
+    if (muiScore > 5) ctx.frameworks["Material UI (MUI)"] = true;
+    if (vuetifyScore > 5) ctx.frameworks["Vuetify"] = true;
+    if (bulmaScore > 10) ctx.frameworks["Bulma"] = true;
+    if (foundationScore > 10) ctx.frameworks["Foundation"] = true;
+  }
+  calculateMetrics(ctx) {
+    let maintainability = 100;
+    let performance = 100;
+    const selectors = [];
+    for (let i = 0; i < ctx.symbols.length; i++) {
+      if (ctx.symbols[i].metadata?.isSelector) selectors.push(ctx.symbols[i]);
+    }
+    const complexSelectors = [];
+    for (let i = 0; i < selectors.length; i++) {
+      if (selectors[i].metadata?.isComplex) complexSelectors.push(selectors[i]);
+    }
+    if (selectors.length > 0) {
+      const complexRatio = complexSelectors.length / selectors.length;
+      if (complexRatio > 0.3) {
+        maintainability -= 20;
+        performance -= 10;
+      }
+    }
+    if (ctx.patterns["Uses !important"]) {
+      maintainability -= 25;
+    }
+    const score = Math.round((maintainability + performance) / 2);
+    const complexity = Math.max(
+      1,
+      (ctx.fileMaxSelectorComplexity ?? 0) + (ctx.fileNestingDepth ?? 0)
+    );
+    return {
+      complexity,
+      score: Math.min(100, Math.max(0, score)),
+      maintainability: Math.min(100, Math.max(0, maintainability)),
+      performance: Math.min(100, Math.max(0, performance)),
+      quality: score >= 80 ? "Excellent" : score >= 60 ? "Good" : "Fair"
+    };
+  }
+  generateInsights(ctx, frameworks) {
+    const insights = [];
+    let hasTailwind = false;
+    let hasBootstrap = false;
+    let hasCSSModules = false;
+    let hasSCSS = false;
+    for (let i = 0; i < frameworks.length; i++) {
+      if (frameworks[i] === "Tailwind CSS") hasTailwind = true;
+      if (frameworks[i] === "Bootstrap" || frameworks[i] === "Bootstrap / Grid System") hasBootstrap = true;
+      if (frameworks[i] === "CSS Modules") hasCSSModules = true;
+      if (frameworks[i] === "SCSS/SASS") hasSCSS = true;
+    }
+    if (hasTailwind) insights.push("Utilizes Tailwind utility paradigms");
+    if (hasBootstrap) insights.push("Utilizes Bootstrap grid and component paradigms");
+    if (hasCSSModules) insights.push("Utilizes isolated CSS Modules for component styling");
+    if (hasSCSS) insights.push("Leverages SCSS/SASS preprocessor macros and mixins");
+    if (ctx.patterns["Complex Selectors"]) insights.push("Deep nesting/complex specificity detected");
+    if (ctx.patterns["Responsive Design (Media Queries)"]) insights.push("Implements responsive viewports");
+    if (ctx.patterns["CSS Custom Properties"]) insights.push("Leverages native CSS variables for theming");
+    if (ctx.patterns["Cascade Layers (@layer)"]) insights.push("Uses Cascade Layers for architectural isolation");
+    if (ctx.patterns["Container Queries (@container)"]) insights.push("Implements component-driven Container Queries");
+    return insights;
+  }
+  nodeToRange(node) {
+    return {
+      startLine: node.startPosition.row + 1,
+      startColumn: node.startPosition.column + 1,
+      endLine: node.endPosition.row + 1,
+      endColumn: node.endPosition.column + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
+    };
+  }
+};
+
+export {
+  cssFileScopeOf,
+  RealCssAnalyzer
+};