@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/chunk-FVVQTSIM.js

@@ -0,0 +1,3427 @@
+import {
+  treeContainsNodeType
+} from "./chunk-R2GW4F6R.js";
+import {
+  ASTEngine
+} from "./chunk-V44PGPA6.js";
+import {
+  BINDING_SEP
+} from "./chunk-KAET47ZL.js";
+
+// src/ast/real-javascript-analyzer.ts
+import * as path from "path";
+
+// src/ast/js-builtin-prototypes.ts
+var JS_BUILTIN_CHAINS = {
+  Map: ["Map", "Object"],
+  Set: ["Set", "Object"],
+  WeakMap: ["WeakMap", "Object"],
+  WeakSet: ["WeakSet", "Object"],
+  Promise: ["Promise", "Object"],
+  Array: ["Array", "Object"],
+  String: ["String", "Object"],
+  Number: ["Number", "Object"],
+  Boolean: ["Boolean", "Object"],
+  Error: ["Error", "Object"],
+  TypeError: ["TypeError", "Error", "Object"],
+  RangeError: ["RangeError", "Error", "Object"],
+  Date: ["Date", "Object"],
+  RegExp: ["RegExp", "Object"],
+  JSON: ["JSON", "Object"],
+  Reflect: ["Reflect", "Object"],
+  URL: ["URL", "Object"],
+  URLSearchParams: ["URLSearchParams", "Object"],
+  Object: ["Object"],
+  HTMLElement: ["HTMLElement", "Element", "Node", "EventTarget", "Object"],
+  Element: ["Element", "Node", "EventTarget", "Object"],
+  Node: ["Node", "EventTarget", "Object"],
+  EventTarget: ["EventTarget", "Object"]
+};
+var MEMBERS = {
+  Map: ["clear", "delete", "entries", "forEach", "get", "has", "keys", "set", "values", "size", "[Symbol.iterator]"],
+  Set: ["add", "clear", "delete", "entries", "forEach", "has", "keys", "size", "values", "[Symbol.iterator]"],
+  WeakMap: ["delete", "get", "has", "set"],
+  WeakSet: ["add", "delete", "has"],
+  Promise: ["all", "allSettled", "any", "catch", "finally", "race", "reject", "resolve", "then"],
+  Array: ["at", "concat", "copyWithin", "entries", "every", "fill", "filter", "find", "findIndex", "flat", "flatMap", "forEach", "includes", "indexOf", "join", "keys", "lastIndexOf", "length", "map", "pop", "push", "reduce", "reduceRight", "reverse", "shift", "slice", "some", "sort", "splice", "toString", "unshift", "values", "[Symbol.iterator]"],
+  String: ["at", "charAt", "charCodeAt", "codePointAt", "concat", "endsWith", "includes", "indexOf", "lastIndexOf", "length", "localeCompare", "match", "normalize", "padEnd", "padStart", "repeat", "replace", "replaceAll", "search", "slice", "split", "startsWith", "substring", "toLowerCase", "toString", "toUpperCase", "trim", "trimEnd", "trimStart"],
+  Number: ["toExponential", "toFixed", "toPrecision", "toString", "valueOf"],
+  Boolean: ["toString", "valueOf"],
+  Error: ["cause", "message", "name", "stack", "toString"],
+  Date: ["getDate", "getDay", "getFullYear", "getHours", "getMilliseconds", "getMinutes", "getMonth", "getSeconds", "getTime", "getTimezoneOffset", "getUTCDate", "getUTCDay", "getUTCFullYear", "getUTCHours", "setDate", "setFullYear", "setHours", "setMinutes", "setMonth", "setSeconds", "setTime", "toISOString", "toJSON", "toLocaleDateString", "toLocaleString", "toLocaleTimeString", "toString", "toUTCString", "valueOf"],
+  RegExp: ["exec", "flags", "global", "lastIndex", "source", "test", "toString"],
+  JSON: ["parse", "stringify"],
+  Reflect: ["apply", "construct", "defineProperty", "deleteProperty", "get", "getOwnPropertyDescriptor", "getPrototypeOf", "getOwnPropertyDescriptor", "has", "isExtensible", "ownKeys", "preventExtensions", "set", "setPrototypeOf"],
+  URL: ["hash", "href", "host", "hostname", "origin", "password", "pathname", "port", "protocol", "search", "searchParams", "toJSON", "toString", "username"],
+  URLSearchParams: ["append", "delete", "entries", "forEach", "get", "getAll", "has", "keys", "set", "size", "sort", "toString", "values", "[Symbol.iterator]"],
+  Object: ["assign", "create", "defineProperty", "entries", "freeze", "fromEntries", "getOwnPropertyDescriptor", "getOwnPropertyNames", "getPrototypeOf", "hasOwn", "hasOwnProperty", "is", "isFrozen", "isSealed", "keys", "preventExtensions", "propertyIsEnumerable", "seal", "setPrototypeOf", "toString", "valueOf"],
+  HTMLElement: ["attachShadow", "blur", "click", "closest", "focus", "getAttribute", "getBoundingClientRect", "getClientRects", "getElementsByClassName", "getElementsByTagName", "hidden", "id", "innerHTML", "innerText", "matches", "remove", "removeAttribute", "scrollIntoView", "setAttribute", "shadowRoot", "style", "tagName", "textContent", "title"],
+  Element: ["closest", "getAttribute", "getAttributeNames", "hasAttribute", "matches", "removeAttribute", "setAttribute", "tagName"],
+  Node: ["appendChild", "childNodes", "cloneNode", "contains", "insertBefore", "nodeName", "nodeType", "parentNode", "removeChild", "replaceChild", "textContent"],
+  EventTarget: ["addEventListener", "removeEventListener", "dispatchEvent"]
+};
+var MEMBER_SETS = Object.fromEntries(
+  Object.entries(MEMBERS).map(([k, v]) => [k, new Set(v)])
+);
+function isJsBuiltin(base) {
+  return Object.prototype.hasOwnProperty.call(JS_BUILTIN_CHAINS, base);
+}
+function jsBuiltinHasMember(base, member) {
+  const chain = JS_BUILTIN_CHAINS[base];
+  if (!chain) return false;
+  for (const link of chain) {
+    const set = MEMBER_SETS[link];
+    if (set && set.has(member)) return true;
+  }
+  return false;
+}
+var HOST_GLOBALS = {
+  // WHATWG HTML §7.3 — the Window interface and its members.
+  window: "WHATWG HTML \xA77.3 Window",
+  document: "WHATWG HTML \xA77.3 Window",
+  console: "WHATWG HTML \xA77.3 Window.console",
+  location: "WHATWG HTML \xA77.3 Window.location",
+  navigator: "WHATWG HTML \xA77.3 Window.navigator",
+  history: "WHATWG HTML \xA77.3 Window.history",
+  screen: "WHATWG HTML \xA77.3 Window.screen",
+  localStorage: "WHATWG HTML \xA77.3 WindowOrWorkerGlobalScope.localStorage",
+  sessionStorage: "WHATWG HTML \xA77.3 WindowOrWorkerGlobalScope.sessionStorage",
+  fetch: "WHATWG HTML \xA77.3 WindowOrWorkerGlobalScope.fetch",
+  setTimeout: "WHATWG HTML \xA77.3 WindowOrWorkerGlobalScope.setTimeout",
+  clearTimeout: "WHATWG HTML \xA77.3 WindowOrWorkerGlobalScope.clearTimeout",
+  setInterval: "WHATWG HTML \xA77.3 WindowOrWorkerGlobalScope.setInterval",
+  clearInterval: "WHATWG HTML \xA77.3 WindowOrWorkerGlobalScope.clearInterval",
+  requestAnimationFrame: "WHATWG HTML \xA77.3 Window.requestAnimationFrame",
+  cancelAnimationFrame: "WHATWG HTML \xA77.3 Window.cancelAnimationFrame",
+  alert: "WHATWG HTML \xA77.3 Window.alert",
+  confirm: "WHATWG HTML \xA77.3 Window.confirm",
+  prompt: "WHATWG HTML \xA77.3 Window.prompt",
+  atob: "WHATWG HTML \xA77.3 WindowOrWorkerGlobalScope.atob",
+  btoa: "WHATWG HTML \xA77.3 WindowOrWorkerGlobalScope.btoa",
+  queueMicrotask: "WHATWG HTML \xA77.3 WindowOrWorkerGlobalScope.queueMicrotask",
+  structuredClone: "WHATWG HTML \xA77.3 WindowOrWorkerGlobalScope.structuredClone",
+  performance: "WHATWG HTML \xA77.3 Window.performance",
+  customElements: "WHATWG HTML \xA77.3 Window.customElements",
+  // ECMA-262 §19–§26 — the global object's own properties.
+  globalThis: "ECMA-262 \xA719.1 globalThis",
+  JSON: "ECMA-262 \xA725.5 JSON",
+  Math: "ECMA-262 \xA721.3 Math",
+  Object: "ECMA-262 \xA720.1 Object",
+  Array: "ECMA-262 \xA723.1 Array",
+  String: "ECMA-262 \xA722.1 String",
+  Number: "ECMA-262 \xA721.1 Number",
+  Boolean: "ECMA-262 \xA720.3 Boolean",
+  Date: "ECMA-262 \xA721.4 Date",
+  RegExp: "ECMA-262 \xA722.2 RegExp",
+  Promise: "ECMA-262 \xA727.2 Promise",
+  Map: "ECMA-262 \xA724.1 Map",
+  Set: "ECMA-262 \xA724.2 Set",
+  WeakMap: "ECMA-262 \xA724.3 WeakMap",
+  WeakSet: "ECMA-262 \xA724.4 WeakSet",
+  Symbol: "ECMA-262 \xA720.4 Symbol",
+  Proxy: "ECMA-262 \xA728.2 Proxy",
+  Reflect: "ECMA-262 \xA728.1 Reflect",
+  Error: "ECMA-262 \xA720.5 Error",
+  TypeError: "ECMA-262 \xA720.5.6 TypeError",
+  RangeError: "ECMA-262 \xA720.5.5 RangeError",
+  parseInt: "ECMA-262 \xA719.2.5 parseInt",
+  parseFloat: "ECMA-262 \xA719.2.4 parseFloat",
+  isNaN: "ECMA-262 \xA719.2.3 isNaN",
+  isFinite: "ECMA-262 \xA719.2.2 isFinite",
+  encodeURIComponent: "ECMA-262 \xA719.2.6 encodeURIComponent",
+  decodeURIComponent: "ECMA-262 \xA719.2.7 decodeURIComponent",
+  encodeURI: "ECMA-262 \xA719.2.8 encodeURI",
+  decodeURI: "ECMA-262 \xA719.2.9 decodeURI",
+  NaN: "ECMA-262 \xA76.1.6 NaN",
+  Infinity: "ECMA-262 \xA76.1.6 Infinity",
+  undefined: "ECMA-262 \xA76.1.1 undefined"
+};
+function hostGlobalCitation(name) {
+  return HOST_GLOBALS[name] ?? null;
+}
+function memberChainClaim(receiverRoot, _member) {
+  if (!receiverRoot) return null;
+  const root = receiverRoot.trim();
+  if (!root) return null;
+  const cite = hostGlobalCitation(root);
+  return cite ? `${cite} (member of a host global; receiver root \`${root}\`)` : null;
+}
+
+// src/ast/js-runtime-globals.ts
+var RUNTIME_GLOBALS = {
+  // ── Node.js host surface ──────────────────────────────────────────────────────────────────────
+  process: "Node.js API \xA7process (https://nodejs.org/api/process.html) \u2014 a global",
+  Buffer: "Node.js API \xA7Buffer (https://nodejs.org/api/buffer.html) \u2014 a global class",
+  global: "Node.js API \xA7global (https://nodejs.org/api/globals.html#global)",
+  setImmediate: "Node.js API \xA7setImmediate (https://nodejs.org/api/timers.html#setimmediatecallback-args)",
+  clearImmediate: "Node.js API \xA7clearImmediate (https://nodejs.org/api/timers.html#clearimmediateimmediate)",
+  require: "Node.js API \xA7require (https://nodejs.org/api/modules.html#requireid) \u2014 the CommonJS wrapper local, available bare",
+  module: "Node.js API \xA7module (https://nodejs.org/api/modules.html#the-module-object) \u2014 the CommonJS wrapper local, available bare",
+  exports: "Node.js API \xA7exports (https://nodejs.org/api/modules.html#exports) \u2014 the CommonJS wrapper local, available bare",
+  __dirname: "Node.js API \xA7__dirname (https://nodejs.org/api/modules.html#__dirname)",
+  __filename: "Node.js API \xA7__filename (https://nodejs.org/api/modules.html#__filename)",
+  // ── Test-runner globals (Jest-canonical spellings; Vitest mirrors them by design) ────────────
+  describe: "Jest Globals \xA7describe (https://jestjs.io/docs/api) \u2014 also a Mocha BDD global (https://mochajs.org/) and mirrored by Vitest (https://vitest.dev/api/)",
+  context: "Mocha BDD \xA7context (https://mochajs.org/) \u2014 an alias of describe",
+  it: "Jest Globals \xA7test, of which `it` is the alias (https://jestjs.io/docs/api) \u2014 also a Mocha BDD global and mirrored by Vitest",
+  test: "Jest Globals \xA7test (https://jestjs.io/docs/api) \u2014 also a Mocha BDD global and mirrored by Vitest",
+  specify: "Mocha BDD \xA7specify (https://mochajs.org/) \u2014 an alias of it",
+  expect: "Jest API \xA7expect (https://jestjs.io/docs/expect) \u2014 mirrored by Vitest (https://vitest.dev/api/)",
+  beforeAll: "Jest Globals \xA7beforeAll (https://jestjs.io/docs/api) \u2014 mirrored by Vitest",
+  afterAll: "Jest Globals \xA7afterAll (https://jestjs.io/docs/api) \u2014 mirrored by Vitest",
+  beforeEach: "Jest Globals \xA7beforeEach (https://jestjs.io/docs/api) \u2014 also a Mocha BDD global; mirrored by Vitest",
+  afterEach: "Jest Globals \xA7afterEach (https://jestjs.io/docs/api) \u2014 also a Mocha BDD global; mirrored by Vitest",
+  before: "Mocha BDD \xA7before (https://mochajs.org/) \u2014 the TDD/BDD hook",
+  after: "Mocha BDD \xA7after (https://mochajs.org/) \u2014 the TDD/BDD hook",
+  jest: "Jest Object (https://jestjs.io/docs/jest-object) \u2014 a global",
+  vi: "Vitest API \xA7vi (https://vitest.dev/api/) \u2014 a global",
+  QUnit: "QUnit API (https://qunitjs.com/api/) \u2014 QUnit exposes its API through the QUnit global"
+};
+function runtimeGlobalCitation(name) {
+  return RUNTIME_GLOBALS[name] ?? null;
+}
+function runtimeGlobalReason(name) {
+  if (!isRuntimeGlobal(name)) return null;
+  return NODE_RUNTIME_NAMES.has(name) ? "node-runtime-global" : "test-runner-global";
+}
+var NODE_RUNTIME_NAMES = /* @__PURE__ */ new Set([
+  "process",
+  "Buffer",
+  "global",
+  "setImmediate",
+  "clearImmediate",
+  "require",
+  "module",
+  "exports",
+  "__dirname",
+  "__filename"
+]);
+function isRuntimeGlobal(name) {
+  return Object.prototype.hasOwnProperty.call(RUNTIME_GLOBALS, name);
+}
+
+// src/ast/real-javascript-analyzer.ts
+var JS_CONSOLE_BUILTINS = /* @__PURE__ */ new Set([
+  "console.log",
+  "console.warn",
+  "console.error",
+  "console.info",
+  "console.debug",
+  "console.trace",
+  "console.table",
+  "console.group",
+  "console.groupEnd",
+  "console.groupCollapsed",
+  "console.time",
+  "console.timeEnd",
+  "console.assert",
+  "console.count",
+  "console.countReset",
+  "console.dir",
+  "console.dirxml",
+  "console.clear",
+  "console.profile",
+  "console.profileEnd"
+]);
+var JS_GLOBAL_CONSTRUCTORS = /* @__PURE__ */ new Set([
+  "Promise",
+  "Date",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Symbol",
+  "Proxy",
+  "Error",
+  "TypeError",
+  "RangeError",
+  "SyntaxError",
+  "URIError",
+  "EvalError",
+  "AggregateError",
+  "RegExp",
+  "Array",
+  "Object",
+  "Function",
+  "Boolean",
+  "Number",
+  "String",
+  "BigInt",
+  "ArrayBuffer",
+  "SharedArrayBuffer",
+  "DataView",
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Uint16Array",
+  "Int32Array",
+  "Uint32Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  "WeakRef",
+  "FinalizationRegistry",
+  "AbortController",
+  "FormData",
+  "Blob",
+  "File",
+  "URL",
+  "URLSearchParams",
+  "Headers",
+  "Request",
+  "Response",
+  "Intl",
+  "Image",
+  "Worker",
+  "SharedWorker",
+  "CustomEvent",
+  "Event",
+  "MouseEvent",
+  "KeyboardEvent",
+  "ResizeObserver",
+  "MutationObserver",
+  "IntersectionObserver",
+  "PerformanceObserver",
+  "FileReader",
+  "XMLHttpRequest",
+  "WebSocket",
+  "TextEncoder",
+  "TextDecoder",
+  "DOMParser",
+  "Notification",
+  "BroadcastChannel",
+  "MessageChannel",
+  "FocusEvent",
+  "InputEvent",
+  "PointerEvent",
+  "TouchEvent",
+  "DragEvent",
+  "ErrorEvent",
+  "UIEvent",
+  "StorageEvent",
+  "PromiseRejectionEvent",
+  "HashChangeEvent",
+  "PageTransitionEvent",
+  "PopStateEvent",
+  "ProgressEvent",
+  "SpeechSynthesisEvent",
+  "AnimationEvent",
+  "TransitionEvent",
+  "ClipboardEvent",
+  "WheelEvent",
+  "CompositionEvent",
+  "BeforeUnloadEvent"
+]);
+var JS_OBJECT_LEAF_METHODS = /* @__PURE__ */ new Set([
+  "toString",
+  "valueOf",
+  "hasOwnProperty",
+  "isPrototypeOf",
+  "propertyIsEnumerable",
+  "toLocaleString",
+  "__defineGetter__",
+  "__defineSetter__"
+]);
+function unquote(text) {
+  if (text.length >= 2) {
+    const first = text[0];
+    if ((first === '"' || first === "'" || first === "`") && text[text.length - 1] === first) {
+      return text.slice(1, -1);
+    }
+  }
+  return text;
+}
+function stringContent(node) {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const c = node.namedChild(i);
+    if (c && c.type === "string_fragment") return c.text;
+  }
+  return unquote(node.text);
+}
+function stripCommentMarkers(text) {
+  if (text.startsWith("//")) return text.slice(2).trimStart();
+  if (text.startsWith("/*")) {
+    const end = text.endsWith("*/") ? text.length - 2 : text.length;
+    return text.slice(2, end).trim();
+  }
+  return text.trim();
+}
+function writtenSegment(prop, lhs) {
+  if (prop) return prop;
+  if (lhs.type === "subscript_expression") return lhs.childForFieldName("index");
+  return null;
+}
+function segmentName(node) {
+  return node.type === "string" ? stringContent(node) : node.text;
+}
+function isPlainJsIdentifier(text) {
+  if (text.length === 0) return false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    const isLetter = c >= 65 && c <= 90 || c >= 97 && c <= 122;
+    const isDigit = c >= 48 && c <= 57;
+    const isStart = isLetter || c === 95 || c === 36;
+    if (i === 0) {
+      if (!isStart) return false;
+      continue;
+    }
+    if (!isStart && !isDigit) return false;
+  }
+  return true;
+}
+function jsIdentifierPrefixEnd(text) {
+  let end = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    const isLetter = c >= 65 && c <= 90 || c >= 97 && c <= 122;
+    const isDigit = c >= 48 && c <= 57;
+    const isStart = isLetter || c === 95 || c === 36;
+    if (end === 0 ? !isStart : !(isStart || isDigit)) break;
+    end = i + 1;
+  }
+  return end;
+}
+var JS_MODULE_LOCALITY_CACHE = /* @__PURE__ */ new WeakMap();
+function jsProjectModuleLocalityOf(index) {
+  const cached = JS_MODULE_LOCALITY_CACHE.get(index);
+  if (cached) return cached;
+  const modules = index.modules ?? /* @__PURE__ */ new Set();
+  const paths = [];
+  const stems = /* @__PURE__ */ new Set();
+  const dirs = /* @__PURE__ */ new Set();
+  const allSegments = /* @__PURE__ */ new Set();
+  for (const raw of modules) {
+    const m = String(raw).split("\\").join("/");
+    if (m.length === 0) continue;
+    paths.push(m);
+    const slash = m.lastIndexOf("/");
+    const base = slash >= 0 ? m.slice(slash + 1) : m;
+    const dot = base.lastIndexOf(".");
+    if (dot > 0) {
+      const stem = base.slice(0, dot);
+      if (stem.length > 0) stems.add(stem);
+    }
+    if (slash > 0) {
+      const dir = m.slice(0, slash);
+      const d = dir.lastIndexOf("/");
+      dirs.add(d >= 0 ? dir.slice(d + 1) : dir);
+    }
+    for (const seg of m.split("/")) if (seg.length > 0) allSegments.add(seg);
+  }
+  const JS_EXTS = [".js", ".jsx", ".mjs", ".cjs", ".json"];
+  const tailNamesIndexedFile = (spec) => {
+    for (const p of paths) {
+      if (p.endsWith(`/${spec}`) || p === spec) return true;
+      for (const ext of JS_EXTS) {
+        if (p.endsWith(`/${spec}${ext}`)) return true;
+      }
+    }
+    return false;
+  };
+  const stripQueryAndHash = (text) => {
+    for (let i = 0; i < text.length; i++) {
+      const ch = text[i];
+      if (ch === "?" || ch === "#") return text.slice(0, i);
+    }
+    return text;
+  };
+  const predicate = (spec) => {
+    const clean = stripQueryAndHash(spec.trim());
+    if (clean.length === 0) return "unknown";
+    const segments = clean.split("/");
+    const root = segments[0];
+    const rootOf = root.startsWith("@") && segments.length >= 2 ? `${root}/${segments[1]}` : root;
+    const rootOfOwn = root.startsWith("@") ? root : rootOf;
+    if (stems.has(rootOf) || dirs.has(rootOf) || dirs.has(rootOfOwn) || stems.has(rootOfOwn) || allSegments.has(rootOf) || allSegments.has(rootOfOwn)) return "project-local";
+    if (segments.length > 1 && tailNamesIndexedFile(clean)) return "project-local";
+    return "third-party";
+  };
+  JS_MODULE_LOCALITY_CACHE.set(index, predicate);
+  return predicate;
+}
+var NAME_NODE_TYPES = /* @__PURE__ */ new Set(["identifier", "property_identifier", "private_property_identifier"]);
+function isNameNode(node) {
+  return !!node && NAME_NODE_TYPES.has(String(node.type ?? ""));
+}
+function hasBraceEquals(text) {
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === "{" || ch === "}" || ch === ";" || ch === "=") return true;
+  }
+  return false;
+}
+function jsDecoratorName(decorator) {
+  const inner = decorator.namedChild(0);
+  const nameText = inner && (inner.type === "call_expression" || inner.type === "member_expression" || inner.type === "identifier") ? inner.type === "call_expression" ? inner.childForFieldName("function")?.text ?? inner.text.split("(")[0] : inner.text.split("(")[0] : decorator.text;
+  return stripLeadingAt(nameText) || stripLeadingAt(decorator.text);
+}
+function stripLeadingAt(text) {
+  return text.startsWith("@") ? text.slice(1) : text;
+}
+function stripWhitespace(text) {
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch !== " " && ch !== "	" && ch !== "\n" && ch !== "\r") out += ch;
+  }
+  return out;
+}
+function isNodeInDeadSpans(spans, n) {
+  if (spans.length === 0) return false;
+  let p = n;
+  while (p) {
+    for (const d of spans) {
+      if (d.s <= p.startIndex && p.endIndex <= d.e) return true;
+    }
+    p = p.parent;
+  }
+  return false;
+}
+function scopeOwnerName(scopes) {
+  for (let i = scopes.length - 1; i >= 0; i--) {
+    if (scopes[i].kind === "class" /* Class */) return scopes[i].name;
+  }
+  return void 0;
+}
+function bindingNameAbove(value) {
+  let q = value.parent;
+  while (q) {
+    if (q.type === "variable_declarator") {
+      const nm = q.childForFieldName("name");
+      return nm && nm.type === "identifier" ? nm.text : void 0;
+    }
+    if (q.type === "assignment_expression") {
+      const l = q.childForFieldName("left");
+      return l && l.type === "identifier" ? l.text : void 0;
+    }
+    if (q.type === "pair" || q.type === "object" || q.type === "return_statement" || q.type === "expression_statement" || q.type === "export_statement") {
+      q = q.parent;
+      continue;
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function containerOwnerName(n) {
+  let p = n.parent;
+  while (p) {
+    if (p.type === "class_declaration") return p.childForFieldName("name")?.text;
+    if (p.type === "class") {
+      return bindingNameAbove(p);
+    }
+    if (p.type === "object") {
+      return bindingNameAbove(p);
+    }
+    if (p.type === "function_declaration" || p.type === "function_expression" || p.type === "arrow_function" || p.type === "generator_function_declaration" || p.type === "method_definition" || p.type === "function") return void 0;
+    p = p.parent;
+  }
+  return void 0;
+}
+function isExternalSpecifier(specifier) {
+  if (specifier.length === 0) return false;
+  if (specifier.startsWith(".") || specifier.startsWith("/")) return false;
+  const low = specifier.toLowerCase();
+  if (low.startsWith("workspace:") || low.startsWith("file:") || low.startsWith("link:")) return false;
+  if (specifier.length >= 3) {
+    const c0 = specifier.charCodeAt(0);
+    const isLetter = c0 >= 65 && c0 <= 90 || c0 >= 97 && c0 <= 122;
+    const s1 = specifier[1];
+    const s2 = specifier[2];
+    if (isLetter && s1 === ":" && (s2 === "\\" || s2 === "/")) return false;
+  }
+  return true;
+}
+function scopeString(scopes) {
+  const parts = [];
+  for (let i = 1; i < scopes.length; i++) {
+    const s = scopes[i];
+    if (s.kind !== "global" /* Global */) parts.push(s.name);
+  }
+  return parts.join(".");
+}
+var FILE_LEVEL_SOURCE = "(file)";
+var RealJavaScriptAnalyzer = class {
+  /**
+   * Whether the file currently being analyzed contains any `decorator` node.
+   * Set once per `analyze` call; see the pre-pass at its assignment for the
+   * measurement that made it worth having.
+   */
+  hasAnyDecoratorNode = false;
+  /**
+   * The positional lexical scope model for the file currently being analyzed (built once per
+   * `analyze`, before the relationship extraction passes, so every emission site can resolve its
+   * own node position exactly). Null outside an `analyze` call.
+   */
+  bindingModel = null;
+  analyze(rootNode, content, filePath, context) {
+    const symbols = [];
+    const relationships = [];
+    const imports = [];
+    const exports = [];
+    const errors = [];
+    const frameworks = { JavaScript: true };
+    const patterns = {};
+    const scopes = [{ name: "__global__", kind: "global" /* Global */ }];
+    this.hasAnyDecoratorNode = treeContainsNodeType(rootNode, "decorator");
+    const moduleName = path.basename(filePath, path.extname(filePath));
+    if (rootNode.hasError) {
+      const errStack = [rootNode];
+      while (errStack.length > 0) {
+        const n = errStack.pop();
+        if (n.type === "ERROR" || n.isMissing) {
+          errors.push({
+            message: `Syntax ${n.type} detected. The Brain Engine is bypassing this broken node.`,
+            range: this.nodeToRange(n),
+            severity: "warning"
+          });
+        }
+        for (let i = n.namedChildCount - 1; i >= 0; i--) {
+          const child = n.namedChild(i);
+          if (child) errStack.push(child);
+        }
+      }
+    }
+    const stack = [{ node: rootNode, scopes, inClassBody: false, functionDepth: 0 }];
+    let cyclomaticComplexity = 1;
+    const seenMethodIdx = /* @__PURE__ */ new Map();
+    const deadSpans = [];
+    const b5Zombies = [];
+    const relSpans = [];
+    while (stack.length > 0) {
+      const { node, scopes: frameScopes, inClassBody, functionDepth } = stack.pop();
+      const scopeStack = [...frameScopes];
+      let nextInClassBody = inClassBody;
+      let nextFunctionDepth = functionDepth;
+      if (node.type === "if_statement" || node.type === "for_statement" || node.type === "for_in_statement" || node.type === "while_statement" || node.type === "do_statement" || node.type === "catch_clause" || node.type === "switch_case" || node.type === "ternary_expression") {
+        cyclomaticComplexity++;
+      } else if (node.type === "binary_expression") {
+        const op = node.childForFieldName("operator")?.text;
+        if (op === "&&" || op === "||" || op === "??") cyclomaticComplexity++;
+      }
+      const relMark = relationships.length;
+      switch (node.type) {
+        case "class_declaration": {
+          const name = node.childForFieldName("name")?.text;
+          if (name) {
+            const comments = this.collectComments(node);
+            const dec = this.collectClassDecoratorDetails(node);
+            const decorators = dec.names;
+            symbols.push({
+              name,
+              kind: ASTEngine.SymbolKind.Class,
+              range: this.nodeToRange(node),
+              scope: scopeString(scopeStack),
+              visibility: "public",
+              decorators: decorators.length > 0 ? decorators : void 0,
+              comments,
+              metadata: {
+                isClass: true,
+                // M49 #868: parallel to `decorators`, so a decorator's
+                // reference edge can name the line the decorator is written
+                // on (the M59 #860 contract the typescript twin already has).
+                ...dec.lines.length > 0 ? { decoratorLines: dec.lines } : {}
+              }
+            });
+            scopeStack.push({ name, kind: "class" /* Class */ });
+            nextInClassBody = true;
+            const heritage = this.findChildByType(node, "class_heritage");
+            if (heritage) {
+              const base = this.findChildByType(heritage, "identifier") ?? this.findChildByType(heritage, "member_expression");
+              if (base) {
+                const boundBase = base.type === "identifier" ? this.localBindingTarget(base, base.text, name) : null;
+                const importedBase = boundBase ? null : base.type === "identifier" ? this.importedBindingFor(base, base.text) : null;
+                relationships.push({
+                  source: name,
+                  target: boundBase ?? base.text,
+                  type: ASTEngine.RelationshipType.Extends,
+                  confidence: 1,
+                  ...this.lineField(base),
+                  metadata: boundBase ? { localBinding: true } : importedBase ? { importedBinding: importedBase } : {}
+                });
+              } else {
+                const rows = this.callShapedHeritageRows(heritage, name);
+                if (rows.base) {
+                  relationships.push({
+                    source: name,
+                    target: rows.base.target,
+                    type: ASTEngine.RelationshipType.Extends,
+                    confidence: 1,
+                    ...this.lineField(rows.base.node),
+                    metadata: rows.base.metadata
+                  });
+                }
+                for (const mix of rows.mixins) {
+                  relationships.push({
+                    source: name,
+                    target: mix.target,
+                    type: ASTEngine.RelationshipType.MixesIn,
+                    confidence: 1,
+                    ...this.lineField(mix.node),
+                    metadata: { ...mix.metadata, isMixin: true }
+                  });
+                }
+              }
+            }
+          }
+          break;
+        }
+        case "class": {
+          const ownName = node.childForFieldName("name")?.text ?? bindingNameAbove(node);
+          const heritage = this.findChildByType(node, "class_heritage");
+          if (heritage && ownName) {
+            const base = this.findChildByType(heritage, "identifier") ?? this.findChildByType(heritage, "member_expression");
+            if (base) {
+              const boundBaseExpr = base.type === "identifier" ? this.localBindingTarget(base, base.text, ownName) : null;
+              const importedBaseExpr = boundBaseExpr ? null : base.type === "identifier" ? this.importedBindingFor(base, base.text) : null;
+              relationships.push({
+                source: ownName,
+                target: boundBaseExpr ?? base.text,
+                type: ASTEngine.RelationshipType.Extends,
+                confidence: 1,
+                ...this.lineField(base),
+                metadata: boundBaseExpr ? { localBinding: true } : importedBaseExpr ? { importedBinding: importedBaseExpr } : {}
+              });
+            } else {
+              const rows = this.callShapedHeritageRows(heritage, ownName);
+              if (rows.base) {
+                relationships.push({
+                  source: ownName,
+                  target: rows.base.target,
+                  type: ASTEngine.RelationshipType.Extends,
+                  confidence: 1,
+                  ...this.lineField(rows.base.node),
+                  metadata: rows.base.metadata
+                });
+              }
+              for (const mix of rows.mixins) {
+                relationships.push({
+                  source: ownName,
+                  target: mix.target,
+                  type: ASTEngine.RelationshipType.MixesIn,
+                  confidence: 1,
+                  ...this.lineField(mix.node),
+                  metadata: { ...mix.metadata, isMixin: true }
+                });
+              }
+            }
+          }
+          break;
+        }
+        case "method_definition": {
+          const name = node.childForFieldName("name")?.text;
+          if (name) {
+            const inObjectLiteral = node.parent?.type === "object";
+            const classOwner = inObjectLiteral ? void 0 : scopeOwnerName(scopeStack);
+            const owner = classOwner ?? containerOwnerName(node);
+            const isConstructor = name === "constructor";
+            const isAccessor = this.hasToken(node, "get") || this.hasToken(node, "set");
+            const kindSlot = isAccessor ? this.hasToken(node, "get") ? ":get" : ":set" : "";
+            const parentType = node.parent?.type;
+            const containerKey = parentType === "object" ? `obj@${node.parent.startIndex}` : parentType === "class_body" ? `cls@${node.parent.startIndex}` : owner;
+            const dedupKey = `${containerKey ?? "module"}:${name}${kindSlot}`;
+            const kind = isConstructor ? ASTEngine.SymbolKind.Constructor : isAccessor ? ASTEngine.SymbolKind.Property : ASTEngine.SymbolKind.Method;
+            const isStatic = this.hasToken(node, "static");
+            const isAsync = this.hasToken(node, "async");
+            const isGenerator = this.hasToken(node, "*");
+            const isPrivateMethod = name.startsWith("#");
+            let seenIdx = seenMethodIdx.get(dedupKey);
+            let seenKey = seenIdx === void 0 ? void 0 : dedupKey;
+            if (seenIdx === void 0) {
+              if (kindSlot === "") {
+                for (const opp of [":get", ":set"]) {
+                  const k2 = dedupKey + opp;
+                  const i2 = seenMethodIdx.get(k2);
+                  if (i2 !== void 0) {
+                    seenIdx = i2;
+                    seenKey = k2;
+                    break;
+                  }
+                }
+              } else {
+                const k2 = dedupKey.slice(0, dedupKey.length - kindSlot.length);
+                const i2 = seenMethodIdx.get(k2);
+                if (i2 !== void 0) {
+                  seenIdx = i2;
+                  seenKey = k2;
+                }
+              }
+            }
+            {
+              const params = this.extractParameters(node.childForFieldName("parameters"));
+              const comments = this.collectComments(node);
+              const dec = this.collectOwnDecoratorDetails(node);
+              const decorators = dec.names;
+              var methodSymbol = {
+                // #813: the declared spelling IS the member's name (every edge
+                // that reads it carries the `#`; see the TS site's note).
+                name,
+                kind,
+                range: this.nodeToRange(node),
+                scope: scopeString(scopeStack),
+                ownerName: owner,
+                ownerKind: classOwner ? ASTEngine.SymbolKind.Class : void 0,
+                // '#' members are class-private regardless of other tokens.
+                visibility: isPrivateMethod ? "private" : "public",
+                isStatic,
+                parameters: params,
+                decorators: decorators.length > 0 ? decorators : void 0,
+                comments,
+                complexity: this.methodComplexity(node),
+                metadata: {
+                  isAccessor,
+                  isAsync,
+                  isGenerator,
+                  ...kindSlot ? { accessorKind: kindSlot === ":get" ? "get" : "set" } : {},
+                  // M49 #868: the decorator's own line, parallel to
+                  // `decorators` (same lockstep as the typescript twin).
+                  ...dec.lines.length > 0 ? { decoratorLines: dec.lines } : {}
+                }
+              };
+            }
+            if (seenIdx === void 0) {
+              seenMethodIdx.set(dedupKey, symbols.length);
+              symbols.push(methodSymbol);
+            } else {
+              const oldRange = symbols[seenIdx].range;
+              if (oldRange && oldRange.startIndex !== void 0 && oldRange.endIndex !== void 0) deadSpans.push({ s: oldRange.startIndex, e: oldRange.endIndex });
+              if (kindSlot === "") {
+                const otherKey = seenKey === dedupKey + ":get" ? dedupKey + ":set" : seenKey === dedupKey + ":set" ? dedupKey + ":get" : void 0;
+                const otherIdx = otherKey !== void 0 ? seenMethodIdx.get(otherKey) : void 0;
+                if (otherIdx !== void 0 && otherIdx !== seenIdx) {
+                  const rj = symbols[otherIdx]?.range;
+                  if (rj && rj.startIndex !== void 0 && rj.endIndex !== void 0) deadSpans.push({ s: rj.startIndex, e: rj.endIndex });
+                  b5Zombies.push(otherIdx);
+                }
+              }
+              symbols[seenIdx] = methodSymbol;
+              if (seenKey) seenMethodIdx.delete(seenKey);
+              seenMethodIdx.set(dedupKey, seenIdx);
+            }
+            scopeStack.push({ name, kind: "function" /* Function */ });
+            nextFunctionDepth = functionDepth + 1;
+            nextInClassBody = false;
+          }
+          break;
+        }
+        case "field_definition": {
+          const prop = node.childForFieldName("property");
+          if (prop) {
+            const name = prop.text;
+            const classOwner = scopeOwnerName(scopeStack);
+            const owner = classOwner ?? containerOwnerName(node);
+            const dec = this.collectOwnDecoratorDetails(node);
+            symbols.push({
+              name,
+              kind: ASTEngine.SymbolKind.Property,
+              range: this.nodeToRange(node),
+              scope: scopeString(scopeStack),
+              ownerName: owner,
+              ownerKind: classOwner ? ASTEngine.SymbolKind.Class : void 0,
+              // J9 (review wave, TS parity): `#x` fields are class-private —
+              // the old hardcoded "public" contradicted metadata.isPrivate
+              // on the same symbol.
+              visibility: prop.type === "private_property_identifier" ? "private" : "public",
+              decorators: dec.names.length > 0 ? dec.names : void 0,
+              metadata: {
+                isPrivate: prop.type === "private_property_identifier",
+                ...dec.lines.length > 0 ? { decoratorLines: dec.lines } : {}
+              }
+            });
+          }
+          break;
+        }
+        case "function_declaration":
+        case "generator_function_declaration": {
+          const name = node.childForFieldName("name")?.text;
+          if (name) {
+            const comments = this.collectComments(node);
+            const params = this.extractParameters(node.childForFieldName("parameters"));
+            const isAsync = this.hasToken(node, "async");
+            symbols.push({
+              name,
+              kind: ASTEngine.SymbolKind.Function,
+              range: this.nodeToRange(node),
+              scope: scopeString(scopeStack),
+              visibility: "public",
+              parameters: params,
+              comments,
+              complexity: this.methodComplexity(node),
+              metadata: {
+                isGenerator: node.type === "generator_function_declaration",
+                isAsync
+              }
+            });
+            scopeStack.push({ name, kind: "function" /* Function */ });
+            nextFunctionDepth = functionDepth + 1;
+          }
+          break;
+        }
+        case "variable_declarator": {
+          const nameNode = node.childForFieldName("name");
+          const valueNode = node.childForFieldName("value");
+          const name = nameNode && nameNode.type === "identifier" ? nameNode.text : void 0;
+          const isFunctionValue = !!valueNode && (valueNode.type === "arrow_function" || valueNode.type === "function_expression" || valueNode.type === "generator_function");
+          const isRequireBinding = !!valueNode && valueNode.type === "call_expression" && valueNode.childForFieldName("function")?.text === "require";
+          if (name && isRequireBinding) {
+            break;
+          }
+          if (name && functionDepth === 0 && !inClassBody) {
+            if (isFunctionValue) {
+              const comments = this.collectComments(node);
+              const params = this.extractParameters(valueNode.childForFieldName("parameters"));
+              const isAsync = this.hasToken(valueNode, "async");
+              symbols.push({
+                name,
+                kind: ASTEngine.SymbolKind.Function,
+                range: this.nodeToRange(node),
+                scope: scopeString(scopeStack),
+                visibility: "public",
+                parameters: params,
+                comments,
+                complexity: this.methodComplexity(valueNode),
+                metadata: { isArrowFunction: valueNode.type === "arrow_function", isAsync }
+              });
+              scopeStack.push({ name, kind: "function" /* Function */ });
+              nextFunctionDepth = functionDepth + 1;
+            } else {
+              const isConst = this.isConstDeclarator(node);
+              symbols.push({
+                name,
+                kind: isConst ? ASTEngine.SymbolKind.Constant : ASTEngine.SymbolKind.Variable,
+                range: this.nodeToRange(node),
+                scope: scopeString(scopeStack),
+                visibility: "public",
+                metadata: { isConst }
+              });
+            }
+          } else if (nameNode && (nameNode.type === "object_pattern" || nameNode.type === "array_pattern") && functionDepth === 0 && !inClassBody) {
+            const isConst = this.isConstDeclarator(node);
+            const pairs = this.collectPatternPairs(nameNode);
+            for (const bound of pairs) {
+              symbols.push({
+                name: bound.name,
+                kind: isConst ? ASTEngine.SymbolKind.Constant : ASTEngine.SymbolKind.Variable,
+                // M59 (#825): each binding ranges at its own NAME, not the
+                // whole declarator (a wrapped binding list stamped `const {`
+                // for every member — measured on element-plus drawer.vue).
+                range: this.nodeToRange(bound.node),
+                scope: scopeString(scopeStack),
+                visibility: "public",
+                metadata: { isConst, isDestructured: true }
+              });
+            }
+          } else if (isFunctionValue) {
+            scopeStack.push({ name: name ?? "anonymous", kind: "function" /* Function */ });
+            nextFunctionDepth = functionDepth + 1;
+          }
+          break;
+        }
+        case "function_expression":
+        case "arrow_function": {
+          const parent = node.parent;
+          if (parent && parent.type !== "variable_declarator") {
+            const nm = `anonymous_function_${node.startIndex}`;
+            scopeStack.push({ name: nm, kind: "function" /* Function */ });
+            nextFunctionDepth = functionDepth + 1;
+          }
+          break;
+        }
+        case "assignment_expression": {
+          const left = node.childForFieldName("left");
+          const right = node.childForFieldName("right");
+          if (left && right) {
+            if (left.type === "identifier" && left.text === "exports") {
+              patterns["CommonJS Exports"] = true;
+              this.collectModuleExports(right, exports, node, false, "exports");
+            }
+            if (left.type === "member_expression" || left.type === "subscript_expression") {
+              const obj = left.childForFieldName("object");
+              const prop = left.childForFieldName("property");
+              const objText = obj ? obj.text : "";
+              const propText = prop ? prop.text : "";
+              if (objText === "module" && propText === "exports") {
+                patterns["CommonJS Exports"] = true;
+                this.collectModuleExports(right, exports, node, true, "module-exports");
+              } else if (obj && writtenSegment(prop, left)) {
+                const surface = this.cjsSurfacePath(obj);
+                if (surface) {
+                  patterns["CommonJS Exports"] = true;
+                  const seg = writtenSegment(prop, left);
+                  const exportName = [...surface, segmentName(seg)].join(".");
+                  exports.push({
+                    name: exportName,
+                    isDefault: false,
+                    range: this.nodeToRange(seg),
+                    metadata: { viaCommonJs: true, cjsForm: "deep-member-assignment" }
+                  });
+                }
+              }
+              const isFunctionRight = right.type === "function_expression" || right.type === "arrow_function" || right.type === "generator_function";
+              if (isFunctionRight && obj && obj.type === "member_expression") {
+                const protoObj = obj.childForFieldName("object");
+                const protoProp = obj.childForFieldName("property");
+                if (protoProp && protoProp.text === "prototype" && protoObj && propText) {
+                  patterns["Prototype Inheritance"] = true;
+                  const className = protoObj.text;
+                  const methodName = propText;
+                  const dedupKey = `${className}:${methodName}`;
+                  {
+                    const params = this.extractParameters(right.childForFieldName("parameters"));
+                    var protoSymbol = {
+                      name: methodName,
+                      kind: ASTEngine.SymbolKind.Method,
+                      range: this.nodeToRange(right),
+                      scope: className,
+                      ownerName: className,
+                      ownerKind: ASTEngine.SymbolKind.Class,
+                      visibility: "public",
+                      parameters: params,
+                      complexity: this.methodComplexity(right),
+                      metadata: { isPrototypeMethod: true, prototypeOwner: className }
+                    };
+                  }
+                  const protoIdx = seenMethodIdx.get(dedupKey);
+                  if (protoIdx === void 0) {
+                    seenMethodIdx.set(dedupKey, symbols.length);
+                    symbols.push(protoSymbol);
+                  } else {
+                    const oldRange = symbols[protoIdx].range;
+                    if (oldRange && oldRange.startIndex !== void 0 && oldRange.endIndex !== void 0) deadSpans.push({ s: oldRange.startIndex, e: oldRange.endIndex });
+                    symbols[protoIdx] = protoSymbol;
+                  }
+                  scopeStack.push({ name: methodName, kind: "function" /* Function */ });
+                  nextFunctionDepth = functionDepth + 1;
+                }
+              }
+            }
+          }
+          break;
+        }
+        case "call_expression": {
+          const fn = node.childForFieldName("function");
+          const isImportCall = !!fn && (fn.type === "import" || fn.type === "identifier" && fn.text === "import");
+          if (fn && (fn.type === "identifier" && fn.text === "require" || isImportCall)) {
+            const args = node.childForFieldName("arguments");
+            if (args && args.namedChildCount > 0) {
+              const arg = args.namedChild(0);
+              if (arg && (arg.type === "string" || arg.type === "template_string")) {
+                const reqPath = stringContent(arg);
+                const isDynamic = isImportCall;
+                let requireIsDefault = true;
+                if (!isDynamic) {
+                  let vp = node.parent;
+                  while (vp && vp.type !== "variable_declarator" && vp.type !== "lexical_declaration" && vp.type !== "variable_declaration" && vp.type !== "export_statement" && vp.type !== "expression_statement" && vp.type !== "program") {
+                    vp = vp.parent;
+                  }
+                  if (vp && vp.type === "variable_declarator") {
+                    const bindName = vp.childForFieldName("name");
+                    requireIsDefault = !!bindName && bindName.type === "identifier";
+                  } else {
+                    requireIsDefault = false;
+                  }
+                }
+                imports.push({
+                  module: reqPath,
+                  items: ["*"],
+                  isDefault: requireIsDefault,
+                  range: this.nodeToRange(node),
+                  metadata: { type: isDynamic ? "dynamic-import" : "require" }
+                });
+                patterns[isDynamic ? "Dynamic Imports" : "CommonJS Imports"] = true;
+                relationships.push({
+                  source: moduleName,
+                  target: `${reqPath}:*`,
+                  type: ASTEngine.RelationshipType.Imports,
+                  // JD-J12 (M60, 2026-09-27): a `*` target names NO SYMBOL.
+                  //
+                  // `require("m")` and `import("m")` are module-level: the
+                  // source declares that the module is loaded, not which member
+                  // is taken from it. Publishing `<module>:*` at 1.0 states a
+                  // certainty the file does not contain — and this is the ONLY
+                  // shape a CJS require ever takes, so for an ES5 corpus it is
+                  // the whole import class.
+                  //
+                  // Measured on the two javascript corpora at 300 files: 310
+                  // edges carry a `*` leaf and **every one is at confidence
+                  // 1.0** — 233 of 1,606 in svelte, and 77 of 77 in lodash
+                  // (whose entire import surface is `require`). No named-leaf
+                  // import edge exists there at all.
+                  //
+                  // This is the same defect shape as java's inferred JPA table
+                  // name (`mapped_table`, fixed earlier in this review): an
+                  // inference published at maximum confidence. The edge is KEPT
+                  // — the module dependency is real and worth recording — but it
+                  // is marked and demoted below the 0.7 fabrication threshold,
+                  // so it is declared suspicion rather than a counted
+                  // relationship, and a consumer can filter on `unresolved`.
+                  confidence: 0.6,
+                  // The module path argument is the name this edge is about.
+                  ...this.lineField(arg),
+                  metadata: {
+                    // THE EVIDENCE KEY for the arbiter's import facts: the module specifier as written.
+                    // The ES-import rows already carried `module`; the require/import() rows did not, and
+                    // the first arbiter smoke measured the cost exactly: SIX importedBinding claims were
+                    // REFUTED because their evidence edge had no `module` to key file->specifier->bindings
+                    // with (every one of the six was a require() binding: fs, path, an absolute pg path,
+                    // ../utils/logger, ../../services/...). The claim's `specifier` and this field must be
+                    // the SAME spelling — both come from stringContent() on the written argument.
+                    module: reqPath,
+                    isRequire: !isDynamic,
+                    isDynamicImport: isDynamic,
+                    unresolved: true,
+                    // THE EVIDENCE the imported-binding claim is verified against: the local names this
+                    // module load binds IN THIS FILE (a destructured `const { a } = require("m")` binds a,
+                    // a bare `const fs = require("m")` binds fs). Dynamic specifiers are refused earlier,
+                    // so they reach no claim — the contract's never-claim (c).
+                    importedBindings: (() => {
+                      let owner = node.parent;
+                      while (owner && owner.type !== "variable_declarator" && owner.type !== "lexical_declaration" && owner.type !== "variable_declaration" && owner.type !== "export_statement" && owner.type !== "expression_statement" && owner.type !== "program") {
+                        owner = owner.parent;
+                      }
+                      const bindName = owner && owner.type === "variable_declarator" ? owner.childForFieldName("name") : null;
+                      return bindName ? this.collectPatternPairs(bindName).map((pair) => pair.name) : [];
+                    })()
+                  }
+                });
+              }
+            }
+          }
+          break;
+        }
+        case "import_statement": {
+          patterns["ES6 Imports"] = true;
+          const srcNode = node.childForFieldName("source");
+          const srcPath = srcNode ? stringContent(srcNode) : "";
+          const items = [];
+          const clause = this.findChildByType(node, "import_clause");
+          let hasDefaultImport = false;
+          if (clause) {
+            for (let i = 0; i < clause.namedChildCount; i++) {
+              const c = clause.namedChild(i);
+              if (!c) continue;
+              if (c.type === "identifier") {
+                items.push({ text: c.text, node: c, declared: "default", kind: "default" });
+                hasDefaultImport = true;
+              } else if (c.type === "named_imports") {
+                for (let j = 0; j < c.namedChildCount; j++) {
+                  const spec = c.namedChild(j);
+                  if (spec && spec.type === "import_specifier") {
+                    const n = this.findChildByType(spec, "identifier");
+                    const alias = spec.childForFieldName("alias");
+                    const item = alias ?? n;
+                    if (item) {
+                      items.push({ text: item.text, node: item, declared: n?.text ?? item.text, kind: "named" });
+                    }
+                  }
+                }
+              } else if (c.type === "namespace_import") {
+                const nsName = c.childForFieldName("name") ?? c.namedChild(0);
+                items.push({ text: "*", node: nsName ?? c, declared: "*", kind: "namespace" });
+              }
+            }
+          }
+          if (srcPath) {
+            imports.push({
+              module: srcPath,
+              items: items.map((i) => i.text),
+              isDefault: hasDefaultImport,
+              range: this.nodeToRange(node),
+              metadata: { type: "import" }
+            });
+            for (const item of items) {
+              const isNamespaceItem = item.text === "*";
+              const jsItemName = item.text.split(" as ")[0];
+              const bareLocalItem = item.kind === "named" && !isNamespaceItem && jsItemName !== "" && (srcPath.startsWith(".") || srcPath.startsWith("/"));
+              const localNamedTarget = item.kind === "named" ? item.declared || jsItemName : jsItemName;
+              relationships.push({
+                source: moduleName,
+                // FOR A LOCAL MODULE the target is the symbol the edge refers to;
+                // for an external one it stays `<specifier>:<local binding>`,
+                // which is what the importing fixtures pin.
+                target: bareLocalItem ? localNamedTarget : `${srcPath}:${isNamespaceItem ? "*" : jsItemName}`,
+                type: ASTEngine.RelationshipType.Imports,
+                confidence: isNamespaceItem ? 0.6 : 1,
+                ...this.lineField(item.node),
+                // JD2b, additive: what the MODULE declares, so the resolver can
+                // reach the right symbol for an aliased or default import. The
+                // edge target above is untouched.
+                metadata: {
+                  // THE MODULE, NOW THAT IT IS NO LONGER GLUED INTO THE TARGET. TypeScript's site
+                  // already carried `module`; this one did not, so a bare item name here would have
+                  // LOST the module half rather than moved it — and an item name with no module is
+                  // unresolvable by construction (which module's `readJson`?).
+                  module: srcPath,
+                  declaredName: item.declared,
+                  declaredKind: item.kind,
+                  // THE LOCAL NAME THIS IMPORT BINDS — the evidence for the imported-binding claim.
+                  // Default/named: the item's local spelling (alias when present); namespace: the
+                  // local `ns` identifier the clause writes (the item's text is `*`).
+                  importedBindings: isNamespaceItem ? String(item.node?.text ?? "") ? [String(item.node.text)] : [] : item.text ? [item.text] : [],
+                  ...isNamespaceItem ? { unresolved: true } : {}
+                }
+              });
+            }
+          }
+          break;
+        }
+        case "export_statement": {
+          patterns["ES6 Exports"] = true;
+          this.collectExportStatement(node, exports);
+          const exportSource = node.childForFieldName("source");
+          if (exportSource) {
+            const modPath = stringContent(exportSource);
+            const namedSpecs = [];
+            const clauseNames = [];
+            const clause2 = this.findChildByType(node, "export_clause");
+            if (clause2) {
+              for (let i = 0; i < clause2.namedChildCount; i++) {
+                const spec = clause2.namedChild(i);
+                if (spec && spec.type === "export_specifier") {
+                  const nameNode = spec.childForFieldName("name") ?? spec.namedChild(0);
+                  const alias = spec.childForFieldName("alias");
+                  const member = nameNode ? nameNode.type === "string" ? stringContent(nameNode) : String(nameNode.text ?? "") : "";
+                  if (nameNode && member) {
+                    namedSpecs.push({ member, exportedAs: alias ? String(alias.text) : member, node: nameNode });
+                    clauseNames.push(alias ? String(alias.text) : member);
+                  }
+                }
+              }
+            }
+            const starOnly = !clause2 && this.hasToken(node, "*");
+            const namespaceExport = this.findChildByType(node, "namespace_export");
+            const namespaceAlias = namespaceExport ? String(namespaceExport.childForFieldName("name") ?? namespaceExport.namedChild(0)?.text ?? "") : "";
+            imports.push({
+              module: modPath,
+              items: starOnly ? ["*"] : clauseNames,
+              isDefault: false,
+              range: this.nodeToRange(node),
+              metadata: { reExport: true }
+            });
+            if (namedSpecs.length) {
+              for (const spec of namedSpecs) {
+                relationships.push({
+                  source: FILE_LEVEL_SOURCE,
+                  // The MEMBER in the source module — not the alias this module
+                  // exports it under, which is what an `exports` edge is about.
+                  target: `${modPath}:${spec.member}`,
+                  type: ASTEngine.RelationshipType.Imports,
+                  // 1.0 for the same reason a named import keeps 1.0: the member
+                  // name is WRITTEN in this file, and ESM fixes its meaning (the
+                  // source module must export `member`), so this is a stated
+                  // dependency and not an inference. `export *` / `export * as ns`
+                  // keep 0.6 and `unresolved` — they write no member name.
+                  confidence: 1,
+                  // The specifier's OWN line: a clause is a list, and the name the
+                  // edge is about is written on its own line.
+                  ...this.lineField(spec.node),
+                  metadata: {
+                    isReExport: true,
+                    declaredName: spec.member,
+                    declaredKind: "named",
+                    // A re-export binds NO local name in this file (never-claim (d): a different
+                    // surface). The key is published on EVERY imports edge so the arbiter never has
+                    // to distinguish "no bindings" from "this row forgot the evidence".
+                    importedBindings: [],
+                    ...spec.exportedAs !== spec.member ? { exportedAs: spec.exportedAs } : {}
+                  }
+                });
+              }
+            } else {
+              relationships.push({
+                source: FILE_LEVEL_SOURCE,
+                target: `${modPath}:*`,
+                type: ASTEngine.RelationshipType.Imports,
+                // JD-J12 (M60, 2026-09-27): a clause-less re-export (`export *
+                // from "m"`) names the MODULE and no member of it — `*` again. A
+                // module path is not a symbol, so 1.0 overstated it the same way
+                // it overstated `require` and the namespace import. Kept, marked,
+                // and demoted: the re-export dependency is real.
+                confidence: 0.6,
+                // A re-export with no clause names the MODULE, so the written
+                // name is the module-path argument itself.
+                ...this.lineField(exportSource),
+                // `starForm` is the discriminator, and it is the one piece of
+                // evidence a resolver needs to tell a REDISTRIBUTION from a
+                // namespace binding: only `all` may be followed for a name this
+                // file does not publish.
+                metadata: {
+                  isReExport: true,
+                  unresolved: true,
+                  starForm: namespaceAlias ? "namespace" : "all",
+                  // A clause-less re-export binds NO local name (never-claim (d)). Published on every
+                  // imports edge so the arbiter never has to distinguish "no bindings" from "missing
+                  // evidence".
+                  importedBindings: [],
+                  ...namespaceAlias ? { namespaceName: namespaceAlias } : {}
+                }
+              });
+            }
+            patterns["ES6 ReExports"] = true;
+          }
+          break;
+        }
+      }
+      for (let i = relMark; i < relationships.length; i++) {
+        relSpans.push({ idx: i, s: node.startIndex, e: node.endIndex });
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) {
+          stack.push({ node: child, scopes: scopeStack, inClassBody: nextInClassBody, functionDepth: nextFunctionDepth });
+        }
+      }
+    }
+    {
+      const deadIdx = new Set(b5Zombies);
+      if (deadSpans.length > 0) {
+        for (let i = 0; i < symbols.length; i++) {
+          const r = symbols[i].range;
+          if (!r || r.startIndex === void 0 || r.endIndex === void 0) continue;
+          for (const d of deadSpans) {
+            if (d.s <= r.startIndex && r.endIndex <= d.e && (d.s !== r.startIndex || r.endIndex !== d.e)) {
+              deadIdx.add(i);
+              break;
+            }
+          }
+        }
+      }
+      if (deadIdx.size > 0) {
+        for (let i = symbols.length - 1; i >= 0; i--) if (deadIdx.has(i)) symbols.splice(i, 1);
+      }
+    }
+    if (deadSpans.length > 0 && relSpans.length > 0) {
+      const drop = /* @__PURE__ */ new Set();
+      for (const r of relSpans) {
+        for (const d of deadSpans) {
+          if (d.s <= r.s && r.e <= d.e) {
+            drop.add(r.idx);
+            break;
+          }
+        }
+      }
+      if (drop.size > 0) {
+        for (let i = relationships.length - 1; i >= 0; i--) if (drop.has(i)) relationships.splice(i, 1);
+      }
+    }
+    {
+      const bySource = /* @__PURE__ */ new Map();
+      const qcOwnerOf = (n) => {
+        let p = n.parent;
+        while (p) {
+          if (p.type === "class_declaration") return p.childForFieldName("name")?.text;
+          if (p.type === "variable_declarator" || p.type === "object" || p.type === "pair" || p.type === "function_declaration" || p.type === "function_expression" || p.type === "arrow_function") return void 0;
+          p = p.parent;
+        }
+        return void 0;
+      };
+      const qcResolve = (n, current) => {
+        const fnName = n.childForFieldName?.("name")?.text;
+        if ((n.type === "function_declaration" || n.type === "generator_function_declaration" || n.type === "method_definition") && fnName) {
+          const owner = n.type === "method_definition" ? qcOwnerOf(n) : void 0;
+          return owner ? `${owner}::${fnName}` : fnName;
+        }
+        if (n.type === "variable_declarator") {
+          const nameNode = n.childForFieldName("name");
+          const valueNode = n.childForFieldName("value");
+          if (nameNode && valueNode && (valueNode.type === "arrow_function" || valueNode.type === "function_expression" || valueNode.type === "generator_function")) {
+            return nameNode.text;
+          }
+        }
+        if (n.type === "assignment_expression") {
+          const left = n.childForFieldName("left");
+          const right = n.childForFieldName("right");
+          if (left && right && (right.type === "function_expression" || right.type === "arrow_function") && left.type === "member_expression") {
+            const obj = left.childForFieldName("object");
+            const prop = left.childForFieldName("property");
+            if (obj && obj.type === "member_expression" && prop) {
+              const protoProp = obj.childForFieldName("property");
+              if (protoProp && protoProp.text === "prototype") {
+                const owner = obj.childForFieldName("object")?.text;
+                return owner ? `${owner}::${prop.text}` : prop.text;
+              }
+            }
+          }
+        }
+        return current;
+      };
+      const qcWalk = (n, current) => {
+        if (isNodeInDeadSpans(deadSpans, n)) return;
+        current = qcResolve(n, current);
+        if (n.type === "call_expression") {
+          const fn = n.childForFieldName("function");
+          const isImportCallee = !!fn && (fn.type === "import" || fn.type === "identifier" && fn.text === "import");
+          if (fn && !(fn.type === "identifier" && fn.text === "require") && !isImportCallee) {
+            const parts = [];
+            let cur = fn;
+            while (cur) {
+              if (cur.type === "member_expression") {
+                const prop2 = cur.childForFieldName("property");
+                parts.unshift(prop2 ? prop2.text : cur.namedChild(cur.namedChildCount - 1)?.text ?? "");
+                cur = cur.childForFieldName("object");
+              } else if (cur.type === "call_expression") {
+                cur = cur.namedChild(0);
+              } else {
+                parts.unshift(cur.text);
+                break;
+              }
+            }
+            const path2 = parts.filter(Boolean).join(".");
+            if (current && path2) {
+              const list = bySource.get(current) ?? [];
+              list.push(path2);
+              bySource.set(current, list);
+            }
+          }
+        }
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) qcWalk(c, current);
+        }
+      };
+      qcWalk(rootNode, null);
+      for (const sym of symbols) {
+        const key = sym.ownerName && sym.ownerKind === ASTEngine.SymbolKind.Class ? `${sym.ownerName}::${sym.name}` : sym.name;
+        const list = bySource.get(key);
+        if (list && list.length > 0) sym.qualified_calls = [...new Set(list)];
+      }
+    }
+    this.bindingModel = this.collectBindingModel(rootNode);
+    this.addContainmentRelationships(symbols, relationships);
+    this.extractOverrideRelationships(symbols, relationships, context?.overrideCompanion);
+    const receiverTypes = this.collectLocalReceiverTypes(rootNode);
+    this.extractCallRelationships(rootNode, symbols, relationships, moduleName, receiverTypes, deadSpans);
+    if (deadSpans.length > 0 && exports.length > 0) {
+      for (let i = exports.length - 1; i >= 0; i--) {
+        const r = exports[i].range;
+        if (r && r.startIndex !== void 0 && r.endIndex !== void 0) {
+          for (const d of deadSpans) {
+            if (d.s <= r.startIndex && r.endIndex <= d.e) {
+              exports.splice(i, 1);
+              break;
+            }
+          }
+        }
+      }
+    }
+    this.extractExportRelationships(
+      exports,
+      relationships,
+      FILE_LEVEL_SOURCE,
+      new Set(symbols.map((sym) => String(sym?.name ?? "")).filter((n) => n.length > 0))
+    );
+    this.extractDecoratorRelationships(symbols, relationships);
+    const architecturalScore = Math.min(100, Math.max(0, 100 - errors.length * 5));
+    const detectedPatterns = Object.keys(patterns);
+    const detectedFrameworks = Object.keys(frameworks);
+    if (this.detectsJsx(rootNode)) {
+      detectedFrameworks.push("React");
+      detectedPatterns.push("JSX Components");
+    }
+    const frameworkPatterns = detectedPatterns.map((p) => ({
+      framework: "JavaScript",
+      patterns: [{ type: "usage", detected: true, description: p }]
+    }));
+    this.collectFieldAccessUses(rootNode, relationships, moduleName, receiverTypes, deadSpans);
+    this.extractInstanceofRefs(rootNode, relationships, moduleName);
+    for (const r of relationships) {
+      if (r.source !== FILE_LEVEL_SOURCE) continue;
+      r.metadata = { ...r.metadata ?? {}, fileLevel: true, scopeName: moduleName };
+    }
+    for (let i = relationships.length - 1; i >= 0; i--) {
+      const r = relationships[i];
+      if (!r.source || !r.target) relationships.splice(i, 1);
+    }
+    this.markExternalClaims(rootNode, relationships, symbols, context);
+    this.classifyEvidenceTier(relationships);
+    return {
+      language: "javascript",
+      symbols,
+      relationships,
+      imports,
+      exports,
+      errors,
+      metadata: {
+        // Real cyclomatic complexity — was the synthetic heuristic
+        // symbols.length + relationships.length, which is not a complexity
+        // metric at all (same defect previously fixed on groovy/scala).
+        complexity: cyclomaticComplexity,
+        linesOfCode: content.split("\n").length,
+        cyclomaticComplexity,
+        framework: detectedFrameworks.length > 1 ? detectedFrameworks[1] : detectedFrameworks[0],
+        patterns: detectedPatterns,
+        detectedFrameworks,
+        frameworkPatterns,
+        architecturalInsights: [],
+        architecturalScore,
+        codeQuality: errors.length === 0 ? "Excellent" : "Fair",
+        hasTypeInference: false,
+        hasFrameworkIntelligence: true,
+        analysisVersion: "3.1.0-m12.10-family-contract"
+      }
+    };
+  }
+  // ============================================================================
+  // RELATIONSHIP PASSES
+  // ============================================================================
+  addContainmentRelationships(symbols, relationships) {
+    for (const symbol of symbols) {
+      if (symbol.ownerName) {
+        relationships.push({
+          source: symbol.ownerName,
+          target: symbol.name,
+          type: ASTEngine.RelationshipType.Contains,
+          confidence: 1,
+          // The MEMBER's declaration line — the edge names the member.
+          ...symbol.range?.startLine ? { line_number: symbol.range.startLine } : {},
+          metadata: {}
+        });
+      }
+    }
+  }
+  extractOverrideRelationships(symbols, relationships, overrideCompanion) {
+    const byName = /* @__PURE__ */ new Map();
+    for (const s of symbols) {
+      const list = byName.get(s.name) ?? [];
+      list.push(s);
+      byName.set(s.name, list);
+    }
+    const baseByClass = /* @__PURE__ */ new Map();
+    for (const r of relationships) {
+      if (r.type === ASTEngine.RelationshipType.Extends && r.source && r.target) {
+        baseByClass.set(r.source, r.target);
+      }
+    }
+    const overrideSeen = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      const isAccessorMember = s.kind === ASTEngine.SymbolKind.Property && s.metadata?.isAccessor === true;
+      if ((s.kind === ASTEngine.SymbolKind.Method || s.kind === ASTEngine.SymbolKind.Constructor || isAccessorMember) && s.ownerName) {
+        if (s.isStatic) continue;
+        const base = baseByClass.get(s.ownerName);
+        if (!base) continue;
+        const isCtor = s.kind === ASTEngine.SymbolKind.Constructor || s.name === "constructor";
+        const inFileDeclares = !isCtor && (byName.get(s.name)?.some((bm) => bm.ownerName === base && (bm.kind === ASTEngine.SymbolKind.Method || bm.kind === ASTEngine.SymbolKind.Property && bm.metadata?.isAccessor === true)) ?? false);
+        if (inFileDeclares || !isCtor && overrideCompanion?.get(base)?.has(s.name)) {
+          const ovKey = `${s.ownerName}.${s.name}->${base}.${s.name}`;
+          if (overrideSeen.has(ovKey)) continue;
+          overrideSeen.add(ovKey);
+          relationships.push({
+            source: `${s.ownerName}.${s.name}`,
+            // THE TARGET IS THE MEMBER NAME, NOT `Owner.member`: the resolver binds against
+            // DECLARATIONS, and a declaration is named by its leaf. Measured: 100% of this lane's
+            // overrides targets are dotted, 100% have their leaf declared in the edge's own file, and
+            // 100% classify unresolved — a naming problem, not a mechanism problem. `localEdgeName`
+            // derives the leaf AFTER the paren deletion `localEdgeLabel` performs, so a dotted
+            // parameter list cannot be cut into a non-name (see its doc).
+            target: s.name,
+            type: ASTEngine.RelationshipType.Overrides,
+            confidence: 0.95,
+            // The OVERRIDING member's own line, not the class's.
+            ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+            metadata: { reasonCode: "verified-in-file" }
+          });
+        } else if (!isCtor && !overrideCompanion?.has(base)) {
+          const baseInFile = symbols.some((s2) => s2.name === base && s2.kind === ASTEngine.SymbolKind.Class);
+          if (baseInFile) continue;
+          if (s.name.startsWith("#")) continue;
+          if (isJsBuiltin(base) && !jsBuiltinHasMember(base, s.name)) continue;
+          const guessKey = `${s.ownerName}.${s.name}->${base}.${s.name}`;
+          if (overrideSeen.has(guessKey)) continue;
+          overrideSeen.add(guessKey);
+          relationships.push({
+            source: `${s.ownerName}.${s.name}`,
+            // THE TARGET IS THE MEMBER NAME, NOT `Owner.member`: the resolver binds against
+            // DECLARATIONS, and a declaration is named by its leaf. Measured: 100% of this lane's
+            // overrides targets are dotted, 100% have their leaf declared in the edge's own file, and
+            // 100% classify unresolved — a naming problem, not a mechanism problem. `localEdgeName`
+            // derives the leaf AFTER the paren deletion `localEdgeLabel` performs, so a dotted
+            // parameter list cannot be cut into a non-name (see its doc).
+            target: s.name,
+            type: ASTEngine.RelationshipType.Overrides,
+            confidence: 0.5,
+            ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+            metadata: { reasonCode: "first-parent-guess" }
+          });
+        }
+      }
+    }
+  }
+  /**
+   * RECEIVER TYPES for a member call on a LOCAL variable — the JavaScript twin of
+   * the TypeScript pass (`collectLocalReceiverTypes` there, where the three-file
+   * measurement and the reasoning live).
+   *
+   * JavaScript states a receiver's type in exactly one syntactic form: an
+   * initialiser. `const c = new Foo()` is the whole rule here; there are no type
+   * annotations to read, which is why this map is smaller than the TS one rather
+   * than narrower by choice. A name declared with two different constructors in
+   * one file is dropped: shadowing makes the file-level answer a guess, and a
+   * wrong owner rewrites a binding that is currently right.
+   */
+  collectLocalReceiverTypes(root) {
+    const types = /* @__PURE__ */ new Map();
+    const conflicted = /* @__PURE__ */ new Set();
+    const record = (name, type, evidence) => {
+      if (name.length === 0 || type.length === 0) return;
+      const previous = types.get(name);
+      if (previous === void 0) {
+        if (!conflicted.has(name)) types.set(name, { type, evidence });
+      } else if (previous.type !== type) {
+        types.delete(name);
+        conflicted.add(name);
+      }
+    };
+    const newCtorLeaf = (value) => {
+      if (!value || value.type !== "new_expression") return null;
+      const ctor = value.childForFieldName("constructor") ?? value.namedChild(0);
+      if (ctor?.type === "identifier") return ctor.text;
+      if (ctor?.type === "member_expression") return ctor.childForFieldName("property")?.text ?? null;
+      return null;
+    };
+    const precedingDoc = (node) => {
+      let stmt = node;
+      while (stmt.parent && stmt.parent.type !== "program" && stmt.parent.type !== "statement_block" && stmt.parent.type !== "class_body" && stmt.parent.type !== "switch_body") {
+        stmt = stmt.parent;
+      }
+      const prev = stmt.previousSibling;
+      if (!prev || prev.type !== "comment") return null;
+      const text = prev.text;
+      return text.startsWith("/**") ? text : null;
+    };
+    const jsdocTypeOf = (node) => {
+      const text = precedingDoc(node);
+      if (text === null) return null;
+      const at = text.indexOf("@type");
+      if (at < 0) return null;
+      const open = text.indexOf("{", at + 5);
+      if (open < 0) return null;
+      const close = text.indexOf("}", open + 1);
+      if (close < 0) return null;
+      const inner = text.slice(open + 1, close).trim();
+      return isPlainJsIdentifier(inner) ? inner : null;
+    };
+    const jsdocParamsOf = (node) => {
+      const out = /* @__PURE__ */ new Map();
+      const text = precedingDoc(node);
+      if (text === null) return out;
+      let from = 0;
+      for (; ; ) {
+        const at = text.indexOf("@param", from);
+        if (at < 0) break;
+        from = at + 6;
+        const open = text.indexOf("{", from);
+        if (open < 0) break;
+        const close = text.indexOf("}", open + 1);
+        if (close < 0) break;
+        const type = text.slice(open + 1, close).trim();
+        let i = close + 1;
+        while (i < text.length && (text[i] === " " || text[i] === "	")) i++;
+        let end = i;
+        while (end < text.length) {
+          const ch = text[end];
+          if (ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "-" || ch === "*" || ch === "/") break;
+          end++;
+        }
+        const name = text.slice(i, end);
+        if (isPlainJsIdentifier(type) && isPlainJsIdentifier(name)) out.set(name, type);
+        from = close + 1;
+      }
+      return out;
+    };
+    const paramScopes = [];
+    {
+      const st = [root];
+      while (st.length > 0) {
+        const n = st.pop();
+        if (n.type === "function_declaration" || n.type === "function_expression" || n.type === "generator_function_declaration" || n.type === "generator_function" || n.type === "arrow_function" || n.type === "method_definition") {
+          const types2 = jsdocParamsOf(n);
+          if (types2.size > 0) {
+            paramScopes.push({ startLine: n.startPosition.row + 1, endLine: n.endPosition.row + 1, types: types2 });
+          }
+        }
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) st.push(c);
+        }
+      }
+    }
+    const jsdocParamTypeAt = (line, name) => {
+      let best = null;
+      for (const scope of paramScopes) {
+        if (line < scope.startLine || line > scope.endLine) continue;
+        if (!scope.types.has(name)) continue;
+        if (best === null || scope.endLine - scope.startLine < best.endLine - best.startLine) best = scope;
+      }
+      return best === null ? null : best.types.get(name) ?? null;
+    };
+    const stack = [root];
+    while (stack.length) {
+      const n = stack.pop();
+      if (n.type === "variable_declarator") {
+        const nameNode = n.childForFieldName("name");
+        const value = n.childForFieldName("value");
+        if (nameNode && nameNode.type === "identifier") {
+          const ctor = newCtorLeaf(value);
+          if (ctor !== null) record(nameNode.text, ctor, "new");
+          else {
+            const docType = jsdocTypeOf(n);
+            if (docType !== null) record(nameNode.text, docType, "jsdoc");
+          }
+        }
+      } else if (n.type === "field_definition") {
+        const prop = n.childForFieldName("property");
+        const value = n.childForFieldName("value");
+        const ctor = newCtorLeaf(value);
+        if (prop?.type === "property_identifier" && ctor !== null) {
+          record(`this.${prop.text}`, ctor, "assignment");
+        }
+      } else if (n.type === "assignment_expression") {
+        const left = n.childForFieldName("left");
+        const right = n.childForFieldName("right");
+        const ctor = newCtorLeaf(right);
+        const line = n.startPosition.row + 1;
+        if (left && ctor !== null) {
+          if (left.type === "identifier") record(left.text, ctor, "assignment");
+          else if (left.type === "member_expression") {
+            const obj = left.childForFieldName("object");
+            const prop = left.childForFieldName("property");
+            if (obj?.type === "this" && prop?.type === "property_identifier") {
+              record(`this.${prop.text}`, ctor, "assignment");
+            }
+          }
+        } else if (left && right && left.type === "member_expression" && right.type === "identifier") {
+          const obj = left.childForFieldName("object");
+          const prop = left.childForFieldName("property");
+          if (obj?.type === "this" && prop?.type === "property_identifier") {
+            const paramType = jsdocParamTypeAt(line, right.text);
+            if (paramType !== null) record(`this.${prop.text}`, paramType, "jsdoc");
+          }
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    return types;
+  }
+  /**
+   * THE CLASS `this` IS BOUND TO AT A CALL SITE — `null` when the call's `this` is not a
+   * class instance (a plain function's dynamic `this`, or no class at all).
+   *
+   * PURE SYNTAX, no inference: an arrow function does not rebind `this`, so it is stepped
+   * through; a `method_definition`'s own class is found by the same walk (the class ancestor
+   * is ABOVE it), and a nested `function` expression/declaration rebinds `this`, so the walk
+   * stops there and answers null. A static method or static block answers the CLASS, which is
+   * what a class-like owner symbol is for.
+   */
+  enclosingThisClass(n) {
+    let p = n.parent;
+    while (p) {
+      if (p.type === "class_declaration") return p.childForFieldName("name")?.text ?? null;
+      if (p.type === "function_declaration" || p.type === "function_expression" || p.type === "generator_function_declaration" || p.type === "generator_function") return null;
+      p = p.parent;
+    }
+    return null;
+  }
+  extractCallRelationships(node, symbols, relationships, moduleName, receiverTypes, deadSpans = []) {
+    const resolveCurrent = (n, current) => {
+      const fnName = n.childForFieldName?.("name")?.text;
+      if ((n.type === "function_declaration" || n.type === "generator_function_declaration" || n.type === "method_definition" || n.type === "function_expression") && fnName) {
+        return fnName;
+      }
+      if (n.type === "variable_declarator") {
+        const nameNode = n.childForFieldName("name");
+        const valueNode = n.childForFieldName("value");
+        if (nameNode && nameNode.type === "identifier" && valueNode && (valueNode.type === "arrow_function" || valueNode.type === "function_expression")) {
+          return nameNode.text;
+        }
+      }
+      if (n.type === "class_declaration") {
+        const nm = n.childForFieldName("name")?.text;
+        if (nm) return nm;
+      }
+      if (n.type === "assignment_expression") {
+        const left = n.childForFieldName("left");
+        const right = n.childForFieldName("right");
+        if (left && right && (right.type === "function_expression" || right.type === "arrow_function") && left.type === "member_expression") {
+          const obj = left.childForFieldName("object");
+          const prop = left.childForFieldName("property");
+          if (obj && obj.type === "member_expression") {
+            const protoProp = obj.childForFieldName("property");
+            if (protoProp && protoProp.text === "prototype" && prop) {
+              return prop.text;
+            }
+          }
+        }
+      }
+      return current;
+    };
+    const processNode = (n, current) => {
+      if (isNodeInDeadSpans(deadSpans, n)) return;
+      if (this.inDecoratorPosition(n)) return;
+      current = resolveCurrent(n, current);
+      const callSource = current || moduleName;
+      if (n.type === "call_expression") {
+        const fn = n.childForFieldName("function");
+        const isImportCallee = !!fn && (fn.type === "import" || fn.type === "identifier" && fn.text === "import");
+        if (fn && !(fn.type === "identifier" && fn.text === "require" || isImportCallee)) {
+          let targetName = fn.text;
+          let fullCallee = fn.text;
+          let skip = false;
+          let nameNode = fn;
+          if (fn.type === "member_expression") {
+            const prop = fn.childForFieldName("property");
+            if (prop) {
+              targetName = prop.text;
+              nameNode = prop;
+            }
+          } else if (fn.type === "subscript_expression") {
+            skip = true;
+          }
+          if (skip) {
+          } else if (targetName.length > 100 || targetName.includes("\n") || targetName.includes("`") || targetName.includes("${") || hasBraceEquals(targetName) || !isNameNode(nameNode)) {
+          } else if (this.isJSBuiltinCall(targetName, fullCallee)) {
+          } else {
+            const boundCallee = fn.type === "identifier" ? this.localBindingTarget(fn, targetName, callSource) : null;
+            const importedCallee = boundCallee ? null : fn.type === "identifier" ? this.importedBindingFor(fn, targetName) : null;
+            let receiverImport = null;
+            if (!boundCallee && !importedCallee && fn.type === "member_expression") {
+              let recvRoot = fn.childForFieldName("object");
+              while (recvRoot && recvRoot.type === "member_expression") recvRoot = recvRoot.childForFieldName("object");
+              if (recvRoot?.type === "identifier") {
+                const candidate = this.importedBindingFor(recvRoot, recvRoot.text);
+                if (candidate && isExternalSpecifier(candidate.specifier)) receiverImport = candidate;
+              }
+              if (receiverImport && receiverImport.binding === targetName) receiverImport = null;
+            }
+            relationships.push({
+              source: callSource,
+              target: boundCallee ?? targetName,
+              type: ASTEngine.RelationshipType.Calls,
+              confidence: 0.9,
+              // The callee LEAF — for `a.b.c()` the property node, so a chain's
+              // call does not take the chain's opening line.
+              ...this.lineField(fn.type === "member_expression" ? fn.childForFieldName("property") ?? fn : fn),
+              metadata: {
+                calleeExpression: fullCallee,
+                ...boundCallee ? { localBinding: true } : {},
+                ...importedCallee ? { importedBinding: importedCallee } : {},
+                ...receiverImport ? {
+                  receiverImport,
+                  receiverImportSpecifier: receiverImport.specifier,
+                  receiverImportBinding: receiverImport.binding
+                } : {},
+                // The receiver's stated type, on the store's EXISTING channel: `metadata.owner`
+                // is what `member-owner-resolution.ts` (claimOwnerCarryingTargets +
+                // resolveMemberTargetsByOwner) reads on BOTH production resolution paths — it
+                // re-resolves the row inside that class, which is what stops `c.run()` binding
+                // to another file's same-named method. `ownerEvidence` says WHICH syntactic
+                // proof produced the owner ({new, assignment, this, jsdoc, class-static,
+                // this-alias}) so coverage is a
+                // countable number per evidence class rather than one asserted figure. NO new
+                // channel is introduced: a wrong owner is worse than none, because the store
+                // withdraws the name binding for an owner-carrying row and then declines.
+                ...fn.type === "member_expression" ? (() => {
+                  const object = fn.childForFieldName("object");
+                  if (!object) return {};
+                  let recv;
+                  if (object.type === "identifier") {
+                    recv = receiverTypes.get(object.text) ?? this.staticClassReceiver(object, object.text) ?? this.thisAliasOwnerAt(object, object.text) ?? void 0;
+                  } else if (object.type === "this") {
+                    const cls = this.enclosingThisClass(fn);
+                    if (cls) recv = { type: cls, evidence: "this" };
+                  } else if (object.type === "member_expression") {
+                    const inner = object.childForFieldName("object");
+                    const prop = object.childForFieldName("property");
+                    if (inner?.type === "this" && prop) recv = receiverTypes.get(`this.${prop.text}`);
+                  }
+                  return recv ? { owner: recv.type, ownerEvidence: recv.evidence } : {};
+                })() : {}
+              }
+            });
+          }
+        }
+      } else if (n.type === "new_expression") {
+        const ctor = n.childForFieldName("constructor");
+        if (ctor) {
+          let ctorName = "";
+          if (ctor.type === "identifier") ctorName = ctor.text;
+          else if (ctor.type === "member_expression") {
+            const prop = ctor.childForFieldName("property");
+            ctorName = prop ? prop.text : ctor.text;
+          }
+          if (ctorName && !JS_GLOBAL_CONSTRUCTORS.has(ctorName)) {
+            const boundCtor = ctor.type === "identifier" ? this.localBindingTarget(ctor, ctorName, callSource) : null;
+            const importedCtor = boundCtor ? null : ctor.type === "identifier" ? this.importedBindingFor(ctor, ctorName) : null;
+            relationships.push({
+              source: callSource,
+              target: boundCtor ?? ctorName,
+              type: ASTEngine.RelationshipType.Instantiates,
+              confidence: 0.95,
+              // The CLASS NAME node: for `new ns.Thing()` the property leaf,
+              // since the target is the leaf (TSD3 leaf identity).
+              ...this.lineField(ctor.type === "member_expression" ? ctor.childForFieldName("property") ?? ctor : ctor),
+              metadata: boundCtor ? { localBinding: true } : importedCtor ? { importedBinding: importedCtor } : {}
+            });
+          }
+        }
+      } else if (n.type === "jsx_element" || n.type === "jsx_self_closing_element") {
+        const opening = n.type === "jsx_self_closing_element" ? n : n.namedChild(0);
+        if (opening && (opening.type === "jsx_self_closing_element" || opening.type === "jsx_opening_element")) {
+          const identifier = opening.namedChild(0);
+          if (identifier && identifier.type === "identifier") {
+            const char = identifier.text[0];
+            if (char && char === char.toUpperCase() && char !== char.toLowerCase()) {
+              const boundJsx = this.localBindingTarget(identifier, identifier.text, callSource);
+              const importedJsx = boundJsx ? null : this.importedBindingFor(identifier, identifier.text);
+              relationships.push({
+                source: callSource,
+                target: boundJsx ?? identifier.text,
+                type: ASTEngine.RelationshipType.Renders,
+                confidence: 0.9,
+                ...this.lineField(identifier),
+                metadata: {
+                  jsxElement: identifier.text,
+                  ...boundJsx ? { localBinding: true } : {},
+                  ...importedJsx ? { importedBinding: importedJsx } : {}
+                }
+              });
+            }
+          }
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const child = n.namedChild(i);
+        if (child) processNode(child, current);
+      }
+    };
+    processNode(node, null);
+  }
+  extractExportRelationships(exports, relationships, moduleActor, declaredNames) {
+    const CJS_PROPERTY_CLAIM_FORMS = /* @__PURE__ */ new Set([
+      "module-exports-object",
+      "exports-object",
+      "deep-member-assignment"
+    ]);
+    for (const item of exports) {
+      const isCjs = item.metadata?.viaCommonJs === true;
+      const localName = typeof item.metadata?.localName === "string" ? String(item.metadata.localName) : "";
+      const defaultForm = isCjs ? "" : item.metadata?.viaDefaultDeclaration === true ? "named-declaration" : item.metadata?.viaAliasDefault === true ? "export-alias" : item.metadata?.viaDefaultExpression === true ? "expression" : item.metadata?.viaAnonymousDefaultExpression === true ? "anonymous" : "anonymous";
+      const claimMarkers = {};
+      if (item.isDefault && !isCjs) {
+        claimMarkers.defaultExportForm = defaultForm;
+        if (localName) claimMarkers.defaultExportLocalName = localName;
+        claimMarkers.defaultExport = { form: defaultForm, ...localName ? { localName } : {} };
+      } else if (isCjs && !item.isDefault && !declaredNames.has(item.name) && CJS_PROPERTY_CLAIM_FORMS.has(String(item.metadata?.cjsForm ?? ""))) {
+        const cjsForm = String(item.metadata?.cjsForm ?? "module-exports-unknown");
+        claimMarkers.moduleExportsProperty = item.name;
+        claimMarkers.moduleExportsForm = cjsForm;
+        claimMarkers.moduleExports = { property: item.name, form: cjsForm };
+      }
+      relationships.push({
+        source: moduleActor,
+        target: item.name,
+        type: ASTEngine.RelationshipType.Exports,
+        confidence: 1,
+        // The exported NAME's own line, from the export's range when the
+        // collector recorded one. Absent rather than invented when it did not.
+        ...item.range?.startLine ? { line_number: item.range.startLine } : {},
+        // THE RECORD'S OWN metadata is carried through, not replaced by
+        // `{isDefault}`. JSD53's ruling: JD-J14 decided a NAMED default
+        // declaration is exported under `default` (ECMAScript) and kept the
+        // declaration's own name in `metadata.localName` "so nothing is lost"
+        // — and this line then dropped it, so the loss was total. The row's
+        // target `default` matches no symbol (it is in the symbol denylist),
+        // so `import Def from "./m"` could not resolve for any module with a
+        // named default export, and `script/m40/verify-import-resolution.ts`
+        // JD2.4 has been red since. `loadImportInputs` reads exactly this
+        // `localName` (src/ast/import-resolution.ts) to recover the
+        // declaration in the row's own file. Additive: `isDefault` stays, and
+        // the engine's own evidenceClass/fileLevel are added later.
+        metadata: { isDefault: item.isDefault, ...item.metadata ?? {}, ...claimMarkers }
+      });
+    }
+  }
+  // ============================================================================
+  // HELPERS
+  // ============================================================================
+  /**
+   * The CJS public-surface path BENEATH the base, read structurally.
+   *
+   * `module.exports.a.b = 1` -> ["a","b"]; `exports.g.x = 1` -> ["g","x"];
+   * `exports.tag = 1` -> [] (an empty array, which is truthy — the caller
+   * relies on that to tell "CJS surface" from "not CJS surface").
+   *
+   * Returns null when the chain is not a module surface (`svc.limit = 1`, whose
+   * obj is a plain identifier) or when a segment is not statically nameable
+   * (`module[expr].a = 1`, `(freeModule.exports = lodash)._ = 1`). An unnameable
+   * segment yields NO export rather than a fabricated one — the defect class the
+   * regex policy exists to prevent, measured on minified lodash where the text
+   * form emitted the literal export name "(ie.exports=we)._".
+   */
+  cjsSurfacePath(obj) {
+    const segs = [];
+    let cur = obj;
+    while (cur && (cur.type === "member_expression" || cur.type === "subscript_expression")) {
+      if (cur.type === "subscript_expression") {
+        const idx = cur.childForFieldName("index");
+        if (!idx) return null;
+        if (idx.type !== "string" && idx.type !== "number") return null;
+        segs.unshift(stringContent(idx));
+      } else {
+        const prop = cur.childForFieldName("property");
+        if (!prop) return null;
+        segs.unshift(prop.text);
+      }
+      cur = cur.childForFieldName("object");
+    }
+    if (!cur) return null;
+    if (cur.type === "member_expression" || cur.type === "subscript_expression") return null;
+    if (cur.type !== "identifier") return null;
+    if (cur.text === "module") return segs[0] === "exports" ? segs.slice(1) : null;
+    if (cur.text === "exports") return segs;
+    return null;
+  }
+  isJSBuiltinCall(targetName, fullCallee) {
+    if (targetName === "super") return true;
+    if (JS_CONSOLE_BUILTINS.has(fullCallee || "")) return true;
+    const trimmed = stripWhitespace(fullCallee || "");
+    if (JS_CONSOLE_BUILTINS.has(trimmed)) return true;
+    if (JS_OBJECT_LEAF_METHODS.has(targetName)) return true;
+    return false;
+  }
+  /**
+   * M49 #868: the JS twin of the typescript analyzer's `decoratorLines`. The
+   * name list is what the store reads on the symbol; the PARALLEL line list
+   * lets the decorator's reference edge name the line the decorator is
+   * written on. A name already recorded keeps its FIRST position, so the two
+   * lists stay in lockstep by construction.
+   */
+  collectOwnDecoratorDetails(node) {
+    const names = [];
+    const lines = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c || c.type !== "decorator") continue;
+      const name = jsDecoratorName(c);
+      if (name.length === 0 || names.includes(name)) continue;
+      names.push(name);
+      lines.push(c.startPosition.row + 1);
+    }
+    return { names, lines };
+  }
+  /**
+   * M49 #868 — is this node written in DECORATOR position?
+   *
+   * A decorator is METADATA on the symbol it decorates, not a call or a read
+   * made by whoever lexically encloses it. The family already rules this way
+   * (typescript: `inDecoratorPosition`, real-typescript-analyzer.ts; the JVM
+   * analyzers attach annotations as metadata and emit no edge; the python
+   * oracle documents PYD1). javascript was the exception: a class-body
+   * `@inject("db")` is syntactically a call expression, so the walk attributed
+   * it to the enclosing CLASS — `calls Service -> inject` beside the
+   * member-scoped edge that should carry it — and the bare-read pass turned
+   * every decorator name into a `uses` edge from the decorated symbol.
+   *
+   * The walk stops at the enclosing statement/declaration boundary rather than
+   * walking to the root: a decorator on a METHOD cannot make the method's own
+   * body a decorator position (its decorators are siblings, never ancestors of
+   * the body).
+   */
+  inDecoratorPosition(n) {
+    if (!this.hasAnyDecoratorNode) return false;
+    let p = n.parent;
+    while (p) {
+      if (p.type === "decorator") return true;
+      if (p.type === "class_declaration" || p.type === "class" || p.type === "function_declaration" || p.type === "generator_function_declaration" || p.type === "method_definition" || p.type === "statement_block" || p.type === "program") {
+        return false;
+      }
+      p = p.parent;
+    }
+    return false;
+  }
+  /**
+   * M49 #868 — CLASS decorators, which the JS grammar places in TWO spots:
+   * own children of `class_declaration`, or own children of the WRAPPING
+   * `export_statement` when the class is exported (probe:
+   * `export_statement children=[decorator@2, export@3, class_declaration@3]`).
+   * The own-child reader alone therefore dropped every decorator on an
+   * exported class — `@sealed export class A {}` produced no decorators on `A`
+   * and no reference edge at all, while the typescript twin's
+   * `collectDecoratorsForClass` already checks the export_statement.
+   */
+  collectClassDecoratorDetails(node) {
+    const own = this.collectOwnDecoratorDetails(node);
+    const wrapping = node.parent?.type === "export_statement" ? this.collectOwnDecoratorDetails(node.parent) : { names: [], lines: [] };
+    if (wrapping.names.length === 0) return own;
+    const names = [...own.names];
+    const lines = [...own.lines];
+    for (let i = 0; i < wrapping.names.length; i++) {
+      if (names.includes(wrapping.names[i])) continue;
+      names.push(wrapping.names[i]);
+      lines.push(wrapping.lines[i]);
+    }
+    return { names, lines };
+  }
+  /**
+   * M49 #868: a decorator is metadata on the symbol it decorates, so its name
+   * is reachable as a REFERENCE from that symbol (the typescript twin's
+   * `extractDecoratorRelationships`, and the shape the M59 #860 fixture pins
+   * there). Emitted for every decorated symbol, with the decorator's OWN line:
+   * a decorator whose line was never recorded stays line-less rather than
+   * borrowing the declaration's line (never invent a line, #823).
+   */
+  extractDecoratorRelationships(symbols, relationships) {
+    for (const symbol of symbols) {
+      if (!symbol.decorators || symbol.decorators.length === 0) continue;
+      const lines = symbol.metadata?.decoratorLines;
+      for (let i = 0; i < symbol.decorators.length; i++) {
+        const decorator = symbol.decorators[i];
+        const line = lines?.[i];
+        relationships.push({
+          source: symbol.name,
+          target: decorator,
+          type: ASTEngine.RelationshipType.Decorates,
+          confidence: 1,
+          ...typeof line === "number" ? { line_number: line } : {},
+          metadata: {
+            isDecorator: true,
+            decoratorLine: typeof line === "number" ? line : null
+          }
+        });
+      }
+    }
+  }
+  hasToken(node, token) {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child || child.isNamed) continue;
+      if (child.type === token) return true;
+    }
+    return false;
+  }
+  isConstDeclarator(node) {
+    const parent = node.parent;
+    if (parent && (parent.type === "lexical_declaration" || parent.type === "variable_declaration")) {
+      const kind = parent.childForFieldName("kind");
+      if (kind) return kind.text === "const";
+    }
+    return false;
+  }
+  /**
+   * M59 (#825) follow-up: the destructuring walk carries the binding NODE so each
+   * destructured symbol ranges at its own NAME
+   * instead of the whole declarator (`const {` for a wrapped binding list).
+   * Names and nodes stay in lockstep by construction (single walk).
+   */
+  collectPatternPairs(pattern) {
+    const out = [];
+    const walk = (n) => {
+      switch (n.type) {
+        case "shorthand_property_identifier":
+        case "shorthand_property_identifier_pattern":
+        case "identifier":
+          if (n.text) out.push({ name: n.text, node: n });
+          break;
+        case "pair_pattern": {
+          const value = n.childForFieldName("value");
+          if (value) walk(value);
+          break;
+        }
+        case "assignment_pattern":
+        case "object_assignment_pattern": {
+          const left = n.childForFieldName("left");
+          if (left) walk(left);
+          break;
+        }
+        case "rest_pattern": {
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (c) walk(c);
+          }
+          break;
+        }
+        default:
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (c) walk(c);
+          }
+      }
+    };
+    walk(pattern);
+    return out;
+  }
+  extractParameters(paramsNode) {
+    if (!paramsNode) return [];
+    const out = [];
+    for (let i = 0; i < paramsNode.namedChildCount; i++) {
+      const p = paramsNode.namedChild(i);
+      if (!p) continue;
+      if (p.type === "identifier") {
+        out.push({ name: p.text });
+      } else if (p.type === "assignment_pattern") {
+        const left = p.childForFieldName("left");
+        if (left && left.type === "identifier") out.push({ name: left.text });
+        else if (left && (left.type === "object_pattern" || left.type === "array_pattern")) {
+          out.push({ name: p.text.slice(0, 60) });
+        }
+      } else if (p.type === "object_pattern" || p.type === "array_pattern") {
+        out.push({ name: p.text.slice(0, 60) });
+      } else if (p.type === "rest_pattern") {
+        const inner = this.findChildByType(p, "identifier");
+        out.push({ name: inner ? inner.text : "..." });
+      }
+    }
+    return out;
+  }
+  methodComplexity(node) {
+    let c = 1;
+    const stack = [node];
+    while (stack.length) {
+      const n = stack.pop();
+      if (n.type === "if_statement" || n.type === "for_statement" || n.type === "for_in_statement" || n.type === "do_statement" || n.type === "while_statement" || n.type === "catch_clause" || n.type === "switch_case" || n.type === "ternary_expression") {
+        c++;
+      } else if (n.type === "binary_expression") {
+        const op = n.childForFieldName("operator")?.text;
+        if (op === "&&" || op === "||" || op === "??") c++;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    return c;
+  }
+  collectComments(node) {
+    const comments = [];
+    const scanNode = node.parent && node.parent.type === "export_statement" ? node.parent : node;
+    let sibling = scanNode.previousSibling;
+    let anchorRow = scanNode.startPosition.row;
+    while (sibling) {
+      if (sibling.type === "comment") {
+        if (sibling.endPosition.row + 1 < anchorRow) break;
+        comments.unshift(stripCommentMarkers(sibling.text));
+        anchorRow = sibling.startPosition.row;
+        sibling = sibling.previousSibling;
+      } else {
+        break;
+      }
+    }
+    return comments.length > 0 ? comments : void 0;
+  }
+  collectModuleExports(right, exports, node, isDefault, surface) {
+    const form = (kind) => `${surface}-${kind}`;
+    if (right.type === "object") {
+      for (let i = 0; i < right.namedChildCount; i++) {
+        const c = right.namedChild(i);
+        if (!c) continue;
+        if (c.type === "shorthand_property_identifier" || c.type === "identifier") {
+          exports.push({ name: c.text, isDefault: false, range: this.nodeToRange(c), metadata: { viaCommonJs: true, cjsForm: form("object") } });
+        } else if (c.type === "pair") {
+          const key = c.childForFieldName("key");
+          if (key && (key.type === "property_identifier" || key.type === "identifier")) {
+            exports.push({ name: key.text, isDefault: false, range: this.nodeToRange(key), metadata: { viaCommonJs: true, cjsForm: form("object") } });
+          }
+        } else if (c.type === "method_definition") {
+          const nm = c.childForFieldName("name");
+          if (nm) exports.push({ name: nm.text, isDefault: false, range: this.nodeToRange(nm), metadata: { viaCommonJs: true, cjsForm: form("object") } });
+        }
+      }
+    } else if (right.type === "identifier") {
+      exports.push({ name: right.text, isDefault, range: this.nodeToRange(right), metadata: { viaCommonJs: true, cjsForm: form("binding") } });
+    } else if (right.type === "function_expression" || right.type === "arrow_function" || right.type === "class_declaration" || right.type === "class") {
+      const nm = right.type === "class_declaration" || right.type === "class" ? right.childForFieldName("name")?.text : void 0;
+      exports.push({ name: nm ?? "default", isDefault, range: this.nodeToRange(right), metadata: { viaCommonJs: true, cjsForm: form("expression") } });
+    }
+    {
+      const seen = /* @__PURE__ */ new Set();
+      for (let i = exports.length - 1; i >= 0; i--) {
+        if (seen.has(exports[i].name)) exports.splice(i, 1);
+        else seen.add(exports[i].name);
+      }
+    }
+  }
+  collectExportStatement(node, exports) {
+    let isDefault = false;
+    for (let i = 0; i < node.childCount; i++) {
+      const t = node.child(i);
+      if (t && !t.isNamed && t.text === "default") {
+        isDefault = true;
+        break;
+      }
+    }
+    let foundNamed = false;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (!child) continue;
+      if (child.type === "identifier" && !isDefault) {
+        foundNamed = true;
+        exports.push({ name: child.text, isDefault, range: this.nodeToRange(child) });
+      } else if (child.type === "export_clause") {
+        for (let j = 0; j < child.namedChildCount; j++) {
+          const spec = child.namedChild(j);
+          if (spec && spec.type === "export_specifier") {
+            const exportName = spec.childForFieldName("alias")?.text ?? spec.childForFieldName("name")?.text ?? this.findChildByType(spec, "identifier")?.text;
+            const aliasNode = spec.childForFieldName("alias");
+            const isAsDefault = !!aliasNode && aliasNode.text === "default";
+            if (exportName) {
+              foundNamed = true;
+              exports.push({
+                name: isAsDefault ? "default" : exportName,
+                isDefault: isAsDefault,
+                range: this.nodeToRange(spec),
+                metadata: isAsDefault ? { viaAliasDefault: true, localName: spec.childForFieldName("name")?.text } : void 0
+              });
+            }
+          }
+        }
+      } else if (child.type === "function_declaration" || child.type === "generator_function_declaration" || child.type === "class_declaration" || child.type === "function_expression" || child.type === "arrow_function" || child.type === "class") {
+        const n = child.childForFieldName("name");
+        foundNamed = true;
+        exports.push({
+          name: isDefault ? "default" : n?.text ?? "default",
+          isDefault,
+          range: this.nodeToRange(child),
+          ...isDefault && n?.text ? { metadata: { viaDefaultDeclaration: true, localName: n.text } } : {}
+        });
+      } else if (child.type === "lexical_declaration" || child.type === "variable_declaration") {
+        for (let j = 0; j < child.namedChildCount; j++) {
+          const decl = child.namedChild(j);
+          if (decl && decl.type === "variable_declarator") {
+            const nm = decl.childForFieldName("name");
+            if (nm && nm.type === "identifier") {
+              foundNamed = true;
+              exports.push({ name: nm.text, isDefault, range: this.nodeToRange(nm) });
+            }
+          }
+        }
+      }
+    }
+    if (isDefault && !foundNamed) {
+      const valueNode = node.childForFieldName("value");
+      const isIdentifierValue = valueNode?.type === "identifier";
+      exports.push({
+        name: "default",
+        isDefault: true,
+        range: this.nodeToRange(node),
+        // EVIDENCE for the exports claim: the statement form, and — when the defaulted expression IS
+        // a plain identifier — the local binding it names (`export default foo`). An anonymous
+        // expression (literal, object, call, anonymous function) states no local name and says so
+        // rather than inventing one.
+        metadata: isIdentifierValue ? { viaDefaultExpression: true, localName: valueNode.text } : { viaAnonymousDefaultExpression: true }
+      });
+    }
+    {
+      let sawDefault = false;
+      for (let i = exports.length - 1; i >= 0; i--) {
+        if (exports[i].name !== "default") continue;
+        if (sawDefault) exports.splice(i, 1);
+        else sawDefault = true;
+      }
+    }
+    {
+      const seenNames = /* @__PURE__ */ new Set();
+      for (let i = exports.length - 1; i >= 0; i--) {
+        if (seenNames.has(exports[i].name)) exports.splice(i, 1);
+        else seenNames.add(exports[i].name);
+      }
+    }
+  }
+  findChildByType(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && child.type === type) return child;
+    }
+    return null;
+  }
+  /**
+   * M14 / R3 — THE CALL-SHAPED CLASS HERITAGE. A class's supertype may be a CALL, and there are
+   * TWO shapes of it, and they put the base and the mixin in OPPOSITE positions:
+   *
+   *   (A) `class X extends Base.extend(M1, M2)` — a MEMBER call. The RECEIVER names the BASE and
+   *       the ARGUMENTS name the MIXINS composed into X's supertype chain. This is the Ember /
+   *       Backbone class-extension idiom, and it is the shape the corpus overwhelmingly has.
+   *   (B) `class X extends MixinFn(Base)` — a plain FUNCTION call. The CALLEE names the MIXIN and
+   *       the ARGUMENT names the BASE. This is the TypeScript/Redwood mixin-factory idiom, where
+   *       `MixinFn(Base)` evaluates to a class that extends Base.
+   *
+   * WHY THE SHAPE, NOT A NAME, DECIDES: C2 forbids a naming convention as the discriminator.
+   * `Route.extend(M)` and `_.extend(obj, props)` are the same member-call shape, and only the
+   * callee's SHAPE (member vs plain) tells the two apart structurally. The discriminator here is
+   * the node shape of the heritage's own expression — `member_expression` versus `identifier` —
+   * and the role of each operand follows from that shape. It is not "the method is called extend".
+   *
+   * WHY IT MATTERS: `findChildByType` scans the DIRECT named children of the node it is given, and
+   * a call-shaped heritage's single direct named child is the `call_expression` — so the base's
+   * `identifier` and `member_expression` are GRANDCHILDREN of it. Before this, every call-shaped
+   * heritage published NO edge at all: neither the base nor the mixin. Measured over the admitted
+   * population by `script/m14/javascript-heritage-census.ts`: 76 call-shaped clauses, of which the
+   * analyzer's own lookup pair found 0.
+   *
+   * WHAT IT DELIBERATELY DOES NOT DO: it does not look inside the call for a base, so it never
+   * claims a base that the call computes rather than names — the 11 arguments that are themselves
+   * calls (`SortableFactory([...])`) contribute a mixin FACTORY, and this publishes the factory's
+   * own name only when the argument names something.
+   */
+  callShapedHeritage(heritage) {
+    const call = this.findChildByType(heritage, "call_expression");
+    if (!call) return null;
+    const callee = call.childForFieldName("function");
+    if (!callee) return null;
+    const args = this.findChildByType(call, "arguments");
+    const argNodes = [];
+    if (args) {
+      for (let i = 0; i < args.namedChildCount; i++) {
+        const a = args.namedChild(i);
+        if (a) argNodes.push(a);
+      }
+    }
+    if (callee.type === "member_expression") {
+      const receiver = callee.childForFieldName("object");
+      return { base: receiver ?? null, mixins: argNodes, shape: "member" };
+    }
+    if (callee.type === "identifier") {
+      return { base: argNodes[0] ?? null, mixins: [callee], shape: "function" };
+    }
+    return null;
+  }
+  /**
+   * M14 / R3 — the relationship rows a call-shaped heritage publishes. The base becomes an
+   * `extends` edge and each mixin becomes a `mixes_in` edge, with the same binding resolution the
+   * identifier form already uses, so the rows are resolvable on exactly the same terms.
+   */
+  callShapedHeritageRows(heritage, source) {
+    const shape = this.callShapedHeritage(heritage);
+    const out = { base: null, mixins: [] };
+    if (!shape) return out;
+    const resolve = (node) => {
+      if (!node) return null;
+      if (node.type === "identifier") {
+        const bound = this.localBindingTarget(node, node.text, source);
+        const imported = bound ? null : this.importedBindingFor(node, node.text);
+        return {
+          target: bound ?? node.text,
+          node,
+          metadata: bound ? { localBinding: true } : imported ? { importedBinding: imported } : {}
+        };
+      }
+      if (node.type === "member_expression") {
+        return { target: node.text, node, metadata: {} };
+      }
+      return null;
+    };
+    const base = resolve(shape.base);
+    if (base) out.base = base;
+    for (const m of shape.mixins) {
+      const r = resolve(m);
+      if (r) out.mixins.push(r);
+    }
+    return out;
+  }
+  detectsJsx(rootNode) {
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (node.type === "jsx_element" || node.type === "jsx_self_closing_element") return true;
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    return false;
+  }
+  /**
+   * Field-access uses: member_expression nodes emit root-anchored Uses edges
+   * @0.6 with isFieldAccess marker - parity with java/groovy/kotlin
+   * collectors. Nested member_expressions mean each chain segment appears as
+   * a target (anti-skip guarantee); optional chains (?.) are
+   * member_expression nodes with optional_chain tokens in this grammar.
+   */
+  /**
+   * M14 — instanceof type references. `x instanceof T` is JavaScript's only
+   * unambiguous named-type usage; emitted as References from the enclosing
+   * function/class. The right operand lexes as identifier (expression
+   * position), so no type_identifier filtering applies.
+   */
+  extractInstanceofRefs(rootNode, relationships, moduleName) {
+    const emitted = /* @__PURE__ */ new Set();
+    const resolveSource = (start) => {
+      let p = start.parent;
+      while (p) {
+        if (p.type === "class_declaration" || p.type === "function_declaration" || p.type === "generator_function_declaration" || p.type === "method_definition" || // M14 #419 J6: top-level const r = x instanceof T attributes the
+        // reference to r (the enclosing declaration), never the global
+        // placeholder (TS same-wave fix).
+        p.type === "variable_declarator") {
+          for (let i = 0; i < p.namedChildCount; i++) {
+            const c = p.namedChild(i);
+            if (!c) continue;
+            if ((c.type === "identifier" || c.type === "property_identifier") && c.text) return c.text;
+          }
+        }
+        p = p.parent;
+      }
+      return moduleName;
+    };
+    const walk = (n) => {
+      if (n.type === "binary_expression") {
+        let isInstanceof = false;
+        for (let i = 0; i < n.childCount; i++) {
+          const c = n.child(i);
+          if (c && !c.isNamed && c.text === "instanceof") {
+            isInstanceof = true;
+            break;
+          }
+        }
+        if (isInstanceof && n.namedChildCount >= 2) {
+          const right = n.namedChild(n.namedChildCount - 1);
+          if (right) {
+            const source = resolveSource(n);
+            const key = `${source}|${right.text}`;
+            if (!emitted.has(key)) {
+              emitted.add(key);
+              const boundRef = right.type === "identifier" ? this.localBindingTarget(right, right.text, source) : null;
+              const importedRef = boundRef ? null : right.type === "identifier" ? this.importedBindingFor(right, right.text) : null;
+              relationships.push({
+                source,
+                target: boundRef ?? right.text,
+                type: ASTEngine.RelationshipType.References,
+                confidence: 0.95,
+                ...this.lineField(right),
+                metadata: {
+                  relationshipType: "instanceof_check",
+                  ...boundRef ? { localBinding: true } : {},
+                  ...importedRef ? { importedBinding: importedRef } : {}
+                }
+              });
+            }
+          }
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) walk(c);
+      }
+    };
+    walk(rootNode);
+  }
+  collectFieldAccessUses(rootNode, relationships, moduleName, receiverTypes, deadSpans = []) {
+    const stack = [
+      { node: rootNode, owner: null, method: null, module: moduleName }
+    ];
+    const seen = /* @__PURE__ */ new Set();
+    while (stack.length > 0) {
+      const item = stack.pop();
+      const node = item.node;
+      const owner = item.owner;
+      const method = item.method;
+      if (this.inDecoratorPosition(node)) continue;
+      if (deadSpans.length > 0 && isNodeInDeadSpans(deadSpans, node)) continue;
+      if (node.type === "class_declaration" || node.type === "class") {
+        const nameNode = node.childForFieldName?.("name") ?? node.namedChildren.find((c) => c.type === "identifier");
+        const nextOwner2 = nameNode ? nameNode.text : owner;
+        for (let i = node.namedChildCount - 1; i >= 0; i--) {
+          const child = node.namedChild(i);
+          if (child) stack.push({ node: child, owner: nextOwner2, method: null, module: moduleName });
+        }
+        continue;
+      }
+      let nextMethod = method;
+      let nextOwner = owner;
+      if (node.type === "function_declaration" || node.type === "generator_function_declaration" || node.type === "method_definition") {
+        const nameNode = node.childForFieldName?.("name");
+        if (nameNode) nextMethod = nameNode.text;
+      } else if (node.type === "variable_declarator") {
+        const v = node.childForFieldName("value");
+        const nm = node.childForFieldName("name")?.text;
+        if (v && nm && (v.type === "arrow_function" || v.type === "function_expression")) nextMethod = nm;
+      } else if (node.type === "arrow_function" || node.type === "function_expression") {
+        const parent = node.parent;
+        if (parent?.type === "assignment_expression") {
+          const left = parent.childForFieldName("left");
+          const obj = left?.childForFieldName("object");
+          const prop = left?.childForFieldName("property");
+          if (obj?.type === "member_expression" && obj.childForFieldName("property")?.text === "prototype" && prop) {
+            nextMethod = prop.text;
+            nextOwner = obj.childForFieldName("object")?.text ?? owner;
+          }
+        }
+      }
+      if (node.type === "member_expression") {
+        const isCallCallee = node.parent?.type === "call_expression" && node.parent.childForFieldName("function")?.id === node.id;
+        if (isCallCallee) {
+          let root = node.childForFieldName("object");
+          while (root && root.type === "member_expression") root = root.childForFieldName("object");
+          const head = root && root.type === "identifier" ? root.text : "";
+          if (head && head !== "this" && head !== "super") {
+            const recvSource = method || owner || moduleName;
+            const recvScopeId = this.localBindingScopeId(root, head);
+            const recvBaseKey = `${recvSource}.#${head}`;
+            const recvKey = recvScopeId ? `${recvBaseKey}|${recvScopeId}` : recvBaseKey;
+            if (!seen.has(recvKey)) {
+              seen.add(recvKey);
+              seen.add(recvBaseKey);
+              const boundRecv = this.localBindingTarget(root, head, recvSource);
+              const importedRecv = boundRecv ? null : this.importedBindingFor(root, head);
+              relationships.push({
+                source: recvSource,
+                target: boundRecv ?? head,
+                type: ASTEngine.RelationshipType.Uses,
+                confidence: 0.6,
+                ...this.lineField(root),
+                metadata: {
+                  isFieldAccess: true,
+                  bareRead: true,
+                  callReceiver: true,
+                  ...boundRecv ? { localBinding: true } : {},
+                  ...recvScopeId ? { localBindingScope: recvScopeId } : {},
+                  ...importedRecv ? { importedBinding: importedRecv } : {}
+                }
+              });
+            }
+          }
+        }
+        if (!isCallCallee) {
+          const parts = [];
+          let cur = node;
+          while (cur && cur.type === "member_expression") {
+            const prop = cur.childForFieldName("property");
+            if (prop) parts.unshift({ seg: prop.text, node: prop });
+            cur = cur.childForFieldName("object");
+          }
+          const head = cur ? cur.text : "";
+          if (head && parts.length >= 1) {
+            const pType = node.parent?.type;
+            let isWrite = false;
+            if (pType === "assignment_expression" || pType === "augmented_assignment_expression") {
+              const lhs = node.parent.childForFieldName("left") ?? node.parent.namedChild(0);
+              isWrite = !!lhs && lhs.startIndex === node.startIndex && lhs.endIndex === node.endIndex;
+            }
+            if (!isWrite) {
+              if (head && head !== "this" && head !== "super" && cur?.type === "identifier") {
+                const rootSource = method || owner || moduleName;
+                const rootScopeId = this.localBindingScopeId(cur, head);
+                const rootBaseKey = `${rootSource}.#${head}`;
+                const rootKey = rootScopeId ? `${rootBaseKey}|${rootScopeId}` : rootBaseKey;
+                if (!seen.has(rootKey)) {
+                  seen.add(rootKey);
+                  seen.add(rootBaseKey);
+                  const boundRoot = cur?.type === "identifier" ? this.localBindingTarget(cur, head, rootSource) : null;
+                  const importedRoot = boundRoot ? null : cur?.type === "identifier" ? this.importedBindingFor(cur, head) : null;
+                  relationships.push({
+                    source: rootSource,
+                    target: boundRoot ?? head,
+                    type: ASTEngine.RelationshipType.Uses,
+                    confidence: 0.6,
+                    // The root identifier's own line (the chain may open on a
+                    // line the segments do not share).
+                    ...this.lineField(cur),
+                    metadata: {
+                      isFieldAccess: true,
+                      chainRoot: true,
+                      ...boundRoot ? { localBinding: true } : {},
+                      ...rootScopeId ? { localBindingScope: rootScopeId } : {},
+                      ...importedRoot ? { importedBinding: importedRoot } : {}
+                    }
+                  });
+                }
+              }
+              for (const { seg, node: segNode } of parts) {
+                const source = method || owner || moduleName;
+                const key = seg.startsWith("#") ? `${source}.$private${seg}` : `${source}.${seg}`;
+                if (!seen.has(key)) {
+                  seen.add(key);
+                  const recvOwner = (() => {
+                    if (cur?.type === "identifier" && head) {
+                      return receiverTypes.get(head) ?? this.staticClassReceiver(cur, head) ?? this.thisAliasOwnerAt(cur, head) ?? void 0;
+                    }
+                    if (cur?.type === "this") {
+                      const cls = this.enclosingThisClass(node);
+                      return cls ? { type: cls, evidence: "this" } : void 0;
+                    }
+                    return void 0;
+                  })();
+                  relationships.push({
+                    source,
+                    target: seg,
+                    type: ASTEngine.RelationshipType.Uses,
+                    confidence: 0.6,
+                    ...this.lineField(segNode),
+                    // `receiverRoot` is the chain's FIRST identifier when it IS an identifier
+                    // (`location.hash.substring` -> `location`), and empty for a call-rooted chain
+                    // (`$(el).removeClass` -> ""). It is published so the terminal claim pass can ask
+                    // memberChainClaim the question the rule is defined on — the RECEIVER ROOT — without
+                    // re-deriving the chain from text. Additive; consumers that do not read it are unaffected.
+                    metadata: {
+                      isFieldAccess: true,
+                      ...cur?.type === "identifier" && head ? { receiverRoot: head } : {},
+                      ...recvOwner ? { owner: recvOwner.type, ownerEvidence: recvOwner.evidence } : {}
+                    }
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+      if (node.type === "identifier") {
+        const txt = node.text;
+        if (txt !== "this" && txt !== "super" && txt !== "undefined" && txt !== "arguments") {
+          const p7 = node.parent;
+          const calleeFn = p7?.type === "call_expression" ? p7.childForFieldName("function") : null;
+          const isCallee = !!calleeFn && calleeFn.id === node.id;
+          let isWrite2 = false;
+          if (p7?.type === "assignment_expression" || p7?.type === "augmented_assignment_expression") {
+            const lhs2 = p7.childForFieldName("left") ?? p7.namedChild(0);
+            isWrite2 = !!lhs2 && lhs2.id === node.id;
+          }
+          const isDeclName = p7?.type === "variable_declarator" && p7.childForFieldName("name")?.id === node.id || p7?.type === "function_declaration" || p7?.type === "function_expression" || p7?.type === "generator_function_declaration" || p7?.type === "generator_function" || p7?.type === "method_definition" || p7?.type === "class_declaration" || p7?.type === "class";
+          const isPropKey = (p7?.type === "pair" || p7?.type === "pair_pattern") && p7.childForFieldName("key")?.id === node.id;
+          const isMemberPart = p7?.type === "member_expression";
+          const isPropName = p7?.type === "property_identifier";
+          const isJsxName = p7?.type.startsWith("jsx_") ?? false;
+          const isLabel = p7?.type === "labeled_statement";
+          const isShorthandProp = p7?.type === "shorthand_property_identifier";
+          const isImportBinding = p7?.type === "import_clause" || p7?.type === "import_specifier" || p7?.type === "namespace_import";
+          const isParamBinding = p7?.type === "formal_parameters" || p7?.type === "arrow_function" || p7?.type === "catch_clause";
+          const isPatternBinding = p7?.type === "rest_pattern" || p7?.type === "array_pattern" || p7?.type === "pair_pattern" || // `a = 1` in a pattern: the LEFT is the binding, the RIGHT is a
+          // genuine read (`function f(a = b)` must still read b).
+          p7?.type === "assignment_pattern" && (p7.childForFieldName("left") ?? p7.namedChild(0))?.id === node.id;
+          const isExportSpecifier = p7?.type === "export_specifier";
+          const isBindingSite = isImportBinding || isParamBinding || isPatternBinding || isExportSpecifier;
+          if (!isCallee && !isWrite2 && !isDeclName && !isPropKey && !isMemberPart && !isPropName && !isLabel && !isShorthandProp && !isJsxName && !isBindingSite) {
+            const bSource = method || owner || moduleName;
+            const bScopeId = this.localBindingScopeId(node, txt);
+            const bBaseKey = `${bSource}.#${txt}`;
+            const bKey = bScopeId ? `${bBaseKey}|${bScopeId}` : bBaseKey;
+            if (!seen.has(bKey)) {
+              seen.add(bKey);
+              seen.add(bBaseKey);
+              const boundRead = this.localBindingTarget(node, txt, bSource);
+              const importedRead = boundRead ? null : this.importedBindingFor(node, txt);
+              relationships.push({
+                source: bSource,
+                target: boundRead ?? txt,
+                type: ASTEngine.RelationshipType.Uses,
+                confidence: 0.6,
+                ...this.lineField(node),
+                metadata: {
+                  isFieldAccess: true,
+                  bareRead: true,
+                  ...boundRead ? { localBinding: true } : {},
+                  ...bScopeId ? { localBindingScope: bScopeId } : {},
+                  ...importedRead ? { importedBinding: importedRead } : {}
+                }
+              });
+            }
+          }
+        }
+      }
+      if (node.type === "template_substitution") {
+        const inCalleeOrWritePosition = (n) => {
+          let cur = n;
+          while (cur) {
+            const p = cur.parent;
+            if (!p || p.type === "template_substitution") break;
+            if (p.type === "call_expression") {
+              const fn = p.childForFieldName("function");
+              if (fn && fn.startIndex <= n.startIndex && n.endIndex <= fn.endIndex) return true;
+            }
+            if (p.type === "assignment_expression" || p.type === "augmented_assignment_expression") {
+              const left = p.childForFieldName("left") ?? p.namedChild(0);
+              if (left && left.startIndex <= n.startIndex && n.endIndex <= left.endIndex) return true;
+            }
+            cur = p;
+          }
+          return false;
+        };
+        const sub = (n) => {
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (!c) continue;
+            if (c.type === "identifier") {
+              if (inCalleeOrWritePosition(c)) continue;
+              const src2 = method || owner || moduleName;
+              const key = `${src2}.${c.text}`;
+              if (!seen.has(key)) {
+                seen.add(key);
+                seen.add(`${src2}.#${c.text}`);
+                const boundTmpl = this.localBindingTarget(c, c.text, src2);
+                const importedTmpl = boundTmpl ? null : this.importedBindingFor(c, c.text);
+                relationships.push({
+                  source: src2,
+                  target: boundTmpl ?? c.text,
+                  type: ASTEngine.RelationshipType.Uses,
+                  confidence: 0.85,
+                  ...this.lineField(c),
+                  metadata: {
+                    isTemplateInterpolation: true,
+                    ...boundTmpl ? { localBinding: true } : {},
+                    ...importedTmpl ? { importedBinding: importedTmpl } : {}
+                  }
+                });
+              }
+            } else if (c.type !== "identifier") {
+              sub(c);
+            }
+          }
+        };
+        sub(node);
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) stack.push({ node: child, owner: nextOwner, method: nextMethod, module: moduleName });
+      }
+    }
+  }
+  /**
+   * BUILD THE POSITIONAL LEXICAL SCOPE MODEL — one walk of the tree, ranges in node offsets.
+   *
+   * THE RULES ARE THE LANGUAGE'S, not an approximation:
+   *   · scopes: program, every function form (declaration / expression / generator / arrow /
+   *     method / constructor / static block), blocks (`statement_block`, `switch_body`), loop
+   *     headers (`for`/`for_in`/`for_of`), catch clauses;
+   *   · `var` HOISTS to the nearest function-or-program scope; `let`/`const` bind in the current
+   *     block; parameters bind in the function scope; a catch parameter binds in its catch scope;
+   *     a function or class DECLARATION binds in its enclosing scope;
+   *   · a later same-scope redeclaration keeps one name (a Set), and an inner binding shadows an
+   *     outer one because resolution walks the scope chain from the innermost containing scope;
+   *   · import bindings and `require(...)` / `import(...)` declarators are recorded in
+   *     `moduleBindings` and are NEVER local-binding claims — they are the imported-binding seam;
+   *   · destructured/rest/default parameter and declarator patterns bind their VALUE sides
+   *     (`collectPatternPairs`, the same reader the symbol walk uses).
+   */
+  collectBindingModel(rootNode) {
+    const scopes = [];
+    const allNames = /* @__PURE__ */ new Set();
+    const moduleBindings = /* @__PURE__ */ new Set();
+    const moduleBindingSpecs = /* @__PURE__ */ new Map();
+    const publishedClasses = /* @__PURE__ */ new Set();
+    const program = {
+      kind: "program",
+      startIndex: rootNode.startIndex,
+      endIndex: rootNode.endIndex,
+      published: true,
+      parent: null,
+      names: /* @__PURE__ */ new Set(),
+      decls: /* @__PURE__ */ new Map()
+    };
+    scopes.push(program);
+    const addName = (scope, name, declNode) => {
+      if (!name) return;
+      scope.names.add(name);
+      if (!scope.decls.has(name)) scope.decls.set(name, declNode?.startIndex ?? scope.startIndex);
+      allNames.add(name);
+    };
+    const newScope = (node, kind, parent, published) => {
+      const scope = { kind, startIndex: node.startIndex, endIndex: node.endIndex, published, parent, names: /* @__PURE__ */ new Set(), decls: /* @__PURE__ */ new Map() };
+      scopes.push(scope);
+      return scope;
+    };
+    const hoistTarget = (scope) => {
+      let cur = scope;
+      while (cur.kind !== "function" && cur.kind !== "program" && cur.parent) cur = cur.parent;
+      return cur;
+    };
+    const addParams = (fnNode, fnScope) => {
+      const paramsNode = fnNode.childForFieldName("parameters");
+      if (paramsNode) {
+        for (let i = 0; i < paramsNode.namedChildCount; i++) {
+          const param = paramsNode.namedChild(i);
+          if (!param) continue;
+          for (const pair of this.collectPatternPairs(param)) addName(fnScope, pair.name, pair.node);
+        }
+      }
+      const single = fnNode.childForFieldName("parameter");
+      if (single) for (const pair of this.collectPatternPairs(single)) addName(fnScope, pair.name, pair.node);
+    };
+    const addImportBindings = (importNode) => {
+      const clause = this.findChildByType(importNode, "import_clause");
+      if (!clause) return;
+      const sourceNode = importNode.childForFieldName("source");
+      const specifier = sourceNode ? stringContent(sourceNode) : "";
+      const add = (name, declNode) => {
+        if (!name) return;
+        addName(program, name, declNode);
+        moduleBindings.add(name);
+        if (specifier) moduleBindingSpecs.set(name, specifier);
+      };
+      for (let i = 0; i < clause.namedChildCount; i++) {
+        const c = clause.namedChild(i);
+        if (!c) continue;
+        if (c.type === "identifier") add(c.text, c);
+        else if (c.type === "namespace_import") {
+          const nm = c.childForFieldName("name") ?? c.namedChild(0);
+          if (nm) add(nm.text, nm);
+        } else if (c.type === "named_imports") {
+          for (let j = 0; j < c.namedChildCount; j++) {
+            const spec = c.namedChild(j);
+            if (!spec || spec.type !== "import_specifier") continue;
+            const alias = spec.childForFieldName("alias");
+            const nm = spec.childForFieldName("name") ?? spec.namedChild(0);
+            const local = alias ?? nm;
+            if (local) add(local.text, local);
+          }
+        }
+      }
+    };
+    const isModuleLoad = (value) => {
+      if (!value || value.type !== "call_expression") return false;
+      const fn = value.childForFieldName("function");
+      if (!fn) return false;
+      return fn.type === "import" || fn.type === "identifier" && (fn.text === "require" || fn.text === "import");
+    };
+    const moduleLoadSpecifier = (value) => {
+      if (!value || value.type !== "call_expression") return "";
+      const args = value.childForFieldName("arguments");
+      const arg = args?.namedChild(0);
+      if (!arg) return "";
+      if (arg.type !== "string" && arg.type !== "template_string") return "";
+      return stringContent(arg);
+    };
+    const walk = (n, scope) => {
+      const t = n.type;
+      if (t === "function_declaration" || t === "generator_function_declaration") {
+        const nm = n.childForFieldName("name");
+        if (nm) addName(scope, nm.text, nm);
+        const fnScope = newScope(n, "function", scope, false);
+        addParams(n, fnScope);
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) walk(c, fnScope);
+        }
+        return;
+      }
+      if (t === "function_expression" || t === "generator_function") {
+        const fnScope = newScope(n, "function", scope, false);
+        const nm = n.childForFieldName("name");
+        if (nm) addName(fnScope, nm.text, nm);
+        addParams(n, fnScope);
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) walk(c, fnScope);
+        }
+        return;
+      }
+      if (t === "arrow_function" || t === "method_definition" || t === "class_static_block") {
+        const fnScope = newScope(n, "function", scope, false);
+        if (t !== "class_static_block") addParams(n, fnScope);
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) walk(c, fnScope);
+        }
+        return;
+      }
+      if (t === "import_statement") {
+        addImportBindings(n);
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) walk(c, scope);
+        }
+        return;
+      }
+      if (t === "variable_declarator") {
+        const nameNode = n.childForFieldName("name");
+        const value = n.childForFieldName("value");
+        const parent = n.parent;
+        const kindNode = parent?.childForFieldName?.("kind");
+        const isVar = parent?.type === "variable_declaration" || kindNode !== void 0 && kindNode !== null && kindNode.text === "var";
+        const target = isVar ? hoistTarget(scope) : scope;
+        const moduleBound = isModuleLoad(value);
+        const moduleSpec = moduleBound ? moduleLoadSpecifier(value) : "";
+        if (nameNode) {
+          for (const pair of this.collectPatternPairs(nameNode)) {
+            addName(target, pair.name, pair.node);
+            if (moduleBound) {
+              moduleBindings.add(pair.name);
+              if (moduleSpec) moduleBindingSpecs.set(pair.name, moduleSpec);
+            }
+          }
+        }
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) walk(c, scope);
+        }
+        return;
+      }
+      if (t === "catch_clause") {
+        const catchScope = newScope(n, "catch", scope, false);
+        const param = n.childForFieldName("parameter");
+        if (param) for (const pair of this.collectPatternPairs(param)) addName(catchScope, pair.name, pair.node);
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) walk(c, catchScope);
+        }
+        return;
+      }
+      if (t === "class_declaration") {
+        const nm = n.childForFieldName("name");
+        if (nm) {
+          addName(scope, nm.text, nm);
+          if (scope.published) publishedClasses.add(nm.text);
+        }
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) walk(c, scope);
+        }
+        return;
+      }
+      if (t === "statement_block" || t === "switch_body") {
+        const blockScope = newScope(n, "block", scope, false);
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) walk(c, blockScope);
+        }
+        return;
+      }
+      if (t === "for_statement" || t === "for_in_statement") {
+        const loopScope = newScope(n, "block", scope, false);
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) walk(c, loopScope);
+        }
+        return;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) walk(c, scope);
+      }
+    };
+    walk(rootNode, program);
+    const declScopeCounts = /* @__PURE__ */ new Map();
+    for (const s of scopes) {
+      for (const n of s.names) declScopeCounts.set(n, (declScopeCounts.get(n) ?? 0) + 1);
+    }
+    const multiScopeNames = /* @__PURE__ */ new Set();
+    for (const [n, count] of declScopeCounts) if (count > 1) multiScopeNames.add(n);
+    return { scopes, allNames, moduleBindings, moduleBindingSpecs, publishedClasses, multiScopeNames };
+  }
+  /**
+   * THE LOCAL-BINDING SPELLING for the site, or `null` when the name at this node is not a
+   * claimable local binding. Returns `${source}${BINDING_SEP}${name}` exactly as the family
+   * contract specifies (php/dart/java/fsharp/haskell): the arbiter verifies the SPELLING (a
+   * declaration name can never contain the separator), the row lands in the gate's `bindOK`
+   * column, and it is never merged into `resolved`.
+   *
+   * REFUSALS, each one a false statement the claim must not make:
+   *   · the file loads the name from a module (`import` / `require` / dynamic `import()`) — that is
+   *     the imported-binding seam class, not a local binding;
+   *   · the name resolves to the PROGRAM scope — module-scope declarations are PUBLISHED SYMBOLS,
+   *     so the edge can resolve normally and a binding claim would deny a real declaration;
+   *   · no lexical binding answers the name at this node's position (the read is of something the
+   *     file does not bind — host global, import through another route, or a genuine gap);
+   *   · the name would be the empty string or is one of the keywords the language never binds.
+   */
+  localBindingTarget(node, name, source) {
+    const model = this.bindingModel;
+    if (!model || !node || !name || !source) return null;
+    if (!this.isLocalBindingName(node, name)) return null;
+    return `${source}${BINDING_SEP}${name}`;
+  }
+  /**
+   * STATIC CLASS RECEIVER — `Service.create()` where the receiver identifier is a PROGRAM-scope
+   * class DECLARATION in this file. That class's members ARE published symbols, so the owner channel
+   * can resolve the member inside it; the proof is positional (the identifier must still resolve to
+   * the program scope at THIS site — a parameter or local shadowing the class name is not the class,
+   * and gets nothing). Evidence class `class-static`.
+   */
+  staticClassReceiver(node, name) {
+    const model = this.bindingModel;
+    if (!model || !node || !name) return null;
+    if (!model.publishedClasses.has(name)) return null;
+    return this.resolveBindingKind(model, node.startIndex, name) === "published" ? { type: name, evidence: "class-static" } : null;
+  }
+  /**
+   * THIS-ALIAS RECEIVER — `const self = this` in the SAME function body as the site, with `this`
+   * provably the enclosing class DECLARATION's instance. Resolved POSITIONALLY, never through the
+   * file map: a file map leaked an alias across sibling functions in the fixture (a plain
+   * function's `const self = this` is dynamic `this`, yet it inherited the class recorded by
+   * another function's alias of the same name) — the leak produced a wrong owner, which is worse
+   * than none. Refusals: a plain function/generator is dynamic `this` (nothing); an arrow is
+   * lexical `this` but the alias would have to be declared in an enclosing body, so this helper
+   * under-claims rather than reach across (nothing); a class expression is not a published symbol.
+   */
+  thisAliasOwnerAt(node, name) {
+    if (!node || !name) return null;
+    const isFunctionForm = (t) => t === "function_declaration" || t === "function_expression" || t === "generator_function_declaration" || t === "generator_function" || t === "arrow_function" || t === "method_definition" || t === "class_static_block";
+    let fn = null;
+    for (let p = node; p; p = p.parent) {
+      if (isFunctionForm(p.type)) {
+        fn = p;
+        break;
+      }
+      if (p.type === "class_declaration" || p.type === "class") return null;
+    }
+    if (!fn) return null;
+    if (fn.type !== "method_definition" && fn.type !== "class_static_block") return null;
+    let cls = null;
+    for (let p = fn.parent; p; p = p.parent) {
+      if (p.type === "class_declaration") {
+        cls = p.childForFieldName("name")?.text ?? null;
+        break;
+      }
+      if (p.type === "class") return null;
+      if (p.type === "function_declaration" || p.type === "function_expression" || p.type === "generator_function_declaration" || p.type === "generator_function") return null;
+    }
+    if (!cls) return null;
+    const stack = [fn];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n !== fn && isFunctionForm(n.type)) continue;
+      if (n.type === "variable_declarator") {
+        const id = n.childForFieldName("name");
+        const value = n.childForFieldName("value");
+        if (id && id.type === "identifier" && id.text === name && value && value.type === "this") {
+          return { type: cls, evidence: "this-alias" };
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return null;
+  }
+  /** innermost scope containing `index`, then the scope chain — "published" | "lexical" | null. */
+  resolveBindingKind(model, index, name) {
+    const scope = this.resolveBindingScope(model, index, name);
+    if (!scope) return null;
+    return scope.published ? "published" : "lexical";
+  }
+  /**
+   * R2 (charter §21.41) — THE SCOPE THAT DECLARES `name` AT `index`: the innermost scope that
+   * contains the position, then the scope chain, exactly the resolution `resolveBindingKind` uses
+   * — but it returns the SCOPE, not the kind, because the scope is what carries the declaration's
+   * identity.
+   */
+  resolveBindingScope(model, index, name) {
+    let best = null;
+    for (const scope of model.scopes) {
+      if (index < scope.startIndex || index > scope.endIndex) continue;
+      if (best === null || scope.endIndex - scope.startIndex < best.endIndex - best.startIndex) best = scope;
+    }
+    let cur = best;
+    while (cur) {
+      if (cur.names.has(name)) return cur;
+      cur = cur.parent;
+    }
+    return null;
+  }
+  /**
+   * R2 (charter §21.41) — THE DECLARATION'S SCOPE IDENTITY for a read of `name` at `node`, or null.
+   *
+   * The identity is the innermost scope that DECLARES the name at this position, plus that
+   * declaration's own offset — the dart lane's shape. Two reads of ONE declaration share it; two
+   * reads of TWO declarations do not. It joins the DEDUP KEY only, and only for a row whose
+   * identity is the occurrence (a local-binding row), so the payload-pollution dedup stays byte for
+   * byte for every other row.
+   *
+   * `null` in three cases, and every one of them keeps the old key:
+   *   · the name is declared in only ONE scope in the file — the base key already separates it;
+   *   · the read resolves to the PROGRAM scope — a published symbol, not a local-binding row, and
+   *     a claim there would deny a real declaration;
+   *   · the name is not bound at this site at all.
+   */
+  localBindingScopeId(node, name) {
+    const model = this.bindingModel;
+    if (!model || !node || !name) return null;
+    if (!model.multiScopeNames.has(name)) return null;
+    if (!this.isLocalBindingName(node, name)) return null;
+    const scope = this.resolveBindingScope(model, node.startIndex, name);
+    if (!scope || scope.published) return null;
+    return `${scope.startIndex}:${scope.decls.get(name) ?? scope.startIndex}`;
+  }
+  /**
+   * IS THIS READ A LOCAL-BINDING ROW? — the ONE test both the TARGET's spelling and the DEDUP KEY's
+   * scope identity must agree on.
+   *
+   * The refusals, each a false statement the row must not make:
+   *   · `this` / `super` / `arguments` / `undefined` are not names a declaration can bind;
+   *   · a name the file binds FROM A MODULE is the imported-binding class, never a local binding
+   *     (its claim is evidence-verified and its target stays bare);
+   *   · a name that resolves to the PROGRAM scope is a published symbol, not a local binding — a
+   *     claim there would deny a real declaration.
+   */
+  isLocalBindingName(node, name) {
+    const model = this.bindingModel;
+    if (!model || !node || !name) return false;
+    if (name === "this" || name === "super" || name === "arguments" || name === "undefined") return false;
+    if (model.moduleBindings.has(name)) return false;
+    return this.resolveBindingKind(model, node.startIndex, name) === "lexical";
+  }
+  /**
+   * IMPORTED-BINDING CLAIM — the EVIDENCE-VERIFIED claim kind (Lead contract, 2026-10-18). Returns
+   * `{ specifier, binding }` when the name IS the imported binding at THIS site, so the caller can
+   * publish `metadata.importedBinding` and keep the target spelling BARE (no BINDING_SEP — the
+   * arbiter verifies this claim against the run's own import rows, not a spelling).
+   *
+   * REFUSALS, each a false statement the claim must not make:
+   *   · the name has no import evidence in this file (no literal specifier: a name the PROJECT
+   *     declares, a name with no import at all, or a DYNAMIC `require(expr)` — never-claim (a)/(c));
+   *   · a LOCAL binding shadows the import at this site (the positional scope check): the target is
+   *     the shadow, not the import;
+   *   · the site is a namespace MEMBER access — the caller only asks this for a target that IS the
+   *     binding (bare callee / bare read / chain root), never a member segment (never-claim (b));
+   *   · re-export rows never reach here (never-claim (d): different surface).
+   */
+  importedBindingFor(node, name) {
+    const model = this.bindingModel;
+    if (!model || !node || !name) return null;
+    const specifier = model.moduleBindingSpecs.get(name);
+    if (specifier === void 0) return null;
+    if (this.resolveBindingKind(model, node.startIndex, name) !== "published") return null;
+    return { specifier, binding: name };
+  }
+  /**
+   * JS EXTERNAL CLAIMS — mark the edges whose target is a platform name the FILE cannot declare,
+   * using the CLOSED CITED vocabulary in `js-builtin-prototypes.ts` and nothing else.
+   *
+   * WHY THIS PASS EXISTS. The lane's unresolved `calls`/`uses` mass is dominated by names no
+   * repository can declare: `document.getElementById`, `window.addEventListener`,
+   * `location.hash.substring`, `JSON.stringify`, `setTimeout`. Before this pass the analyzer
+   * published those rows with NO claim at all, so they read exactly like a name the project
+   * failed to bind. The claim fixes the READ, not the binding — it never picks a declaration,
+   * so it cannot raise `arbitraryTwin`, `bindFAIL` or `extFAIL` for a DOTLESS target (the
+   * arbiter looks a dotless target up by its own spelling and can only reach a refutation on a
+   * target that names a declaration — which is why this pass NEVER rewrites a target, and why
+   * it refuses every non-identifier target; a dotted target is looked up by its OWNER, which a
+   * project may well publish).
+   *
+   * THE TWO PROOFS, both readable from the syntax with NO type inference:
+   *
+   *   bare name is a cited host global           `setTimeout(...)`      -> claim, cites ECMA-262 §19.2
+   *   receiver ROOT is a cited host global       `document.getElementById` -> claim, cites WHATWG HTML §7.3
+   *   receiver root is a LOCAL                    `x.substring(...)`    -> NO CLAIM (x may be a project object)
+   *   name/receiver root the FILE DECLARES        `class Map {}; Map.x()` -> NO CLAIM (the declaration outranks the table)
+   *
+   * The vocabulary is `HOST_GLOBALS` (57 cited entries) + `memberChainClaim` in
+   * `js-builtin-prototypes.ts` — the same module the differential's oracle imports, so the two
+   * sides cannot drift into two copies of one rule. A name NOT in that list gets NO claim: a
+   * heuristic ("looks like a DOM name") would be the closed-list lie this fleet keeps catching.
+   *
+   * THE IMPORT CLASS is claimed too, and it is a DIFFERENT claim kind on purpose: an `imports`
+   * row spells `<module>:<item>`, so the claim is about the MODULE (a namespace, not a
+   * declaration). The arbiter's `moduleNamespace` claim verifies the module ROOT against the
+   * project's own file/directory names and FAILS CLOSED when the root is project-owned, so a
+   * workspace package that names a real project directory cannot be laundered. A relative or
+   * absolute specifier is NEVER claimed: it names a FILE in this project, and a file claim that
+   * misses is REFUTED against the lane — this per-file analyzer is not given the project's file
+   * list, so those rows stay unclaimed rather than risk a false external statement.
+   *
+   * WHAT IT DELIBERATELY DOES NOT CLAIM, and the counts are the next measurement: Node runtime
+   * globals (`process`, `Buffer`, `module`, `require`), test-runner globals (`describe`, `it`,
+   * `test`, `expect`, `assert`) and imported bindings from external packages are OUTSIDE the
+   * cited list. They stay unresolved until each gets its own cited vocabulary; they are named in
+   * `validation/m14/verification/JAVASCRIPT-RESOLUTION-CLASSIFICATION.md` with their measured
+   * counts rather than smuggled into this table.
+   *
+   * The claim's own words are published twice: `externalReason` (the machine bucket the arbiter
+   * reads) and `externalClaimReason` (the full citation a human audits). `externalReceiver`
+   * names the receiver root when the proof is the MEMBER rule, so a reader can re-run the rule
+   * from the edge itself.
+   */
+  markExternalClaims(rootNode, relationships, symbols, context) {
+    const declaredHere = /* @__PURE__ */ new Set();
+    for (const s of symbols) if (s.name) declaredHere.add(String(s.name));
+    const bound = this.bindingModel ? this.bindingModel.allNames : this.collectBoundNames(rootNode);
+    let marked = 0;
+    for (const r of relationships) {
+      const label = String(r.type ?? "");
+      const target = String(r.target ?? "");
+      if (target.length === 0) continue;
+      const md = r.metadata ?? (r.metadata = {});
+      if (md.isExternalTarget === true) continue;
+      if (label !== "imports" && !isPlainJsIdentifier(target)) continue;
+      if (declaredHere.has(target)) continue;
+      let reason = null;
+      let citation = null;
+      let receiver = null;
+      if (label === "calls") {
+        const callee = String(md.calleeExpression ?? "");
+        if (callee.length > 0 && callee === target) {
+          if (!bound.has(target)) {
+            citation = hostGlobalCitation(target);
+            if (citation !== null) reason = "host-global-bare";
+            else {
+              citation = runtimeGlobalCitation(target);
+              if (citation !== null) reason = runtimeGlobalReason(target);
+            }
+          }
+        } else if (callee.length > 0 && callee.endsWith(`.${target}`)) {
+          const recvChain = callee.slice(0, callee.length - target.length - 1);
+          const rootEnd = jsIdentifierPrefixEnd(recvChain);
+          const root = recvChain.slice(0, rootEnd);
+          if (root.length > 0 && isPlainJsIdentifier(root) && !bound.has(root) && !declaredHere.has(root)) {
+            citation = memberChainClaim(root, target);
+            if (citation !== null) {
+              reason = "host-global-member";
+              receiver = root;
+            }
+          }
+        }
+      } else if (label === "uses") {
+        const isBareRead = md.bareRead === true || md.chainRoot === true || md.callReceiver === true || md.isTemplateInterpolation === true;
+        if (isBareRead) {
+          if (!bound.has(target)) {
+            citation = hostGlobalCitation(target);
+            if (citation !== null) reason = "host-global-bare";
+            else {
+              citation = runtimeGlobalCitation(target);
+              if (citation !== null) reason = runtimeGlobalReason(target);
+            }
+          }
+        } else if (md.isFieldAccess === true) {
+          const root = String(md.receiverRoot ?? "");
+          if (root.length > 0 && isPlainJsIdentifier(root) && !bound.has(root) && !declaredHere.has(root)) {
+            citation = memberChainClaim(root, target);
+            if (citation !== null) {
+              reason = "host-global-member";
+              receiver = root;
+            }
+          }
+        }
+      } else if (label === "imports") {
+        const at = target.lastIndexOf(":");
+        if (at > 0) {
+          const spec = target.slice(0, at);
+          const item = target.slice(at + 1);
+          const isRelative = spec.startsWith(".") || spec.startsWith("/");
+          const isScheme = spec.includes("://");
+          const isPathish = spec.includes("\\") || spec.length === 0 || item.length === 0;
+          const index = context?.projectIndex;
+          if (!isRelative && !isScheme && !isPathish && index !== void 0 && index.complete === true) {
+            const verdict = jsProjectModuleLocalityOf(index)(spec);
+            if (verdict === "third-party") {
+              reason = "module-namespace";
+              citation = `import specifier \`${spec}\` names no module of this project (complete project index; ${item === "*" ? "namespace import" : `item ${item}`})`;
+              receiver = spec;
+            }
+          }
+        }
+      } else if (label === "extends" || label === "references" || label === "instantiates") {
+        if (!bound.has(target) && label !== "instantiates") {
+          citation = hostGlobalCitation(target);
+          if (citation !== null) reason = label === "extends" ? "host-global-base" : "host-global-type";
+        }
+        if (citation === null && !bound.has(target)) {
+          citation = runtimeGlobalCitation(target);
+          if (citation !== null) reason = runtimeGlobalReason(target);
+        }
+      }
+      if (reason === null || citation === null) continue;
+      md.isExternalTarget = true;
+      md.externalReason = reason;
+      md.externalClaimReason = citation;
+      if (receiver !== null) md.externalReceiver = receiver;
+      if (reason === "module-namespace" && receiver !== null) md.externalSpecifier = receiver;
+      marked++;
+    }
+    return marked;
+  }
+  /**
+   * EVERY NAME THIS FILE BINDS — the negative control of the claim pass, and deliberately
+   * over-collecting: a name collected here that is not really a binding can only REFUSE a
+   * claim, never make one, so the conservative direction is the safe direction.
+   *
+   * The positions are the grammar's own definition positions, matched by the same node-type
+   * tests the bare-read walk applies (`isImportBinding` / `isParamBinding` / `isPatternBinding`
+   * / declaration names), read from the IDENTIFIER's parent rather than re-walking each
+   * construct — one pass, no shape re-derived.
+   */
+  collectBoundNames(rootNode) {
+    const out = /* @__PURE__ */ new Set();
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "identifier") {
+        const p = n.parent;
+        if (p) {
+          const isDeclName = p.type === "variable_declarator" && p.childForFieldName("name")?.id === n.id || p.type === "function_declaration" && p.childForFieldName("name")?.id === n.id || p.type === "generator_function_declaration" && p.childForFieldName("name")?.id === n.id || p.type === "class_declaration" && p.childForFieldName("name")?.id === n.id || p.type === "function_expression" && p.childForFieldName("name")?.id === n.id || p.type === "method_definition" && p.childForFieldName("name")?.id === n.id;
+          const isBindingPosition = p.type === "formal_parameters" || p.type === "import_clause" || p.type === "import_specifier" || p.type === "namespace_import" || p.type === "catch_clause" || p.type === "object_pattern" || p.type === "array_pattern" || p.type === "rest_pattern" || p.type === "shorthand_property_identifier_pattern" || p.type === "pair_pattern" || p.type === "assignment_pattern" && (p.childForFieldName("left") ?? p.namedChild(0))?.id === n.id || p.type === "arrow_function" && p.childForFieldName("parameter")?.id === n.id;
+          if (isDeclName || isBindingPosition) out.add(n.text);
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return out;
+  }
+  /**
+   * M14 #299 - evidence-tier classification for EVERY emitted relationship.
+   * Same rules as the JVM/TS family. JS calls are usage_contextual,
+   * field_access uses are usage_contextual, imports are import_based.
+   */
+  classifyEvidenceTier(relationships) {
+    for (const r of relationships) {
+      const md = r.metadata ?? (r.metadata = {});
+      if (md.evidenceClass) continue;
+      const t = String(r.type ?? "");
+      const conf = typeof r.confidence === "number" ? r.confidence : 1;
+      if (t === "contains" || t === "exports") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (t === "imports") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (t === "references") {
+        md.evidenceClass = "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 = conf >= 0.9 ? "structural" : "usage_contextual";
+        continue;
+      }
+      md.evidenceClass = "usage_contextual";
+    }
+  }
+  /**
+   * M59 (#825): the `line_number` for a relationship, taken from the node that
+   * SPELLS the name the edge is about.
+   *
+   * javascript is the largest silent lane in the product: measured by the M59
+   * oracle before this round, **0 of 5,818 relationships on a 40-file sample
+   * carried a line** (vue 0/3,940 and svelte 0/526, both of which delegate their
+   * script block to this analyzer — so one defect blanked three lanes). The
+   * contract is inherited, not re-invented: **the line belongs to the name, never
+   * to the construct that contains it.** A `call_expression` starts at its
+   * RECEIVER (`a.b.c()` opens on `a`, not on `c`), a `new_expression` on its
+   * `new` token, an `import_statement` on `import` even when its named specifiers
+   * sit three lines below, and a class body's children open at their decorators.
+   * Callers therefore pass the NAME node and this returns nothing when there is
+   * none — never `0`, because `0` reads as "unknown" and unknown must be absent.
+   */
+  lineField(nameNode, fallback) {
+    const n = nameNode ?? fallback;
+    return n ? { line_number: n.startPosition.row + 1 } : {};
+  }
+  nodeToRange(node) {
+    let startSource = node;
+    {
+      let i = 0;
+      while (i < node.childCount && node.child(i)?.type === "decorator") i++;
+      const first = i < node.childCount ? node.child(i) : null;
+      if (i > 0 && first) startSource = first;
+    }
+    return {
+      startLine: startSource.startPosition.row + 1,
+      startColumn: startSource.startPosition.column + 1,
+      endLine: node.endPosition.row + 1,
+      endColumn: node.endPosition.column + 1,
+      startIndex: startSource.startIndex,
+      endIndex: node.endIndex
+    };
+  }
+};
+
+export {
+  RealJavaScriptAnalyzer
+};