@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/real-svelte-analyzer-NHEN2SX5.js

@@ -0,0 +1,2532 @@
+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-svelte-analyzer.ts
+import { readdirSync, readFileSync, statSync } from "fs";
+import * as path from "path";
+function shiftMetadataLineMirrors(md, lineOffset) {
+  if (!md || lineOffset === 0) return;
+  for (const [k, v] of Object.entries(md)) {
+    if (!keyCarriesALine(k)) 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 PROJECT_PUBLISHED_PACKAGES = /* @__PURE__ */ new Map();
+function projectPublishedPackages(projectRoot) {
+  const cached = PROJECT_PUBLISHED_PACKAGES.get(projectRoot);
+  if (cached) return cached;
+  const names = /* @__PURE__ */ new Set();
+  const read = (p) => {
+    try {
+      const j = JSON.parse(readFileSync(p, "utf8"));
+      if (typeof j?.name === "string" && j.name.trim() !== "") names.add(j.name.trim());
+    } catch {
+    }
+  };
+  read(path.join(projectRoot, "package.json"));
+  for (const dir of ["packages", "apps"]) {
+    let entries;
+    try {
+      entries = readdirSync(path.join(projectRoot, dir));
+    } catch {
+      continue;
+    }
+    for (const e of entries) read(path.join(projectRoot, dir, e, "package.json"));
+  }
+  PROJECT_PUBLISHED_PACKAGES.set(projectRoot, names);
+  return names;
+}
+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).
+  //
+  // Kept in LOCKSTEP with the vue lane's list: script/m14/verify-cross-language-consistency.ts
+  // extracts both sets and both against the oracle's ORACLE_HTML_TAGS, and fails if they
+  // differ, because whether a tag is markup or a component is a fact about the tag, not
+  // about the language it is written in. NO DOUBLE QUOTES OR CLOSING-BRACKET-PAREN PAIR in
+  // this comment: the parity gate slices this literal to the first such pair and treats
+  // every quoted string in the slice as a tag.
+  //
+  // Measured on THIS lane's corpora before assuming, and the number is zero: 0 of the
+  // 6,436 .svelte files on disk (svelte 4,561 + shadcn-svelte 1,878) contain a filter
+  // primitive or a `<filter>` element at all. So this lane inherits the vocabulary from
+  // the parity rule rather than from a defect anyone can see here today — the live
+  // measurement is the vue lane's, and this lane's obligation is that it USES the set,
+  // which is what svelte/svg-filter-builtin-tags pins and
+  // svelte/reemit-svg-filter-tags regresses.
+  // The defect it fixes was measured on the vue corpus (<filter>
+  // and every filter PRIMITIVE published `instantiates` edges to targets no file declares:
+  // 377 edges, 6 primitives); this lane has the same gap by construction, and the svelte
+  // fixture set carries the twin check through the parity gate rather than a second corpus
+  // measurement it has no draw for. An unknown namespace still fails toward VISIBILITY (see
+  // BUILTIN_NAMESPACES); an element the SVG spec DEFINES is markup.
+  "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 —
+  // the SPEC's vocabulary, counted separately from the measured block above.
+  "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 SVELTE_BUILTIN_TAGS = /* @__PURE__ */ new Set([
+  "slot",
+  "svelte:component",
+  "svelte:self",
+  "svelte:element",
+  "svelte:window",
+  "svelte:document",
+  "svelte:body",
+  "svelte:head",
+  "svelte:options",
+  "svelte:fragment",
+  "svelte:boundary"
+]);
+var SVELTE_MEMBER_READ_DIRECTIVES = /* @__PURE__ */ new Set(["bind", "class", "style"]);
+var SVELTE_INVOKED_DIRECTIVES = /* @__PURE__ */ new Set(["use", "transition", "in", "out", "animate"]);
+var SVELTE_DECLARING_DIRECTIVES = /* @__PURE__ */ new Set(["let"]);
+var SVELTE_RUNES = /* @__PURE__ */ new Set([
+  "$state",
+  "$state.raw",
+  "$state.snapshot",
+  "$state.eager",
+  "$derived",
+  "$derived.by",
+  "$effect",
+  "$effect.pre",
+  "$effect.tracking",
+  "$effect.root",
+  "$effect.untracked",
+  "$effect.pending",
+  "$props",
+  "$props.id",
+  "$props.is_safe",
+  "$bindable",
+  "$host",
+  "$inspect",
+  "$inspect.trace",
+  "$render",
+  "$props"
+]);
+var NON_CALLABLE_LITERALS = /* @__PURE__ */ new Set(["null", "undefined", "true", "false", "NaN", "Infinity", "this"]);
+function isIdentifier(text) {
+  if (text.length === 0) return false;
+  const first = text[0];
+  if (!(first >= "a" && first <= "z" || first >= "A" && first <= "Z" || first === "_" || first === "$")) return false;
+  for (let i = 1; i < text.length; i++) {
+    const c = text[i];
+    if (!(c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c >= "0" && c <= "9" || c === "_" || c === "$")) return false;
+  }
+  return true;
+}
+function containsWhitespace(text) {
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c === 9 || c === 10 || c === 11 || c === 12 || c === 13 || c === 32 || c === 160 || c === 5760) return true;
+    if (c >= 8192 && c <= 8202) return true;
+    if (c === 8232 || c === 8233 || c === 8239 || c === 8287 || c === 12288 || c === 65279) return true;
+  }
+  return false;
+}
+function isUriSchemeSpecifier(spec) {
+  const colon = spec.indexOf(":");
+  if (colon <= 0) return false;
+  for (let i = 0; i < colon; i++) {
+    const c = spec.charCodeAt(i);
+    const letter = c >= 65 && c <= 90 || c >= 97 && c <= 122;
+    if (i === 0) {
+      if (!letter) return false;
+      continue;
+    }
+    const digit = c >= 48 && c <= 57;
+    if (!letter && !digit && c !== 43 && c !== 46 && c !== 45) return false;
+  }
+  return true;
+}
+function isDottedIdentifierChain(text) {
+  let start = 0;
+  while (true) {
+    const dot = text.indexOf(".", start);
+    const end = dot < 0 ? text.length : dot;
+    if (!isIdentifier(text.slice(start, end))) return false;
+    if (dot < 0) return true;
+    start = dot + 1;
+  }
+}
+function splitAwaitHead(text) {
+  const isSpace = (c) => c === " " || c === "	" || c === "\n" || c === "\r";
+  let i = 0;
+  while (i < text.length) {
+    if (!isSpace(text[i])) {
+      i++;
+      continue;
+    }
+    const wsStart = i;
+    while (i < text.length && isSpace(text[i])) i++;
+    const kwStart = i;
+    let kwLen = 0;
+    if (text.startsWith("then", i)) kwLen = 4;
+    else if (text.startsWith("as", i)) kwLen = 2;
+    if (kwLen > 0 && i + kwLen < text.length && isSpace(text[i + kwLen])) {
+      let after = i + kwLen;
+      while (after < text.length && isSpace(text[after])) after++;
+      return { head: text.slice(0, wsStart), matchLength: after };
+    }
+    i = kwStart + 1;
+  }
+  return void 0;
+}
+function keyCarriesALine(key) {
+  return key.toLowerCase().indexOf("line") >= 0;
+}
+function isOnEventAttrName(name) {
+  if (name.length < 3 || name[0] !== "o" || name[1] !== "n") return false;
+  for (let i = 2; i < name.length; i++) {
+    const c = name[i];
+    if (c < "a" || c > "z") return false;
+  }
+  return true;
+}
+var RUNE_LEAF_SEGMENTS = /* @__PURE__ */ new Set([
+  "state",
+  "raw",
+  "snapshot",
+  "derived",
+  "by",
+  "effect",
+  "pre",
+  "tracking",
+  "root",
+  "untracked",
+  "props",
+  "id",
+  "is_safe",
+  "bindable",
+  "host",
+  "inspect",
+  "trace",
+  "render"
+]);
+var SVELTE_INVOKING_RUNES = /* @__PURE__ */ new Set([
+  "$effect",
+  "$effect.pre",
+  "$effect.root",
+  "$effect.untracked",
+  "$derived.by",
+  "$host"
+]);
+function isInvokingRune(calleeExpression) {
+  return SVELTE_INVOKING_RUNES.has(calleeExpression);
+}
+function isRuneCallee(calleeExpression) {
+  if (!calleeExpression.startsWith("$")) return false;
+  if (SVELTE_RUNES.has(calleeExpression)) return true;
+  const leaf = calleeExpression.split(".").pop() ?? "";
+  return RUNE_LEAF_SEGMENTS.has(leaf);
+}
+var DELEGATE_FILE_ACTOR = "(file)";
+var RealSvelteAnalyzer = class _RealSvelteAnalyzer {
+  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["Svelte 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.childCount - 1; i >= 0; i--) {
+          const child = n.child(i);
+          if (child) errStack.push(child);
+        }
+      }
+    }
+    symbols.push({
+      name: moduleName,
+      kind: ASTEngine.SymbolKind.Class,
+      range: this.nodeToRange(rootNode),
+      scope: "",
+      visibility: "public",
+      metadata: { isSvelteComponent: true, isSfc: true }
+    });
+    const seenUsages = /* @__PURE__ */ new Set();
+    let templateDecisions = 0;
+    const templateExprNames = /* @__PURE__ */ new Map();
+    const templateReadSites = /* @__PURE__ */ new Map();
+    const directiveCalls = [];
+    const seenDirectiveCalls = /* @__PURE__ */ new Set();
+    const carrierReadKeys = /* @__PURE__ */ new Set();
+    const thisTargets = /* @__PURE__ */ new Map();
+    const thisTargetSites = /* @__PURE__ */ new Map();
+    const dottedTags = /* @__PURE__ */ new Map();
+    const templateStack = [
+      { node: rootNode, scope: { shadowed: /* @__PURE__ */ new Set() } }
+    ];
+    while (templateStack.length > 0) {
+      const { node: n, scope } = templateStack.pop();
+      const t = n.type;
+      if (t === "script_element" || t === "style_element") continue;
+      const shadowed = scope.shadowed;
+      const opensScope = t === "each_statement" || t === "await_statement" || t === "if_statement" || t === "else_if_block" || t === "key_statement" || t === "snippet_statement";
+      const childScope = opensScope ? { shadowed: new Set(shadowed) } : scope;
+      const childShadowed = childScope.shadowed;
+      if (t === "snippet_statement") {
+        const nm = this.findDescendant(n, (c) => c.type === "snippet_name");
+        if (nm && !seenUsages.has("snippet:" + nm.text)) {
+          seenUsages.add("snippet:" + nm.text);
+          symbols.push({
+            name: nm.text,
+            kind: ASTEngine.SymbolKind.Method,
+            range: this.nodeToRange(n),
+            scope: moduleName,
+            ownerName: moduleName,
+            ownerKind: ASTEngine.SymbolKind.Class,
+            visibility: "public",
+            metadata: { isSnippet: true }
+          });
+          this.collectSnippetParams(n, templateExprNames, childShadowed, templateReadSites);
+        }
+      }
+      if (t === "render_tag") {
+        const text = n.text.replace("{@render", "").trim();
+        let end = 0;
+        while (end < text.length && isIdentifier(text.slice(0, end + 1))) end++;
+        let targetName = text.slice(0, end);
+        const afterLead = text.slice(end).trimStart();
+        if (targetName && (afterLead.startsWith(".") || afterLead.startsWith("?."))) {
+          const leaf = this.dottedRenderLeaf(text);
+          if (leaf) targetName = leaf;
+        }
+        const target = targetName ? { text: targetName } : void 0;
+        if (target && isIdentifier(target.text)) {
+          relationships.push({
+            source: moduleName,
+            target: target.text,
+            type: ASTEngine.RelationshipType.Calls,
+            confidence: 0.9,
+            // M59 (#825): the `{@render ...}` tag the name is written in.
+            line_number: n.startPosition.row + 1,
+            metadata: { context: "Svelte {@render} tag" }
+          });
+          const open = text.indexOf("(");
+          if (open >= 0) {
+            const args = text.slice(open + 1, text.endsWith(")") ? text.length - 1 : text.length);
+            if (args.trim()) {
+              this.collectIdentifiersFromText(
+                args,
+                templateExprNames,
+                childShadowed,
+                n.startPosition.row + 1 + _RealSvelteAnalyzer.linesBefore(text, open + 1),
+                templateReadSites
+              );
+            }
+          }
+        }
+      }
+      if (t === "if_statement" || t === "else_if_block" || t === "each_statement" || t === "await_statement" || t === "key_statement") {
+        templateDecisions++;
+      }
+      if (t === "each_statement") {
+        this.collectEachExpression(n, templateExprNames, childShadowed, templateReadSites);
+      }
+      if (t === "await_statement") {
+        this.collectAwaitExpression(n, templateExprNames, childShadowed, templateReadSites);
+      }
+      if (t === "if_statement" || t === "else_if_block" || t === "key_statement") {
+        this.collectConditionExpression(n, templateExprNames, childShadowed, templateReadSites);
+      }
+      if (t === "expression") {
+        this.collectExpressionIdentifiers(n, templateExprNames, childShadowed, templateReadSites);
+      }
+      if (t === "html_tag" || t === "const_tag" || t === "debug_tag") {
+        this.collectTagExpressionIdentifiers(n, templateExprNames, childShadowed, templateReadSites);
+        if (t === "const_tag") {
+          const body = this.expressionText(n);
+          const eq = this.topLevelEq(body);
+          if (eq >= 0) this.collectShadowNames(body.slice(0, eq), childShadowed);
+        }
+      }
+      if (t === "element" || t === "self_closing_tag") {
+        const tag = this.elementTagName(n);
+        if (tag && tag.startsWith("svelte:") && !SVELTE_BUILTIN_TAGS.has(tag)) {
+        } else if (tag && tag.includes(".") && !seenUsages.has(tag)) {
+          seenUsages.add(tag);
+          const tagNode = this.elementTagNameNode(n);
+          const nsSegment = tag.slice(0, tag.indexOf("."));
+          dottedTags.set(tag, {
+            line: tagNode ? tagNode.startPosition.row + 1 : 0,
+            templateLocal: shadowed.has(nsSegment)
+          });
+        } else if (tag && !HTML_BUILTIN_TAGS.has(tag) && !SVELTE_BUILTIN_TAGS.has(tag) && !seenUsages.has(tag)) {
+          seenUsages.add(tag);
+          const tagNode = this.elementTagNameNode(n);
+          relationships.push({
+            source: moduleName,
+            target: tag,
+            // RENDERS, NOT INSTANTIATES (2026-10-23, extended vocabulary). A component tag creates
+            // an element the HOST RENDERER mounts; the source contains no `new`, so an
+            // `instantiates` edge claimed an allocation site the file does not have (types.ts'
+            // Renders contract). `instantiates` keeps its OWN sites: the JS/TS delegate's script
+            // `new` rows, copied by the seam below — the two relations stay distinct.
+            type: ASTEngine.RelationshipType.Renders,
+            confidence: 0.95,
+            // M59 (#825): the `<Child/>` tag as written.
+            ...tagNode ? { line_number: tagNode.startPosition.row + 1 } : {},
+            metadata: { isComponentUsage: true }
+          });
+        }
+        if (tag === "svelte:component" || tag === "svelte:element") {
+          const thisTag = this.findChildByType(n, "start_tag") || this.findChildByType(n, "self_closing_tag");
+          if (thisTag) {
+            for (let i = 0; i < thisTag.namedChildCount; i++) {
+              const attr = thisTag.namedChild(i);
+              if (!attr || attr.type !== "attribute" || this.attributeName(attr) !== "this") continue;
+              const valueNode = this.findChildByType(attr, "expression");
+              if (!valueNode) continue;
+              let vt = valueNode.text.trim();
+              if (vt.startsWith("{") && vt.endsWith("}")) vt = vt.slice(1, -1).trim();
+              if (vt && isIdentifier(vt)) {
+                const siteLine = valueNode.startPosition.row + 1;
+                thisTargets.set(vt, siteLine);
+                const prior = thisTargetSites.get(vt);
+                if (prior) prior.push(siteLine);
+                else thisTargetSites.set(vt, [siteLine]);
+              }
+            }
+          }
+        }
+        const startTag2 = this.findChildByType(n, "start_tag") || this.findChildByType(n, "self_closing_tag");
+        if (startTag2) {
+          for (let i = 0; i < startTag2.namedChildCount; i++) {
+            const attr = startTag2.namedChild(i);
+            if (!attr || attr.type !== "attribute") continue;
+            const attrName = this.attributeName(attr);
+            if (!attrName || attrName.startsWith("on:")) continue;
+            if (this.findChildByType(attr, "expression")) continue;
+            if (attrName.startsWith("{") && attrName.endsWith("}")) {
+              const inner = attrName.slice(1, -1).trim();
+              const expr = inner.startsWith("...") ? inner.slice(3) : inner;
+              this.collectIdentifiersFromText(expr, templateExprNames, childShadowed, attr.startPosition.row + 1, templateReadSites);
+            }
+          }
+        }
+        for (let i = 0; startTag2 && i < startTag2.namedChildCount; i++) {
+          const attr = startTag2.namedChild(i);
+          if (!attr || attr.type !== "attribute") continue;
+          const attrName = this.attributeName(attr);
+          if (!attrName) continue;
+          const colon = attrName.indexOf(":");
+          if (colon <= 0) continue;
+          const prefix = attrName.slice(0, colon);
+          const rest = attrName.slice(colon + 1);
+          if (!rest) continue;
+          if (attrName.startsWith("on:")) continue;
+          if (SVELTE_DECLARING_DIRECTIVES.has(prefix)) continue;
+          const exprNode = this.findChildByType(attr, "expression");
+          if (SVELTE_MEMBER_READ_DIRECTIVES.has(prefix)) {
+            const text = exprNode ? this.expressionText(exprNode) : "";
+            if (!text) continue;
+            const base = exprNode ? exprNode.startPosition.row + 1 : attr.startPosition.row + 1;
+            const before = new Set(templateExprNames.keys());
+            this.collectIdentifiersFromText(text, templateExprNames, childShadowed, base, templateReadSites);
+            for (const nm of templateExprNames.keys()) if (!before.has(nm)) carrierReadKeys.add(`${nm}@${templateExprNames.get(nm)}`);
+            continue;
+          }
+          if (SVELTE_INVOKED_DIRECTIVES.has(prefix)) {
+            if (rest === moduleName) continue;
+            const leaf = rest.includes(".") ? rest.slice(rest.lastIndexOf(".") + 1) : rest;
+            if (!leaf) continue;
+            if (NON_CALLABLE_LITERALS.has(leaf)) continue;
+            seenDirectiveCalls.add(`${leaf}@${attr.startPosition.row + 1}`);
+            directiveCalls.push({
+              leaf,
+              line: attr.startPosition.row + 1,
+              context: `Svelte ${prefix} directive ${attrName}`
+            });
+          }
+        }
+        const startTag = this.findChildByType(n, "start_tag") || this.findChildByType(n, "self_closing_tag");
+        if (startTag) {
+          for (let i = 0; i < startTag.namedChildCount; i++) {
+            const attr = startTag.namedChild(i);
+            if (!attr || attr.type !== "attribute") continue;
+            const attrName = this.attributeName(attr);
+            if (!attrName) continue;
+            const isOnDirective = attrName.startsWith("on:");
+            const isOnclickAttr = !isOnDirective && isOnEventAttrName(attrName) && attrName.length > 4 && !!tag && tag[0] === tag[0].toLowerCase() && !tag.includes(".") && (!tag.includes(":") || tag.startsWith("svelte:"));
+            if (!isOnDirective && !isOnclickAttr) continue;
+            const handlerSite = this.onHandlerCall(attr);
+            const handler = handlerSite?.name;
+            if (handler && handler !== moduleName) {
+              relationships.push({
+                source: moduleName,
+                target: handler,
+                type: ASTEngine.RelationshipType.Calls,
+                confidence: 0.85,
+                ...typeof handlerSite.line === "number" ? { line_number: handlerSite.line } : {},
+                metadata: {
+                  context: isOnDirective ? `Svelte event directive ${attrName}` : `Svelte event attribute ${attrName}`
+                }
+              });
+            }
+          }
+          for (let i = 0; i < startTag.childCount; i++) {
+            const directive = startTag.child(i);
+            if (!directive || directive.type !== "ERROR") continue;
+            const kids = [];
+            for (let j = 0; j < directive.childCount; j++) {
+              const c = directive.child(j);
+              if (c) kids.push(c);
+            }
+            const attachIdx = kids.findIndex((k) => k.type === "ERROR" && k.text === "attach");
+            if (attachIdx < 0) continue;
+            const nameTok = kids[attachIdx + 1];
+            if (!nameTok || !isIdentifier(nameTok.text)) continue;
+            const afterText = (kids[attachIdx + 2]?.text ?? "}").trim();
+            if (afterText !== "}" && afterText !== "(") continue;
+            const attachHandler = nameTok.text;
+            if (attachHandler === moduleName) continue;
+            relationships.push({
+              source: moduleName,
+              target: attachHandler,
+              type: ASTEngine.RelationshipType.Calls,
+              confidence: 0.8,
+              line_number: nameTok.startPosition.row + 1,
+              metadata: { context: "Svelte attach directive" }
+            });
+          }
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const child = n.namedChild(i);
+        if (child) templateStack.push({ node: child, scope: childScope });
+      }
+    }
+    const scriptTrees = context?.sfcScriptTrees ?? [];
+    const scriptLines = context?.sfcScriptLines ?? [];
+    const scriptCols = context?.sfcScriptCols ?? [];
+    const scriptStartIdx = context?.sfcScriptStartIndex ?? [];
+    let scriptDecisions = 0;
+    for (let bi = 0; bi < scriptTrees.length; bi++) {
+      const scriptTree = scriptTrees[bi];
+      const scriptStartLine = scriptLines[bi];
+      const scriptStartColumn = scriptCols[bi];
+      const scriptBlockIndex = scriptStartIdx[bi] ?? 0;
+      if (!scriptTree || scriptStartLine === void 0) continue;
+      const scriptContent = scriptTree.rootNode?.text ?? "";
+      const lineOffset = scriptStartLine - 1;
+      const colOffset = scriptStartColumn ?? 0;
+      const isTs = context?.sfcScriptLangs?.[bi] === "ts" || context?.sfcScriptLangs?.[bi] === "tsx";
+      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"
+        });
+      }
+      this.extractSvelteDeclarations(scriptTree.rootNode, moduleName, symbols, lineOffset, colOffset, scriptBlockIndex);
+      this.extractRuneInvocations(scriptTree.rootNode, moduleName, relationships, lineOffset);
+      const isModuleBlock = this.isModuleContextBlock(rootNode, bi);
+      const runePropNames = /* @__PURE__ */ new Set();
+      this.collectPropsDestructuredNames(scriptTree.rootNode, runePropNames);
+      const runePropNamesLowered = new Set(scriptContent.length > 0 ? [...runePropNames] : []);
+      const reactiveTargetNames = /* @__PURE__ */ new Set();
+      this.collectReactiveTargetNames(scriptTree.rootNode, reactiveTargetNames);
+      for (const s of sub.symbols ?? []) {
+        if (runePropNamesLowered.has(s.name ?? "")) continue;
+        if (reactiveTargetNames.has(s.name ?? "")) continue;
+        const firstLine = s.range.startLine === 1;
+        s.range.startLine += lineOffset;
+        s.range.endLine += lineOffset;
+        if (firstLine && colOffset) {
+          s.range.startColumn += colOffset;
+          if (s.range.endLine === s.range.startLine) s.range.endColumn += colOffset;
+        }
+        if (scriptBlockIndex && s.range.startIndex !== void 0) s.range.startIndex += scriptBlockIndex;
+        if (scriptBlockIndex && s.range.endIndex !== void 0) s.range.endIndex += scriptBlockIndex;
+        shiftMetadataLineMirrors(s.metadata, lineOffset);
+        if (!isModuleBlock && this.isExported(sub.exports ?? [], s.name)) {
+          const wasVariable = s.kind === ASTEngine.SymbolKind.Variable;
+          if (wasVariable) {
+            s.kind = ASTEngine.SymbolKind.Property;
+            s.metadata = { ...s.metadata ?? {}, isSvelteProp: true };
+          }
+          s.ownerName = moduleName;
+          s.ownerKind = ASTEngine.SymbolKind.Class;
+          s.scope = moduleName;
+        }
+        symbols.push(s);
+      }
+      const moduleExportNames = new Set(
+        isModuleBlock ? (sub.exports ?? []).map((e) => e.name) : []
+      );
+      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 (SVELTE_RUNES.has(tgt)) continue;
+        if (r.type === ASTEngine.RelationshipType.Contains && isModuleBlock && moduleExportNames.has(tgt)) continue;
+        const callee = r.metadata?.calleeExpression ?? "";
+        if (isRuneCallee(callee) || r.source === "(script)" && SVELTE_RUNES.has(tgt)) 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);
+      }
+      for (const i of sub.imports ?? []) {
+        if (i.range) {
+          const firstLine = i.range.startLine === 1;
+          i.range.startLine += lineOffset;
+          i.range.endLine += lineOffset;
+          if (firstLine && colOffset) {
+            i.range.startColumn += colOffset;
+            if (i.range.endLine === i.range.startLine) i.range.endColumn += colOffset;
+          }
+          if (scriptBlockIndex && i.range.startIndex !== void 0) i.range.startIndex += scriptBlockIndex;
+          if (scriptBlockIndex && i.range.endIndex !== void 0) i.range.endIndex += scriptBlockIndex;
+        }
+        imports.push(i);
+      }
+      if (isModuleBlock) {
+        for (const e of sub.exports ?? []) {
+          const r = e.range;
+          if (r) {
+            const firstLine = r.startLine === 1;
+            r.startLine += lineOffset;
+            r.endLine += lineOffset;
+            if (firstLine && colOffset) {
+              r.startColumn += colOffset;
+              if (r.endLine === r.startLine) r.endColumn += colOffset;
+            }
+            if (scriptBlockIndex && r.startIndex !== void 0) r.startIndex += scriptBlockIndex;
+            if (scriptBlockIndex && r.endIndex !== void 0) r.endIndex += scriptBlockIndex;
+          }
+          exports.push(e);
+        }
+      }
+      for (const er of sub.errors ?? []) {
+        const r = er.range;
+        if (r) {
+          const firstLine = r.startLine === 1;
+          r.startLine += lineOffset;
+          r.endLine += lineOffset;
+          if (firstLine && typeof r.startColumn === "number") {
+            r.startColumn += colOffset;
+            r.endColumn += colOffset;
+          }
+          if (typeof r.startIndex === "number") {
+            r.startIndex += scriptBlockIndex;
+            r.endIndex += scriptBlockIndex;
+          }
+        }
+        errors.push(er);
+      }
+      scriptDecisions += Math.max(0, (sub.metadata?.cyclomaticComplexity ?? 1) - 1);
+    }
+    if (templateExprNames.size > 0) {
+      const memberNames = new Set(symbols.map((s) => s.name));
+      const seenUses = /* @__PURE__ */ new Set();
+      for (const [name, line] of templateExprNames) {
+        let resolved = name;
+        if (!memberNames.has(name) && name.startsWith("$") && !name.startsWith("$$") && memberNames.has(name.slice(1))) {
+          resolved = name.slice(1);
+        }
+        if (!memberNames.has(resolved)) continue;
+        const key = `${moduleName}:${resolved}`;
+        if (seenUses.has(key)) continue;
+        seenUses.add(key);
+        const sites = templateReadSites.get(name) ?? (resolved === name ? void 0 : templateReadSites.get(resolved));
+        relationships.push({
+          source: moduleName,
+          target: resolved,
+          type: ASTEngine.RelationshipType.Uses,
+          confidence: 0.95,
+          // M59 (#825): the line the identifier is WRITTEN on, recorded where
+          // the text was scanned. `0` can only appear if a caller passed no
+          // base line for a fragment it could not locate — the oracle counts
+          // that as a wrong line rather than a silent pass. This is the LAST site;
+          // the whole set is in `templateReadSites` below.
+          ...line > 0 ? { line_number: line } : {},
+          metadata: {
+            isTemplateExpression: true,
+            // D12: present only for a carrier-sourced read. Absent means the read came
+            // from a block construct, a store subscription or a tag expression, so a
+            // consumer can tell a two-way binding from an ordinary template read.
+            ...carrierReadKeys.has(`${resolved}@${line}`) ? { carrierDirective: true } : {},
+            // Present only when the member is read on MORE THAN ONE site, so a
+            // single-read edge carries no extra key. `templateReadSitesCollapsed`
+            // is the machine-readable statement that `line_number` above is one
+            // of several and not the only place to look.
+            ...sites && sites.length > 1 ? { templateReadSites: [...sites], templateReadSitesCollapsed: sites.length } : {}
+          }
+        });
+      }
+    }
+    if (dottedTags.size > 0) {
+      const nsBindings = /* @__PURE__ */ new Map();
+      for (const imp of imports) {
+        for (const b of this.importLocalBindings(imp)) nsBindings.set(b.name, b.module);
+      }
+      const declaredNames = new Set(symbols.map((s) => s.name));
+      for (const [tag, site] of dottedTags) {
+        const dot = tag.indexOf(".");
+        const ns = tag.slice(0, dot);
+        const module = nsBindings.get(ns);
+        if (module === void 0 && !site.templateLocal && !declaredNames.has(ns)) continue;
+        relationships.push({
+          source: moduleName,
+          target: tag,
+          // RENDERS: the dotted tag is a component render, exactly like the plain tag above.
+          type: ASTEngine.RelationshipType.Renders,
+          confidence: 0.9,
+          ...site.line > 0 ? { line_number: site.line } : {},
+          metadata: {
+            isComponentUsage: true,
+            resolution: "namespace-member",
+            // The MODULE is deliberately NOT copied onto the edge. It is already in
+            // this same result's `imports` records, keyed by `namespaceBinding`, and
+            // repeating a module specifier on every edge cost 45 bytes × 7,802 corpus
+            // edges: measured +903 KiB (+16.6%) on shadcn-svelte's serialized
+            // relationship payload before this was removed, for information the
+            // consumer already had. `namespaceBinding` is the key into it.
+            ...module !== void 0 ? { namespaceBinding: ns } : {},
+            ...module === void 0 && site.templateLocal ? { namespaceLocal: true } : {},
+            ...module === void 0 && !site.templateLocal ? { namespaceSymbol: true } : {}
+          }
+        });
+      }
+    }
+    if (thisTargets.size > 0) {
+      const memberNames = new Set(symbols.map((s) => s.name));
+      const importBindings = /* @__PURE__ */ new Set();
+      for (const imp of imports) {
+        for (const b of this.importLocalBindings(imp)) importBindings.add(b.name);
+      }
+      for (const [name, line] of thisTargets) {
+        if (memberNames.has(name) || !importBindings.has(name)) continue;
+        const sites = thisTargetSites.get(name);
+        relationships.push({
+          source: moduleName,
+          target: name,
+          // RENDERS: a `<svelte:component this={X}/>` mounts X — a component render, not a `new`.
+          type: ASTEngine.RelationshipType.Renders,
+          confidence: 0.95,
+          // M59 (#825): the `this={X}` value's line. F22: the LAST site, kept
+          // deliberately — see the site map's declaration.
+          ...line > 0 ? { line_number: line } : {},
+          metadata: {
+            isComponentUsage: true,
+            // F22: the full site set, sorted ascending so two runs agree.
+            //
+            // EMITTED FOR A SINGLE SITE TOO, and that is a PIN rather than a
+            // preference: `svelte/dynamic-target-sites` requires
+            // `dynamicTargetLines: [30]` for its one-site `Panel`, while
+            // `svelte/multi-site-read-record` requires the read map to be ABSENT
+            // (`templateReadSites: null`) for its one-site reads. The two
+            // conventions therefore DIVERGE, and the divergence is recorded here
+            // rather than smoothed over: unifying them is a payload change on one
+            // fixture or the other, not a fix, and it belongs to whichever round
+            // decides which of the two shapes a consumer should read.
+            ...sites && sites.length > 0 ? { dynamicTargetLines: [...sites].sort((a, b) => a - b) } : {}
+          }
+        });
+      }
+    }
+    for (const s of symbols) {
+      if (s.ownerName) {
+        relationships.push({
+          source: s.ownerName,
+          target: s.name,
+          type: ASTEngine.RelationshipType.Contains,
+          confidence: 1,
+          // M59 (#825): the MEMBER's declaration line (already in 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: "Svelte",
+      patterns: [{ type: "usage", detected: true, description: p }]
+    }));
+    for (const dc of directiveCalls) {
+      relationships.push({
+        source: moduleName,
+        target: dc.leaf,
+        type: ASTEngine.RelationshipType.Calls,
+        confidence: 0.85,
+        line_number: dc.line,
+        metadata: { context: dc.context }
+      });
+    }
+    const relSeen = /* @__PURE__ */ new Map();
+    const uniqueRelationships = [];
+    for (const r of relationships) {
+      const key = `${String(r.type)}|${String(r.source)}|${String(r.target)}`;
+      const prior = relSeen.get(key);
+      if (!prior) {
+        relSeen.set(key, r);
+        uniqueRelationships.push(r);
+        continue;
+      }
+      _RealSvelteAnalyzer.recordDroppedTemplateRead(prior, r);
+    }
+    relationships.length = 0;
+    relationships.push(...uniqueRelationships);
+    this.publishResolutionClaims(relationships, imports, symbols, filePath, context?.projectRoot);
+    this.classifyEvidenceTier(relationships);
+    const cyclomaticComplexity = 1 + templateDecisions + scriptDecisions;
+    return {
+      language: "svelte",
+      symbols,
+      relationships,
+      imports,
+      exports,
+      errors,
+      metadata: {
+        // Real cyclomatic complexity: script decisions + template decision
+        // blocks. Was the synthetic symbols+relationships heuristic with a
+        // hardcoded cyclomatic of 1 (fourth analyzer with this disease).
+        complexity: cyclomaticComplexity,
+        linesOfCode: content.split("\n").length,
+        cyclomaticComplexity,
+        framework: "Svelte",
+        patterns: detectedPatterns,
+        detectedFrameworks: ["Svelte"],
+        frameworkPatterns,
+        architecturalInsights: [],
+        architecturalScore,
+        hasFrameworkIntelligence: true,
+        hasTypeInference: false
+      }
+    };
+  }
+  // ============================================================================
+  // SVELTE-SPECIFIC DECLARATION EXTRACTION
+  // ============================================================================
+  /**
+   * S2 (#419): the binding names declared by a $props() destructure
+   * (`let { a, b, c = 5 } = $props()`). These are component-owned Properties
+   * emitted by extractSvelteDeclarations; the JS sub-analyzer's parallel
+   * destructured Variables are dropped to avoid double declaration.
+   */
+  collectPropsDestructuredNames(root, out) {
+    const stack = [root];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "call_expression") {
+        const callee = n.childForFieldName?.("function") ?? n.namedChild(0);
+        if (callee && (callee.text === "$props" || callee.text === "$props()")) {
+          const declarator = this.findAncestor(n, (p) => p.type === "variable_declarator");
+          if (declarator) {
+            const pattern = declarator.childForFieldName?.("name") ?? this.findChildByType(declarator, "object_pattern");
+            const names = pattern ? this.objectPatternNames(pattern) : [];
+            names.forEach((nm) => out.add(nm));
+          }
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+  }
+  objectPatternNames(pattern) {
+    return this.objectPatternPairs(pattern).map((p) => p.name);
+  }
+  /**
+   * M59 (#825) follow-up, measured on a `$props()` rename destructure: the
+   * pair VALUE binds, not the key (`let { renamed: local }` binds `local`).
+   * The old key-side naming emitted a phantom Property `renamed` AND defeated
+   * the merge dedupe (the JS delegate's correct `local` survived alongside
+   * it — one binding, two symbols). Each pair also carries its node so the
+   * symbol ranges at its own NAME line, not the whole declarator.
+   */
+  objectPatternPairs(pattern) {
+    const out = [];
+    const take = (n) => {
+      if (n.type === "identifier" || n.type === "shorthand_property_identifier" || n.type === "shorthand_property_identifier_pattern") {
+        out.push({ name: n.text, node: n });
+      } else if (n.type === "pair_pattern") {
+        const value = n.childForFieldName?.("value");
+        if (value) take(value);
+      } else if (n.type === "rest_pattern") {
+        const inner = n.namedChild(0);
+        if (inner) take(inner);
+      } else if (n.type === "assignment_pattern") {
+        const left = n.childForFieldName?.("left") ?? n.namedChild(0);
+        if (left) take(left);
+      } else if (n.type === "object_assignment_pattern") {
+        const left = n.childForFieldName?.("left") ?? n.childForFieldName?.("pattern") ?? n.namedChild(0);
+        if (left) take(left);
+      } else if (
+        // `object_assignment_pattern_deprecated` was a dead disjunct: measured
+        // 2026-10-08, the pinned svelte grammar declares no assignment-pattern
+        // type at all, and the pinned typescript/javascript grammars declare
+        // `object_assignment_pattern` and `assignment_pattern` with no deprecated
+        // spelling. A real parse of `let { a = 1, ...rest } = obj` builds
+        // `object_pattern` -> `object_assignment_pattern`, which is the shape the
+        // arm ABOVE already handles; this container branch is for the patterns
+        // whose children are all bindings.
+        n.type === "object_pattern" || n.type === "array_pattern"
+      ) {
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) take(c);
+        }
+      }
+    };
+    take(pattern);
+    return out;
+  }
+  /**
+   * S6 (#419): collect the target names of every `$:` reactive declaration
+   * (`$: doubled = expr` → `doubled`). Used at the merge to drop the JS/TS
+   * sub-analyzer's PLACE COPY of such a variable, so the component-owned
+   * reactive symbol emitted by extractSvelteDeclarations is the ONLY one —
+   * the same dedupe S2 applies to $props() bindings.
+   */
+  collectReactiveTargetNames(root, out) {
+    const stack = [root];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "labeled_statement") {
+        const label = n.namedChild(0);
+        if (label && label.text === "$") {
+          const assignment = this.findDescendant(n, (c) => c.type === "assignment_expression");
+          const left = assignment?.childForFieldName?.("left") ?? assignment?.namedChild(0);
+          if (left && left.type === "identifier") out.add(left.text);
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+  }
+  /** D7 (RULED 2026-09-27): `calls` edges for named functions passed to an
+   *  INVOKING rune. See SVELTE_INVOKING_RUNES for why the set is the invoking
+   *  half of the rune surface and not all of it.
+   *
+   *  Only a BARE IDENTIFIER argument produces an edge. An arrow function is not a
+   *  name and its body is already walked; a call argument (`$effect(doThing())`)
+   *  is a use, not a call of `doThing`; a member expression (`$effect(obj.m)`)
+   *  names a method the analyzer does not resolve here. Emitting for those would
+   *  be the fabrication class this lane already fixed twice.
+   */
+  extractRuneInvocations(root, componentName, relationships, lineOffset) {
+    const seen = /* @__PURE__ */ new Set();
+    const stack = [root];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "call_expression") {
+        const callee = n.childForFieldName?.("function") ?? n.namedChild(0);
+        const calleeText = callee?.text ?? "";
+        if (isInvokingRune(calleeText)) {
+          const argsField = n.childForFieldName?.("arguments");
+          const argList = [];
+          if (argsField) {
+            for (let i = 0; i < argsField.namedChildCount; i++) {
+              const a = argsField.namedChild(i);
+              if (a) argList.push(a);
+            }
+          }
+          const line = this.nodeToRange(n).startLine + lineOffset;
+          for (const arg of argList) {
+            if (arg.type !== "identifier") continue;
+            const name = arg.text;
+            if (name === componentName || isRuneCallee(name)) continue;
+            const key = `${calleeText}|${name}|${line}`;
+            if (seen.has(key)) continue;
+            seen.add(key);
+            relationships.push({
+              source: componentName,
+              target: name,
+              type: ASTEngine.RelationshipType.Calls,
+              confidence: 0.85,
+              line_number: line,
+              metadata: { context: `Svelte rune ${calleeText}`, runeCallee: calleeText, evidenceClass: "structural" }
+            });
+          }
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+  }
+  extractSvelteDeclarations(root, componentName, symbols, lineOffset, colOffset, indexOffset = 0) {
+    const stack = [root];
+    const reactiveTargets = /* @__PURE__ */ new Set();
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "call_expression") {
+        const callee = n.childForFieldName?.("function") ?? n.namedChild(0);
+        if (callee && (callee.text === "$props" || callee.text === "$props()")) {
+          const declarator = this.findAncestor(n, (p) => p.type === "variable_declarator");
+          if (declarator) {
+            const pattern = declarator.childForFieldName?.("name") ?? this.findChildByType(declarator, "object_pattern");
+            const pairs = pattern && pattern.type === "object_pattern" ? this.objectPatternPairs(pattern) : [];
+            for (const { name, node: nameNode } of pairs) {
+              symbols.push({
+                name,
+                kind: ASTEngine.SymbolKind.Property,
+                range: this.offsetRange(this.nodeToRange(nameNode), lineOffset, colOffset, indexOffset),
+                scope: componentName,
+                ownerName: componentName,
+                ownerKind: ASTEngine.SymbolKind.Class,
+                visibility: "public",
+                metadata: { isSvelteProp: true, fromRunes: true }
+              });
+            }
+          }
+        }
+      }
+      if (n.type === "labeled_statement") {
+        const label = n.namedChild(0);
+        if (label && label.text === "$") {
+          const assignment = this.findDescendant(n, (c) => c.type === "assignment_expression");
+          if (assignment) {
+            const left = assignment.childForFieldName?.("left") ?? assignment.namedChild(0);
+            if (left && left.type === "identifier") {
+              if (reactiveTargets.has(left.text)) continue;
+              reactiveTargets.add(left.text);
+              symbols.push({
+                name: left.text,
+                kind: ASTEngine.SymbolKind.Variable,
+                range: this.offsetRange(this.nodeToRange(assignment), lineOffset, colOffset, indexOffset),
+                scope: componentName,
+                ownerName: componentName,
+                ownerKind: ASTEngine.SymbolKind.Class,
+                visibility: "public",
+                metadata: { isReactiveDeclaration: true }
+              });
+            }
+          }
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+  }
+  /**
+   * Is the bi-th <script> block a MODULE block? Module-block exports are
+   * module-level API - they must NOT become component props.
+   *
+   * Svelte spells this two ways and BOTH are real: `context="module"` and the
+   * bare `module` attribute (the Svelte 3/4 shorthand, still what the corpus
+   * writes - `sv-addons/registry/template/src/lib/registry/ui/button/button.svelte`
+   * opens `<script lang="ts" module>`). The old predicate compared the whole
+   * start-tag TEXT for the literal `context="module"`, so every bare-`module`
+   * block was read as an INSTANCE block: its exports became component props
+   * (ownerName = the component, plus a `contains` edge) and the `exports[]`
+   * channel stayed empty. Measured on the 200-file sample: exports[] 0 rows,
+   * and the 22 `exports` edges all arrived from the JS delegate's own
+   * `export const` handling rather than from the module API they are.
+   *
+   * Both spellings are now read STRUCTURALLY, off the attribute nodes: an
+   * `attribute` whose `attribute_name` is `context` with value `module`, or one
+   * whose `attribute_name` is `module` with no value. No pattern literal, and a
+   * single-quoted `context='module'` is now found for the same reason the
+   * double-quoted one always was: by construction, not by spelling.
+   */
+  isModuleContextBlock(rootNode, index) {
+    const blocks = [];
+    const walk = (n) => {
+      if (n.type === "script_element") {
+        blocks.push(n);
+        return;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) walk(c);
+      }
+    };
+    walk(rootNode);
+    const block = blocks[index];
+    if (!block) return false;
+    const startTag = this.findChildByType(block, "start_tag");
+    if (!startTag) return false;
+    for (let i = 0; i < startTag.namedChildCount; i++) {
+      const attr = startTag.namedChild(i);
+      if (!attr || attr.type !== "attribute") continue;
+      const name = this.attributeName(attr);
+      if (name === "module") return true;
+      if (name === "context" && this.attributeValue(attr) === "module") return true;
+    }
+    return false;
+  }
+  /** The `attribute_value` text of an attribute, however it is quoted. */
+  attributeValue(attr) {
+    const value = this.findChildByType(attr, "attribute_value");
+    if (value) return value.text;
+    const quoted = this.findChildByType(attr, "quoted_attribute_value");
+    if (!quoted) return "";
+    const inner = this.findChildByType(quoted, "attribute_value");
+    return inner ? inner.text : "";
+  }
+  isExported(exportInfos, name) {
+    for (const e of exportInfos) {
+      if (e.name === name && !e.isDefault) return true;
+    }
+    return false;
+  }
+  /**
+   * ONTOLOGY-WORKSTREAM SVELTE3 — the LOCAL BINDING an `import` introduces, which
+   * is the only name Svelte's template can legitimately write.
+   *
+   * The JS/TS sub-analyzer does not write bare binding names in `items`; it writes
+   * the item AS SPELLED. Measured on real analyzer-local records:
+   *
+   *   import * as Card from "./card"      -> items ["* as Card"],  alias "Card"
+   *   import { alpha as beta } from "./b" -> items ["alpha as beta"], alias undefined
+   *   import Foo from "./foo"             -> items ["Foo"], alias undefined
+   *   import { qux } from "./qux"         -> items ["qux"], alias undefined
+   *
+   * So a consumer that adds `items` to a set of binding names holds `"* as Card"`
+   * and `"alpha as beta"` and never `Card` or `beta`. Two rules were reading that
+   * set and both were silent on the forms above; this is the one derivation they
+   * share now.
+   *
+   * Pure String operations — the `as` split is `indexOf`/`slice`, never a regex
+   * (the lane is regex-free by contract).
+   */
+  importLocalBindings(imp) {
+    const module = String(imp?.module ?? "");
+    const out = [];
+    if (imp?.isSideEffectImport === true) return out;
+    const items = Array.isArray(imp?.items) ? imp.items : [];
+    const alias = typeof imp?.alias === "string" ? String(imp.alias).trim() : "";
+    if (alias) {
+      out.push({ name: alias, isNamespace: items.some((i) => String(i).trim().startsWith("*")), module });
+      return out;
+    }
+    for (const raw of items) {
+      let item = String(raw).trim();
+      if (!item) continue;
+      const isNamespace = item.startsWith("*");
+      if (isNamespace) {
+        item = item.startsWith("* as ") ? item.slice(4).trim() : "";
+        if (!item) continue;
+      }
+      const asIdx = item.indexOf(" as ");
+      if (asIdx >= 0) item = item.slice(asIdx + 4).trim();
+      if (!item) continue;
+      out.push({ name: item, isNamespace, module });
+    }
+    return out;
+  }
+  /**
+   * IS THIS MODULE SPECIFIER A PACKAGE THE PROJECT DOES NOT PUBLISH?
+   *
+   * The NEGATIVE cases are the whole rule, and each one is a shape that would otherwise be
+   * claimed wrongly:
+   *
+   *   * `.` / `..` / `/` — a FILE, not a package. That question belongs to the file claim
+   *     (`importProjectFile`) and is answered separately below.
+   *   * `$lib`, `$app`, `$env` — a framework ALIAS into the project's own tree. In this
+   *     corpus the app root is not the project root (`shadcn-svelte/docs/src/lib`), so the
+   *     analyzer cannot even spell the file it names; calling it external would be a false
+   *     statement that the admitted file list happens to confirm, which is the laundering
+   *     shape and is refused here rather than discovered later.
+   *   * a URI scheme (`virtual:`, `http:`, `data:`) — not a package at all.
+   *   * a bare name the project PUBLISHES (`projectPublishedPackages`) — the monorepo
+   *     self-reference, measured above at 24 import records in the `svelte` checkout.
+   *
+   * A single-segment specifier IS eligible, and that is deliberately wider than the shape
+   * rule `sourcePathClaim`'s own docstring states for FILE targets (`"dependency"`,
+   * `"SubProjectB"`): a module specifier with no separator and no extension cannot name a
+   * relative file in ESM, and the thing that stops a self-reference is the published-name
+   * table rather than the shape. Measured after the change: 0 of the resulting claims was
+   * refuted by the project's own file list.
+   */
+  isExternalPackageSpecifier(spec, published) {
+    if (spec === "" || spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("$")) return false;
+    if (spec.includes("\\") || containsWhitespace(spec)) return false;
+    if (isUriSchemeSpecifier(spec)) return false;
+    const segs = spec.split("/").filter((s) => s !== "");
+    if (segs.length === 0) return false;
+    const root = spec.startsWith("@") ? segs.slice(0, 2).join("/") : segs[0];
+    if (root === "" || root === "@") return false;
+    return !published.has(root);
+  }
+  /**
+   * PUBLISH THE CLAIM THE LANE ALREADY HOLDS — the module half of an import edge, and the
+   * PROVENANCE of an imported binding.
+   *
+   * THE DEFECT IS NOT A MISSING COMPUTATION. Three of this lane's four largest unresolved
+   * shapes are edges where the answer is already computed and thrown away one line later:
+   *
+   *   imports (616 of 616 unresolved)  the edge publishes `<specifier>:<item>` and
+   *     `metadata.module` carries the specifier, but NO claim key is set — so a dependency
+   *     the project HAS (142 relative `.svelte` specifiers in this draw) and a dependency the
+   *     project CANNOT have (bare npm packages) both read "no answer". `externalClaimOf`
+   *     reads `importProjectFile` and `sourcePathClaim`; neither was ever set here.
+   *   instantiates / calls / uses / references  a target whose ROOT binding is an import
+   *     from a package the project does not publish (`TrendingUpIcon` from
+   *     `@lucide/svelte/icons/minus`, `AccordionPrimitive.Root` from `bits-ui`) names a
+   *     declaration outside the population — which is precisely what `isExternal` claims,
+   *     and what the checkout's own package names can PROVE from provenance instead of
+   *     guessing from the name.
+   *
+   * WHAT IS DELIBERATELY NOT DONE, and this is the trap refused in CODE rather than in
+   * prose: **no target is ever rebased.** `<Card.Root/>` is not rewritten to `Root` or to
+   * the module's file stem `card`; `$lib/utils.js:cn` is not rewritten to `cn`. That rewrite
+   * moves edges out of `unresolved` and into `collRes` — a tie-break the indexer measures
+   * 37,318 of 49,729 WRONG — and the names it would land on in this corpus (`Root`,
+   * `Header`, `Title`, `Trigger`, `Button`, `card`) are exactly the registry's recurring
+   * ones. A claim is not a resolution: `classifyEdge` reads an external marker or a cause
+   * ONLY where the target names nothing (`decls === 0`), so no edge here can become
+   * `resolved` and the ambiguity columns cannot move.
+   *
+   * AND THE `$lib` / RELATIVE NON-FILE HALF IS LEFT ALONE ON PURPOSE. 251 `$lib` import
+   * edges and the 214 component/read edges bound to `$lib` or relative modules name
+   * declarations that ARE in the project (the module resolves under `src/lib`; the component
+   * is `button.svelte`'s own `button` symbol). No honest claim exists for them, and the
+   * module-namespace member (`<Card.Root/>`, 419 edges — this lane's top cause) has no
+   * name-keyed identity at all. Both are ruled in `validation/m14/verification/SVELTE-FIX.md`
+   * §2 with the file-level evidence.
+   */
+  publishResolutionClaims(relationships, imports, symbols, filePath, projectRoot) {
+    if (!projectRoot) return;
+    const published = projectPublishedPackages(projectRoot);
+    const bindings = /* @__PURE__ */ new Map();
+    for (const imp of imports) {
+      for (const b of this.importLocalBindings(imp)) if (!bindings.has(b.name)) bindings.set(b.name, b.module);
+    }
+    const declaredHere = new Set(symbols.map((s) => String(s.name ?? "")));
+    for (const r of relationships) {
+      const md = r.metadata ?? (r.metadata = {});
+      const tgt = String(r.target ?? "");
+      if (String(r.type) === ASTEngine.RelationshipType.Imports) {
+        const spec2 = typeof md.module === "string" ? md.module : "";
+        if (spec2 === "") continue;
+        if (spec2.startsWith("./") || spec2.startsWith("../")) {
+          if (!spec2.endsWith(".svelte")) continue;
+          const abs = path.resolve(path.dirname(filePath), spec2);
+          let isFile = false;
+          try {
+            isFile = statSync(abs).isFile();
+          } catch {
+            isFile = false;
+          }
+          if (!isFile) continue;
+          const rel = path.relative(projectRoot, abs).split(path.sep).join("/");
+          if (rel === "" || rel.startsWith("..")) continue;
+          md.importProjectFile = rel;
+          continue;
+        }
+        if (this.isExternalPackageSpecifier(spec2, published)) md.sourcePathClaim = [spec2];
+        continue;
+      }
+      if (!isDottedIdentifierChain(tgt)) continue;
+      const root = tgt.includes(".") ? tgt.slice(0, tgt.indexOf(".")) : tgt;
+      if (declaredHere.has(root)) continue;
+      const spec = bindings.get(root);
+      if (spec === void 0) continue;
+      if (!this.isExternalPackageSpecifier(spec, published)) continue;
+      md.isExternal = true;
+    }
+  }
+  // ============================================================================
+  // S1 TEMPLATE EXPRESSION EXTRACTION
+  // ============================================================================
+  /** Extract the opaque expression text from a node (svelte_raw_text child). */
+  /** The `svelte_raw_text` node the expression body lives in — the node that
+   *  gives the expression a LINE (M59 #825). `expressionText` returns only the
+   *  string, which is exactly why every template read in this analyzer claimed
+   *  no line at all. */
+  expressionTextNode(node) {
+    const stack = [node];
+    while (stack.length > 0) {
+      const m = stack.pop();
+      if (m.type === "svelte_raw_text") return m;
+      for (let i = m.namedChildCount - 1; i >= 0; i--) {
+        const c = m.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return null;
+  }
+  expressionText(node) {
+    return this.expressionTextNode(node)?.text ?? "";
+  }
+  /** Every `svelte_raw_text` node under `root`, in document order — text AND
+   *  position from the same node, so a fragment's line cannot drift from the
+   *  fragment the name was read out of. */
+  rawTextNodes(root) {
+    const out = [];
+    const stack = [root];
+    while (stack.length > 0) {
+      const m = stack.pop();
+      if (m.type === "svelte_raw_text") out.push(m);
+      for (let i = m.namedChildCount - 1; i >= 0; i--) {
+        const c = m.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return out.sort((a, b) => a.startIndex - b.startIndex);
+  }
+  /** Line breaks before `end` — how far into a fragment a match sits. */
+  static linesBefore(text, end) {
+    let n = 0;
+    for (let i = 0; i < end && i < text.length; i++) if (text[i] === "\n") n++;
+    return n;
+  }
+  /**
+   * Shadow-binding sites only: the names are DEFINITIONS, so no line is ever
+   * claimed for them — but they MUST land in `shadowed`.
+   *
+   * Careful: the pre-#825 call sites did this by passing the shadow set as the
+   * collector's `out` (`collectIdentifiersFromText(vars, shadowed, new Set())`),
+   * which is where the bindings were registered. Now that `out` is a Map, that
+   * shape silently registers nothing — measured: `{#each rows as row}` and
+   * `{#await p then value}` stopped shadowing, so `row`/`item`/`total`/`value`/
+   * `d` all came back as template READS (two existing fixtures caught it:
+   * svelte/each-shadow-collision and svelte/await-inline-shadow). So the names
+   * are collected into a scratch Map and then transferred, preserving the
+   * original semantics exactly.
+   */
+  collectShadowNames(text, shadowed) {
+    const names = /* @__PURE__ */ new Map();
+    this.collectIdentifiersFromText(text, names, /* @__PURE__ */ new Set());
+    for (const n of names.keys()) shadowed.add(n);
+  }
+  collectIdentifiersFromText(text, out, shadowed, baseLine = 0, sites) {
+    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 = [];
+    const brackets = [];
+    const ternary = [];
+    const isObjectKey = (end) => {
+      let j = end;
+      while (j < text.length && isSpace(text[j])) j++;
+      if (text[j] !== ":") return false;
+      const top = brackets.length > 0 ? brackets[brackets.length - 1] : "";
+      if (top !== "{") return false;
+      const t = ternary.length > 0 ? ternary[ternary.length - 1] : false;
+      return !t;
+    };
+    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] : "";
+      if (prev === "." && prev2 !== ".") return;
+      if (prev2 === "?" && prev === ".") return;
+      if (prev === "#") return;
+      if (shadowed.has(word)) return;
+      if (isObjectKey(start + word.length)) return;
+      const site = baseLine + _RealSvelteAnalyzer.linesBefore(text, start);
+      out.set(word, site);
+      if (sites) {
+        const arr = sites.get(word);
+        if (arr) {
+          if (arr[arr.length - 1] !== site) arr.push(site);
+        } else sites.set(word, [site]);
+      }
+    };
+    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("${");
+          brackets.push("{");
+          ternary.push(false);
+          i += 2;
+          continue;
+        }
+        if (ch === "`") {
+          stack.pop();
+          brackets.pop();
+          ternary.pop();
+          i++;
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (ch === "'" || ch === '"' || ch === "`") {
+        stack.push(ch);
+        i++;
+        continue;
+      }
+      if (ch === "{") {
+        stack.push(ch);
+        brackets.push("{");
+        ternary.push(false);
+        i++;
+        continue;
+      }
+      if (ch === "(" || ch === "[") {
+        stack.push(ch);
+        brackets.push(ch);
+        ternary.push(false);
+        i++;
+        continue;
+      }
+      if (ch === "}") {
+        if (top === "{" || top === "${") {
+          stack.pop();
+          brackets.pop();
+          ternary.pop();
+        } else if (top === "(") {
+          stack.pop();
+          brackets.pop();
+          ternary.pop();
+        }
+        i++;
+        continue;
+      }
+      if (ch === ")") {
+        if (top === "(") {
+          stack.pop();
+          brackets.pop();
+          ternary.pop();
+        }
+        i++;
+        continue;
+      }
+      if (ch === "]") {
+        if (top === "[") {
+          stack.pop();
+          brackets.pop();
+          ternary.pop();
+        }
+        i++;
+        continue;
+      }
+      if (ch === "?") {
+        if (text[i + 1] === "?" || text[i + 1] === ".") {
+          i += 2;
+          continue;
+        }
+        if (ternary.length > 0) ternary[ternary.length - 1] = true;
+        i++;
+        continue;
+      }
+      if (ch === ":") {
+        if (ternary.length > 0) ternary[ternary.length - 1] = false;
+        i++;
+        continue;
+      }
+      if (ch === "/" && (text[i + 1] === "/" || text[i + 1] === "*")) {
+        if (text[i + 1] === "/") {
+          const nl = text.indexOf("\n", i + 2);
+          i = nl >= 0 ? nl + 1 : text.length;
+        } else {
+          const end = text.indexOf("*/", i + 2);
+          i = end >= 0 ? end + 2 : text.length;
+        }
+        continue;
+      }
+      if (!isIdentStart(ch)) {
+        i++;
+        continue;
+      }
+      let j = i + 1;
+      while (j < text.length && isIdentPart(text[j])) j++;
+      emit(text.slice(i, j), i);
+      i = j;
+    }
+  }
+  /** {#each items as item, i} — collection is a use; loop vars shadow. */
+  collectEachExpression(node, out, shadowed, sites) {
+    const start = this.findDescendant(node, (c) => c.type === "each_start");
+    if (!start) return;
+    const rawTexts = this.rawTextNodes(start);
+    const collection = rawTexts[0];
+    if (collection) this.collectIdentifiersFromText(collection.text, out, shadowed, collection.startPosition.row + 1, sites);
+    const vars = rawTexts[1];
+    const varsText = vars?.text ?? "";
+    const varsBase = (vars?.startPosition.row ?? 0) + 1;
+    const keyClause = _RealSvelteAnalyzer.patternKeySplit(varsText);
+    if (keyClause) {
+      this.collectBindingPattern(keyClause.pattern, out, shadowed, varsBase, sites);
+      this.collectIdentifiersFromText(
+        keyClause.keyText,
+        out,
+        shadowed,
+        varsBase + _RealSvelteAnalyzer.linesBefore(varsText, keyClause.keyAt),
+        sites
+      );
+    } else {
+      this.collectBindingPattern(varsText, out, shadowed, varsBase, sites);
+    }
+  }
+  /** {#await promise then value} {:catch err} — promise is a use; vars shadow. */
+  collectAwaitExpression(node, out, shadowed, sites) {
+    const start = this.findDescendant(node, (c) => c.type === "await_start");
+    const thenBlk = this.findDescendant(node, (c) => c.type === "then_start");
+    const catchBlk = this.findDescendant(node, (c) => c.type === "catch_start");
+    if (start) {
+      const rawNodes = this.rawTextNodes(start);
+      const rawTexts = rawNodes.map((r) => r.text);
+      const text = rawTexts.join(" ");
+      const firstLine = rawNodes[0] ? rawNodes[0].startPosition.row + 1 : 0;
+      const m = splitAwaitHead(text);
+      const promiseExpr = m ? m.head : text;
+      this.collectIdentifiersFromText(promiseExpr, out, shadowed, firstLine);
+      if (m) {
+        this.collectBindingPattern(
+          text.slice(m.matchLength),
+          out,
+          shadowed,
+          firstLine + _RealSvelteAnalyzer.linesBefore(text, m.matchLength),
+          sites
+        );
+      }
+    }
+    for (const blk of [thenBlk, catchBlk]) {
+      if (!blk) continue;
+      const rawNodes = this.rawTextNodes(blk);
+      this.collectBindingPattern(
+        rawNodes.map((r) => r.text).join(" "),
+        out,
+        shadowed,
+        rawNodes[0] ? rawNodes[0].startPosition.row + 1 : 0,
+        sites
+      );
+    }
+  }
+  /** D5: {#if cond} / {:else if cond} / {#key exp} — the condition is a
+   *  svelte_raw_text child of if_start/else_if_start/key_start (no
+   *  `expression` wrapper, unlike mustache bodies). Every identifier is a
+   *  member read; these heads bind nothing, so no shadow registration. */
+  collectConditionExpression(node, out, shadowed, sites) {
+    const start = this.findDescendant(node, (c) => c.type === "if_start" || c.type === "else_if_start" || c.type === "key_start");
+    if (!start) return;
+    const rawNodes = this.rawTextNodes(start);
+    const baseLine = rawNodes[0] ? rawNodes[0].startPosition.row + 1 : 0;
+    this.collectIdentifiersFromText(rawNodes.map((r) => r.text).join(" "), out, shadowed, baseLine, sites);
+  }
+  /**
+   * {#snippet row(label, count)} heads — params are template-local.
+   *
+   * F28: `{#snippet counter(c = count)}` binds `c` and READS `count`, and the
+   * grammar hands the parameter list over WITHOUT its parens or the snippet name
+   * (measured: `snippet_start` raw text is `c = count` for exactly that head), so the
+   * pattern scanner takes the fragment as-is. A parameter annotation is a type and
+   * the bare `{#snippet typed(c: number = 4)}` spelling is the fixture's shape for
+   * it: `number` is neither a read nor a binding.
+   */
+  collectSnippetParams(node, out, shadowed, sites) {
+    const start = this.findDescendant(node, (c) => c.type === "snippet_start");
+    if (!start) return;
+    const rawNodes = this.rawTextNodes(start);
+    this.collectBindingPattern(
+      rawNodes.map((r) => r.text).join(" "),
+      out,
+      shadowed,
+      rawNodes[0] ? rawNodes[0].startPosition.row + 1 : 0,
+      sites
+    );
+  }
+  /** A template expression body ({count}, label={label}, {@html raw}). */
+  collectExpressionIdentifiers(node, out, shadowed, sites) {
+    const textNode = this.expressionTextNode(node);
+    const text = textNode?.text ?? "";
+    const decl = _RealSvelteAnalyzer.declarationTagSplit(text);
+    if (decl) {
+      this.collectBindingPattern(decl.head, out, shadowed, textNode ? textNode.startPosition.row + 1 : 0, sites);
+      this.collectIdentifiersFromText(
+        decl.tail,
+        out,
+        shadowed,
+        (textNode ? textNode.startPosition.row + 1 : 0) + _RealSvelteAnalyzer.linesBefore(text, decl.eqAt + 1),
+        sites
+      );
+      return;
+    }
+    const scope = this.eventCarrierName(node.parent) ? this.withArrowParams(shadowed, text) : shadowed;
+    this.collectIdentifiersFromText(text, out, scope, textNode ? textNode.startPosition.row + 1 : 0, sites);
+  }
+  /**
+   * M60 SVELTE-D6 / F26: split a Svelte 5.36 declaration tag `{let x = …}` /
+   * `{const x = …}` into its binding head and its initialiser. Returns null for
+   * an ordinary mustache, which is the overwhelming majority. A leading
+   * `let`/`const` is REQUIRED and so is the word boundary after it: without the
+   * boundary `{letter = 5}` — an assignment to a member named `letter` — parses as
+   * a `let` tag binding `ter`, a fabricated shadow rather than a real one.
+   */
+  static declarationTagSplit(text) {
+    const ws = (i2) => {
+      while (i2 < text.length && (text[i2] === " " || text[i2] === "	" || text[i2] === "\n" || text[i2] === "\r")) i2++;
+      return i2;
+    };
+    const i = ws(0);
+    const kw = text.startsWith("let", i) ? "let" : text.startsWith("const", i) ? "const" : null;
+    if (!kw) return null;
+    const after = i + kw.length;
+    const next = text[after];
+    const boundary = next === "{" || next === "[" || next === " " || next === "	" || next === "\n" || next === "\r";
+    if (!boundary) return null;
+    const body = ws(after);
+    let depth = 0;
+    for (let j = body; j < text.length; j++) {
+      const ch = text[j];
+      if (ch === "(" || ch === "[" || ch === "{") depth++;
+      else if (ch === ")" || ch === "]" || ch === "}") depth--;
+      else if (ch === "=" && depth === 0) {
+        if (text[j + 1] === "=" || text[j - 1] === "=" || text[j - 1] === "!" || text[j - 1] === "<" || text[j - 1] === ">") continue;
+        return { head: text.slice(body, j), tail: text.slice(j + 1), eqAt: j };
+      }
+    }
+    return null;
+  }
+  /**
+   * F28 (2026-10-12): A BINDING PATTERN HAS READ POSITIONS AND BINDING POSITIONS.
+   *
+   * Every template site that writes a PATTERN — `{#each rows as …}`, `{#await p
+   * then …}`, `{:catch …}`, `{#snippet name(…)}`, `{let …}` / `{@const …}` heads —
+   * used to hand its text to the flat word collector, which did two wrong things at
+   * once:
+   *
+   *   a LOST READ     `{#snippet counter(c = count)}` binds `c` and READS `count`;
+   *   a FALSE SHADOW  `{#each xs as { a: b }}` binds `b` alone — `a` is a PROPERTY
+   *                   name, so registering it silenced a member named `a` for the
+   *                   whole block.
+   *
+   * Measured before this fix over the 6,439-file corpus (svelte 4,561 + shadcn-svelte
+   * 1,878 git-tracked .svelte files) with the grammar-derived oracle
+   * (`script/m14/tmp/svelte-uses-oracle.ts`, which re-parses each template fragment
+   * with the JAVASCRIPT grammar and so decides the split from
+   * `assignment_pattern.right` and `computed_property_name` rather than from a
+   * character walk): 35 template reads the payload does not publish, 27 of them this
+   * class, over 81 sites carrying a computed key or a default value.
+   *
+   * The split, and nothing wider than the split:
+   *   COMPUTED KEY  `{ [k]: v }`      the inside of `[ ]` is an EXPRESSION (a read)
+   *   DEFAULT VALUE `x = expr`        `expr` is an EXPRESSION (a read) and `x` binds
+   *   PROPERTY NAME `{ a: b }`        `a` is neither a read nor a binding
+   *   VALUE         `{ a: b }`        `b` binds, recursively (nested patterns too)
+   *   SHORTHAND     `{ a }`           `a` binds
+   *   REST          `...props`        `props` binds
+   *   ANNOTATION    `c: number = 4`   `number` is neither: it is a type
+   *   BOUND EARLIER `{ idx, [idx - 1]: last }`  `idx` is a template-local by the
+   *                   time the computed key reads it, so it publishes NOTHING
+   *
+   * The last rule is why the walk is ONE LEFT-TO-RIGHT PASS that mutates the shadow
+   * set as it binds: a reader that collects all reads before all bindings publishes
+   * a false edge on the first entry of every `{ name, [name …] }` pattern, and that
+   * is the one row the fixture pins as forbidden precisely because it would silently
+   * ADD edges rather than lose them.
+   *
+   * Pure-String scanning: this family's regex census is 0 and stays 0.
+   */
+  collectBindingPattern(text, out, shadowed, baseLine = 0, sites) {
+    if (!text) return;
+    const isSpace = (c) => c === " " || c === "	" || c === "\n" || c === "\r";
+    const isIdentStart = (c) => c >= "A" && c <= "Z" || c >= "a" && c <= "z" || c === "_" || c === "$";
+    const isIdentPart = (c) => isIdentStart(c) || c >= "0" && c <= "9";
+    const skipWs = (i, e2) => {
+      while (i < e2 && isSpace(text[i])) i++;
+      return i;
+    };
+    const identAt = (i) => {
+      if (i >= text.length || !isIdentStart(text[i])) return null;
+      let j = i + 1;
+      while (j < text.length && isIdentPart(text[j])) j++;
+      return { name: text.slice(i, j), end: j };
+    };
+    const read = (s2, e2) => {
+      if (s2 >= e2) return;
+      this.collectIdentifiersFromText(
+        text.slice(s2, e2),
+        out,
+        shadowed,
+        baseLine + _RealSvelteAnalyzer.linesBefore(text, s2),
+        sites
+      );
+    };
+    const bind = (name) => {
+      if (isIdentifier(name)) shadowed.add(name);
+    };
+    const atTopLevel = (i, e2, ch) => {
+      let d = 0;
+      let j = i;
+      while (j < e2) {
+        const c = text[j];
+        if (c === "'" || c === '"' || c === "`") {
+          j = _RealSvelteAnalyzer.skipQuoted(text, j);
+          continue;
+        }
+        if (c === "(" || c === "[" || c === "{") {
+          d++;
+          j++;
+          continue;
+        }
+        if (c === ")" || c === "]" || c === "}") {
+          d--;
+          j++;
+          continue;
+        }
+        if (c === ch && d === 0) {
+          const prev = j > 0 ? text[j - 1] : "";
+          const next = text[j + 1] ?? "";
+          if (ch === "=" && (next === "=" || prev === "=" || prev === "!" || prev === "<" || prev === ">")) {
+            j++;
+            continue;
+          }
+          return j;
+        }
+        j++;
+      }
+      return -1;
+    };
+    const scanValue = (s0, e2) => {
+      const s2 = skipWs(s0, e2);
+      if (s2 >= e2) return;
+      if (text.startsWith("...", s2)) {
+        const w2 = identAt(skipWs(s2 + 3, e2));
+        if (w2) bind(w2.name);
+        return;
+      }
+      const ch = text[s2];
+      if (ch === "{" || ch === "[") {
+        const close = _RealSvelteAnalyzer.matchingBracket(text, s2);
+        const end = close < 0 || close > e2 ? e2 : close;
+        if (ch === "{") scanObject(s2 + 1, end);
+        else scanArray(s2 + 1, end);
+        return;
+      }
+      const w = identAt(s2);
+      if (!w) {
+        read(s2, e2);
+        return;
+      }
+      let k = skipWs(w.end, e2);
+      if (k < e2 && text[k] === "?" && text[k + 1] === ":") k = skipWs(k + 1, e2);
+      if (k < e2 && text[k] === ":") {
+        bind(w.name);
+        const eq = atTopLevel(k + 1, e2, "=");
+        if (eq >= 0) read(eq + 1, e2);
+        return;
+      }
+      if (k < e2 && text[k] === "=") {
+        bind(w.name);
+        read(k + 1, e2);
+        return;
+      }
+      bind(w.name);
+    };
+    const scanObject = (s2, e2) => {
+      for (const [a, b] of _RealSvelteAnalyzer.splitTopLevel(text, s2, e2)) {
+        const i = skipWs(a, b);
+        if (i >= b) continue;
+        if (text.startsWith("...", i)) {
+          const w2 = identAt(skipWs(i + 3, b));
+          if (w2) bind(w2.name);
+          continue;
+        }
+        const ch = text[i];
+        if (ch === "[") {
+          const close = _RealSvelteAnalyzer.matchingBracket(text, i);
+          const end = close < 0 || close > b ? b : close;
+          read(i + 1, end);
+          const k2 = skipWs(end + 1, b);
+          if (k2 < b && text[k2] === ":") scanValue(k2 + 1, b);
+          else if (k2 < b && text[k2] === "=") read(k2 + 1, b);
+          continue;
+        }
+        if (ch === "'" || ch === '"' || ch === "`") {
+          const k2 = skipWs(_RealSvelteAnalyzer.skipQuoted(text, i), b);
+          if (k2 < b && text[k2] === ":") scanValue(k2 + 1, b);
+          continue;
+        }
+        const w = identAt(i);
+        if (!w) {
+          read(i, b);
+          continue;
+        }
+        const k = skipWs(w.end, b);
+        if (k < b && text[k] === ":") {
+          scanValue(k + 1, b);
+          continue;
+        }
+        if (k < b && text[k] === "=") {
+          bind(w.name);
+          read(k + 1, b);
+          continue;
+        }
+        bind(w.name);
+      }
+    };
+    const scanArray = (s2, e2) => {
+      for (const [a, b] of _RealSvelteAnalyzer.splitTopLevel(text, s2, e2)) scanValue(a, b);
+    };
+    let s = skipWs(0, text.length);
+    let e = text.length;
+    if (s < e && text[s] === "(") {
+      const close = _RealSvelteAnalyzer.matchingBracket(text, s);
+      if (close >= 0 && skipWs(close + 1, e) >= e) {
+        s = s + 1;
+        e = close;
+      }
+    }
+    for (const [a, b] of _RealSvelteAnalyzer.splitTopLevel(text, s, e)) scanValue(a, b);
+  }
+  /**
+   * `i` is at a quote: the index just past its closing quote (or the end of the
+   * text when it never closes). A TEMPLATE literal's `${ … }` re-enters code, so its
+   * braces are tracked — otherwise a `,` inside an interpolation would split a
+   * parameter list. Structural scanning only; the READ side is the ordinary
+   * character collector, which has its own (identical) quote machine.
+   */
+  static skipQuoted(text, i) {
+    const q = text[i];
+    let j = i + 1;
+    let depth = 0;
+    while (j < text.length) {
+      const c = text[j];
+      if (c === "\\") {
+        j += 2;
+        continue;
+      }
+      if (q === "`") {
+        if (c === "$" && text[j + 1] === "{") {
+          depth++;
+          j += 2;
+          continue;
+        }
+        if (c === "}" && depth > 0) {
+          depth--;
+          j++;
+          continue;
+        }
+      }
+      if (c === q && depth === 0) return j + 1;
+      j++;
+    }
+    return text.length;
+  }
+  /** Index of the bracket matching the opener at `open`, or -1 when unbalanced. */
+  static matchingBracket(text, open) {
+    const closerOf = (c) => c === "(" ? ")" : c === "[" ? "]" : c === "{" ? "}" : "";
+    const stack = [];
+    let i = open;
+    while (i < text.length) {
+      const ch = text[i];
+      if (ch === "'" || ch === '"' || ch === "`") {
+        i = _RealSvelteAnalyzer.skipQuoted(text, i);
+        continue;
+      }
+      const expect = closerOf(ch);
+      if (expect) {
+        stack.push(expect);
+        i++;
+        continue;
+      }
+      if (ch === ")" || ch === "]" || ch === "}") {
+        if (stack.length === 0 || stack[stack.length - 1] !== ch) return -1;
+        stack.pop();
+        if (stack.length === 0) return i;
+      }
+      i++;
+    }
+    return -1;
+  }
+  /** `[s, e)` split on TOP-LEVEL commas: quotes, brackets and `${…}` are skipped whole. */
+  static splitTopLevel(text, s, e) {
+    const segs = [];
+    let start = s;
+    let i = s;
+    while (i < e) {
+      const ch = text[i];
+      if (ch === "'" || ch === '"' || ch === "`") {
+        i = _RealSvelteAnalyzer.skipQuoted(text, i);
+        continue;
+      }
+      if (ch === "(" || ch === "[" || ch === "{") {
+        const close = _RealSvelteAnalyzer.matchingBracket(text, i);
+        i = close < 0 || close >= e ? e : close + 1;
+        continue;
+      }
+      if (ch === ",") {
+        segs.push([start, i]);
+        start = i + 1;
+        i++;
+        continue;
+      }
+      i++;
+    }
+    segs.push([start, e]);
+    return segs;
+  }
+  /**
+   * F25/F28: split a loop binding list's trailing KEY CLAUSE off its pattern —
+   * `row (keyOf(row))` gives the pattern `row ` and the key `keyOf(row)`.
+   *
+   * The grammar keeps the key INSIDE the same fragment as the bindings
+   * (`{#each rows as row}` gives `row`, `{#each rows as row (row.id)}` gives
+   * `row (row.id)`), so the two halves have to be separated by hand. The test is
+   * STRUCTURAL rather than `indexOf("(")`: the key clause is the parenthesised group
+   * that ends the list, which keeps a `(` inside a pattern's own default
+   * (`{ [k]: v = f() }`) from being mistaken for it.
+   */
+  static patternKeySplit(text) {
+    let e = text.length;
+    while (e > 0 && (text[e - 1] === " " || text[e - 1] === "	" || text[e - 1] === "\n" || text[e - 1] === "\r")) e--;
+    if (e === 0 || text[e - 1] !== ")") return null;
+    let depth = 0;
+    let openAt = -1;
+    for (let i = 0; i < e; i++) {
+      const ch = text[i];
+      if (ch === "'" || ch === '"' || ch === "`") {
+        i = _RealSvelteAnalyzer.skipQuoted(text, i) - 1;
+        continue;
+      }
+      if (ch === "(" || ch === "[" || ch === "{") {
+        if (depth === 0 && ch === "(") openAt = i;
+        depth++;
+        continue;
+      }
+      if (ch === ")" || ch === "]" || ch === "}") {
+        depth--;
+        if (depth === 0) {
+          if (i === e - 1 && openAt >= 0) {
+            return { pattern: text.slice(0, openAt), keyText: text.slice(openAt + 1, e - 1), keyAt: openAt + 1 };
+          }
+          openAt = -1;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * F29: record the TEMPLATE read a dedupe drop would otherwise lose.
+   *
+   * Called only from the graph dedupe, for a row that is being DROPPED in favour of a
+   * row already published for the same `type|source|target`. It does nothing unless
+   * the dropped row is a template read and the survivor is not one — the case the
+   * fixture measures — and it writes onto the SURVIVOR:
+   *
+   *   `isTemplateRead: true`        "this row stands for a template read too"
+   *   `templateReadSites: [ … ]`    WHICH sites, merged with any already recorded
+   *
+   * The site list is written even for a SINGLE site, unlike the read map's
+   * `templateReadSites` convention (present only when a member is read on more than
+   * one line). The two are not inconsistent, and the difference is what
+   * `line_number` means on each: on a template-read row `line_number` IS a site, so a
+   * one-element list adds nothing; here `line_number` is the SCRIPT's line, so for a
+   * single dropped site the list is the only place that site exists. The divergence
+   * is recorded in `archive/docs-pre-consolidation/analyzers-BRANCH-INVENTORY-2026-10-07.md` rather than smoothed
+   * over. Returns whether anything was recorded, so a caller could assert the empty
+   * case.
+   */
+  static recordDroppedTemplateRead(survivor, dropped) {
+    if (dropped.metadata?.isTemplateExpression !== true) return false;
+    if (survivor.metadata?.isTemplateExpression === true) return false;
+    const sites = new Set(survivor.metadata?.templateReadSites ?? []);
+    for (const s of dropped.metadata?.templateReadSites ?? []) {
+      if (typeof s === "number") sites.add(s);
+    }
+    if (typeof dropped.line_number === "number") sites.add(dropped.line_number);
+    if (sites.size === 0) return false;
+    survivor.metadata = {
+      ...survivor.metadata ?? {},
+      isTemplateRead: true,
+      templateReadSites: [...sites].sort((a, b) => a - b)
+    };
+    return true;
+  }
+  /**
+   * F23: is this attribute one of the two EVENT CARRIERS — the two spellings that
+   * make their value a function Svelte calls, and therefore the only two whose
+   * arrow parameters bind?
+   *
+   * `eventCarrierName` is deliberately narrower than "an attribute whose name
+   * starts with on": `onclick` is an event only on an INTRINSIC tag (on a
+   * component it is a prop, and the parent attribute node does not carry the tag
+   * this walk already resolved), so the caller's own `on:`/`onclick` decision is
+   * what this reads. A bare `on:click={save}` has no arrow at all and
+   * `arrowParams` returns nothing, which is correct: a bare identifier is a call
+   * target and is handled by `onHandlerCall`.
+   */
+  eventCarrierName(parent) {
+    if (!parent || parent.type !== "attribute") return null;
+    const name = this.attributeName(parent);
+    if (!name) return null;
+    if (name.startsWith("on:")) return name;
+    return isOnEventAttrName(name) && name.length > 4 ? name : null;
+  }
+  /** `shadowed` widened by the parameters written at the head of `text`. */
+  withArrowParams(shadowed, text) {
+    const params = _RealSvelteAnalyzer.arrowParams(text);
+    if (params.length === 0) return shadowed;
+    const out = new Set(shadowed);
+    for (const p of params) out.add(p);
+    return out;
+  }
+  /**
+   * F23: the bound names of an arrow function's parameters, read off the text
+   * before the FIRST top-level `=>`. Pure-String scanning, no regex — this
+   * family's regex census is 0 and stays 0.
+   *
+   * `(evt) =>` gives `evt`; `() =>` gives nothing; `async ({ data }) =>` gives
+   * `data`. Inside a DESTRUCTURING pattern an identifier immediately after a `:`
+   * is the rename KEY (`{ a: local }` binds `local`, not `a`) and one inside
+   * `[ ]` is a COMPUTED key, which is a read rather than a binding — both are
+   * skipped rather than over-shadowed, because over-shadowing silently drops a
+   * true read instead of publishing a false one.
+   */
+  static arrowParams(text) {
+    const out = [];
+    let depth = 0;
+    let arrow = -1;
+    for (let i = 0; i < text.length; i++) {
+      const c = text[i];
+      if (c === "(" || c === "[" || c === "{") depth++;
+      else if (c === ")" || c === "]" || c === "}") depth--;
+      else if (depth === 0 && c === "=" && text[i + 1] === ">") {
+        arrow = i;
+        break;
+      } else if (c === ";") break;
+    }
+    if (arrow < 0) return out;
+    let head = text.slice(0, arrow).trim();
+    if (head.startsWith("async")) head = head.slice(5).trim();
+    if (head.startsWith("(") && head.endsWith(")")) head = head.slice(1, -1);
+    else if (!isIdentifier(head)) return out;
+    const isWordChar = (ch) => ch >= "A" && ch <= "Z" || ch >= "a" && ch <= "z" || ch >= "0" && ch <= "9" || ch === "_" || ch === "$";
+    const binding = (raw) => {
+      let t = raw.trim();
+      if (!t) return;
+      if (t.startsWith("...")) t = t.slice(3).trim();
+      if (!t) return;
+      const destructured = t.indexOf("{") >= 0 || t.indexOf("[") >= 0;
+      if (!destructured) {
+        let end = t.length;
+        for (let i2 = 0; i2 < t.length; i2++) {
+          if (t[i2] === "=" || t[i2] === ":") {
+            end = i2;
+            break;
+          }
+        }
+        const w = t.slice(0, end).trim();
+        if (isIdentifier(w)) out.push(w);
+        return;
+      }
+      let bracket = 0;
+      let i = 0;
+      while (i < t.length) {
+        const c = t[i];
+        if (c === "[") {
+          bracket++;
+          i++;
+          continue;
+        }
+        if (c === "]") {
+          if (bracket > 0) bracket--;
+          i++;
+          continue;
+        }
+        if (bracket > 0 || !isWordChar(c) || c >= "0" && c <= "9") {
+          i++;
+          continue;
+        }
+        let j = i;
+        while (j < t.length && isWordChar(t[j])) j++;
+        const w = t.slice(i, j);
+        let k = i - 1;
+        while (k >= 0 && (t[k] === " " || t[k] === "	")) k--;
+        if (!(t[k] === ":")) out.push(w);
+        i = j;
+      }
+    };
+    let d = 0;
+    let token = "";
+    for (const ch of head) {
+      if (ch === "(" || ch === "[" || ch === "{") {
+        d++;
+        token += ch;
+        continue;
+      }
+      if (ch === ")" || ch === "]" || ch === "}") {
+        d--;
+        if (d < 0) break;
+        token += ch;
+        if (d === 0) binding(token);
+        token = "";
+        continue;
+      }
+      if (d === 0 && ch === ",") {
+        binding(token);
+        token = "";
+        continue;
+      }
+      token += ch;
+    }
+    binding(token);
+    return [...new Set(out)];
+  }
+  /** D4: last all-identifier segment of a dotted render target
+   *  (`ns.row(it)` -> row; `a . b . c()` -> c). Returns undefined unless
+   *  every segment is a bare identifier — the caller keeps its fallback. */
+  dottedRenderLeaf(text) {
+    let body = text.trim();
+    if (body.endsWith("}")) body = body.slice(0, -1);
+    const paren = body.indexOf("(");
+    if (paren >= 0) body = body.slice(0, paren);
+    const parts = body.split(".").map((p) => {
+      let q = p.trim();
+      if (q.endsWith("?")) q = q.slice(0, -1).trim();
+      return q;
+    });
+    if (parts.length < 2 || !parts.every((p) => isIdentifier(p))) return void 0;
+    return parts[parts.length - 1];
+  }
+  /** {@html raw} / {@const total = expr} / {@debug expr} — body is a direct
+   *  svelte_raw_text child of the tag (no `expression` wrapper). */
+  collectTagExpressionIdentifiers(node, out, shadowed, sites) {
+    const textNode = this.expressionTextNode(node);
+    const baseLine = textNode ? textNode.startPosition.row + 1 : 0;
+    let text = textNode?.text ?? "";
+    let base = baseLine;
+    if (node.type === "const_tag") {
+      const eq = this.topLevelEq(text);
+      if (eq >= 0) {
+        this.collectBindingPattern(text.slice(0, eq), out, shadowed, baseLine, sites);
+        base = baseLine + _RealSvelteAnalyzer.linesBefore(text, eq + 1);
+        text = text.slice(eq + 1);
+      }
+    }
+    this.collectIdentifiersFromText(text, out, shadowed, base, sites);
+  }
+  /** Index of the first top-level `=` (not inside () / [] / {}) in `text`.*/
+  topLevelEq(text) {
+    let depth = 0;
+    for (let i = 0; i < text.length; i++) {
+      const c = text[i];
+      if (c === "(" || c === "[" || c === "{") depth++;
+      else if (c === ")" || c === "]" || c === "}") depth--;
+      else if (c === "=" && depth === 0) return i;
+    }
+    return -1;
+  }
+  /**
+   * M59 (#825) follow-up, measured on shadcn-svelte forms: the handler's
+   * NAME and its LINE travel together. The old text-only leaf plus the
+   * expression node's line split them across lines for multiline arrow
+   * bodies. Same three rules as before (first call target, bare identifier,
+   * dotted callable leaf), each now carrying its offset into the raw text.
+   */
+  onHandlerCall(attr) {
+    const value = this.findChildByType(attr, "expression");
+    if (!value) return void 0;
+    let text = "";
+    let baseLine = 0;
+    const stack = [value];
+    while (stack.length > 0) {
+      const m = stack.pop();
+      if (m.type === "svelte_raw_text") {
+        text = m.text;
+        baseLine = m.startPosition.row + 1;
+        break;
+      }
+      for (let i = m.namedChildCount - 1; i >= 0; i--) {
+        const c = m.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    if (!text) return void 0;
+    const at = (offset) => baseLine + _RealSvelteAnalyzer.linesBefore(text, offset);
+    for (let i = 0; i < text.length; i++) {
+      const ch = text[i];
+      if (ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch === "_" || ch === "$") {
+        let end = i;
+        while (end < text.length) {
+          const c = text[end];
+          if (c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c >= "0" && c <= "9" || c === "_" || c === "$") end++;
+          else break;
+        }
+        const ident = text.slice(i, end);
+        if (end < text.length && text[end] === "(") {
+          let back = i - 1;
+          while (back >= 0 && (text[back] === " " || text[back] === "	" || text[back] === "\n")) back--;
+          if (back < 0 || text[back] !== ".") return { name: ident, line: at(i) };
+        }
+        i = end;
+      }
+    }
+    if (isIdentifier(text) && !NON_CALLABLE_LITERALS.has(text)) return { name: text, line: at(0) };
+    const parts = text.split(".");
+    if (parts.length > 1 && parts.every((p) => isIdentifier(p))) {
+      const leaf = parts[parts.length - 1];
+      if (NON_CALLABLE_LITERALS.has(leaf)) return void 0;
+      return { name: leaf, line: at(text.lastIndexOf(leaf)) };
+    }
+    return void 0;
+  }
+  /**
+   * #419-D - evidence-tier classification for EVERY emitted relationship.
+   * Same rules as the Vue/JVM family. Template RENDERS are
+   * usage_contextual (component usage by tag name); the delegate's script `new`
+   * `instantiates` rows keep their structural tier.
+   */
+  classifyEvidenceTier(relationships) {
+    for (const r of relationships) {
+      const md = r.metadata ?? (r.metadata = {});
+      if (md.evidenceClass) continue;
+      const t = String(r.type ?? r.relationshipType ?? "");
+      const conf = typeof r.confidence === "number" ? r.confidence : 1;
+      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;
+      }
+      md.evidenceClass = "usage_contextual";
+    }
+  }
+  findAncestor(node, predicate) {
+    let current = node.parent;
+    while (current) {
+      if (predicate(current)) return current;
+      current = current.parent;
+    }
+    return null;
+  }
+  findDescendant(node, predicate) {
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (!(n.startIndex === node.startIndex && n.endIndex === node.endIndex) && predicate(n)) return n;
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return null;
+  }
+  elementTagName(el) {
+    return this.elementTagNameNode(el)?.text;
+  }
+  /** The `tag_name` node itself — the node that SPELLS the tag (M59 #825: the
+   *  Instantiates edge for a component usage is about that name, so its line
+   *  must come from the tag, not from the element's opening bracket). */
+  elementTagNameNode(el) {
+    const startTag = this.findChildByType(el, "start_tag") || this.findChildByType(el, "self_closing_tag");
+    if (startTag) {
+      const tag = this.findChildByType(startTag, "tag_name");
+      if (tag) return tag;
+    }
+    return this.findChildByType(el, "tag_name");
+  }
+  attributeName(attr) {
+    const name = this.findChildByType(attr, "attribute_name");
+    return name ? name.text : "";
+  }
+  offsetRange(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;
+  }
+  findChildByType(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type === type) return c;
+    }
+    return null;
+  }
+  nodeToRange(node) {
+    return {
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1,
+      // Columns are 1-based everywhere else in the codebase (+1); this
+      // analyzer silently emitted 0-based columns.
+      startColumn: node.startPosition.column + 1,
+      endColumn: node.endPosition.column + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
+    };
+  }
+};
+export {
+  RealSvelteAnalyzer,
+  containsWhitespace,
+  isDottedIdentifierChain,
+  isUriSchemeSpecifier,
+  splitAwaitHead
+};