@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/real-vue-analyzer-OO4FUGBV.js

@@ -0,0 +1,2680 @@
+import {
+  RealTypeScriptAnalyzer
+} from "./chunk-XJKJYIPP.js";
+import {
+  RealJavaScriptAnalyzer
+} from "./chunk-FVVQTSIM.js";
+import "./chunk-R2GW4F6R.js";
+import {
+  ASTEngine
+} from "./chunk-V44PGPA6.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-vue-analyzer.ts
+import * as path from "path";
+function shiftMetadataLineMirrors(md, lineOffset) {
+  if (!md || lineOffset === 0) return;
+  for (const [k, v] of Object.entries(md)) {
+    if (!k.toLowerCase().includes("line")) continue;
+    if (typeof v === "number") md[k] = v + lineOffset;
+    else if (Array.isArray(v) && v.some((x) => typeof x === "number")) {
+      md[k] = v.map((x) => typeof x === "number" ? x + lineOffset : x);
+    }
+  }
+}
+var HTML_BUILTIN_TAGS = /* @__PURE__ */ new Set([
+  "a",
+  "abbr",
+  "address",
+  "area",
+  "article",
+  "aside",
+  "audio",
+  "b",
+  "base",
+  "bdi",
+  "bdo",
+  "blockquote",
+  "body",
+  "br",
+  "button",
+  "canvas",
+  "caption",
+  "cite",
+  "code",
+  "col",
+  "colgroup",
+  "data",
+  "datalist",
+  "dd",
+  "del",
+  "details",
+  "dfn",
+  "dialog",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "embed",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "header",
+  "hgroup",
+  "hr",
+  "html",
+  "i",
+  "iframe",
+  "img",
+  "input",
+  "ins",
+  "kbd",
+  "label",
+  "legend",
+  "li",
+  "link",
+  "main",
+  "map",
+  "mark",
+  "menu",
+  "meta",
+  "meter",
+  "nav",
+  "noscript",
+  "object",
+  "ol",
+  "optgroup",
+  "option",
+  "output",
+  "p",
+  "picture",
+  "pre",
+  "progress",
+  "q",
+  "rp",
+  "rt",
+  "ruby",
+  "s",
+  "samp",
+  "script",
+  "search",
+  "section",
+  "select",
+  "slot",
+  "small",
+  "source",
+  "span",
+  "strong",
+  "style",
+  "sub",
+  "summary",
+  "sup",
+  "table",
+  "tbody",
+  "td",
+  "template",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "title",
+  "tr",
+  "track",
+  "u",
+  "ul",
+  "var",
+  "video",
+  "wbr",
+  // SVG
+  "svg",
+  "path",
+  "g",
+  "rect",
+  "circle",
+  "ellipse",
+  "line",
+  "polyline",
+  "polygon",
+  "text",
+  "tspan",
+  "use",
+  "defs",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "mask",
+  "pattern",
+  "marker",
+  "view",
+  "symbol",
+  "clipPath",
+  // SVG — the FILTER module and the rest of the element vocabulary (F30, 2026-10-12).
+  //
+  // The list above covered the SVG elements a chart OR a decorative icon uses and
+  // stopped there, so `<filter>` and every filter PRIMITIVE fell through the builtin
+  // filter and were published as component usages: `<feGaussianBlur/>` emitted
+  // `instantiates -> feGaussianBlur`, a target no file in any corpus declares. Measured
+  // through production `parseFile` over the lane's 1,162-file draw (element-plus,
+  // vuejs, vue-element-admin, vue-core): 377 such edges from just six primitives —
+  // feGaussianBlur 64, feFlood 63, feColorMatrix 63, feOffset 63, feBlend 63,
+  // feComposite 61 — every one of them a dangling endpoint of exactly the class F23/F26
+  // removed for reads. An unknown namespace still fails toward VISIBILITY (see
+  // BUILTIN_NAMESPACES below); an element the SVG spec DEFINES is markup, and the rule
+  // this list encodes is that a real element is not a component — not that a lowercase
+  // name is not a component.
+  //
+  // NO DOUBLE QUOTES AND NO CLOSING-BRACKET-PAREN PAIR IN THIS COMMENT OR THE TWO
+  // BELOW, and that is a constraint, not a style preference:
+  // verify-cross-language-consistency.ts extracts this literal by slicing from the
+  // `new Set` open anchor to the FIRST closing-bracket-paren pair after it, then matching
+  // every quoted string in that slice. So a quoted phrase in a comment here becomes a
+  // PHANTOM TAG, and that pair ends the slice early — silently dropping the very tags the
+  // fix adds. Measured twice, not assumed: the first draft of this comment quoted the
+  // rule and the gate reported extra tags, and the second draft wrote the pair out and
+  // the gate reported every new SVG tag as missing from this list only.
+  "filter",
+  "feBlend",
+  "feColorMatrix",
+  "feComponentTransfer",
+  "feComposite",
+  "feConvolveMatrix",
+  "feDiffuseLighting",
+  "feDisplacementMap",
+  "feDistantLight",
+  "feDropShadow",
+  "feFlood",
+  "feFuncA",
+  "feFuncB",
+  "feFuncG",
+  "feFuncR",
+  "feGaussianBlur",
+  "feImage",
+  "feMerge",
+  "feMergeNode",
+  "feMorphology",
+  "feOffset",
+  "fePointLight",
+  "feSpecularLighting",
+  "feSpotLight",
+  "feTile",
+  "feTurbulence",
+  // the rest of SVG 2's element list, plus the SVG 1.1 elements browsers still parse.
+  // Counted separately from the block above on purpose: the block above is measured on
+  // the corpus, this one is the SPEC's vocabulary, and the difference is recorded rather
+  // than blurred (same honesty rule the svelte lane's read map uses for its site lists).
+  "switch",
+  "foreignObject",
+  "desc",
+  "metadata",
+  "textPath",
+  "tref",
+  "mpath",
+  "animate",
+  "animateMotion",
+  "animateTransform",
+  "set",
+  "discard",
+  "solidColor",
+  "mesh",
+  "meshgradient",
+  "meshpatch",
+  "meshrow",
+  "hatch",
+  "hatchpath",
+  "altGlyph",
+  "altGlyphDef",
+  "altGlyphItem",
+  "glyphRef",
+  "animateColor",
+  "cursor",
+  "color-profile",
+  "font",
+  "font-face",
+  "font-face-format",
+  "font-face-name",
+  "font-face-src",
+  "font-face-uri",
+  "glyph",
+  "hkern",
+  "missing-glyph",
+  "vkern"
+]);
+var VUE_BUILTIN_TAGS = /* @__PURE__ */ new Set([
+  "component",
+  "transition",
+  "transition-group",
+  "keep-alive",
+  "teleport",
+  "suspense",
+  "fragment"
+]);
+var BUILTIN_NAMESPACES = /* @__PURE__ */ new Set([
+  "svg",
+  "math",
+  "mathml",
+  "xlink",
+  "html",
+  "xhtml"
+]);
+var VUE_COMPILER_MACROS = /* @__PURE__ */ new Set([
+  "defineProps",
+  "defineEmits",
+  "defineExpose",
+  "withDefaults",
+  "defineModel",
+  "defineSlots",
+  "defineOptions"
+]);
+function vueRegistryName(tag) {
+  const candidates = [tag];
+  const kebab = tag.includes("-");
+  let camel = false;
+  if (!kebab) {
+    for (let ci = 1; ci < tag.length; ci++) {
+      const cc = tag.charCodeAt(ci);
+      if (cc >= 65 && cc <= 90) {
+        camel = true;
+        break;
+      }
+    }
+  }
+  if (!kebab && !camel) return { target: tag, candidates, normalized: false };
+  const pascal = kebab ? tag.split("-").filter(Boolean).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("") : tag.charAt(0).toUpperCase() + tag.slice(1);
+  if (pascal.length === 0 || pascal === tag) return { target: tag, candidates, normalized: false };
+  const camelized = pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  if (camelized !== tag) candidates.push(camelized);
+  candidates.push(pascal);
+  return { target: pascal, candidates, normalized: true };
+}
+function peelTypeWrappers(node) {
+  let cur = node;
+  for (let i = 0; i < 8; i++) {
+    const t = cur.type;
+    if (t !== "as_expression" && t !== "satisfies_expression" && t !== "parenthesized_expression" && t !== "non_null_expression") return cur;
+    const kids = cur.namedChildren;
+    const first = kids[0];
+    if (!first) return cur;
+    cur = first;
+  }
+  return cur;
+}
+function isVueModuleSpecifier(specifier) {
+  return specifier === "vue" || specifier.startsWith("vue/") || specifier.startsWith("@vue/");
+}
+function unquote(text) {
+  if (text.length >= 2) {
+    const first = text[0];
+    if ((first === '"' || first === "'") && text[text.length - 1] === first) {
+      return text.slice(1, -1);
+    }
+  }
+  return text;
+}
+var DELEGATE_FILE_ACTOR = "(file)";
+var RealVueAnalyzer = class _RealVueAnalyzer {
+  analyze(rootNode, content, filePath, context) {
+    const symbols = [];
+    const relationships = [];
+    const imports = [];
+    const exports = [];
+    const errors = [];
+    const patterns = {};
+    const moduleName = path.basename(filePath, path.extname(filePath));
+    patterns["Vue SFC"] = true;
+    if (rootNode.hasError) {
+      const errStack = [rootNode];
+      while (errStack.length > 0) {
+        const n = errStack.pop();
+        if (n.type === "ERROR" || n.isMissing) {
+          errors.push({
+            message: `Syntax ${n.type} detected. The Brain Engine is bypassing this broken node.`,
+            range: this.nodeToRange(n),
+            severity: "warning"
+          });
+        }
+        for (let i = n.namedChildCount - 1; i >= 0; i--) {
+          const child = n.namedChild(i);
+          if (child) errStack.push(child);
+        }
+      }
+    }
+    symbols.push({
+      name: moduleName,
+      kind: ASTEngine.SymbolKind.Class,
+      range: this.nodeToRange(rootNode),
+      scope: "",
+      visibility: "public",
+      metadata: { isVueComponent: true, isSfc: true }
+    });
+    const templateStack = [rootNode];
+    const usageRows = /* @__PURE__ */ new Map();
+    const usageSpellings = /* @__PURE__ */ new Map();
+    let templateDecisions = 0;
+    const templateExprNames = /* @__PURE__ */ new Map();
+    const shadowStack = [{ node: rootNode, shadowed: /* @__PURE__ */ new Set() }];
+    while (shadowStack.length > 0) {
+      const { node: n, shadowed } = shadowStack.pop();
+      const t = n.type;
+      if (t === "script_element" || t === "style_element") continue;
+      const childShadowed = new Set(shadowed);
+      if (t === "element" || t === "template_element") {
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (!c || c.type !== "start_tag") continue;
+          this.collectNodeShadowBindings(c, childShadowed);
+        }
+        const rawTag = this.elementTagSpelling(n);
+        const dotIdx = rawTag?.indexOf(".") ?? -1;
+        const colonIdx = rawTag?.indexOf(":") ?? -1;
+        const tag = dotIdx > 0 ? rawTag.slice(0, dotIdx) : rawTag;
+        const member = dotIdx > 0 ? rawTag.slice(dotIdx + 1) : void 0;
+        const nsPrefix = colonIdx > 0 ? rawTag.slice(0, colonIdx) : void 0;
+        const isBuiltinNamespace = nsPrefix !== void 0 && BUILTIN_NAMESPACES.has(nsPrefix);
+        if (tag && !isBuiltinNamespace && !HTML_BUILTIN_TAGS.has(tag) && !VUE_BUILTIN_TAGS.has(tag)) {
+          const registry = vueRegistryName(tag);
+          const spellings = usageSpellings.get(registry.target);
+          if (spellings) {
+            if (!spellings.includes(tag)) {
+              spellings.push(tag);
+              const row = usageRows.get(registry.target);
+              row.metadata = { ...row.metadata, tagSpellingsWritten: [...spellings].sort() };
+            }
+          } else {
+            usageSpellings.set(registry.target, [tag]);
+            const tagNode = this.elementTagNameNode(n);
+            const row = {
+              source: moduleName,
+              target: registry.target,
+              // RENDERS, NOT INSTANTIATES (2026-10-24, extended vocabulary; the svelte
+              // precedent, Lead-ruled). A template component tag mounts an element the
+              // HOST RENDERER creates — the source contains no `new`, so an
+              // `instantiates` edge claimed an allocation site the file does not have
+              // (types.ts' Renders contract: "NOT `instantiates`: nothing is `new`ed —
+              // the host renderer constructs the element"). `instantiates` keeps its
+              // OWN rows: the JS/TS delegate's script `new` rows, copied by the seam
+              // below — the two relations stay distinct, exactly as svelte's migration
+              // kept 191 delegate `new` rows while moving 11,512 template rows.
+              // Measured before the relabel over the whole 1,155-file admitted
+              // population: 2,235 template rows (isComponentUsage:true) and 16
+              // delegate `new` rows = the 2,251 `instantiates` the last whole-
+              // population run published — so the relabel moves 2,235 rows and no
+              // edge is gained or lost.
+              type: ASTEngine.RelationshipType.Renders,
+              confidence: 0.95,
+              // (#825): the `<Child/>` tag as written in the template.
+              ...tagNode ? { line_number: tagNode.startPosition.row + 1 } : {},
+              metadata: {
+                // F9(b): the leaf of a dotted tag — see the comment at the filter.
+                // Merged HERE rather than spread above, because this literal's own
+                // `metadata` key comes later and a spread placed before it is
+                // silently overwritten (which is exactly what the first attempt did).
+                ...member ? { member, componentPath: rawTag } : {},
+                // F31: the target is the registry name (see `vueRegistryName`). When it
+                // is not the spelling the template wrote, the edge says so and carries
+                // the written spelling plus Vue's lookup order, so nothing is lost and a
+                // reader can tell a normalized target from a literal one.
+                ...registry.normalized ? {
+                  // The family's reason code for "why this target string is what it
+                  // is" (`svelte` writes `resolution: namespace-member` for its own
+                  // non-literal target), so a reader has one key to look for.
+                  resolution: "registry-name",
+                  tagSpellingsWritten: [tag],
+                  tagAsWritten: tag,
+                  componentNameCandidates: registry.candidates,
+                  componentNameNormalized: true
+                } : {},
+                isComponentUsage: true
+              }
+            };
+            usageRows.set(registry.target, row);
+            relationships.push(row);
+          }
+        }
+      }
+      if (t === "directive_attribute") {
+        const dname = this.findChildByType(n, "directive_name")?.text;
+        if (dname === "v-if" || dname === "v-else-if" || dname === "v-for" || dname === "v-show") templateDecisions++;
+        const value = this.findChildByType(n, "quoted_attribute_value");
+        const attrVal = value ? this.findChildByType(value, "attribute_value") : null;
+        if (attrVal) {
+          if (dname === "v-for") {
+            this.collectVForUsage(attrVal.text, templateExprNames, childShadowed, attrVal.startPosition.row + 1);
+          } else if (dname === "#" || dname === "v-slot") {
+          } else {
+            this.collectIdentifiers(attrVal.text, templateExprNames, childShadowed, attrVal.startPosition.row + 1);
+          }
+        }
+      }
+      if (t === "interpolation") {
+        const raw = this.findChildByType(n, "raw_text");
+        if (raw) {
+          this.collectIdentifiers(raw.text, templateExprNames, childShadowed, raw.startPosition.row + 1);
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const child = n.namedChild(i);
+        if (child) shadowStack.push({ node: child, shadowed: childShadowed });
+      }
+    }
+    const scriptTreeCount = context?.sfcScriptTrees?.length ?? 0;
+    const pushedComponentNames = /* @__PURE__ */ new Set([moduleName]);
+    const pendingContracts = [];
+    const pendingInjections = [];
+    const pendingProvided = [];
+    let scriptCyclomaticSum = 0;
+    let dispatchedToTypeScript = false;
+    const MEMBER_TARGET = /* @__PURE__ */ new Set([
+      ASTEngine.RelationshipType.Contains,
+      ASTEngine.RelationshipType.Provides
+    ]);
+    let componentIdentity = moduleName;
+    let declaredNameUnread = false;
+    let declaredNameFromLocalConst;
+    let declaredNameUnreadSetup = false;
+    let declaredNameFromOptions;
+    let optionsScriptIndex = 0;
+    for (let bi = 0; bi < scriptTreeCount; bi++) {
+      const scriptTree = context.sfcScriptTrees[bi];
+      const scriptStartLine = context.sfcScriptLines[bi];
+      const scriptStartColumn = context.sfcScriptCols[bi] ?? 0;
+      const scriptStartIndex = context?.sfcScriptStartIndex?.[bi] ?? 0;
+      const isTs = context?.sfcScriptLangs?.[bi] === "ts" || context?.sfcScriptLangs?.[bi] === "tsx";
+      if (isTs) dispatchedToTypeScript = true;
+      {
+        const scriptContent = scriptTree.rootNode?.text ?? "";
+        const lineOffset = scriptStartLine - 1;
+        const colOffset = scriptStartColumn;
+        const defaultExport = this.findExportDefault(scriptTree.rootNode);
+        const defaultObject = defaultExport ? this.findDescendantObject(defaultExport) : void 0;
+        if (defaultObject) patterns["Options API"] = true;
+        else patterns["Composition API"] = true;
+        let sub;
+        try {
+          sub = isTs ? new RealTypeScriptAnalyzer().analyze(scriptTree.rootNode, scriptContent, filePath) : new RealJavaScriptAnalyzer().analyze(scriptTree.rootNode, scriptContent, filePath, context);
+        } catch (e) {
+          sub = { symbols: [], relationships: [], imports: [], exports: [], errors: [], metadata: {} };
+          errors.push({
+            message: `script sub-parse failed: ${e?.message?.slice(0, 120)}`,
+            range: { startLine: scriptStartLine, startColumn: 0, endLine: scriptStartLine, endColumn: 0 },
+            severity: "warning"
+          });
+        }
+        scriptCyclomaticSum += Math.max(0, (sub.metadata?.cyclomaticComplexity ?? 1) - 1);
+        const defaultPayloads = /* @__PURE__ */ new Map();
+        if (defaultObject) {
+          for (const s of sub.symbols ?? []) {
+            if ((s.range.startIndex ?? 0) >= defaultObject.startIndex && (s.range.endIndex ?? 0) <= defaultObject.endIndex && (s.kind === ASTEngine.SymbolKind.Method || s.kind === ASTEngine.SymbolKind.Function) && !defaultPayloads.has(s.name)) {
+              defaultPayloads.set(s.name, s);
+            }
+          }
+        }
+        if (defaultObject) {
+          let componentName = moduleName;
+          const namePair = defaultObject.namedChildren.find(
+            (c) => c.type === "pair" && c.childForFieldName("key")?.text === "name"
+          );
+          let declaredNameUnreadable = false;
+          if (namePair) {
+            const v = namePair.childForFieldName("value");
+            const declared = this.declaredNameValue(v, scriptTree.rootNode);
+            if (declared) {
+              componentName = declared.name;
+              declaredNameFromLocalConst = declared.constName;
+            } else if (v) declaredNameUnreadable = true;
+          }
+          declaredNameUnread = declaredNameUnread || declaredNameUnreadable;
+          if (componentName !== moduleName) {
+            const sfcSymbol = symbols.find((sy) => sy.kind === ASTEngine.SymbolKind.Class && sy.name === moduleName);
+            if (sfcSymbol) {
+              sfcSymbol.name = componentName;
+              sfcSymbol.metadata = {
+                ...sfcSymbol.metadata ?? {},
+                moduleName,
+                isOptionsComponent: true,
+                ...declaredNameUnreadable ? { declaredNameUnreadable: true } : {}
+              };
+              componentIdentity = componentName;
+            }
+          }
+          pushedComponentNames.add(componentName);
+          this.extractOptionsApi(defaultObject, componentName, symbols, patterns, lineOffset, colOffset, defaultPayloads, scriptStartIndex, scriptTree.rootNode, relationships);
+        }
+        const defaultStart = defaultObject ? defaultObject.startIndex : -1;
+        const defaultEnd = defaultObject ? defaultObject.endIndex : -1;
+        for (const s of sub.symbols ?? []) {
+          if (defaultStart !== -1 && (s.range.startIndex ?? 0) >= defaultStart && (s.range.endIndex ?? 0) <= defaultEnd) continue;
+          s.range.startLine += lineOffset;
+          s.range.endLine += lineOffset;
+          if (s.range.startLine === 1 + lineOffset) s.range.startColumn += colOffset;
+          if (scriptStartIndex && s.range.startIndex !== void 0) s.range.startIndex += scriptStartIndex;
+          if (scriptStartIndex && s.range.endIndex !== void 0) s.range.endIndex += scriptStartIndex;
+          shiftMetadataLineMirrors(s.metadata, lineOffset);
+          symbols.push(s);
+        }
+        const delegateBases = /* @__PURE__ */ new Map();
+        for (const rb of sub.relationships ?? []) {
+          if (rb?.type !== ASTEngine.RelationshipType.Extends) continue;
+          if (typeof rb.source === "string" && rb.source !== "" && typeof rb.target === "string" && rb.target !== "") {
+            delegateBases.set(rb.source, rb.target);
+          }
+        }
+        for (const r of sub.relationships ?? []) {
+          const tgt = r.target ?? "";
+          if (VUE_COMPILER_MACROS.has(tgt)) continue;
+          if (String(r.type ?? r.relationshipType) === ASTEngine.RelationshipType.Exports && tgt === "default") {
+            if (r.metadata?.isDefault !== true) continue;
+          }
+          if (typeof r.line_number === "number") r.line_number += lineOffset;
+          shiftMetadataLineMirrors(r.metadata, lineOffset);
+          if (r.source === DELEGATE_FILE_ACTOR) r.source = moduleName;
+          if (r.type === ASTEngine.RelationshipType.Imports) {
+            const mod = r.metadata?.module;
+            if (typeof mod === "string" && mod !== "" && typeof r.target === "string" && r.target !== "" && !r.target.includes(":") && !r.target.includes("/")) {
+              r.target = `${mod}:${r.target}`;
+            }
+          }
+          if (r.type === ASTEngine.RelationshipType.Overrides) {
+            if (typeof r.source === "string" && typeof r.target === "string" && r.target !== "" && !r.target.includes(".")) {
+              const owner = r.source.slice(0, r.source.lastIndexOf("."));
+              const base = owner === "" ? void 0 : delegateBases.get(owner);
+              if (base) r.target = `${base}.${r.target}`;
+            }
+          }
+          r.metadata = { ...r.metadata ?? {}, sfcDelegated: true, sfcLineOffset: lineOffset };
+          relationships.push(r);
+        }
+        const namedDefaultDeclaration = defaultExport ? (defaultExport.namedChildren ?? []).some(
+          (c) => c.type === "class_declaration" || c.type === "abstract_class_declaration" || c.type === "function_declaration" || c.type === "generator_function_declaration"
+        ) : false;
+        if (isTs && defaultExport && !namedDefaultDeclaration) {
+          const alreadyPublished = relationships.some(
+            (x) => String(x.type ?? x.relationshipType) === ASTEngine.RelationshipType.Exports && String(x.target ?? "") === "default" && x.metadata?.isDefault === true
+          );
+          if (!alreadyPublished) {
+            relationships.push({
+              source: moduleName,
+              target: "default",
+              type: ASTEngine.RelationshipType.Exports,
+              confidence: 1,
+              line_number: defaultExport.startPosition.row + 1 + lineOffset,
+              metadata: { isDefault: true, sfcDefaultExport: true }
+            });
+          }
+        }
+        for (const i of sub.imports ?? []) {
+          if (i.range) {
+            const shifted = this.shiftScriptRange(i.range, lineOffset, colOffset, scriptStartIndex);
+            i.range.startLine = shifted.startLine;
+            i.range.endLine = shifted.endLine;
+            i.range.startColumn = shifted.startColumn;
+            i.range.endColumn = shifted.endColumn;
+            if (shifted.startIndex !== void 0) i.range.startIndex = shifted.startIndex;
+            if (shifted.endIndex !== void 0) i.range.endIndex = shifted.endIndex;
+          }
+          imports.push(i);
+        }
+        for (const e of sub.exports ?? []) {
+          if (e.range) {
+            const shifted = this.shiftScriptRange(e.range, lineOffset, colOffset, scriptStartIndex);
+            e.range.startLine = shifted.startLine;
+            e.range.endLine = shifted.endLine;
+            e.range.startColumn = shifted.startColumn;
+            e.range.endColumn = shifted.endColumn;
+            if (shifted.startIndex !== void 0) e.range.startIndex = shifted.startIndex;
+            if (shifted.endIndex !== void 0) e.range.endIndex = shifted.endIndex;
+          }
+          exports.push(e);
+        }
+        for (const er of sub.errors ?? []) {
+          if (er.range) {
+            const shifted = this.shiftScriptRange(er.range, lineOffset, colOffset, scriptStartIndex);
+            er.range.startLine = shifted.startLine;
+            er.range.endLine = shifted.endLine;
+            er.range.startColumn = shifted.startColumn;
+            er.range.endColumn = shifted.endColumn;
+            if (shifted.startIndex !== void 0) er.range.startIndex = shifted.startIndex;
+            if (shifted.endIndex !== void 0) er.range.endIndex = shifted.endIndex;
+          }
+          errors.push(er);
+        }
+        {
+          const macroStack = [scriptTree.rootNode];
+          const seenMacroNames = /* @__PURE__ */ new Set();
+          while (macroStack.length > 0) {
+            const n = macroStack.pop();
+            if (n.type === "call_expression") {
+              const fn = n.childForFieldName("function");
+              if (fn && (fn.text === "defineProps" || fn.text === "defineEmits")) {
+                const args = n.childForFieldName("arguments");
+                const firstArg = args?.namedChild(0);
+                const which = fn.text === "defineProps" ? "props" : "emits";
+                const defaultsArg = which === "props" ? this.withDefaultsObject(n) : null;
+                const propDefaults = this.defaultsEntries(defaultsArg);
+                const defaultsExpression = defaultsArg && defaultsArg.type !== "object" ? defaultsArg.text : void 0;
+                const typeArgsNode = this.findChildByType(n, "type_arguments");
+                for (const part of this.contractTypeShape(typeArgsNode).participants) {
+                  const partKey = `${which}:${part.name}`;
+                  if (seenMacroNames.has(partKey)) continue;
+                  seenMacroNames.add(partKey);
+                  pendingContracts.push({
+                    name: part.name,
+                    marker: which === "props" ? "isPropContract" : "isEmitContract",
+                    resolved: this.hasTopLevelDeclaration(part.name, n),
+                    line: this.offsetRange(this.nodeToRange(part.node), lineOffset, colOffset, scriptStartIndex).startLine,
+                    lineOffset,
+                    // F3, and a consequence of moving the participant push UP here:
+                    // this row is now the FIRST to claim `seenMacroNames`, so it is
+                    // also the row the F12 `macroContractName` branch skips. Without
+                    // the defaults carried along, adding F14 silently stripped every
+                    // withDefaults default off every NAMED contract — the fixture
+                    // caught it, which is the only reason it is worth recording.
+                    ...propDefaults.size > 0 ? { defaults: propDefaults } : {},
+                    ...defaultsExpression ? { defaultsExpression } : {}
+                  });
+                }
+                const declRefs = this.propDeclarationEntries(firstArg ?? void 0);
+                for (const d of declRefs) {
+                  const contractKey = `${which}:${d.name}`;
+                  if (seenMacroNames.has(contractKey)) continue;
+                  seenMacroNames.add(contractKey);
+                  pendingContracts.push({
+                    name: d.name,
+                    marker: which === "props" ? "isPropContract" : "isEmitContract",
+                    // Same certainty as the macro hoist: the name is written here,
+                    // but this lane has not read the declaration, so the row is the
+                    // weaker of the two — matching `defineProps(binding)`'s shape
+                    // rather than claiming more resolution than it did.
+                    resolved: false,
+                    line: this.offsetRange(this.nodeToRange(d.node), lineOffset, colOffset, scriptStartIndex).startLine,
+                    lineOffset
+                  });
+                }
+                let fromBinding = false;
+                let inlineGeneric = false;
+                let entries = this.propEntries(firstArg ?? void 0);
+                if (entries.length === 0) {
+                  entries = this.genericMacroEntries(n, which);
+                  if (entries.length > 0) inlineGeneric = true;
+                }
+                if (entries.length === 0) {
+                  entries = this.boundMacroEntries(firstArg ?? void 0, scriptTree.rootNode, which);
+                  if (entries.length > 0) fromBinding = true;
+                }
+                if (entries.length === 0) {
+                  const declared = this.macroContractName(n, firstArg ?? void 0, which);
+                  if (declared) {
+                    const key = `${which}:${declared.name}`;
+                    if (!seenMacroNames.has(key)) {
+                      seenMacroNames.add(key);
+                      const macroKey = which === "props" ? "isPropContract" : "isEmitContract";
+                      pendingContracts.push({
+                        name: declared.name,
+                        marker: macroKey,
+                        module: declared.module,
+                        resolved: declared.resolved,
+                        line: this.offsetRange(this.nodeToRange(declared.node), lineOffset, colOffset, scriptStartIndex).startLine,
+                        lineOffset,
+                        ...propDefaults.size > 0 ? { defaults: propDefaults } : {},
+                        ...defaultsExpression ? { defaultsExpression } : {}
+                      });
+                    }
+                    continue;
+                  }
+                }
+                const kind = fn.text === "defineProps" ? ASTEngine.SymbolKind.Property : ASTEngine.SymbolKind.Event;
+                const meta = fn.text === "defineProps" ? "isProp" : "isEmit";
+                for (const { name: pn, node: pnNode } of entries) {
+                  const dedupe = `${meta}:${pn}`;
+                  if (seenMacroNames.has(dedupe)) continue;
+                  seenMacroNames.add(dedupe);
+                  symbols.push({
+                    name: pn,
+                    kind,
+                    range: this.offsetRange(this.nodeToRange(pnNode), lineOffset, colOffset, scriptStartIndex),
+                    // F8: a contract symbol belongs to the ONE component. `name:`
+                    // is read from a `name:` option in the FIRST block, so by the
+                    // time a `<script setup>` block's macros run, `componentIdentity`
+                    // already holds the declared name — and a script-setup prop
+                    // owned by the FILE STEM while an Options prop is owned by the
+                    // component is exactly the split identity F8 removed.
+                    scope: componentIdentity,
+                    ownerName: componentIdentity,
+                    ownerKind: ASTEngine.SymbolKind.Class,
+                    visibility: "public",
+                    metadata: {
+                      [meta]: true,
+                      isScriptSetup: true,
+                      // Which shape the names came from: "inline" (a literal
+                      // argument), "generic" (an inline type literal) or
+                      // "binding" (a same-file declaration resolved by name).
+                      contractSource: fromBinding ? "binding" : inlineGeneric ? "generic" : "inline",
+                      // F3: the `withDefaults` default for this prop, as WRITTEN
+                      // SOURCE. A same-file binding is included, which is why this
+                      // is keyed off the map rather than off the shape: a binding's
+                      // members have no type annotation, and the default is the only
+                      // thing that says the prop is genuinely optional-by-default.
+                      ...propDefaults.has(pn) ? { defaultValue: propDefaults.get(pn), hasDefault: true } : {}
+                    }
+                  });
+                }
+              }
+            }
+            for (let i = 0; i < n.namedChildCount; i++) {
+              const c = n.namedChild(i);
+              if (c) macroStack.push(c);
+            }
+          }
+          {
+            const pjStack = [scriptTree.rootNode];
+            while (pjStack.length > 0) {
+              const n = pjStack.pop();
+              if (n.type === "call_expression") {
+                const callee = n.childForFieldName("function")?.text;
+                if (callee === "provide" || callee === "inject") {
+                  const vueContract = this.contractNameIsVueBinding(callee, n);
+                  const argsNode = n.childForFieldName("arguments");
+                  const keyNode = argsNode?.namedChild(0);
+                  if (vueContract && keyNode && (keyNode.type === "identifier" || keyNode.type === "string")) {
+                    const keyName = keyNode.type === "string" ? unquote(keyNode.text) : keyNode.text;
+                    if (keyName) {
+                      pendingInjections.push({
+                        key: keyName,
+                        marker: callee === "provide" ? "isProvideContract" : "isInjectContract",
+                        line: this.offsetRange(this.nodeToRange(keyNode), lineOffset, colOffset, scriptStartIndex).startLine,
+                        lineOffset
+                      });
+                      if (callee === "provide") {
+                        const value = this.providedValueObject(argsNode?.namedChild(1) ?? null);
+                        if (value) {
+                          for (let i = 0; i < value.namedChildCount; i++) {
+                            const c = value.namedChild(i);
+                            if (!c || c.type !== "pair" && c.type !== "method_definition" && c.type !== "shorthand_property_identifier") continue;
+                            const shorthand = c.type === "shorthand_property_identifier";
+                            const k = shorthand ? c.text : c.type === "pair" ? c.childForFieldName("key")?.text : c.childForFieldName("name")?.text;
+                            if (k && !k.startsWith("[")) {
+                              pendingProvided.push({
+                                name: unquote(k),
+                                owner: moduleName,
+                                line: n.startPosition.row + 1 + scriptStartLine,
+                                column: n.startPosition.column + 1 + (context.sfcScriptCols[bi] ?? 0)
+                              });
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+              for (let i = 0; i < n.namedChildCount; i++) {
+                const c = n.namedChild(i);
+                if (c) pjStack.push(c);
+              }
+            }
+          }
+        }
+      }
+    }
+    for (const [bi, scriptTree] of (context?.sfcScriptTrees ?? []).entries()) {
+      const optsCall = this.findCallNamed(scriptTree.rootNode, "defineOptions");
+      if (!optsCall) continue;
+      const optsObj = this.firstObjectArgument(optsCall);
+      if (!optsObj) continue;
+      const stack = [optsObj];
+      while (stack.length > 0 && declaredNameFromOptions === void 0) {
+        const n = stack.pop();
+        const keyNode = this.findChildByType(n, "property_identifier");
+        if (n.type === "pair" && keyNode && keyNode.text === "name") {
+          const value = n.childForFieldName("value") ?? this.findChildByType(n, "string");
+          const declared = this.declaredNameValue(value, scriptTree.rootNode);
+          if (declared) {
+            declaredNameFromOptions = declared.name;
+            declaredNameFromLocalConst = declared.constName;
+          } else if (value) declaredNameUnreadSetup = true;
+        }
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) stack.push(c);
+        }
+      }
+      if (declaredNameFromOptions) {
+        optionsScriptIndex = bi;
+        break;
+      }
+    }
+    if (declaredNameFromOptions && declaredNameFromOptions !== componentIdentity) {
+      const cls = symbols.find(
+        (sy) => sy.kind === ASTEngine.SymbolKind.Class && sy.name === componentIdentity && sy.metadata?.isVueComponent === true
+      );
+      if (cls) {
+        cls.metadata = {
+          ...cls.metadata ?? {},
+          moduleName: componentIdentity,
+          isScriptSetupComponent: true
+        };
+        const col = context.sfcScriptCols?.[optionsScriptIndex] ?? 0;
+        cls.range = { ...cls.range, startColumn: cls.range.startColumn + col };
+        const oldIdentity = cls.name;
+        for (const sym of symbols) {
+          if (sym.ownerName === oldIdentity || sym.ownerName === moduleName) sym.ownerName = declaredNameFromOptions;
+          if (sym.scope === oldIdentity || sym.scope === moduleName) sym.scope = declaredNameFromOptions;
+        }
+        for (const e of relationships) {
+          if (e.source === oldIdentity || e.source === moduleName) e.source = declaredNameFromOptions;
+          if (e.target === oldIdentity || e.target === moduleName) e.target = declaredNameFromOptions;
+        }
+        cls.name = declaredNameFromOptions;
+        componentIdentity = declaredNameFromOptions;
+      }
+    }
+    {
+      const cls = symbols.find(
+        (sy) => sy.kind === ASTEngine.SymbolKind.Class && sy.metadata?.isVueComponent === true
+      );
+      if (cls) {
+        if (cls.name === moduleName) cls.metadata = { ...cls.metadata ?? {}, synthesized: true, identityFromFileStem: true };
+        if (declaredNameUnread || declaredNameUnreadSetup) cls.metadata = { ...cls.metadata ?? {}, declaredNameUnreadable: true };
+        if (declaredNameFromLocalConst) {
+          cls.metadata = { ...cls.metadata ?? {}, nameFromLocalConst: declaredNameFromLocalConst };
+        }
+      }
+    }
+    for (const c of pendingInjections) {
+      const meta = { [c.marker]: true, sfcDelegated: true, sfcLineOffset: c.lineOffset };
+      const existing = relationships.find(
+        (x) => x.source === moduleName && x.target === c.key && String(x.type ?? x.relationshipType) === String(ASTEngine.RelationshipType.References)
+      );
+      if (existing) {
+        existing.metadata = { ...existing.metadata ?? {}, ...meta };
+      } else {
+        relationships.push({
+          source: moduleName,
+          target: c.key,
+          type: ASTEngine.RelationshipType.References,
+          confidence: 0.9,
+          line_number: c.line,
+          metadata: meta
+        });
+      }
+    }
+    for (const c of pendingContracts) {
+      const contractMeta = {
+        [c.marker]: true,
+        ...c.module ? { contractModule: c.module } : {},
+        ...c.resolved ? {} : { unresolved: true },
+        // F3: the defaults map, plus its size so a consumer can answer "does this
+        // contract declare defaults" without walking the keys.
+        ...c.defaults && c.defaults.size > 0 ? { defaults: Object.fromEntries(c.defaults), defaultKeys: c.defaults.size } : {},
+        // F3: an indirect defaults expression, kept as text. Deliberately NOT
+        // `defaultKeys: 0` — zero keys would claim the component declares no
+        // defaults, which is the opposite of the truth.
+        ...c.defaultsExpression ? { defaultsExpression: c.defaultsExpression } : {}
+      };
+      const sameEdge = (x) => x.target === c.name && String(x.type ?? x.relationshipType) === String(ASTEngine.RelationshipType.References) && x.metadata?.sfcDelegated === true && (x.line_number ?? x.line) === c.line;
+      const existing = relationships.find(sameEdge);
+      if (existing) {
+        existing.metadata = { ...existing.metadata ?? {}, ...contractMeta };
+        if (existing.metadata?.sfcDelegated === true) existing.source = componentIdentity;
+      } else {
+        relationships.push({
+          source: componentIdentity,
+          target: c.name,
+          type: ASTEngine.RelationshipType.References,
+          confidence: c.resolved ? 1 : 0.8,
+          line_number: c.line,
+          metadata: { ...contractMeta, sfcDelegated: true, sfcLineOffset: c.lineOffset }
+        });
+      }
+    }
+    if (templateExprNames.size > 0) {
+      const memberNames = new Set(symbols.map((s) => s.name));
+      const seenUses = /* @__PURE__ */ new Set();
+      for (const [name, line] of templateExprNames) {
+        if (!memberNames.has(name)) continue;
+        const key = `${moduleName}:${name}`;
+        if (seenUses.has(key)) continue;
+        seenUses.add(key);
+        relationships.push({
+          source: moduleName,
+          target: name,
+          type: ASTEngine.RelationshipType.Uses,
+          confidence: 0.95,
+          // (#825): the line the identifier is WRITTEN on (the fragment's
+          // base plus its offset inside it).
+          line_number: line,
+          metadata: { isTemplateExpression: true }
+        });
+      }
+    }
+    if (componentIdentity !== moduleName) {
+      for (const rel of relationships) {
+        if (rel.source === moduleName) rel.source = componentIdentity;
+      }
+    }
+    for (const p of pendingProvided) {
+      const sym = symbols.find((sy) => sy.name === p.name && sy.ownerName === void 0);
+      if (sym) {
+        sym.ownerName = p.owner;
+        sym.ownerKind = ASTEngine.SymbolKind.Class;
+        sym.scope = p.owner;
+        sym.metadata = { ...sym.metadata ?? {}, isProvided: true };
+        continue;
+      }
+      if (symbols.some((sy) => sy.name === p.name && sy.ownerName === p.owner)) continue;
+      symbols.push({
+        name: p.name,
+        kind: ASTEngine.SymbolKind.Variable,
+        ownerName: p.owner,
+        ownerKind: ASTEngine.SymbolKind.Class,
+        scope: p.owner,
+        line_number: p.line,
+        range: { startLine: p.line, startColumn: p.column, endLine: p.line, endColumn: p.column + p.name.length },
+        metadata: { isProvided: true, synthesized: true }
+      });
+    }
+    const existingContains = /* @__PURE__ */ new Set();
+    for (const r of relationships) {
+      if (r.type === ASTEngine.RelationshipType.Contains && r.source && r.target) {
+        existingContains.add(`${r.source}::${r.target}`);
+      }
+    }
+    for (const s of symbols) {
+      if (s.ownerName) {
+        const key = `${s.ownerName}::${s.name}`;
+        if (existingContains.has(key)) continue;
+        existingContains.add(key);
+        relationships.push({
+          source: s.ownerName,
+          target: s.name,
+          type: ASTEngine.RelationshipType.Contains,
+          confidence: 1,
+          // (#825): the MEMBER's declaration line (its symbol range, already
+          // shifted to SFC coordinates) — the edge names the member.
+          ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+          metadata: {}
+        });
+      }
+    }
+    const architecturalScore = Math.min(100, Math.max(0, 100 - errors.length * 5));
+    const detectedPatterns = Object.keys(patterns);
+    const frameworkPatterns = detectedPatterns.map((p) => ({
+      framework: "Vue",
+      patterns: [{ type: "usage", detected: true, description: p }]
+    }));
+    this.classifyEvidenceTier(relationships);
+    if (componentIdentity !== moduleName) {
+      for (const sym of symbols) {
+        if (sym.ownerName === moduleName) sym.ownerName = componentIdentity;
+        if (sym.scope === moduleName) sym.scope = componentIdentity;
+      }
+      for (const e of relationships) {
+        if (e.source === moduleName) e.source = componentIdentity;
+      }
+    }
+    return {
+      language: "vue",
+      symbols,
+      relationships,
+      imports,
+      exports,
+      errors,
+      metadata: {
+        // Real cyclomatic complexity: script-block decisions (per JS/TS
+        // contract) plus template decision directives (v-if/v-for/v-show).
+        // Was hardcoded 1 / the synthetic symbols+relationships heuristic.
+        complexity: 1 + scriptCyclomaticSum + templateDecisions,
+        linesOfCode: content.split("\n").length,
+        cyclomaticComplexity: 1 + scriptCyclomaticSum + templateDecisions,
+        framework: "Vue",
+        patterns: detectedPatterns,
+        detectedFrameworks: ["Vue"],
+        frameworkPatterns,
+        architecturalInsights: [],
+        architecturalScore,
+        codeQuality: errors.length === 0 ? "Excellent" : "Fair",
+        // F7: true iff a <script> block was parsed with a TypeScript grammar
+        // (lang="ts" or lang="tsx", #903's three-way dispatch). A plain block,
+        // or an SFC with no script, is the JavaScript analyzer and stays false.
+        hasTypeInference: dispatchedToTypeScript,
+        hasFrameworkIntelligence: true,
+        analysisVersion: "5.0.0-m12.12-family-contract"
+      }
+    };
+  }
+  // ============================================================================
+  // OPTIONS API EXTRACTION
+  // ============================================================================
+  /**
+   * Which shape the LAST contract resolution came from. A field rather than a
+   * return value because the two call sites (the Options options and the
+   * script-setup macros) each consume the entries in their own loop; the marker
+   * is what lets a fixture pin the shape and a mutant revert one of them
+   * without touching the others.
+   */
+  lastContractSource = "none";
+  extractOptionsApi(objectNode, componentName, symbols, patterns, lineOffset, colOffset, payloads, indexOffset, scriptRoot, relationships) {
+    const memberName = (n) => {
+      const key = n.childForFieldName("key");
+      if (key) return key.text;
+      const name = n.childForFieldName("name");
+      if (name) return name.text;
+      return this.findChildByType(n, "property_identifier")?.text;
+    };
+    const mergeBases = [];
+    for (let i = 0; i < objectNode.namedChildCount; i++) {
+      const child = objectNode.namedChild(i);
+      if (!child) continue;
+      if (child.type !== "pair" && child.type !== "method_definition") continue;
+      const key = memberName(child);
+      if (!key) continue;
+      const value = child.type === "pair" ? child.childForFieldName("value") : void 0;
+      if (key === "methods" && value) {
+        patterns["Options API"] = true;
+        this.emitObjectMembers(value, componentName, symbols, ASTEngine.SymbolKind.Method, "method", lineOffset, colOffset, payloads, indexOffset);
+      } else if (key === "computed" && value) {
+        patterns["Options API"] = true;
+        this.emitObjectMembers(value, componentName, symbols, ASTEngine.SymbolKind.Property, "computed", lineOffset, colOffset, payloads, indexOffset);
+      } else if (key === "data") {
+        symbols.push({
+          name: "data",
+          kind: ASTEngine.SymbolKind.Method,
+          range: this.offsetRange(this.nodeToRange(child), lineOffset, colOffset, indexOffset),
+          scope: componentName,
+          ownerName: componentName,
+          ownerKind: ASTEngine.SymbolKind.Class,
+          visibility: "public",
+          metadata: { isOptionsData: true }
+        });
+        const dataValue = child.type === "pair" ? child.childForFieldName("value") : void 0;
+        if (dataValue && dataValue.type === "object") {
+          this.emitDataKeys(dataValue, componentName, symbols, lineOffset, colOffset, indexOffset);
+        } else if (child.type === "method_definition") {
+          const returned = this.findReturnedObject(child);
+          if (returned) this.emitDataKeys(returned, componentName, symbols, lineOffset, colOffset, indexOffset);
+        } else if (dataValue && (dataValue.type === "arrow_function" || dataValue.type === "function_expression" || dataValue.type === "function")) {
+          const returned = this.findReturnedObject(dataValue);
+          if (returned) this.emitDataKeys(returned, componentName, symbols, lineOffset, colOffset, indexOffset);
+        }
+      } else if (key === "props") {
+        for (const { name: pn, node: pnode } of this.resolveContractEntries(value ?? child, scriptRoot, "props", relationships, componentName)) {
+          symbols.push({
+            name: pn,
+            kind: ASTEngine.SymbolKind.Property,
+            // (#825): the prop KEY's own node — the line and column a
+            // navigation to this prop must land on.
+            range: this.offsetRange(this.nodeToRange(pnode), lineOffset, colOffset, indexOffset),
+            scope: componentName,
+            ownerName: componentName,
+            ownerKind: ASTEngine.SymbolKind.Class,
+            visibility: "public",
+            metadata: { isProp: true, contractSource: this.lastContractSource }
+          });
+        }
+      } else if (key === "emits") {
+        for (const { name: en, node: enode } of this.resolveContractEntries(value ?? child, scriptRoot, "emits", relationships, componentName)) {
+          symbols.push({
+            name: en,
+            kind: ASTEngine.SymbolKind.Event,
+            range: this.offsetRange(this.nodeToRange(enode), lineOffset, colOffset, indexOffset),
+            scope: componentName,
+            ownerName: componentName,
+            ownerKind: ASTEngine.SymbolKind.Class,
+            visibility: "public",
+            metadata: { isEmit: true, contractSource: this.lastContractSource }
+          });
+        }
+      } else if (key === "extends" || key === "mixins") {
+        if (!value || !relationships) continue;
+        const isMixin = key === "mixins";
+        for (const base of this.identifiersOf(value)) {
+          relationships.push({
+            source: componentName,
+            target: base.name,
+            type: ASTEngine.RelationshipType.Extends,
+            // A named component the analyzer cannot see is the Vue
+            // documentation's own guarantee — the option is resolved by Vue at
+            // runtime — so this is a declaration of the relationship, not a
+            // guess. It is not `structural` in the closure sense (nothing in
+            // this file states the base's members), which is why the
+            // confidence is below 1.
+            confidence: 0.9,
+            line_number: this.offsetRange(this.nodeToRange(base.node), lineOffset, colOffset, indexOffset).startLine,
+            metadata: { isMixin, isOptionsApi: true }
+          });
+        }
+        for (const base of this.identifiersOf(value)) {
+          mergeBases.push({
+            name: base.name,
+            isMixin,
+            node: base.node,
+            optionsObject: this.sameTreeOptionsObject(base.node, value, scriptRoot)
+          });
+        }
+        if (value.type === "object") {
+          for (let i2 = 0; i2 < value.namedChildCount; i2++) {
+            const sub = value.namedChild(i2);
+            if (!sub || sub.type !== "pair" && sub.type !== "method_definition") continue;
+            const subKey = sub.type === "pair" ? sub.childForFieldName("key")?.text : sub.childForFieldName("name")?.text;
+            const subValue = sub.type === "pair" ? sub.childForFieldName("value") : void 0;
+            if (!subKey) continue;
+            if ((subKey === "methods" || subKey === "computed") && subValue) {
+              this.emitObjectMembers(
+                subValue,
+                componentName,
+                symbols,
+                subKey === "methods" ? ASTEngine.SymbolKind.Method : ASTEngine.SymbolKind.Property,
+                subKey === "methods" ? "method" : "computed",
+                lineOffset,
+                colOffset,
+                payloads,
+                indexOffset
+              );
+            } else if (subKey === "props" && subValue) {
+              for (const { name: pn, node: pnode } of this.propEntries(subValue)) {
+                symbols.push({
+                  name: pn,
+                  kind: ASTEngine.SymbolKind.Property,
+                  range: this.offsetRange(this.nodeToRange(pnode), lineOffset, colOffset, indexOffset),
+                  scope: componentName,
+                  ownerName: componentName,
+                  ownerKind: ASTEngine.SymbolKind.Class,
+                  visibility: "public",
+                  metadata: { isProp: true, inheritedFrom: "extends" }
+                });
+              }
+            }
+          }
+        }
+      } else if (key === "watch") {
+        if (value) {
+          patterns["Options API"] = true;
+          this.emitObjectMembers(value, componentName, symbols, ASTEngine.SymbolKind.Method, "isWatcher", lineOffset, colOffset, payloads, indexOffset);
+        }
+      } else if (key === "setup") {
+        patterns["Options API"] = true;
+        symbols.push({
+          name: key,
+          kind: ASTEngine.SymbolKind.Method,
+          range: this.offsetRange(this.nodeToRange(child), lineOffset, colOffset, indexOffset),
+          scope: componentName,
+          ownerName: componentName,
+          ownerKind: ASTEngine.SymbolKind.Class,
+          visibility: "public",
+          metadata: { isSetup: true }
+        });
+      } else if (this.isLifecycleHook(key)) {
+        symbols.push({
+          name: key,
+          kind: ASTEngine.SymbolKind.Method,
+          range: this.offsetRange(this.nodeToRange(child), lineOffset, colOffset, indexOffset),
+          scope: componentName,
+          ownerName: componentName,
+          ownerKind: ASTEngine.SymbolKind.Class,
+          visibility: "public",
+          metadata: { isLifecycleHook: true }
+        });
+      }
+    }
+    if (mergeBases.length > 0 && relationships) {
+      const MEMBER_KINDS = /* @__PURE__ */ new Set([
+        ASTEngine.SymbolKind.Method,
+        ASTEngine.SymbolKind.Property,
+        ASTEngine.SymbolKind.Event
+      ]);
+      const own = /* @__PURE__ */ new Map();
+      for (const s of symbols) {
+        if (s.ownerName !== componentName) continue;
+        if (!MEMBER_KINDS.has(s.kind)) continue;
+        own.set(s.name, s);
+      }
+      const emitted = /* @__PURE__ */ new Set();
+      for (const base of mergeBases) {
+        const baseMembers = base.optionsObject ? this.optionsMemberNames(base.optionsObject) : void 0;
+        if (!baseMembers || baseMembers.size === 0) continue;
+        for (const [name, sym] of own) {
+          if (!baseMembers.has(name)) continue;
+          const edgeKey = `${componentName}.${name}->${base.name}.${name}`;
+          if (emitted.has(edgeKey)) continue;
+          emitted.add(edgeKey);
+          relationships.push({
+            source: `${componentName}.${name}`,
+            target: `${base.name}.${name}`,
+            type: ASTEngine.RelationshipType.Overrides,
+            confidence: 0.95,
+            ...sym.range?.startLine ? { line_number: this.offsetRange(sym.range, lineOffset, colOffset, indexOffset).startLine } : {},
+            metadata: {
+              baseOption: base.name,
+              isMixin: base.isMixin,
+              isOptionsApi: true,
+              // Honesty contract : a sub-1.0 confidence carries a
+              // machine-readable reason, not just a number.
+              reasonCode: "verified-in-file"
+            }
+          });
+        }
+      }
+    }
+  }
+  /**
+   * ONTOLOGY : the options OBJECT a `mixins`/`extends` base names,
+   * when this parse tree can read one, and `undefined` when it cannot.
+   *
+   * Two accepted shapes, both resolved WITHOUT leaving the tree:
+   *
+   *   INLINE       `mixins: [{ methods: { … } }]` / `extends: { … }` — the object
+   *                is the element (or the value) itself.
+   *   SAME-FILE    `const shared = { … }` in the same `<script>` block, named by
+   *                the mixins array. Resolved by walking `variable_declarator`s
+   *                for the wanted name, which is exactly what `boundMacroEntries`
+   *                does for `defineProps(binding)` — the same rule, for the same
+   *                reason: a same-tree declaration is the only form whose keys are
+   *                published by nothing else, so reading them here cannot double
+   *                count another producer's symbols.
+   *
+   * Anything else returns `undefined` and the caller emits nothing. That is the
+   * honest answer for an imported base: the analyzer has not read the base, so it
+   * does not know what the base declares, and an `overrides` row needs that.
+   */
+  sameTreeOptionsObject(baseNode, value, scriptRoot) {
+    if (baseNode.type === "object") return baseNode;
+    if (value.type === "object" && baseNode.startIndex === value.startIndex) return value;
+    if (baseNode.type !== "identifier" || !scriptRoot) return void 0;
+    const wanted = baseNode.text;
+    const stack = [scriptRoot];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "variable_declarator") {
+        const nameField = n.childForFieldName("name");
+        const valueField = n.childForFieldName("value");
+        if (nameField?.type === "identifier" && nameField.text === wanted && valueField) {
+          const peeled = peelTypeWrappers(valueField);
+          if (peeled.type === "object") return peeled;
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return void 0;
+  }
+  /**
+   * ONTOLOGY : the member names an options
+   * object declares — restricted to the options Vue's OWN MERGE TABLE REPLACES,
+   * and to nothing else.
+   *
+   * WHY THE RESTRICTION IS THE WHOLE FIX. The first version of this read every
+   * `pair` child of `MEMBER_OPTIONS` plus every `method_definition` child, on
+   * the stated premise that "Vue's own merge rule is that a component's own
+   * value for an option WINS over the base's, so a member declared here that the
+   * base also declares is an override of that member". That premise is FALSE, and
+   * Vue's own source says so in one table.
+   *
+   * vuejs@4ab865a, packages/runtime-core/src/componentOptions.ts:1005-1035,
+   * `internalOptionMergeStrats`:
+   *
+   *   methods, computed, components, directives -> mergeObjectOptions
+   *        `extend(Object.create(null), to, from)` — the CHILD'S value for a
+   *        same-named key wins outright.                                  OVERRIDE
+   *   props, emits -> mergeEmitsOrPropsOptions
+   *        `extend({}, normalize(to), normalize(from ?? {}))` — same.    OVERRIDE
+   *   inject -> mergeInject -> mergeObjectOptions                       OVERRIDE
+   *   data -> mergeDataFn
+   *        BOTH factories run and the results are `extend`ed, so the child's
+   *        wins PER RETURNED KEY while the `data` option itself survives as
+   *        two. Not a member override — but the colliding DATA KEYS are real.
+   *   beforeCreate … serverPrefetch (14 hooks) -> mergeAsArray
+   *        `[...new Set([].concat(to, from))]` — BOTH HOOKS RUN.      NOT one.
+   *        Confirmed independently at apiLifecycle.ts:26-27:
+   *        `const hooks = target[type] || (target[type] = []); hooks.push(...)`.
+   *   watch -> mergeWatchOptions
+   *        per key the two are CONCATENATED into an array — both run.    NOT one.
+   *   provide -> mergeDataFn, same as data.                            NOT one.
+   *
+   * So of the option kinds a real merge can collide on, four classes are a
+   * replacement and four are a merge. The first version could not tell them
+   * apart, and it emitted a row for all of them.
+   *
+   * WHAT THAT COST, MEASURED. Over the 1,151 admitted `.vue` files of
+   * element-plus + vue-element-admin + vuejs there are 9 `extends`/`mixins`
+   * heritage edges and 21 name collisions across them — and every one of the 21
+   * is in the merge half: `mounted`, `beforeDestroy`, `activated`, `deactivated`
+   * and the `data` factory. A cross-file resolution built on the old rule would
+   * have emitted 21 fabricated `overrides` rows and 0 true ones
+   * (`script/m14/vue-overrides-crossfile-probe.mts`; evidence in
+   * `validation/m14/results/archive/vue-verify8-overrides-crossfile.json`). Under this
+   * rule the same corpus supports 0, which is the correct answer and not a gap.
+   *
+   * A fabricated edge is the most expensive mistake available in this programme
+   * (ONTOLOGY-WORKSTREAM, "The fabrication rule"): it counts as `unexplained`
+   * and it poisons bb_graph, bb_impact and bb_migrate. Removing 21 false rows is
+   * worth more than adding them.
+   *
+   * WHAT IS DELIBERATELY NOT IN THE SET, each exclusion a decision:
+   *   - lifecycle hooks, `data`, `setup`, `watch`: merged, per the table above.
+   *   - `components` / `directives`: merged per key like `methods`, so they COULD
+   *     collide — but this analyzer publishes no symbol for an asset
+   *     registration, so a collision could never be joined to an own member and
+   *     the rule could never fire. Adding it would be a branch that cannot fire,
+   *     which is the dead-code class this workstream exists to remove.
+   */
+  optionsMemberNames(optionsObject) {
+    const out = /* @__PURE__ */ new Set();
+    const MEMBER_OPTIONS = /* @__PURE__ */ new Set(["methods", "computed", "props", "emits", "inject"]);
+    for (let i = 0; i < optionsObject.namedChildCount; i++) {
+      const child = optionsObject.namedChild(i);
+      if (!child) continue;
+      if (child.type === "method_definition") continue;
+      if (child.type !== "pair") continue;
+      const key = child.childForFieldName("key")?.text;
+      if (!key || key.startsWith("[")) continue;
+      const k = child.childForFieldName("key").type === "string" ? unquote(key) : key;
+      if (!MEMBER_OPTIONS.has(key)) continue;
+      const v = child.childForFieldName("value");
+      if (!v) {
+        out.add(k);
+        continue;
+      }
+      if (v.type === "object") {
+        for (let j = 0; j < v.namedChildCount; j++) {
+          const m = v.namedChild(j);
+          if (!m || m.type !== "pair" && m.type !== "method_definition" && m.type !== "shorthand_property_identifier") continue;
+          const mk = m.type === "pair" ? m.childForFieldName("key")?.text : m.type === "method_definition" ? m.childForFieldName("name")?.text : m.text;
+          if (mk && !mk.startsWith("[")) out.add(unquote(mk));
+        }
+      } else if (v.type === "array") {
+        for (let j = 0; j < v.namedChildCount; j++) {
+          const m = v.namedChild(j);
+          if (m?.type === "string") out.add(unquote(m.text));
+        }
+      } else {
+        out.add(k);
+      }
+    }
+    for (const dk of this.optionsDataKeys(optionsObject)) out.add(dk);
+    return out;
+  }
+  /**
+   * The keys a `data` option RETURNS — the one collision class `data` really does
+   * replace, because `mergeDataFn` runs both factories and `extend`s the two
+   * results with the child's last.
+   *
+   * Two shapes, both read off the options object and neither leaving the tree:
+   * the object form (`data: { n: 0 }`) and the factory form
+   * (`data() { return { n: 0 } }`), which is `findReturnedObject`'s job. An arrow
+   * factory written as a `pair` value (`data: () => ({ … })`) goes through the
+   * same call, because `findReturnedObject` handles an expression body.
+   */
+  optionsDataKeys(optionsObject) {
+    const out = /* @__PURE__ */ new Set();
+    const addFrom = (o) => {
+      if (!o || o.type !== "object") return;
+      for (let i = 0; i < o.namedChildCount; i++) {
+        const p = o.namedChild(i);
+        if (p?.type !== "pair") continue;
+        const raw = p.childForFieldName("key")?.text;
+        if (!raw || raw.startsWith("[")) continue;
+        out.add(unquote(raw));
+      }
+    };
+    for (let i = 0; i < optionsObject.namedChildCount; i++) {
+      const child = optionsObject.namedChild(i);
+      if (!child) continue;
+      if (child.type === "method_definition") {
+        if (child.childForFieldName("name")?.text !== "data") continue;
+        addFrom(this.findReturnedObject(child));
+        continue;
+      }
+      if (child.type !== "pair" || child.childForFieldName("key")?.text !== "data") continue;
+      const v = child.childForFieldName("value");
+      if (!v) continue;
+      if (v.type === "object") {
+        addFrom(v);
+        continue;
+      }
+      if (v.type === "arrow_function" || v.type === "function_expression" || v.type === "function") {
+        addFrom(this.findReturnedObject(v));
+      }
+    }
+    return out;
+  }
+  /**
+   * H1 (review wave): emit one Property symbol per key of a data-state
+   * object (pair ranges, so hover lands on the key). String keys unquoted.
+   */
+  emitDataKeys(objectNode, componentName, symbols, lineOffset, colOffset, indexOffset) {
+    const seen = /* @__PURE__ */ new Map();
+    for (let i = 0; i < objectNode.namedChildCount; i++) {
+      const child = objectNode.namedChild(i);
+      if (!child || child.type !== "pair") continue;
+      const keyNode = child.childForFieldName("key");
+      if (!keyNode) continue;
+      if (keyNode.text.startsWith("[")) continue;
+      const name = keyNode.type === "string" ? unquote(keyNode.text) : keyNode.text;
+      if (!name) continue;
+      const prevIdx = seen.get(name);
+      const sym = {
+        name,
+        kind: ASTEngine.SymbolKind.Property,
+        range: this.offsetRange(this.nodeToRange(child), lineOffset, colOffset, indexOffset),
+        scope: componentName,
+        ownerName: componentName,
+        ownerKind: ASTEngine.SymbolKind.Class,
+        visibility: "public",
+        metadata: { isDataKey: true }
+      };
+      if (prevIdx !== void 0) {
+        symbols[prevIdx] = sym;
+      } else {
+        seen.set(name, symbols.length);
+        symbols.push(sym);
+      }
+    }
+  }
+  /**
+   * H1 (review wave): first `return {...}` object literal under a data()
+   * factory body. Conditional/multiple returns: first wins (documented
+   * approximation — branches are not evaluated). D2 (deeper review):
+   * expression-bodied arrows (`() => ({...})`) carry the object as the
+   * direct body — an object reached with only parenthesized wrappers
+   * between it and an arrow/function start is the body's value, not a
+   * nested construction.
+   */
+  findReturnedObject(methodNode) {
+    const isStart = (p) => !!p && p.startIndex === methodNode.startIndex && p.endIndex === methodNode.endIndex;
+    const stack = [methodNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "return_statement") {
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c && c.type === "object") return c;
+        }
+      }
+      if (n.type === "object" && !isStart(n)) {
+        let ok = true;
+        let p = n.parent;
+        while (p && !isStart(p)) {
+          if (p.type !== "parenthesized_expression" && p.type !== "arrow_function" && p.type !== "function_expression" && p.type !== "function" && p.type !== "method_definition") {
+            ok = false;
+            break;
+          }
+          p = p.parent;
+        }
+        if (ok && p) return n;
+      }
+      if (!isStart(n) && (n.type === "function_expression" || n.type === "arrow_function" || n.type === "function_declaration" || n.type === "method_definition")) continue;
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return void 0;
+  }
+  emitObjectMembers(valueNode, componentName, symbols, kind, meta, lineOffset, colOffset, payloads, indexOffset) {
+    const seen = /* @__PURE__ */ new Map();
+    for (let i = 0; i < valueNode.namedChildCount; i++) {
+      const child = valueNode.namedChild(i);
+      if (!child) continue;
+      let name;
+      if (child.type === "method_definition" || child.type === "pair") {
+        const raw = child.childForFieldName("name")?.text || child.childForFieldName("key")?.text;
+        if (!raw) continue;
+        if (raw.startsWith("[")) continue;
+        name = unquote(raw);
+      } else if (child.type === "property_identifier") {
+        name = child.text;
+      }
+      if (!name) continue;
+      const prevIdx = seen.get(name);
+      const payload = payloads?.get(name);
+      const sym = {
+        name,
+        kind,
+        range: this.offsetRange(this.nodeToRange(child), lineOffset, colOffset, indexOffset),
+        scope: componentName,
+        ownerName: componentName,
+        ownerKind: ASTEngine.SymbolKind.Class,
+        visibility: "public",
+        parameters: payload?.parameters,
+        returnType: payload?.returnType,
+        complexity: payload?.complexity,
+        qualified_calls: payload?.qualified_calls,
+        metadata: { [meta]: true }
+      };
+      if (prevIdx !== void 0) {
+        symbols[prevIdx] = sym;
+      } else {
+        seen.set(name, symbols.length);
+        symbols.push(sym);
+      }
+    }
+  }
+  /**
+   * F12: a contract OPTION's entries, in the shape order —
+   * inline literal, then a same-file BINDING, then the declaration EDGE.
+   *
+   * Shared by the Options `props:`/`emits:` options and (for the binding half)
+   * the script-setup macros, because the two differ only in spelling: Vue
+   * hoists the declaration to a `const` in both styles, and both styles lost
+   * the whole contract when the name was not followed.
+   */
+  resolveContractEntries(value, scriptRoot, which, relationships, componentName) {
+    const inline = this.propEntries(value ?? void 0);
+    if (inline.length > 0) {
+      this.lastContractSource = "inline";
+      return inline;
+    }
+    if (!value || !scriptRoot) {
+      this.lastContractSource = "none";
+      return [];
+    }
+    const bound = this.boundMacroEntries(value, scriptRoot, which);
+    if (bound.length > 0) {
+      this.lastContractSource = "binding";
+      return bound;
+    }
+    this.lastContractSource = "none";
+    if (!relationships) return [];
+    const declared = this.macroContractNameFromNode(value, which);
+    if (!declared) return [];
+    const marker = which === "props" ? "isPropContract" : "isEmitContract";
+    relationships.push({
+      source: componentName,
+      target: declared.name,
+      type: ASTEngine.RelationshipType.References,
+      confidence: declared.resolved ? 1 : 0.8,
+      ...declared.node.startPosition ? { line_number: declared.node.startPosition.row + 1 } : {},
+      metadata: {
+        [marker]: true,
+        isOptionsApi: true,
+        ...declared.module ? { contractModule: declared.module } : {},
+        ...declared.resolved ? {} : { unresolved: true }
+      }
+    });
+    return [];
+  }
+  /** The declaration a bare identifier argument names, without a call node. */
+  macroContractNameFromNode(arg, _which) {
+    if (arg.type !== "identifier") return void 0;
+    const root = this.scriptRootOf(arg);
+    return {
+      name: arg.text,
+      node: arg,
+      module: root ? this.importModuleFor(arg.text, arg) : void 0,
+      resolved: root ? this.hasTopLevelDeclaration(arg.text, arg) : false
+    };
+  }
+  /**
+   * The identifiers a heritage option names, in the three shapes Vue accepts:
+   * a bare name (`extends: Base`), an array of them (`extends: [A, B]`), and a
+   * string name — which Vue also honours for a globally-registered component.
+   *
+   * Only names are taken. An inline OBJECT (`extends: { methods: … }`) is a
+   * merge rather than a reference, and its members are extracted by the caller;
+   * naming the literal's own keys as base classes would fabricate an inheritance
+   * to a property.
+   */
+  identifiersOf(node) {
+    const out = [];
+    if (node.type === "identifier") {
+      out.push({ name: node.text, node });
+      return out;
+    }
+    if (node.type === "string") {
+      const v = unquote(node.text);
+      if (v) out.push({ name: v, node });
+      return out;
+    }
+    if (node.type === "array") {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (!c) continue;
+        if (c.type === "identifier") out.push({ name: c.text, node: c });
+        else if (c.type === "string") {
+          const v = unquote(c.text);
+          if (v) out.push({ name: v, node: c });
+        }
+      }
+      return out;
+    }
+    return out;
+  }
+  /**
+   * F12: a same-file BINDING as the macro's argument —
+   * `defineProps(boundProps)` / `defineEmits(boundEmits)`.
+   *
+   * The name is an `identifier`; this resolves it to its `variable_declarator`
+   * in the SAME script tree and reads the literal it holds, which is the only
+   * form whose keys are published by nothing else — so component-owned symbols
+   * are safe here and match what the inline runtime form already emits. A
+   * binding that does not resolve (imported from a sibling module) returns
+   * nothing and the caller emits the contract edge instead; this walk never
+   * leaves the tree, so it costs no I/O and cannot depend on the filesystem.
+   */
+  boundMacroEntries(arg, scriptRoot, which) {
+    if (!arg) return [];
+    const nameNode = arg.type === "identifier" ? arg : this.findChildByType(arg, "identifier");
+    if (!nameNode) return [];
+    const wanted = nameNode.text;
+    const stack = [scriptRoot];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "variable_declarator") {
+        const nameField = n.childForFieldName("name");
+        const valueField = n.childForFieldName("value");
+        if (nameField?.type === "identifier" && nameField.text === wanted && valueField) {
+          return this.propEntries(peelTypeWrappers(valueField));
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    void which;
+    return [];
+  }
+  /**
+   * F12: the DECLARATION a macro names, when it is not an inline literal —
+   * `defineProps<AffixProps>()` (a `type_identifier` in `type_arguments`) or
+   * `defineProps(affixProps)` (a `binding` identifier). Returns the name plus
+   * the node that writes it, and whether the declaration is reachable in THIS
+   * tree (`resolved`) — which selects the edge's confidence, since a
+   * same-file declaration is a certainty and an imported one is the import's
+   * word for it.
+   */
+  macroContractName(callNode, arg, _which) {
+    if (arg) {
+      let inner = arg;
+      for (let i = 0; i < 8 && inner; i++) {
+        if (inner.type === "identifier") break;
+        if (inner.type === "as_expression" || inner.type === "satisfies_expression" || inner.type === "parenthesized_expression" || inner.type === "non_null_expression") {
+          const kids = inner.namedChildren;
+          inner = kids.length > 0 ? kids[0] ?? null : null;
+          continue;
+        }
+        break;
+      }
+      if (inner?.type === "identifier") {
+        const resolved = this.hasTopLevelDeclaration(inner.text, callNode);
+        return { name: inner.text, node: inner, module: this.importModuleFor(inner.text, callNode), resolved };
+      }
+    }
+    return void 0;
+  }
+  /** Is `name` declared at this tree's top level (an interface or a type alias)? */
+  hasTopLevelDeclaration(name, callNode) {
+    const root = callNode.parent ? this.scriptRootOf(callNode) : null;
+    const scope = root ?? callNode;
+    const stack = [];
+    for (let i = 0; i < scope.namedChildCount; i++) {
+      const c = scope.namedChild(i);
+      if (c) stack.push(c);
+    }
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if ((n.type === "interface_declaration" || n.type === "type_alias_declaration") && n.childForFieldName("name")?.text === name) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /** The `program` node this call sits in, by climbing parents (web-tree-sitter
+   *  hands back fresh wrappers, so identity is never compared by reference). */
+  /** The first call expression in `root` whose callee is `name` (F16). */
+  findCallNamed(root, name) {
+    const stack = [root];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "call_expression") {
+        const fn = n.childForFieldName("function");
+        if (fn?.text === name) return n;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return null;
+  }
+  /**
+   * F32 . The component name a `name:` option declares, resolved one
+   * step further than a string literal.
+   *
+   * WHY. F17  ruled that a non-literal `name:` keeps the file stem and
+   * records `declaredNameUnreadable`, because the value is "an IMPORTED IDENTIFIER,
+   * whose value lives in another module". That ruling is right about an import and
+   * wrong about the shape this corpus is full of — element-plus declares almost
+   * every component's name through a LOCAL constant:
+   *
+   *     const COMPONENT_NAME = 'ElInput'      // input.vue
+   *     defineOptions({ name: COMPONENT_NAME })
+   *
+   * Measured on the 1,162-file draw before this: 724 unresolved component-usage
+   * `instantiates` edges, of which **253 (34.9%) named a component whose own name is
+   * assigned as a string literal in the DECLARING file** — `ElInput` 59 edges,
+   * `ElSelect` 42, `ElSwitch` 33, `ElForm` 20, 25 distinct names — while the lane
+   * published the stem (`input`, `select`) and no reader could bind the tag.
+   *
+   * WHAT IT READS, and the ORDER is the contract: an IMPORTED identifier is refused
+   * FIRST (F17's case — the value really is in another module, and this lane does not
+   * do cross-file resolution), then a TOP-LEVEL `const`/`let`/`var NAME = '<literal>'`
+   * in the SAME program is read. Top-level only, for the same reason
+   * `importModuleFor` and `hasTopLevelDeclaration` are: a declarator nested inside a
+   * function body is not a binding the options object can see, so `program`'s direct
+   * children are the complete search space.
+   *
+   * A `name:` that is neither a literal nor a readable local const still returns
+   * undefined, so the caller keeps F17's stem fallback and its marker.
+   */
+  declaredNameValue(valueNode, scriptRoot) {
+    if (!valueNode) return void 0;
+    if (valueNode.type === "string") return { name: unquote(valueNode.text) };
+    if (valueNode.type !== "identifier") return void 0;
+    const name = valueNode.text;
+    if (this.importModuleFor(name, valueNode) !== void 0) return void 0;
+    for (let i = 0; i < scriptRoot.namedChildCount; i++) {
+      const stmt = scriptRoot.namedChild(i);
+      if (!stmt) continue;
+      if (stmt.type !== "lexical_declaration" && stmt.type !== "variable_declaration") continue;
+      for (let j = 0; j < stmt.namedChildCount; j++) {
+        const d = stmt.namedChild(j);
+        if (!d || d.type !== "variable_declarator") continue;
+        if (d.childForFieldName("name")?.text !== name) continue;
+        const value = d.childForFieldName("value");
+        if (value?.type === "string") return { name: unquote(value.text), constName: name };
+      }
+    }
+    return void 0;
+  }
+  /** The first object-typed argument of a call, if any (F16). */
+  firstObjectArgument(call) {
+    const args = call.childForFieldName("arguments");
+    if (!args) return null;
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const c = args.namedChild(i);
+      if (c?.type === "object") return c;
+    }
+    return null;
+  }
+  scriptRootOf(node) {
+    let cur = node.parent;
+    let last = node;
+    while (cur) {
+      if (cur.type === "program") return cur;
+      last = cur;
+      cur = cur.parent;
+    }
+    return last.parent ? null : last;
+  }
+  /** The module specifier an identifier was imported from, if any. */
+  importModuleFor(name, callNode) {
+    const root = this.scriptRootOf(callNode);
+    if (!root) return void 0;
+    const stack = [];
+    for (let i = 0; i < root.namedChildCount; i++) {
+      const c = root.namedChild(i);
+      if (c) stack.push(c);
+    }
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "import_statement") {
+        const src = this.findChildByType(n, "string");
+        const clause = n.namedChildren.find((c) => c.type === "import_clause");
+        for (const c of clause?.namedChildren ?? []) {
+          if (!c) continue;
+          if (c.type === "named_imports") {
+            for (const sp of c.namedChildren) {
+              if (!sp) continue;
+              const alias = sp.childForFieldName("alias")?.text;
+              const imp = sp.childForFieldName("name")?.text;
+              if ((alias ?? imp) === name) return src ? unquote(src.text) : void 0;
+            }
+          } else if (c.type === "identifier" && c.text === name) {
+            return src ? unquote(src.text) : void 0;
+          }
+        }
+      }
+    }
+    return void 0;
+  }
+  /**
+   * F21 . Does `name` at this call site still denote Vue's
+   * `provide`/`inject`? Ordered narrowest-first, and the ORDER is the contract:
+   * a decorator is a syntactic position, so it decides before any name lookup; a
+   * bound name is decided by its module; only an UNBOUND name reaches the local
+   * declaration test, where a top-level declaration of the same name is the
+   * shadow. A nested declaration deliberately does NOT count: it does not shadow
+   * a call in a sibling scope, and treating it as one would suppress genuine
+   * contract edges in real components — the failure mode a blanket name filter
+   * has anyway.
+   */
+  contractNameIsVueBinding(name, callNode) {
+    if (this.isInsideDecorator(callNode)) return false;
+    const module = this.importModuleFor(name, callNode);
+    if (module !== void 0) return isVueModuleSpecifier(module);
+    return !this.hasProgramBinding(name, callNode);
+  }
+  /** Is this call written inside a decorator (`@inject("db")`)? */
+  isInsideDecorator(node) {
+    let cur = node.parent;
+    while (cur) {
+      if (cur.type === "decorator") return true;
+      cur = cur.parent;
+    }
+    return false;
+  }
+  /**
+   * Is `name` declared as a VALUE binding among this program's top-level
+   * statements (`function inject`, `class inject`, `const/let/var inject`, and a
+   * destructuring declaration that binds it)? Short-circuits on the same
+   * reasoning as `importModuleFor`: only top-level statements can shadow a
+   * program-wide global, and `program`'s direct children are their whole search
+   * space.
+   */
+  hasProgramBinding(name, callNode) {
+    const root = this.scriptRootOf(callNode);
+    if (!root) return false;
+    for (let i = 0; i < root.namedChildCount; i++) {
+      const n = root.namedChild(i);
+      if (!n) continue;
+      if (n.type === "function_declaration" || n.type === "generator_function_declaration" || n.type === "class_declaration") {
+        if (n.childForFieldName("name")?.text === name) return true;
+      } else if (n.type === "lexical_declaration" || n.type === "variable_declaration") {
+        for (let j = 0; j < n.namedChildCount; j++) {
+          const d = n.namedChild(j);
+          if (d?.type !== "variable_declarator") continue;
+          const bound = d.childForFieldName("name");
+          if (!bound) continue;
+          if (bound.type === "identifier" ? bound.text === name : this.patternBindsName(bound, name)) return true;
+        }
+      }
+    }
+    return false;
+  }
+  /** Does a destructuring PATTERN bind `name`? (an object/array pattern's own
+   *  identifier leaves, including a shorthand `{ inject }`.) */
+  patternBindsName(pattern, name) {
+    const stack = [pattern];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if ((n.type === "identifier" || n.type === "shorthand_property_identifier_pattern") && n.text === name) {
+        return true;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return false;
+  }
+  propNames(node) {
+    return this.propEntries(node).map((e) => e.name);
+  }
+  /**
+   * The prop/emit names WITH the node that writes each one (#825).
+   *
+   * The string-only walk was enough while nothing asked WHERE a prop is
+   * declared, and the caller then stamped every prop with the `props: { … }`
+   * PAIR's range — one line for all of them. The oracle made that visible the
+   * moment `contains` edges carried lines: Account.vue claimed `user` at line 17
+   * (`props: {`) while `user` is written at 18 (the same for UserCard.vue:60 and
+   * TabPane.vue:70's `type`). A prop's declaration line is the line its own key
+   * is written on, which only this walk can say.
+   */
+  /**
+   * F3 (vue master review 2026-09-30): the DEFAULTS object of a
+   * `withDefaults(defineProps<T>(), { … })` call.
+   *
+   * The macro handler visits the inner `defineProps` call, so the defaults sit
+   * one frame UP the parent chain — that frame is what was never looked at, and
+   * it is the whole reason 98 corpus files lost their declared defaults. Climbs
+   * from the macro call to the nearest enclosing `withDefaults` and returns its
+   * SECOND argument, or null when there is no wrapper (the plain `defineProps`
+   * form, which legitimately has no defaults). The hop bound guards against a
+   * pathological tree; `scriptRootOf` above climbs the same way without one.
+   */
+  withDefaultsObject(macroCall) {
+    let n = macroCall.parent;
+    let hops = 0;
+    while (n && hops < 8) {
+      if (n.type === "call_expression") {
+        const fn = n.childForFieldName("function");
+        if (fn && fn.text === "withDefaults") return n.childForFieldName("arguments")?.namedChild(1) ?? null;
+      }
+      n = n.parent;
+      hops++;
+    }
+    return null;
+  }
+  /**
+   * F3: key → raw default-value TEXT of a `withDefaults` defaults object.
+   *
+   * The value is kept as WRITTEN SOURCE, not evaluated: a default may be any
+   * expression (`0`, `'hi'`, `() => []`, `defaultSize`) and this lane has no
+   * evaluator, so pretending otherwise would be a worse lie than storing the
+   * text. A BRACKET-LED computed key is skipped under the same F6 ruling — its
+   * "default" is a variable reference, not a static default.
+   */
+  defaultsEntries(objects) {
+    const out = /* @__PURE__ */ new Map();
+    if (!objects || objects.type !== "object") return out;
+    for (let i = 0; i < objects.namedChildCount; i++) {
+      const c = objects.namedChild(i);
+      if (!c || c.type !== "pair") continue;
+      const keyNode = c.childForFieldName("key");
+      const raw = keyNode?.text;
+      if (!raw || raw.startsWith("[")) continue;
+      const value = c.childForFieldName("value");
+      if (!value) continue;
+      const k = keyNode.type === "string" ? unquote(raw) : raw;
+      if (k) out.set(k, value.text);
+    }
+    return out;
+  }
+  propEntries(node) {
+    if (!node) return [];
+    const out = [];
+    if (node.type === "array") {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c && c.type === "string") {
+          const v = unquote(c.text);
+          if (v) out.push({ name: v, node: c });
+        }
+      }
+    } else if (node.type === "object") {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c && c.type === "pair") {
+          const keyNode = c.childForFieldName("key");
+          const key = keyNode?.text;
+          if (key && !key.startsWith("[")) out.push({ name: key, node: keyNode ?? c });
+        }
+      }
+    }
+    return out;
+  }
+  /**
+   * F13 (full 829-file corpus draw, 2026-09-30): the IDENTIFIER elements of a
+   * `defineProps([ … ])` / `defineEmits([ … ])` array.
+   *
+   * `propEntries` accepts string elements only, which is right for its callers —
+   * an identifier is not an event NAME and must not become a symbol (that would
+   * be the F6 phantom class again: `CHANGE_EVENT` is a declaration, and its
+   * value is the event). But dropping it was worse than either: measured, 13
+   * corpus files lost a member of their event set outright, and
+   * time-select.vue's `defineEmits([CHANGE_EVENT, 'blur', 'focus', 'clear',
+   * UPDATE_MODEL_EVENT])` published three events where the component emits five.
+   *
+   * Those constants are imported, so resolving their VALUES needs cross-file
+   * constant folding this lane does not do. The DECLARATION is nameable right
+   * here, and F12 already established the rule for exactly this situation in
+   * `defineProps(binding)`: a named declaration becomes a contract EDGE, never a
+   * copy of its members. This is a separate accessor rather than a flag on
+   * `propEntries` so that the Options-API path, which uses the same helper for
+   * `emits: [ … ]`, keeps ignoring identifiers rather than inheriting a
+   * declaration edge it never asked for.
+   */
+  propDeclarationEntries(node) {
+    if (!node || node.type !== "array") return [];
+    const out = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type === "identifier") out.push({ name: c.text, node: c });
+    }
+    return out;
+  }
+  /**
+   * V1 (#419): names from the TYPE-LITERAL generic form of the script-setup
+   * compiler macros — defineProps<{ id: string }>() and
+   * defineEmits<{ (e: 'save'): void }>() — where the public contract lives in
+   * the type_arguments node, not a runtime argument. Probe-verified against
+   * tree-sitter-typescript: props = property_identifier under object_type;
+   * emits = the first string literal of each call_signature's formal
+   * parameters.
+   */
+  genericMacroNames(callNode, which) {
+    return this.genericMacroEntries(callNode, which).map((e) => e.name);
+  }
+  /**
+   * (#825) follow-up: genericMacroNames carrying the name node, so macro
+   * symbols range at their own key lines (same contract as the runtime form).
+   */
+  /**
+   * F14 (full 829-file corpus draw, 2026-09-30): the shape of a macro's TYPE
+   * ARGUMENT, at the level of the contract, with one rule — descend through
+   * intersection / union constituents and through type wrappers, read a generic's
+   * OWN name, and STOP at an object literal.
+   *
+   * The old code had no shape at all: `findChildByType(typeArgs, "object_type")`
+   * reads DIRECT children only, so `defineProps<{ … } & Pick<X, 'a'>>()` — an
+   * intersection — matched nothing and published NO props (measured:
+   * cascader-panel/src/menu.vue, prop symbols `[]`), while a separate
+   * blind-descendant search for the first `type_identifier` reached INTO the
+   * object literal's property signatures and named a prop's TYPE as the
+   * contract. Both halves were visible only at the 829-file draw, and in
+   * opposite directions: node.vue's plain literal `defineProps<{ node: NodeShape;
+   * menuId?: string }>()` should name nothing, yet the oracle derived
+   * `NodeShape` for it — a MISSING that no sampled run had ever seen.
+   *
+   * `CascaderNode[]` inside a property signature is still inside one, so the
+   * array case that made the old pre-order rule look reasonable is covered by
+   * the same stop.
+   */
+  contractTypeShape(typeArgs) {
+    const objectTypes = [];
+    const participants = [];
+    const seenParticipants = /* @__PURE__ */ new Set();
+    const addParticipant = (n) => {
+      if (!n || !n.text) return;
+      if (seenParticipants.has(n.text)) return;
+      seenParticipants.add(n.text);
+      participants.push({ name: n.text, node: n });
+    };
+    const walk = (node, depth) => {
+      if (!node || depth > 8) return;
+      switch (node.type) {
+        case "intersection_type":
+        case "union_type":
+          for (let i = 0; i < node.namedChildCount; i++) walk(node.namedChild(i), depth + 1);
+          return;
+        case "parenthesized_type":
+        case "as_expression":
+        case "satisfies_expression":
+        case "non_null_expression": {
+          const kids = node.namedChildren;
+          walk(kids.length ? kids[0] : null, depth + 1);
+          return;
+        }
+        case "object_type":
+          objectTypes.push(node);
+          return;
+        case "generic_type": {
+          const kids = node.namedChildren;
+          const nameNode = kids.length > 0 ? kids[0] : null;
+          if (nameNode && (nameNode.type === "type_identifier" || nameNode.type === "nested_type_identifier")) {
+            addParticipant(nameNode);
+          }
+          return;
+        }
+        case "type_identifier":
+          addParticipant(node);
+          return;
+        default:
+          return;
+      }
+    };
+    if (typeArgs) for (let i = 0; i < typeArgs.namedChildCount; i++) walk(typeArgs.namedChild(i), 0);
+    return { objectTypes, participants };
+  }
+  genericMacroEntries(callNode, which) {
+    const out = [];
+    const typeArgs = this.findChildByType(callNode, "type_arguments");
+    if (!typeArgs) return out;
+    const objectTypes = this.contractTypeShape(typeArgs).objectTypes;
+    for (const objectType of objectTypes) for (let i = 0; i < objectType.namedChildCount; i++) {
+      const member = objectType.namedChild(i);
+      if (!member) continue;
+      if (which === "props") {
+        if (member.type === "property_signature") {
+          const pid = this.findChildByType(member, "property_identifier");
+          if (pid?.text) out.push({ name: pid.text, node: pid });
+        } else if (member.type === "index_signature") {
+        }
+      } else {
+        if (member.type === "call_signature") {
+          const fp = this.findChildByType(member, "formal_parameters");
+          if (!fp) continue;
+          const seen = /* @__PURE__ */ new Set();
+          for (let j = 0; j < fp.namedChildCount; j++) {
+            const p = fp.namedChild(j);
+            if (!p) continue;
+            this.collectUnionStringNodes(p, seen, out);
+          }
+        }
+      }
+    }
+    return out;
+  }
+  /** collectUnionStrings carrying the literal node (generic-emits key lines). */
+  collectUnionStringNodes(root, seen, out) {
+    const stack = [root];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "string") {
+        const v = unquote(n.text);
+        if (v && !seen.has(v)) {
+          seen.add(v);
+          out.push({ name: v, node: n });
+        }
+        continue;
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+  }
+  findDescendantType(root, type) {
+    const stack = [root];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === type) return n;
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return null;
+  }
+  /**
+   * V1b (#419): collect every string-literal event name under a parameter's
+   * type — the type_annotation may be a literal_type ('save') or a union_type
+   * ('save' | 'close'); both declare event names.
+   */
+  collectUnionStrings(root, out) {
+    const stack = [root];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "string") {
+        const v = unquote(n.text);
+        if (v) out.add(v);
+        continue;
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+  }
+  /**
+   * V2 (#419) + M1 (review wave) + D1 (deeper review): extract simple
+   * identifier tokens from a template expression's raw text ({{ count }},
+   * :label="label", @click="onSave", v-model="count", v-if="show"). The vue
+   * grammar keeps these as opaque text — no child AST — so tokenization is
+   * by character walk (no regex). Only chain ROOTS are uses: in `item.id`,
+   * `id` is a read of the loop variable, never of a same-named member —
+   * emitting it fabricated member edges (family receiver-only rule). An
+   * identifier preceded (modulo whitespace) by `.`, `?.` or `#` is skipped.
+   * String/template-literal CONTENTS are not identifiers either:
+   * `@click="go('save')"` must not read 'save' as a member. Single/double
+   * quotes skip to their closer (backslash escapes honored); backticks
+   * additionally re-enter code inside ${...} (nesting tracked).
+   *
+   * V4 (#419): identifiers bound by a template-local construct (v-for loop
+   * var, slot prop) in the current scope are skipped — they shadow any
+   * same-named member.
+   */
+  /** Counts the line breaks before `end` — how many lines into the fragment a
+   *  match sits. (#825): a template expression's identifier has a REAL line
+   *  (the line of the text fragment it is written in, plus its own offset within
+   *  that fragment when the fragment wraps), and the collector is the only place
+   *  that still knows it — a `Set<string>` throws that away, which is why vue's
+   *  template `uses` edges carried no line at all.
+   */
+  static linesBefore(text, end) {
+    let n = 0;
+    for (let i = 0; i < end && i < text.length; i++) if (text[i] === "\n") n++;
+    return n;
+  }
+  collectIdentifiers(text, out, shadowed, baseLine) {
+    const isIdentStart = (ch) => ch >= "A" && ch <= "Z" || ch >= "a" && ch <= "z" || ch === "_" || ch === "$";
+    const isIdentPart = (ch) => isIdentStart(ch) || ch >= "0" && ch <= "9";
+    const isSpace = (ch) => ch === " " || ch === "	" || ch === "\n" || ch === "\r";
+    const stack = [];
+    let braceDepth = 0;
+    const pendingTernary = /* @__PURE__ */ new Set();
+    const isKeyPosition = (start) => {
+      let k = start;
+      while (k < text.length && isIdentPart(text[k])) k++;
+      while (k < text.length && isSpace(text[k])) k++;
+      if (text[k] !== ":") return false;
+      if (text[k + 1] === ":") return false;
+      if (pendingTernary.has(braceDepth)) {
+        pendingTernary.delete(braceDepth);
+        return false;
+      }
+      return true;
+    };
+    const emit = (word, start) => {
+      let k = start - 1;
+      while (k >= 0 && isSpace(text[k])) k--;
+      const prev = k >= 0 ? text[k] : "";
+      const prev2 = k - 1 >= 0 ? text[k - 1] : "";
+      const chained = prev === "." || prev2 === "?" && prev === "." || prev === "#";
+      if (!chained && !shadowed?.has(word)) out.set(word, baseLine + _RealVueAnalyzer.linesBefore(text, start));
+    };
+    let i = 0;
+    while (i < text.length) {
+      const ch = text[i];
+      const top = stack.length > 0 ? stack[stack.length - 1] : "";
+      if (top === "'" || top === '"') {
+        if (ch === "\\") {
+          i += 2;
+          continue;
+        }
+        if (ch === top) stack.pop();
+        i++;
+        continue;
+      }
+      if (top === "`") {
+        if (ch === "\\") {
+          i += 2;
+          continue;
+        }
+        if (ch === "$" && text[i + 1] === "{") {
+          stack.push("${");
+          braceDepth++;
+          pendingTernary.delete(braceDepth);
+          i += 2;
+          continue;
+        }
+        if (ch === "`") {
+          stack.pop();
+          i++;
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (ch === "'" || ch === '"' || ch === "`") {
+        stack.push(ch);
+        i++;
+        continue;
+      }
+      if (ch === "{") {
+        stack.push(ch);
+        braceDepth++;
+        pendingTernary.delete(braceDepth);
+        i++;
+        continue;
+      }
+      if (ch === "}") {
+        if (top === "{" || top === "${") {
+          stack.pop();
+          braceDepth--;
+          pendingTernary.delete(braceDepth);
+        }
+        i++;
+        continue;
+      }
+      if (ch === "?") {
+        if (text[i + 1] !== "." && text[i + 1] !== "?") pendingTernary.add(braceDepth);
+        i++;
+        continue;
+      }
+      if (ch === ":") {
+        if (pendingTernary.has(braceDepth)) pendingTernary.delete(braceDepth);
+        i++;
+        continue;
+      }
+      if (!isIdentStart(ch)) {
+        i++;
+        continue;
+      }
+      let j = i + 1;
+      while (j < text.length && isIdentPart(text[j])) j++;
+      if (!isKeyPosition(i)) emit(text.slice(i, j), i);
+      i = j;
+    }
+  }
+  /**
+   * V4 (#419): template-local bindings declared on an element's start tag.
+   * (a) v-for="item in items" / v-for="(item, i) in items" — the loop
+   *     variable(s) are bound locally;
+   * (b) slot props #default="{ row }" / v-slot="{ row, col }" — destructured
+   *     names are bound locally.
+   */
+  collectNodeShadowBindings(startTag, shadowed) {
+    for (let i = 0; i < startTag.namedChildCount; i++) {
+      const c = startTag.namedChild(i);
+      if (!c || c.type !== "directive_attribute") continue;
+      const dname = this.findChildByType(c, "directive_name")?.text;
+      const value = this.findChildByType(c, "quoted_attribute_value");
+      const attrVal = value ? this.findChildByType(value, "attribute_value") : null;
+      if (!attrVal) continue;
+      if (dname === "v-for") {
+        this.collectVForVars(attrVal.text, shadowed);
+      } else if (dname === "#" || dname === "v-slot") {
+        this.collectIdentifierNames(attrVal.text, shadowed, attrVal.startPosition.row);
+      }
+    }
+  }
+  /**
+   * V4 (#419): the loop-variable part of v-for="item in items" (before
+   * in/of) is bound locally; only the collection part is a member use.
+   */
+  collectVForUsage(text, out, shadowed, baseLine) {
+    const m = this.parseVForDirective(text);
+    const collection = m && m.collectionStart >= 0 ? m.collection : text;
+    const start = m && m.collectionStart >= 0 ? m.collectionStart : 0;
+    this.collectIdentifiers(collection, out, shadowed, baseLine + _RealVueAnalyzer.linesBefore(text, start));
+  }
+  /**
+   * V4 (#419): the loop variables themselves (item, or item + i in the
+   * parenthesized form) are bound locally.
+   */
+  collectVForVars(text, shadowed) {
+    const m = this.parseVForDirective(text);
+    const vars = m ? m.aliases : text;
+    this.collectIdentifierNames(vars, shadowed, 0);
+  }
+  /**
+   * The `v-for` directive grammar, with NO regular expression.
+   *
+   *   v-for="item in items"        v-for="(row, col) in grid"
+   *   v-for="item of items"        v-for="(value, key) of map"
+   *
+   * This replaces `/^\s*\(?([^)]*?)\)?\s+(?:in|of)\s+(.+)$/` and its tail-less
+   * sibling, and reproduces their behaviour rather than an idealised version of
+   * it, because three of the old behaviours are load-bearing:
+   *
+   * 1. `([^)]*?)` is LAZY, so the alias head is the SHORTEST run without a `)`
+   *    for which the rest of the pattern matches. A greedy scan would make
+   *    `item in items` bind `item in items`.
+   * 2. `\)?` is optional, so the `)` belongs to the KEYWORD MATCH, not the head.
+   *    `(row, col) in grid` must bind `row` and `col` — and must stop at the
+   *    first `)`, because the head cannot contain one.
+   * 3. `(.+)$` has no `s` flag, so `.` does NOT match a newline: a collection that
+   *    spans lines fails the pattern, and the caller falls back to treating the
+   *    WHOLE directive as the collection. That fallback is preserved, including
+   *    its consequence that such a file loses its shadowing (the tail-less
+   *    sibling still matches, so `collectVForVars` is unaffected).
+   *
+   * `collectionStart` is the byte offset of the collection within `text`, which
+   * is what `collectVForUsage` needs to count the line breaks before it. It is
+   * `-1` when the tail-less form matched but the collection form did not.
+   */
+  parseVForDirective(text) {
+    const n = text.length;
+    const isWs = (ch) => ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f" || ch === "\v";
+    let i = 0;
+    while (i < n && isWs(text[i])) i++;
+    if (i < n && text[i] === "(") i++;
+    const aliasStart = i;
+    const keywordAt = (e) => {
+      let j = e;
+      if (j < n && text[j] === ")") j++;
+      const ws1 = j;
+      while (j < n && isWs(text[j])) j++;
+      if (j === ws1) return null;
+      const two = text.slice(j, j + 2);
+      if (two !== "in" && two !== "of") return null;
+      j += 2;
+      const ws2 = j;
+      while (j < n && isWs(text[j])) j++;
+      if (j === ws2) return null;
+      return { wsStart: ws2, wsEnd: j };
+    };
+    const limit = (() => {
+      const close = text.indexOf(")", aliasStart);
+      return close < 0 ? n : close;
+    })();
+    let aliases = "";
+    let collectionStart = -1;
+    for (let e = aliasStart; e <= limit; e++) {
+      const kw = keywordAt(e);
+      if (!kw) continue;
+      let chosen = -1;
+      for (let q = kw.wsEnd; q > kw.wsStart; q--) {
+        const tail = text.slice(q);
+        if (tail.length === 0) continue;
+        if (tail.includes("\n")) continue;
+        chosen = q;
+        break;
+      }
+      if (chosen < 0) continue;
+      aliases = text.slice(aliasStart, e);
+      collectionStart = chosen;
+      break;
+    }
+    if (collectionStart < 0) {
+      for (let e = aliasStart; e <= limit; e++) {
+        if (!keywordAt(e)) continue;
+        aliases = text.slice(aliasStart, e);
+        break;
+      }
+    }
+    if (aliases === "") return null;
+    return {
+      aliases,
+      collection: collectionStart >= 0 ? text.slice(collectionStart) : text,
+      collectionStart
+    };
+  }
+  /**
+   * Tokenize identifiers out of template expression TEXT and SHADOW them, using
+   * the same stack machine `collectIdentifiers` uses for member reads. The lane
+   * previously ran a regex over this input in two places while the stack machine
+   * sat one method away; both now share one tokenizer.
+   */
+  collectIdentifierNames(text, into, baseLine) {
+    const scratch = /* @__PURE__ */ new Map();
+    this.collectIdentifiers(text, scratch, void 0, baseLine);
+    for (const k of scratch.keys()) into.add(k);
+  }
+  isLifecycleHook(key) {
+    return key === "beforeCreate" || key === "created" || key === "beforeMount" || key === "mounted" || key === "beforeUpdate" || key === "updated" || key === "beforeUnmount" || key === "unmounted" || key === "activated" || key === "deactivated" || key === "errorCaptured" || key === "renderTracked" || key === "renderTriggered" || key === "beforeDestroy" || key === "destroyed" || // M3 (review wave): the Vue 3 SSR hook was missing, so
+    // serverPrefetch() methods were invisible.
+    key === "serverPrefetch";
+  }
+  // ============================================================================
+  // HELPERS
+  // ============================================================================
+  /**
+   * M14 #299 - evidence-tier classification for EVERY emitted relationship.
+   * Same rules as the JVM family. Vue template component tags are
+   * usage_contextual (component usage by tag name, not construction).
+   *
+   * THE 0.7 FLOOR IS APPLIED HERE, AND THIS IS THE ONLY LAYER THAT CAN APPLY IT
+   * (F20, re-measured 2026-10-25 on the way to closing the fixture). The contract
+   * in src/lsp/evidence_tier.ts is two rules that interact: rule 1 says a STORED
+   * legend-tier evidenceClass WINS and is "never re-derived, never re-upgraded",
+   * and rule 2 says an edge below the 0.7 floor is a guess and MUST read
+   * `inferred`. Because rule 1 short-circuits the derivation, a confident class
+   * STORED on a heuristic row is final — nobody downstream can correct it. The
+   * lane measured the consequence over 1,151 corpus files: 1,628 rows sit at
+   * confidence 0.6 (1,616 `uses` field-read/bare-read rows and 12 unresolved
+   * dynamic-import/`require` rows) and every one was stored as `usage_contextual`
+   * or `import_based`. So the floor is applied at the TOP of this pass, before
+   * the stored-class skip and before any per-label arm: a sub-floor row stores
+   * `inferred` whoever produced it (a delegate's `import_based` at 0.6 is the
+   * same claim about a row the analyzer cannot see inside), and a row at or
+   * above the floor keeps the arm's own classification. The confident template
+   * read at 0.95 stays `usage_contextual` — the fixture pins it beside the
+   * downgraded rows so a mutant that downgraded EVERYTHING would be caught.
+   */
+  classifyEvidenceTier(relationships) {
+    for (const r of relationships) {
+      const md = r.metadata ?? (r.metadata = {});
+      const conf = typeof r.confidence === "number" ? r.confidence : 1;
+      if (conf < 0.7) {
+        md.evidenceClass = "inferred";
+        continue;
+      }
+      if (md.evidenceClass) continue;
+      const t = String(r.type ?? r.relationshipType ?? "");
+      if (t === "contains" || t === "exports") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (t === "references") {
+        md.evidenceClass = md.isImport ? "import_based" : "reference_qualified";
+        continue;
+      }
+      if (t === "extends" || t === "implements" || t === "overrides") {
+        md.evidenceClass = conf >= 1 ? "structural" : conf >= 0.85 ? "usage_contextual" : "inferred";
+        continue;
+      }
+      if (t === "instantiates") {
+        md.evidenceClass = md.isComponentUsage ? "usage_contextual" : "structural";
+        continue;
+      }
+      if (t === "renders") {
+        md.evidenceClass = "usage_contextual";
+        continue;
+      }
+      md.evidenceClass = "usage_contextual";
+    }
+  }
+  findDescendantObject(root) {
+    const stack = [root];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "object") return n;
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return void 0;
+  }
+  findExportDefault(root) {
+    const stack = [root];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "export_statement" && this.isDefaultExportStatement(n)) return n;
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return null;
+  }
+  isDefaultExportStatement(n) {
+    let seenExport = false;
+    for (let i = 0; i < n.childCount; i++) {
+      const c = n.child(i);
+      if (!c || c.type === "comment" || c.type === "decorator") continue;
+      if (!seenExport) {
+        if (!c.isNamed && c.text === "export") seenExport = true;
+        else if (c.isNamed) return false;
+        continue;
+      }
+      if (!c.isNamed && c.text === "default") return true;
+      if (c.isNamed) return false;
+    }
+    return false;
+  }
+  elementTagName(element) {
+    return this.elementTagNameNode(element)?.text;
+  }
+  /**
+   * F9(b): the tag as WRITTEN, dotted segments and namespace included.
+   *
+   * `tag_name` spells only the FIRST segment: for `<Form.Input />` it is `Form`,
+   * so reading it alone is what silently dropped the sub-component. The spelling
+   * lives in the enclosing `start_tag` / `self_closing_tag` text, up to the first
+   * delimiter. Written with indexOf rather than a regex on purpose — this file's
+   * regex census is a claim the docs now publish, and adding an 7th literal to
+   * recover a string the grammar already hands us in two pieces is the wrong
+   * trade.
+   */
+  elementTagSpelling(element) {
+    const tagNode = this.elementTagNameNode(element);
+    const holder = this.findChildByType(element, "start_tag") ?? this.findChildByType(element, "self_closing_tag");
+    let text = holder?.text ?? tagNode?.text;
+    if (!text) return void 0;
+    if (text.charCodeAt(0) === 60) text = text.slice(1);
+    let end = text.length;
+    for (const delim of [" ", "	", "\n", "\r", ">", "/"]) {
+      const i = text.indexOf(delim);
+      if (i >= 0 && i < end) end = i;
+    }
+    return end > 0 ? text.slice(0, end) : void 0;
+  }
+  /** The `tag_name` node itself — the node that SPELLS the tag, for its line. */
+  elementTagNameNode(element) {
+    const tagNode = this.findChildByType(element, "start_tag") || this.findChildByType(element, "self_closing_tag");
+    if (!tagNode) return null;
+    return this.findChildByType(tagNode, "tag_name");
+  }
+  offsetRange(range, lineOffset, colOffset, indexOffset = 0) {
+    const out = { ...range };
+    out.startLine += lineOffset;
+    out.endLine += lineOffset;
+    if (range.startLine === 1) out.startColumn += colOffset;
+    if (indexOffset && out.startIndex !== void 0) out.startIndex += indexOffset;
+    if (indexOffset && out.endIndex !== void 0) out.endIndex += indexOffset;
+    return out;
+  }
+  /**
+   * H2 (review wave): full script→SFC shift — lines always, columns when on
+   * the script's first line (endColumn only when the range never leaves
+   * it). Errors, exports, and imports were pushed raw, pointing at script
+   * coordinates while symbols pointed at SFC ones.
+   */
+  shiftScriptRange(range, lineOffset, colOffset, indexOffset = 0) {
+    const out = { ...range };
+    const firstLine = out.startLine === 1;
+    out.startLine += lineOffset;
+    out.endLine += lineOffset;
+    if (firstLine && colOffset) {
+      out.startColumn += colOffset;
+      if (out.endLine === out.startLine) out.endColumn += colOffset;
+    }
+    if (indexOffset && out.startIndex !== void 0) out.startIndex += indexOffset;
+    if (indexOffset && out.endIndex !== void 0) out.endIndex += indexOffset;
+    return out;
+  }
+  /**
+   * The object literal a `provide(key, …)` publishes, unwrapping ONE call layer.
+   *
+   * `provide(k, reactive({ a, b }))` publishes `a` and `b`, but the direct
+   * argument is a call, not an object, so reading only `args[1]` as an object
+   * found nothing. `reactive` / `readonly` / `markRaw` / `computed` all take the
+   * object as their first argument, which is why one level is enough;
+   * `form.vue`'s `provide(formContextKey, reactive({ ...toRefs(props), emit,
+   * resetFields, clearValidate, validateField }))` lost every one of those keys
+   * this way. One layer only — deeper is a shape this lane should not guess at.
+   */
+  providedValueObject(value) {
+    if (!value) return null;
+    if (value.type === "object") return value;
+    if (value.type !== "call_expression") return null;
+    const args = this.findChildByType(value, "arguments");
+    if (!args) return null;
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const c = args.namedChild(i);
+      if (c && c.type === "object") return c;
+    }
+    return null;
+  }
+  findChildByType(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && child.type === type) return child;
+    }
+    return null;
+  }
+  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 {
+  RealVueAnalyzer
+};