@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/real-swift-analyzer-MN5QT3QN.js

@@ -0,0 +1,2311 @@
+import {
+  findDeclaringParent
+} from "./chunk-OWISBAOF.js";
+import {
+  ASTEngine
+} from "./chunk-3ZTOHHSW.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-swift-analyzer.ts
+var ENUM_RAW_VALUE_TYPES = /* @__PURE__ */ new Set([
+  "String",
+  "Character",
+  "Int",
+  "Int8",
+  "Int16",
+  "Int32",
+  "Int64",
+  "UInt",
+  "UInt8",
+  "UInt16",
+  "UInt32",
+  "UInt64",
+  "Float",
+  "Float32",
+  "Float64",
+  "Double"
+]);
+var MEMBER_OWNER_KINDS = /* @__PURE__ */ new Set([
+  ASTEngine.SymbolKind.Class,
+  ASTEngine.SymbolKind.Struct,
+  ASTEngine.SymbolKind.Interface,
+  ASTEngine.SymbolKind.Enum,
+  ASTEngine.SymbolKind.Actor,
+  ASTEngine.SymbolKind.Extension
+]);
+var LOCAL_SCOPE_BODIES = /* @__PURE__ */ new Set([
+  "function_body",
+  "computed_property",
+  "computed_getter",
+  "computed_setter",
+  "willset_didset_block",
+  "willset_clause",
+  "didset_clause",
+  "lambda_literal"
+]);
+var SCOPE_RESET_DECLARATIONS = /* @__PURE__ */ new Set([
+  "class_declaration",
+  "protocol_declaration",
+  "function_declaration",
+  "protocol_function_declaration",
+  "init_declaration"
+]);
+var BUILTIN_BARE_CALLS = /* @__PURE__ */ new Set([
+  "print",
+  "debugPrint",
+  "assert",
+  "precondition",
+  "fatalError",
+  "String",
+  "Int",
+  "Double",
+  "Float",
+  "Bool",
+  "Array",
+  "Dictionary",
+  "Set",
+  "Optional",
+  "Any",
+  "Void",
+  "Character",
+  "Data",
+  "Date",
+  // Fixed-width stdlib numerics (SWIFTD16): trivial value construction, same
+  // class as Int/Double — filtered for consistency (Int8-64/UInt8-64 were
+  // previously missed while Int was filtered; corpus: UInt8 244 / Int64 72 /
+  // UInt16 47 bare constructions per swift-nio 200-file census).
+  "UInt",
+  "UInt8",
+  "UInt16",
+  "UInt32",
+  "UInt64",
+  "Int8",
+  "Int16",
+  "Int32",
+  "Int64",
+  // `defer { }` parses as call_expression(simple_identifier "defer", lambda_literal)
+  // in the pinned grammar — it is a control keyword, never a real function call.
+  "defer",
+  // SW-E (ultimate review): `type(of:)` is a stdlib free function like
+  // print/assert — a bare `type` call is the metatype query, never user
+  // code. Member reads (`x.type` is invalid Swift) are unaffected.
+  "type"
+]);
+var SWIFT_FRAMEWORK_ORDER = ["SwiftUI", "Combine", "UIKit", "Foundation"];
+var SWIFT_FRAMEWORK_PATTERNS = {
+  SwiftUI: ["declarative_ui"],
+  Combine: ["reactive_streams"],
+  UIKit: ["ui_framework"],
+  Foundation: ["base_library"]
+};
+var RealSwiftAnalyzer = class {
+  analyze(rootNode, content, filePath, context) {
+    const symbols = [];
+    const imports = [];
+    const relationships = [];
+    const exports = [];
+    const patternsObj = {};
+    const frameworksObj = {};
+    const metadata = {
+      linesOfCode: 0,
+      performanceScore: 100,
+      architecturalInsights: [],
+      detectedFrameworks: [],
+      patterns: []
+    };
+    if (!rootNode) return { symbols, imports, relationships, exports, metadata, errors: [] };
+    if (rootNode.hasError) {
+      const errStack = [rootNode];
+      while (errStack.length > 0) {
+        const n = errStack.pop();
+        if (n.type === "ERROR" || n.isMissing) {
+          ;
+          metadata.errors = metadata.errors || [];
+          metadata.errors.push({
+            message: `Syntax ${n.type} detected. The Brain Engine is bypassing this broken node.`,
+            range: {
+              startLine: n.startPosition.row + 1,
+              startColumn: n.startPosition.column + 1,
+              endLine: n.endPosition.row + 1,
+              endColumn: n.endPosition.column + 1,
+              startIndex: n.startIndex,
+              endIndex: n.endIndex
+            },
+            severity: "warning"
+          });
+        }
+        for (let i = n.namedChildCount - 1; i >= 0; i--) {
+          const child = n.namedChild(i);
+          if (child) errStack.push(child);
+        }
+      }
+    }
+    let loc = 1;
+    for (let i = 0; i < content.length; i++) {
+      if (content[i] === "\n") loc++;
+    }
+    metadata.linesOfCode = loc;
+    const overrideTasks = [];
+    const classHierarchy = /* @__PURE__ */ new Map();
+    const symbolMap = /* @__PURE__ */ new Map();
+    const inFileKinds = /* @__PURE__ */ new Map();
+    this.collectDeclaredKinds(rootNode, inFileKinds);
+    const cross = this.crossFileTables(context, classHierarchy);
+    const emittedCalls = /* @__PURE__ */ new Set();
+    const callSiteCounts = /* @__PURE__ */ new Map();
+    const callSiteLines = /* @__PURE__ */ new Map();
+    const emittedUses = /* @__PURE__ */ new Set();
+    const emittedContains = /* @__PURE__ */ new Set();
+    const enumCtorCandidates = [];
+    const superByClass = /* @__PURE__ */ new Map();
+    const reExports = [];
+    const moduleSource = this.moduleLeafName(filePath);
+    const emittedExportNames = /* @__PURE__ */ new Set();
+    const stack = [
+      { node: rootNode, parentSymbol: null, typeName: null, localScope: false }
+    ];
+    while (stack.length > 0) {
+      const popped = stack.pop();
+      if (!popped) continue;
+      const { node: curr, parentSymbol, localScope } = popped;
+      let newParentSymbol = parentSymbol;
+      let newTypeName = popped.typeName;
+      const nominalRecovery = curr.type === "ERROR" && this.isNominalRecovery(curr);
+      const childLocalScope = SCOPE_RESET_DECLARATIONS.has(curr.type) || nominalRecovery ? false : LOCAL_SCOPE_BODIES.has(curr.type) ? true : localScope;
+      if (curr.type === "import_declaration") {
+        this.handleImport(curr, imports, frameworksObj, reExports);
+      } else if (curr.type === "protocol_declaration") {
+        newParentSymbol = this.handleProtocol(curr, symbols, relationships, parentSymbol, patternsObj, classHierarchy, localScope);
+        if (newParentSymbol) newTypeName = newParentSymbol.name;
+      } else if (curr.type === "class_declaration") {
+        newParentSymbol = this.handleDeclaration(curr, symbols, relationships, parentSymbol, patternsObj, classHierarchy, inFileKinds, cross.kinds, superByClass, localScope);
+        if (newParentSymbol) newTypeName = newParentSymbol.name;
+      } else if (nominalRecovery) {
+        newParentSymbol = this.handleDeclaration(curr, symbols, relationships, parentSymbol, patternsObj, classHierarchy, inFileKinds, cross.kinds, superByClass, localScope);
+        if (newParentSymbol) newTypeName = newParentSymbol.name;
+      } else if (curr.type === "function_declaration" || curr.type === "protocol_function_declaration") {
+        newParentSymbol = this.handleFunction(curr, symbols, relationships, parentSymbol, overrideTasks, context?.overrideCompanion, localScope);
+      } else if (curr.type === "init_declaration") {
+        const vis = this.getVisibility(curr);
+        const meta = {};
+        const funcAttrs = this.extractAttributes(curr);
+        if (funcAttrs.length > 0) meta.annotations = funcAttrs;
+        const sym = this.createSymbol("constructor", ASTEngine.SymbolKind.Constructor, curr, parentSymbol, symbols, meta, vis, this.getDeclaredVisibility(curr), localScope);
+        this.collectFunctionMeta(curr, meta, sym);
+        newParentSymbol = sym;
+      } else if (curr.type === "deinit_declaration" || curr.type === "subscript_declaration") {
+      } else if (curr.type === "property_declaration" || curr.type === "protocol_property_declaration") {
+        this.handleVariable(curr, symbols, parentSymbol, newTypeName, frameworksObj, patternsObj, localScope);
+      } else if (curr.type === "enum_entry") {
+        if (!localScope && parentSymbol && parentSymbol.kind === ASTEngine.SymbolKind.Enum) {
+          let caseNode = null;
+          for (let i = 0; i < curr.namedChildCount; i++) {
+            const c = curr.namedChild(i);
+            if (!c || c.type === "modifiers" || c.type === "attribute") continue;
+            caseNode = c;
+            if (c.type === "simple_identifier" || c.type === "identifier") break;
+          }
+          const caseName = caseNode ? caseNode.text : curr.text;
+          if (caseName && caseName !== "case") {
+            this.createSymbol(caseName, ASTEngine.SymbolKind.EnumMember, caseNode ?? curr, parentSymbol, symbols, { enumCase: true });
+          }
+        }
+      } else if (curr.type === "typealias_declaration") {
+        const nameNode = this.findChildByType(curr, "type_identifier") || this.firstNamedChild(curr);
+        if (nameNode && (nameNode.type === "type_identifier" || nameNode.type === "simple_identifier" || nameNode.type === "identifier")) {
+          this.createSymbol(nameNode.text, ASTEngine.SymbolKind.Type, curr, parentSymbol, symbols, { isTypeAlias: true }, this.getVisibility(curr), this.getDeclaredVisibility(curr), localScope);
+        }
+      } else if (curr.type === "associatedtype_declaration") {
+        const nameNode = this.findChildByType(curr, "type_identifier") || this.firstNamedChild(curr);
+        if (nameNode && (nameNode.type === "type_identifier" || nameNode.type === "simple_identifier" || nameNode.type === "identifier")) {
+          this.createSymbol(nameNode.text, ASTEngine.SymbolKind.Type, curr, parentSymbol, symbols, { isAssociatedType: true }, this.getVisibility(curr), this.getDeclaredVisibility(curr), localScope);
+        }
+      } else if (curr.type === "call_expression") {
+        this.handleCall(curr, relationships, parentSymbol, emittedCalls, enumCtorCandidates, superByClass, callSiteCounts, callSiteLines);
+      } else if (curr.type === "navigation_expression") {
+        this.handleSelfUse(curr, relationships, newTypeName, parentSymbol, emittedUses);
+        this.handleMemberUses(curr, relationships, parentSymbol, newTypeName, emittedUses);
+      } else if (curr.type === "key_path_expression") {
+        this.handleKeyPathUses(curr, relationships, parentSymbol, newTypeName, emittedUses);
+      }
+      if (parentSymbol === null && !localScope && this.isExportingDeclaration(curr)) {
+        this.emitDeclarationExport(curr, moduleSource, relationships, exports, emittedExportNames);
+      }
+      if (curr.type === "type_constraints") {
+        patternsObj["Generics with Where Clauses"] = true;
+      } else if (curr.type === "willset_clause" || curr.type === "didset_clause" || curr.type === "willset_didset_block") {
+        patternsObj["Property Observers (willSet/didSet)"] = true;
+      } else if (curr.type === "call_expression" && this.isDeferCall(curr)) {
+        patternsObj["Defer (Cleanup)"] = true;
+      } else if (curr.type === "do_statement") {
+        patternsObj["Do-Catch Blocks"] = true;
+      } else if (curr.type === "getter_specifier" || curr.type === "setter_specifier") {
+        patternsObj["Computed Properties"] = true;
+      } else if (curr.type === "availability_condition") {
+        patternsObj["Platform Availability Checks"] = true;
+      } else if (curr.type === "macro_declaration") {
+        patternsObj["Swift Macros"] = true;
+      } else if (curr.type === "lambda_literal") {
+        patternsObj["Closures"] = true;
+      }
+      if (curr.type === "try_operator" || curr.type === "catch_block" || curr.type === "control_transfer_statement" && this.hasChildType(curr, "throw_keyword")) {
+        patternsObj["Error Handling"] = true;
+      }
+      if (curr.type === "await_expression" || curr.type === "async") {
+        patternsObj["Async/Await"] = true;
+      }
+      if (curr.type === "optional_type" || curr.type === "guard_statement" || curr.type === "navigation_expression" && this.hasAnonToken(curr, "?") || (curr.type === "if_statement" || curr.type === "while_statement") && this.hasChildType(curr, "value_binding_pattern")) {
+        patternsObj["Optional Handling"] = true;
+      }
+      if (curr.type === "type_parameters") {
+        patternsObj["Generics"] = true;
+      }
+      if (curr.type === "if_statement" || curr.type === "for_statement" || curr.type === "while_statement" || curr.type === "repeat_while_statement" || curr.type === "switch_statement") {
+        if (!metadata.cyclomaticComplexity) metadata.cyclomaticComplexity = 1;
+        metadata.cyclomaticComplexity++;
+      }
+      if (curr.type === "modifiers") {
+        for (let i = 0; i < curr.namedChildCount; i++) {
+          const mod = curr.namedChild(i);
+          if (!mod) continue;
+          if (mod.type === "ownership_modifier")
+            patternsObj["ARC Memory Management"] = true;
+          if (mod.type === "property_behavior_modifier" || mod.text === "lazy")
+            patternsObj["Lazy Initialization"] = true;
+          if (mod.type === "inheritance_modifier" || mod.text === "final")
+            patternsObj["Final/Sealed"] = true;
+        }
+      }
+      for (let i = curr.childCount - 1; i >= 0; i--) {
+        const child = curr.child(i);
+        if (child) stack.push({ node: child, parentSymbol: newParentSymbol, typeName: newTypeName, localScope: childLocalScope });
+      }
+    }
+    this.handleBareUses(rootNode, relationships, symbols, emittedUses);
+    if (enumCtorCandidates.length > 0) {
+      const enumCases = /* @__PURE__ */ new Set();
+      for (const s of symbols) {
+        if (s.kind === ASTEngine.SymbolKind.EnumMember && s.ownerName) {
+          enumCases.add(`${s.ownerName}.${s.name}`);
+        }
+      }
+      if (enumCases.size > 0) {
+        const retiredSites = /* @__PURE__ */ new Set();
+        const retiredLines = /* @__PURE__ */ new Map();
+        const constructions = [];
+        for (const cand of enumCtorCandidates) {
+          const key = cand.head ?? cand.owner;
+          if (!key || !enumCases.has(`${key}.${cand.leaf}`)) continue;
+          if (cand.removeCalls) {
+            const siteKey = `${cand.source}\0${cand.leaf}`;
+            const left = (callSiteCounts.get(siteKey) ?? 0) - 1;
+            callSiteCounts.set(siteKey, left);
+            if (typeof cand.line === "number") {
+              const set = retiredLines.get(siteKey);
+              if (set) set.add(cand.line);
+              else retiredLines.set(siteKey, /* @__PURE__ */ new Set([cand.line]));
+            }
+            if (left <= 0) retiredSites.add(siteKey);
+          }
+          constructions.push({ source: cand.source, target: key, line: cand.line });
+        }
+        if (retiredSites.size > 0) {
+          for (let i = relationships.length - 1; i >= 0; i--) {
+            const r = relationships[i];
+            if (r.type !== ASTEngine.RelationshipType.Calls) continue;
+            if (!retiredSites.has(`${r.source}\0${String(r.target)}`)) continue;
+            relationships.splice(i, 1);
+          }
+        }
+        if (callSiteLines.size > 0) {
+          for (const r of relationships) {
+            if (r.type !== ASTEngine.RelationshipType.Calls) continue;
+            const key = `${r.source}\0${String(r.target)}`;
+            const lines = callSiteLines.get(key);
+            if (!lines) continue;
+            const retired = retiredLines.get(key);
+            if (!retired) continue;
+            let kept;
+            for (const l of lines) {
+              if (!retired.has(l)) {
+                kept = l;
+                break;
+              }
+            }
+            if (typeof kept === "number") r.line_number = kept;
+          }
+        }
+        for (const c of constructions) {
+          const ekey = `${c.source}\0instantiates\0${c.target}`;
+          if (emittedCalls.has(ekey)) continue;
+          emittedCalls.add(ekey);
+          relationships.push({
+            type: ASTEngine.RelationshipType.Instantiates,
+            source: c.source,
+            target: c.target,
+            isExternal: true,
+            weight: 0.7,
+            confidence: 0.95,
+            // The CONVERTED call site's line, carried on the candidate.
+            ...typeof c.line === "number" ? { line_number: c.line } : {},
+            metadata: { isEnumConstruction: true }
+          });
+        }
+      }
+    }
+    for (const p in patternsObj) {
+      metadata.patterns.push(p);
+    }
+    const emittedFrameworks = SWIFT_FRAMEWORK_ORDER.filter((f) => frameworksObj[f] === true);
+    const unlistedFrameworks = [];
+    for (const f in frameworksObj) {
+      if (frameworksObj[f] === true && SWIFT_FRAMEWORK_ORDER.indexOf(f) === -1) unlistedFrameworks.push(f);
+    }
+    unlistedFrameworks.sort();
+    for (let i = 0; i < unlistedFrameworks.length; i++) emittedFrameworks.push(unlistedFrameworks[i]);
+    metadata.detectedFrameworks = emittedFrameworks;
+    metadata.framework = emittedFrameworks.length > 0 ? emittedFrameworks[0] : void 0;
+    metadata.frameworkPatterns = emittedFrameworks.map((f) => ({
+      framework: f,
+      patterns: SWIFT_FRAMEWORK_PATTERNS[f] ?? ["usage"]
+    }));
+    for (const s of symbols) {
+      if (s.kind === ASTEngine.SymbolKind.Method || s.kind === ASTEngine.SymbolKind.Constructor || s.kind === ASTEngine.SymbolKind.Function) {
+        const owner = s.ownerName || "root";
+        symbolMap.set(`${owner}.${s.name}`, s);
+      }
+    }
+    for (const s of symbols) {
+      const _owner = s.ownerName || s.scope;
+      if (_owner && s.name && s.kind !== ASTEngine.SymbolKind.Extension) {
+        const key = `${_owner}\0${s.name}`;
+        if (!emittedContains.has(key)) {
+          emittedContains.add(key);
+          relationships.push({
+            type: ASTEngine.RelationshipType.Contains,
+            source: _owner,
+            target: s.name,
+            isExternal: false,
+            weight: 1,
+            confidence: 1,
+            // The DECLARATION's own line (the member's range start).
+            ...typeof s.range?.startLine === "number" ? { line_number: s.range.startLine } : {},
+            metadata: {}
+          });
+        }
+      }
+    }
+    for (const imp of imports) {
+      if (imp.module) {
+        relationships.push({
+          type: ASTEngine.RelationshipType.References,
+          source: "root",
+          target: imp.module,
+          isExternal: true,
+          weight: 0.9,
+          confidence: 1,
+          // The import statement's own line (handleImport records the range).
+          ...typeof imp.range?.startLine === "number" ? { line_number: imp.range.startLine } : {},
+          // `isImportNameReference` is the marker the `references` family uses to
+          // say this edge names a MODULE brought into scope rather than a symbol
+          // the graph holds (INCOMING_SWIFT JOB 2, preserved by DERIV_EXPORTS_SWIFT4).
+          // It is why leaving `references` in place beside `imports` is not a
+          // duplicate claim: the two carry different markers and answer different
+          // questions ("what names came into scope" vs "what does this file depend on").
+          //
+          // M14 SWIFT RESIDUAL — THE CLAIM MOVES ONTO THE KEY THE ARBITER READS.
+          // `isExternal: true` has been set on this RELATIONSHIP since INCOMING_SWIFT
+          // JOB 2, and `externalClaimOf` (script/m14/incoming-rule.ts:396) reads
+          // `rel.metadata` ONLY — so the statement was invisible and the lane's `extOK`
+          // column read 0 while its own sentence above said "a MODULE brought into scope
+          // rather than a symbol the graph holds". Measured on the 400-file bounded run
+          // (`m14-swift-cause-probe.mts`): 916 `references` + 900 `imports` edges are
+          // unresolvable, every one of them naming a module no file in the run declares
+          // (Foundation, UIKit, XCTest, Flutter, NIOCore …). Publishing the SAME claim
+          // inside `metadata` is ROUTING, not a new judgement. It cannot move a
+          // resolution: `classifyEdge` consults a claim only where the run declares no
+          // symbol of that name (`:1147`), and with a declaration present it reads the
+          // claim "to RECORD it, never to move the outcome" (`:1188-1194`) — so
+          // `resolved`, `collRes` and `amb(decl)` are untouched in both directions.
+          metadata: { importModule: imp.module, isImportNameReference: true, isExternal: true }
+        });
+      }
+    }
+    {
+      const seen = /* @__PURE__ */ new Set();
+      for (const re of reExports) {
+        const key = `${moduleSource}\0${re.module}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        const reLine = this.nodeLine(re.node);
+        relationships.push({
+          type: ASTEngine.RelationshipType.Exports,
+          source: moduleSource,
+          target: re.module,
+          isExternal: true,
+          weight: 0.9,
+          confidence: 1,
+          // The MODULE NAME's own line — the site a reader checks, the same node
+          // the ImportInfo row and the references edge are lined at (
+          // `@_exported\nimport Basic` lines the edge at the module name, 11,
+          // never the attribute's line, 10).
+          ...typeof reLine === "number" ? { line_number: reLine } : {},
+          // M14 SWIFT RESIDUAL: `@_exported import M` re-exports a MODULE, and the
+          // relationship already says `isExternal: true` (`:768`) — but the arbiter
+          // reads `metadata`. Same routing, same safety, as the `references`/`imports`
+          // edges: a claim is consulted only where the run declares no symbol of that
+          // name, so no resolution can move. The `exports` INFO row below keeps its
+          // metadata unchanged: it is a declaration, not an external claim.
+          metadata: { exportForm: re.form, reExport: true, reexportsModule: re.module, isExternal: true }
+        });
+        if (!emittedExportNames.has(re.module)) {
+          emittedExportNames.add(re.module);
+          exports.push({
+            name: re.module,
+            type: "module",
+            range: {
+              startLine: re.node.startPosition.row + 1,
+              startColumn: re.node.startPosition.column + 1,
+              endLine: re.node.endPosition.row + 1,
+              endColumn: re.node.endPosition.column + 1,
+              startIndex: re.node.startIndex,
+              endIndex: re.node.endIndex
+            },
+            metadata: { exportForm: re.form, reExport: true, reexportsModule: re.module }
+          });
+        }
+      }
+    }
+    const emittedImports = /* @__PURE__ */ new Set();
+    const scopedImportsPerModule = /* @__PURE__ */ new Map();
+    for (const imp of imports) {
+      const imd = imp.metadata ?? {};
+      const im = typeof imd.module === "string" ? imd.module : null;
+      if (!im || imd.isScopedImport !== true) continue;
+      scopedImportsPerModule.set(im, (scopedImportsPerModule.get(im) ?? 0) + 1);
+    }
+    for (const imp of imports) {
+      const md = imp.metadata ?? {};
+      const spelled = typeof imp.module === "string" ? imp.module : "";
+      const moduleName = typeof md.module === "string" && md.module ? md.module : spelled.split(".")[0] || null;
+      if (!moduleName || emittedImports.has(moduleName)) continue;
+      emittedImports.add(moduleName);
+      const scopedHere = scopedImportsPerModule.get(moduleName) ?? 0;
+      const edgeMd = {
+        ...md,
+        // `isImport` is the MARKER the completeness section-B inventory reads,
+        // so the kind is claimed twice over (go GO precedent) and the evidence
+        // tier stays import_based.
+        isImport: true,
+        isModuleDependency: true,
+        // #910: the importer is this FILE, so the indexer must be told this is
+        // a file-level edge rather than a scope placeholder named `root`.
+        fileLevel: true,
+        // M14 SWIFT RESIDUAL: the same module-external claim the `references` edge
+        // carries, on the key the arbiter reads — see the block at that edge above.
+        // `isExternal` was already `true` on this relationship (`:893`); `metadata` is
+        // the only place `externalClaimOf` looks.
+        isExternal: true
+      };
+      if (scopedHere > 1) {
+        delete edgeMd.scopedItem;
+        edgeMd.scopedItemCount = scopedHere;
+      }
+      relationships.push({
+        type: ASTEngine.RelationshipType.Imports,
+        source: "root",
+        target: moduleName,
+        isExternal: true,
+        weight: 0.9,
+        confidence: 1,
+        // The MODULE NAME's own line (handleImport records the name node's
+        // range), the same site the references edge names.
+        ...typeof imp.range?.startLine === "number" ? { line_number: imp.range.startLine } : {},
+        metadata: edgeMd
+      });
+    }
+    this.resolveOverrides(
+      overrideTasks,
+      classHierarchy,
+      symbolMap,
+      relationships,
+      context?.overrideCompanion ?? cross.companion,
+      cross.getParents(classHierarchy)
+    );
+    this.classifyEvidenceTier(relationships);
+    return {
+      symbols,
+      relationships,
+      imports,
+      exports,
+      metadata,
+      errors: metadata.errors || []
+    };
+  }
+  /** Pre-pass: record every protocol/class/struct/actor/enum/extension name. */
+  collectDeclaredKinds(rootNode, out) {
+    const stack = [rootNode];
+    let guard = 0;
+    while (stack.length > 0 && guard++ < 5e5) {
+      const n = stack.pop();
+      if (n.type === "protocol_declaration") {
+        const nm = this.findChildByType(n, "type_identifier");
+        if (nm) out.set(nm.text, "interface");
+      } else if (n.type === "class_declaration") {
+        const nm = this.findChildByType(n, "type_identifier") || this.findChildByType(n, "user_type");
+        if (nm) {
+          const leaf = nm.type === "user_type" && nm.namedChildCount > 0 ? nm.namedChild(0).text : nm.text;
+          if (this.hasAnonToken(n, "class")) out.set(leaf, "class");
+          else if (this.hasAnonToken(n, "struct")) out.set(leaf, "struct");
+          else if (this.hasAnonToken(n, "actor")) out.set(leaf, "actor");
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+  }
+  // ============================================================================
+  // EVIDENCE TIERS
+  // ============================================================================
+  /**
+   * Evidence-tier classification (managed-OO family contract — mirrors
+   * dart/csharp/java; M14 section D requires >=2 distinct evidenceClass
+   * values). Same rules as the family: structural (grammar clauses, conf
+   * 1.0) | usage_contextual (calls, mixin uses) | import_based (import
+   * directives) | inferred (confidence < 1 edges).
+   */
+  classifyEvidenceTier(relationships) {
+    for (const r of relationships) {
+      const type = r.type ?? r.relationshipType ?? "";
+      const md = r.metadata ?? {};
+      if (type === "contains") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (type === "imports" || type === "references") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (type === "exports") {
+        md.evidenceClass = md.reExport === true ? "import_based" : "structural";
+        continue;
+      }
+      if (type === "calls" || type === "uses") {
+        md.evidenceClass = (r.confidence ?? 0) >= 0.85 ? "usage_contextual" : "inferred";
+        continue;
+      }
+      if (type === "instantiates" || type === "extends" || type === "implements") {
+        md.evidenceClass = (r.confidence ?? 0) >= 0.9 ? "structural" : "inferred";
+        continue;
+      }
+      if (type === "overrides") {
+        md.evidenceClass = (r.confidence ?? 0) >= 0.9 ? "structural" : "inferred";
+        continue;
+      }
+      md.evidenceClass = "usage_contextual";
+    }
+  }
+  // ==========================================================================
+  // Declaration handlers
+  // ==========================================================================
+  handleProtocol(node, symbols, relationships, parent, patternsObj, classHierarchy, localScope = false) {
+    patternsObj["Protocol-Oriented Programming"] = true;
+    const nameNode = this.findChildByType(node, "type_identifier") || this.firstNamedChild(node);
+    if (!nameNode) return parent;
+    const meta = { isProtocol: true, hasGenerics: this.hasChildType(node, "type_parameters") };
+    if (meta.hasGenerics) patternsObj["Generics"] = true;
+    const vis = this.getVisibility(node);
+    const symbol = this.createSymbol(nameNode.text, ASTEngine.SymbolKind.Interface, nameNode, parent, symbols, meta, vis, this.getDeclaredVisibility(node), localScope);
+    const baseSites = this.extractBaseSites(node);
+    const parents = [];
+    for (let i = 0; i < baseSites.length; i++) {
+      const base = baseSites[i].name;
+      if (base === "AnyObject" || base === "Any") continue;
+      parents.push(base);
+      relationships.push({
+        type: ASTEngine.RelationshipType.Extends,
+        source: symbol.name,
+        target: base,
+        isExternal: true,
+        weight: 1,
+        confidence: 1,
+        // The base SPECIFIER's own line in the inheritance clause.
+        line_number: this.nodeLine(baseSites[i].node),
+        metadata: { isImplements: false }
+      });
+    }
+    if (parents.length > 0) classHierarchy.set(symbol.name, parents);
+    return symbol;
+  }
+  handleDeclaration(node, symbols, relationships, parent, patternsObj, classHierarchy, inFileKinds, crossFileKinds, superByClass, localScope = false) {
+    let kind = ASTEngine.SymbolKind.Class;
+    const recoveredKind = node.type === "ERROR" ? this.recoveryKind(node) : null;
+    if (recoveredKind) {
+      kind = recoveredKind;
+    } else if (this.hasAnonToken(node, "actor")) {
+      kind = ASTEngine.SymbolKind.Actor;
+    } else if (this.hasAnonToken(node, "struct")) {
+      kind = ASTEngine.SymbolKind.Struct;
+    } else if (this.hasAnonToken(node, "enum")) {
+      kind = ASTEngine.SymbolKind.Enum;
+    } else if (this.hasAnonToken(node, "extension")) {
+      kind = ASTEngine.SymbolKind.Extension;
+    }
+    let nameNode = null;
+    const recoveredName = node.type === "ERROR" ? this.recoveryNameNode(node) : null;
+    if (recoveredName) {
+      nameNode = recoveredName;
+    } else if (kind === ASTEngine.SymbolKind.Extension) {
+      const ut = this.findChildByType(node, "user_type");
+      if (ut) {
+        nameNode = this.lastTypeIdentifier(ut);
+      } else {
+        nameNode = this.findDescendantTypeIdentifier(node);
+      }
+    } else {
+      nameNode = this.findChildByType(node, "type_identifier") || this.findChildByType(node, "user_type") || this.firstNamedChild(node);
+    }
+    if (!nameNode) return parent;
+    let rawName = nameNode.type === "user_type" && nameNode.namedChildCount > 0 ? nameNode.namedChild(0).text : nameNode.text;
+    if (kind === ASTEngine.SymbolKind.Extension && nameNode.type === "user_type") {
+      const leaf = this.lastTypeIdentifier(nameNode);
+      if (leaf) rawName = leaf.text;
+    }
+    const meta = {
+      hasGenerics: this.hasChildType(node, "type_parameters")
+    };
+    if (meta.hasGenerics) patternsObj["Generics"] = true;
+    if (kind === ASTEngine.SymbolKind.Struct) meta.isValueType = true;
+    if (kind === ASTEngine.SymbolKind.Enum) meta.isValueType = true;
+    const vis = this.getVisibility(node);
+    if (kind === ASTEngine.SymbolKind.Enum) {
+      const rawType = this.findEnumRawType(node);
+      if (rawType && ENUM_RAW_VALUE_TYPES.has(rawType)) meta.rawType = rawType;
+    }
+    const symbol = this.createSymbol(rawName, kind, nameNode, parent, symbols, meta, vis, this.getDeclaredVisibility(node), localScope);
+    const baseSites = this.extractBaseSites(node);
+    const bases = baseSites.map((b) => b.name);
+    const parents = [];
+    if (kind === ASTEngine.SymbolKind.Class || kind === ASTEngine.SymbolKind.Struct || kind === ASTEngine.SymbolKind.Actor) {
+      const firstIsSuperclass = kind === ASTEngine.SymbolKind.Class && (bases.length > 0 ? (inFileKinds.get(bases[0]) ?? crossFileKinds?.get(bases[0]) ?? "class") === "class" : true);
+      for (let i = 0; i < bases.length; i++) {
+        const base = bases[i];
+        parents.push(base);
+        const isExtends = firstIsSuperclass && i === 0;
+        if (isExtends && superByClass) superByClass.set(symbol.name, base);
+        relationships.push({
+          type: isExtends ? ASTEngine.RelationshipType.Extends : ASTEngine.RelationshipType.Implements,
+          source: symbol.name,
+          target: base,
+          isExternal: true,
+          weight: isExtends ? 1 : 0.9,
+          confidence: 1,
+          line_number: this.nodeLine(baseSites[i].node),
+          metadata: { isImplements: !isExtends }
+        });
+      }
+      if (parents.length > 0) classHierarchy.set(symbol.name, parents);
+    } else if (kind === ASTEngine.SymbolKind.Extension) {
+      for (let i = 0; i < baseSites.length; i++) {
+        const base = baseSites[i].name;
+        parents.push(base);
+        relationships.push({
+          type: ASTEngine.RelationshipType.Implements,
+          source: symbol.name,
+          target: base,
+          isExternal: true,
+          weight: 0.9,
+          confidence: 1,
+          line_number: this.nodeLine(baseSites[i].node),
+          metadata: { isImplements: true }
+        });
+      }
+    } else if (kind === ASTEngine.SymbolKind.Enum) {
+      const skipFirst = bases.length > 0 && ENUM_RAW_VALUE_TYPES.has(bases[0]);
+      for (let i = skipFirst ? 1 : 0; i < bases.length; i++) {
+        const base = bases[i];
+        relationships.push({
+          type: ASTEngine.RelationshipType.Implements,
+          source: symbol.name,
+          target: base,
+          isExternal: true,
+          weight: 0.9,
+          confidence: 1,
+          line_number: this.nodeLine(baseSites[i].node),
+          metadata: { isImplements: true }
+        });
+      }
+    }
+    if (kind === ASTEngine.SymbolKind.Class || kind === ASTEngine.SymbolKind.Struct || kind === ASTEngine.SymbolKind.Extension) {
+      if (bases.includes("View")) {
+        this.extractRenderRelationships(node, symbol.name, relationships);
+      }
+    }
+    return symbol;
+  }
+  /**
+   * `renders` — the rendered component named by a View body's TOP-LEVEL DSL
+   * call. Swift's rendering entry point is `var body: some View { … }` on a
+   * type conforming to `View`; the component the body's outermost
+   * `call_expression` names is what the type renders (the dart lane's
+   * `build`-returns-`Widget` shape, `real-dart-analyzer.ts:4274`). Deeper
+   * constructions stay their existing `calls`/`instantiates` rows — only the
+   * top-level expression is the rendered tree's root, and every other
+   * construction inside it is an ARGUMENT or a CHILD, not the render.
+   */
+  extractRenderRelationships(node, className, relationships) {
+    const classBody = this.findChildByType(node, "class_body");
+    if (!classBody) return;
+    for (let i = 0; i < classBody.namedChildCount; i++) {
+      const member = classBody.namedChild(i);
+      if (!member || member.type !== "property_declaration") continue;
+      const pattern = this.findChildByType(member, "pattern");
+      if (!pattern || pattern.text !== "body") continue;
+      const typeAnno = this.findChildByType(member, "type_annotation");
+      if (!typeAnno || typeAnno.text.trim() !== ": some View") continue;
+      const computed = this.findChildByType(member, "computed_property");
+      if (!computed) continue;
+      const statements = this.findChildByType(computed, "statements");
+      if (!statements) continue;
+      const expr = statements.namedChild(0);
+      if (!expr || expr.type !== "call_expression") continue;
+      const callee = this.findChildByType(expr, "simple_identifier") || this.findChildByType(expr, "identifier");
+      if (!callee) continue;
+      const target = callee.text;
+      const firstCode = target.length > 0 ? target.charCodeAt(0) : 0;
+      if (!(firstCode >= 65 && firstCode <= 90) || target === "View" || target === "Self") continue;
+      relationships.push({
+        source: className,
+        target,
+        type: ASTEngine.RelationshipType.Renders,
+        confidence: 0.9,
+        line_number: this.nodeLine(callee),
+        metadata: { isRenderHost: true, renderHost: "body", renderTarget: target }
+      });
+    }
+  }
+  handleFunction(node, symbols, relationships, parent, overrideTasks, companion, localScope = false) {
+    const nameNode = this.findChildByType(node, "simple_identifier") || this.findChildByType(node, "identifier");
+    const opName = nameNode ? null : this.operatorName(node);
+    if (!nameNode && !opName) return parent;
+    const isMethod = !!parent && MEMBER_OWNER_KINDS.has(parent.kind);
+    const kind = isMethod ? ASTEngine.SymbolKind.Method : ASTEngine.SymbolKind.Function;
+    const vis = this.getVisibility(node);
+    const meta = {
+      hasGenerics: this.hasChildType(node, "type_parameters")
+    };
+    const funcAttrs = this.extractAttributes(node);
+    if (funcAttrs.length > 0) meta.annotations = funcAttrs;
+    const symbol = this.createSymbol(opName ?? nameNode.text, kind, opName ? node : nameNode, parent, symbols, meta, vis, this.getDeclaredVisibility(node), localScope);
+    this.collectFunctionMeta(node, meta, symbol);
+    symbol.complexity = this.calculateCyclomaticComplexity(node);
+    if (this.hasDescendantAnonToken(node, "override") && parent) {
+      overrideTasks.push({
+        fqn: `${parent.name}.${symbol.name}`,
+        methodName: symbol.name,
+        ownerFqn: parent.name,
+        line: symbol.range?.startLine
+      });
+    }
+    const returnNode = this.findReturnType(node);
+    if (returnNode) symbol.returnType = returnNode.text;
+    return symbol;
+  }
+  // ==========================================================================
+  // Variable / call / uses handlers
+  // ==========================================================================
+  handleVariable(node, symbols, parent, typeName, frameworksObj, patternsObj, localScope = false) {
+    if (localScope) return;
+    if (parent && !MEMBER_OWNER_KINDS.has(parent.kind)) return;
+    const vis = this.getVisibility(node);
+    const annotations = [];
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && (c.type === "modifiers" || c.type === "attribute")) {
+        for (let j = 0; j < c.namedChildCount; j++) {
+          const mod = c.namedChild(j);
+          if (!mod) continue;
+          if (mod.type === "attribute") {
+            const text = mod.text;
+            annotations.push(text);
+            if (text.indexOf("@State") !== -1 || text.indexOf("@Binding") !== -1 || text.indexOf("@Environment") !== -1 || text.indexOf("@ObservedObject") !== -1) {
+              frameworksObj["SwiftUI"] = true;
+              patternsObj["Property Wrappers"] = true;
+            }
+            if (text.indexOf("@Published") !== -1) {
+              frameworksObj["Combine"] = true;
+              patternsObj["Property Wrappers"] = true;
+            }
+            if (text.indexOf("@MainActor") !== -1 || text.indexOf("@Sendable") !== -1 || text.indexOf("@globalActor") !== -1) {
+              patternsObj["Swift Concurrency"] = true;
+            }
+            if (text.startsWith("@")) patternsObj["Property Wrappers"] = true;
+          }
+        }
+      }
+    }
+    const meta = {};
+    if (annotations.length > 0) meta.annotations = annotations;
+    const kind = parent ? ASTEngine.SymbolKind.Property : ASTEngine.SymbolKind.Variable;
+    const patternNodes = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type === "pattern") patternNodes.push(c);
+    }
+    if (patternNodes.length > 0) {
+      for (const pn of patternNodes) {
+        const idNode = this.findChildByType(pn, "simple_identifier") || this.findChildByType(pn, "identifier") || this.firstNamedChild(pn);
+        if (idNode) {
+          this.createSymbol(idNode.text, kind, idNode, parent, symbols, meta, vis, this.getDeclaredVisibility(node), localScope);
+        }
+      }
+    } else {
+      const idNode = this.findChildByType(node, "simple_identifier") || this.findChildByType(node, "identifier");
+      if (idNode) {
+        this.createSymbol(idNode.text, kind, idNode, parent, symbols, meta, vis, this.getDeclaredVisibility(node));
+      }
+    }
+  }
+  handleCall(node, relationships, parent, emittedCalls, enumCtorCandidates, superByClass, callSiteCounts, callSiteLines) {
+    if (this.isCasePatternRecovery(node)) return;
+    const source = parent ? parent.name : "root";
+    const funcNode = this.findChildByType(node, "simple_identifier") || this.findChildByType(node, "identifier") || this.findChildByType(node, "navigation_expression");
+    if (!funcNode) {
+      if (enumCtorCandidates) {
+        const pre = this.findChildByType(node, "prefix_expression");
+        const dotFirst = pre ? pre.child(0) : null;
+        if (pre && dotFirst && !dotFirst.isNamed && dotFirst.type === ".") {
+          let leaf = null;
+          for (let i = 0; i < pre.namedChildCount; i++) {
+            const c = pre.namedChild(i);
+            if (c && (c.type === "simple_identifier" || c.type === "identifier")) {
+              leaf = c.text;
+              break;
+            }
+          }
+          const owner = parent?.ownerName ?? null;
+          if (leaf && owner) {
+            enumCtorCandidates.push({ source, head: null, owner, leaf, removeCalls: false, line: this.nodeLine(node) });
+          }
+        }
+      }
+      return;
+    }
+    if (this.isSubscriptRead(node)) return;
+    if (funcNode.type === "navigation_expression") {
+      const leaf = this.navigationLeaf(funcNode);
+      if (!leaf || leaf === "$0") return;
+      if (leaf === "init") {
+        const recv = this.navigationReceiver(funcNode);
+        if (recv === "super" || recv === "self" || recv === "Self") {
+          const owner = parent ? MEMBER_OWNER_KINDS.has(parent.kind) ? parent.name : parent.ownerName ?? null : null;
+          let target2 = null;
+          if ((recv === "self" || recv === "Self") && owner) target2 = owner;
+          else if (recv === "super" && owner && superByClass) target2 = superByClass.get(owner) ?? null;
+          if (target2) {
+            const key = `${source}\0instantiates\0${target2}`;
+            if (!emittedCalls.has(key)) {
+              emittedCalls.add(key);
+              relationships.push({
+                type: ASTEngine.RelationshipType.Instantiates,
+                source,
+                target: target2,
+                isExternal: true,
+                weight: 0.7,
+                confidence: 0.95,
+                // The DELEGATION call site's line (`self.init()` / `super.init()`).
+                ...typeof this.nodeLine(node) === "number" ? { line_number: this.nodeLine(node) } : {},
+                metadata: { isSuperInit: recv === "super", isSelfInit: recv !== "super" }
+              });
+            }
+          }
+          return;
+        }
+      }
+      this.emitCall(relationships, source, leaf, emittedCalls, callSiteCounts, this.nodeLine(this.navigationLeafNode(funcNode)), callSiteLines);
+      if (enumCtorCandidates) {
+        const chain = this.navigationChain(funcNode);
+        const receiver = chain.length >= 2 ? chain[chain.length - 2] : null;
+        if (receiver && this.isTypeName(receiver) && receiver !== "Self" && receiver !== "super" && receiver !== "this") {
+          enumCtorCandidates.push({ source, head: receiver, owner: null, leaf, removeCalls: true, line: this.nodeLine(this.navigationLeafNode(funcNode)) });
+        } else if (receiver === "Self") {
+          const owner = parent?.ownerName ?? null;
+          if (owner) enumCtorCandidates.push({ source, head: null, owner, leaf, removeCalls: true, line: this.nodeLine(this.navigationLeafNode(funcNode)) });
+        }
+      }
+      return;
+    }
+    const target = this.stripNameQuoting(funcNode.text);
+    if (!target || BUILTIN_BARE_CALLS.has(target)) return;
+    if (target.startsWith("XCT")) return;
+    const firstChar = target.charCodeAt(0);
+    const isCapitalized = firstChar >= 65 && firstChar <= 90;
+    if (isCapitalized) {
+      const key = `${source}\0instantiates\0${target}`;
+      if (!emittedCalls.has(key)) {
+        emittedCalls.add(key);
+        relationships.push({
+          type: ASTEngine.RelationshipType.Instantiates,
+          source,
+          target,
+          isExternal: true,
+          weight: 0.7,
+          confidence: 1,
+          // The construction site's callee node line.
+          ...typeof this.nodeLine(funcNode) === "number" ? { line_number: this.nodeLine(funcNode) } : {},
+          metadata: { isInstantiation: true }
+        });
+      }
+    } else {
+      this.emitCall(relationships, source, target, emittedCalls, callSiteCounts, this.nodeLine(funcNode), callSiteLines);
+    }
+  }
+  emitCall(relationships, source, target, emittedCalls, callSiteCounts, line, callSiteLines) {
+    if (callSiteCounts) {
+      const siteKey = `${source}\0${target}`;
+      callSiteCounts.set(siteKey, (callSiteCounts.get(siteKey) ?? 0) + 1);
+      if (typeof line === "number") {
+        const arr = callSiteLines?.get(siteKey);
+        if (arr) arr.push(line);
+        else callSiteLines?.set(siteKey, [line]);
+      }
+    }
+    const key = `${source}\0calls\0${target}`;
+    if (emittedCalls.has(key)) return;
+    emittedCalls.add(key);
+    relationships.push({
+      type: ASTEngine.RelationshipType.Calls,
+      source,
+      target,
+      isExternal: true,
+      weight: 1,
+      confidence: 0.95,
+      // The CALLEE node's own line — the site a reader checks.
+      ...typeof line === "number" ? { line_number: line } : {},
+      metadata: {}
+    });
+  }
+  handleSelfUse(node, relationships, typeName, parent, emittedUses) {
+    {
+      let a = node.parent;
+      while (a && (a.type === "directly_assignable_expression" || a.type === "postfix_expression" || a.type === "navigation_expression" || a.type === "navigation_suffix")) a = a.parent;
+      if (a && a.type === "assignment") {
+        const lhs = a.namedChild(0);
+        if (lhs && lhs.startIndex <= node.startIndex && lhs.endIndex >= node.endIndex) return;
+      }
+    }
+    const hasSelf = this.hasSelfReceiver(node);
+    if (!hasSelf) return;
+    const par = node.parent;
+    if (par && par.type === "call_expression" && !this.isSubscriptRead(par)) return;
+    const leaf = this.navigationLeaf(node);
+    if (!leaf) return;
+    const source = (parent && (parent.kind === ASTEngine.SymbolKind.Method || parent.kind === ASTEngine.SymbolKind.Constructor) ? parent.name : null) || typeName || (parent?.ownerName ? parent.ownerName : null) || parent?.name || "root";
+    const key = `${source}\0uses\0${leaf}`;
+    if (emittedUses.has(key)) return;
+    emittedUses.add(key);
+    relationships.push({
+      type: ASTEngine.RelationshipType.Uses,
+      source,
+      target: leaf,
+      isExternal: false,
+      weight: 0.7,
+      confidence: 0.95,
+      // The leaf segment's own node line (`self.a.b` -> the `b` node).
+      ...typeof this.nodeLine(this.navigationLeafNode(node)) === "number" ? { line_number: this.nodeLine(this.navigationLeafNode(node)) } : {},
+      metadata: { isFieldAccess: true }
+    });
+  }
+  /**
+   * M49 #754 (CONV-SW-1): BARE member reads. The main walk only emits uses
+   * for `self.x` navigation reads, so a plain `return count` on a declared
+   * property emitted NOTHING while `return self.count` did (probe-confirmed
+   * live: `uses edges on x: 0`). Mirrors java #739 / dart #752. Gate A: the
+   * name must resolve to a DECLARED MEMBER of the enclosing type (the symbol
+   * table's ownerName IS the enclosing type); gate B (CGD15): a name the
+   * CURRENT function binds locally is not a member read — without it every
+   * local/loop variable fabricates an edge.
+   */
+  handleBareUses(rootNode, relationships, symbols, emittedUses) {
+    const membersByOwner = /* @__PURE__ */ new Map();
+    for (const s of symbols) {
+      if (!s.ownerName) continue;
+      let set = membersByOwner.get(s.ownerName);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        membersByOwner.set(s.ownerName, set);
+      }
+      set.add(s.name);
+    }
+    const NOT_A_READ = /* @__PURE__ */ new Set([
+      "pattern",
+      "parameter",
+      "function_declaration",
+      "protocol_function_declaration",
+      "class_declaration",
+      "protocol_declaration",
+      "struct_declaration",
+      "enum_declaration",
+      "extension_declaration",
+      "actor_declaration",
+      "typealias_declaration",
+      "associatedtype_declaration",
+      "type_annotation",
+      "user_type",
+      "import_declaration",
+      "attribute",
+      "enum_entry",
+      "value_argument_label"
+    ]);
+    const TYPE_DECLS = /* @__PURE__ */ new Set([
+      "class_declaration",
+      "protocol_declaration",
+      "struct_declaration",
+      "enum_declaration",
+      "extension_declaration",
+      "actor_declaration"
+    ]);
+    const FUNC_SCOPES = /* @__PURE__ */ new Set([
+      "function_declaration",
+      "protocol_function_declaration",
+      "init_declaration",
+      "deinit_declaration"
+    ]);
+    const VALUE_SCOPES = /* @__PURE__ */ new Set(["lambda_literal", "property_declaration"]);
+    const isWrite = (n) => {
+      let a = n.parent;
+      while (a && (a.type === "directly_assignable_expression" || a.type === "postfix_expression" || a.type === "navigation_expression" || a.type === "navigation_suffix")) a = a.parent;
+      if (a && a.type === "assignment") {
+        const lhs = a.namedChild(0);
+        return !!lhs && lhs.startIndex <= n.startIndex && lhs.endIndex >= n.endIndex;
+      }
+      return false;
+    };
+    const ownNameSpan = (scope) => {
+      if (scope.type === "property_declaration") {
+        const pat = this.findChildByType(scope, "pattern");
+        const id = pat ? this.findChildByType(pat, "simple_identifier") : null;
+        return id ? id.startIndex : -1;
+      }
+      return -1;
+    };
+    const collectBound = (node, out) => {
+      const own = ownNameSpan(node);
+      const w = [node];
+      while (w.length > 0) {
+        const m = w.pop();
+        if (m.type === "simple_identifier" && m.startIndex !== own) {
+          const pt = m.parent?.type ?? "";
+          if (pt === "parameter" || pt === "pattern") out.add(m.text);
+        }
+        for (let i = m.namedChildCount - 1; i >= 0; i--) {
+          const c = m.namedChild(i);
+          if (c) w.push(c);
+        }
+      }
+    };
+    const extendLocals = (locals, scope) => {
+      const bound = /* @__PURE__ */ new Set();
+      collectBound(scope, bound);
+      if (bound.size === 0) return locals;
+      const next = new Set(locals);
+      for (const nm of bound) next.add(nm);
+      return next;
+    };
+    const walk = (n, ty, fn, locals) => {
+      const t = n.type;
+      let cTy = ty;
+      let cFn = fn;
+      let cLocals = locals;
+      if (TYPE_DECLS.has(t)) {
+        const nameNode = this.firstDescendantOfType(n, "type_identifier") || this.firstDescendantOfType(n, "simple_identifier");
+        if (nameNode) {
+          cTy = nameNode.text;
+          cFn = null;
+        }
+      } else if (this.isNominalRecovery(n)) {
+        const nm = this.recoveryName(n);
+        if (nm) {
+          cTy = nm;
+          cFn = null;
+        }
+      } else if (FUNC_SCOPES.has(t)) {
+        cFn = t === "init_declaration" ? "constructor" : this.findChildByType(n, "simple_identifier")?.text ?? cFn;
+        cLocals = extendLocals(locals, n);
+      } else if (VALUE_SCOPES.has(t)) {
+        cLocals = extendLocals(locals, n);
+      }
+      if (t === "simple_identifier") {
+        const txt = n.text;
+        const pt = n.parent?.type ?? "";
+        let lookup = txt;
+        if (lookup.startsWith("$")) {
+          const rest = lookup.slice(1);
+          if (!rest || this.isAllDigits(rest)) {
+            for (let i = 0; i < n.namedChildCount; i++) {
+              const c = n.namedChild(i);
+              if (c) walk(c, cTy, cFn, cLocals);
+            }
+            return;
+          }
+          lookup = rest;
+        }
+        lookup = this.stripNameQuoting(lookup);
+        const isMember = !!cTy && (membersByOwner.get(cTy)?.has(lookup) ?? false);
+        const isImplicitMember = pt === "prefix_expression" && (n.parent?.text ?? "").startsWith(".");
+        if (!NOT_A_READ.has(pt) && !isImplicitMember && pt !== "navigation_suffix" && pt !== "call_expression" && !isWrite(n) && !cLocals.has(txt) && !cLocals.has(lookup) && isMember) {
+          const source = cFn || cTy || "root";
+          const key = `${source}\0uses\0${lookup}`;
+          if (!emittedUses.has(key)) {
+            emittedUses.add(key);
+            relationships.push({
+              type: ASTEngine.RelationshipType.Uses,
+              source,
+              target: lookup,
+              isExternal: false,
+              weight: 0.7,
+              confidence: 0.6,
+              line_number: this.nodeLine(n),
+              metadata: { isBareRead: true }
+            });
+          }
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) walk(c, cTy, cFn, cLocals);
+      }
+    };
+    walk(rootNode, null, null, /* @__PURE__ */ new Set());
+  }
+  // ==========================================================================
+  // Override resolution (Java/C# shared machinery)
+  // ==========================================================================
+  /**
+   * The PROJECT's cross-file declaration tables, read from
+   * `AnalyzeContext.projectIndex` when a caller supplied one.
+   *
+   * WHY THIS EXISTS, WITH THE NUMBER. `overrides` resolves in three passes
+   * (exact in-file BFS -> companion-verified declaring parent -> first-parent
+   * guess at confidence 0.5). Pass 2 needs BOTH a companion (owner -> declared
+   * members) and a way to walk bases it cannot see in this file. Measured over
+   * the 1,256-file draw with `script/m14/swift-overrides-premise-probe.ts`:
+   *
+   *     tier                        edges  parent declares the method
+   *     pass1 in-file (1.0)            71            71  (100.0%)
+   *     pass3 first-parent (0.5)      210            87  ( 41.4%)
+   *
+   * so the guess's premise — "the first hierarchy parent declares the method" —
+   * fails for 123 of 210 edges (58.6%). swift-nio shows the mechanism:
+   * `final class PipeChannel: BaseStreamSocketChannel<PipePair>` overriding
+   * `connectSocket`, where `connectSocket` is declared two levels up, on
+   * `BaseSocketChannel` (Sources/NIOPosix/BaseSocketChannel.swift:479). The
+   * guess names the DIRECT base, which does not declare it.
+   *
+   * Pass 2 could not fix that, and the reason is a wiring fact rather than a
+   * logic one: Pass 2 reads `context.overrideCompanion`, and
+   * `src/ast/parallel-indexer.ts` builds the batch companion only for the
+   * languages its `PROJECT_INDEX_EXTENSIONS` map lists — today `".sol"` — so no
+   * Swift caller has ever supplied one. `src/ast/pool-worker.ts`'s `parse_batch`
+   * supplies `context.projectIndex` instead, and the Dart lane already reads
+   * that channel (`dartCompanionFor`). This method is the Swift equivalent: it
+   * reads the channel production is designed to fill, so the moment the indexer
+   * is told to build an index for `.swift`, this lane needs no further change.
+   *
+   * ADDITIVE AND INERT WHEN ABSENT. With no `projectIndex` — a single-file
+   * parse, every fixture, the differential — `companion` is undefined, `kinds`
+   * is `context.typeKinds` exactly as before, and `getParents` returns the
+   * per-file hierarchy, so output is byte-identical to before this method
+   * existed. Nothing here decides anything on its own: it only supplies the
+   * cross-file answers the file cannot see.
+   */
+  crossFileTables(context, classHierarchy) {
+    const pi = context?.projectIndex;
+    const kinds = context?.typeKinds ?? (pi?.typeKinds instanceof Map ? pi.typeKinds : void 0);
+    if (!pi || !(pi.typeMembers instanceof Map) || !(pi.typeBases instanceof Map)) {
+      return { companion: void 0, kinds, getParents: (local) => (t) => local.get(t) ?? [] };
+    }
+    const cache = /* @__PURE__ */ new Map();
+    const closure = (owner, seen = /* @__PURE__ */ new Set()) => {
+      const hit = cache.get(owner);
+      if (hit) return hit;
+      const out = /* @__PURE__ */ new Set();
+      if (seen.has(owner)) return out;
+      seen.add(owner);
+      for (const m of pi.typeMembers.get(owner) ?? []) out.add(m);
+      for (const b of pi.typeBases.get(owner) ?? []) {
+        for (const m of closure(b, seen)) out.add(m);
+      }
+      cache.set(owner, out);
+      return out;
+    };
+    const companion = /* @__PURE__ */ new Map();
+    for (const owner of pi.typeMembers.keys()) companion.set(owner, closure(owner));
+    return {
+      companion,
+      kinds,
+      // The project's bases first, the file's own second: a type declared in
+      // THIS file is authoritative here, and a type the file never mentions can
+      // only come from the index.
+      getParents: (local) => (t) => {
+        const localParents = local.get(t);
+        if (localParents && localParents.length > 0) return localParents;
+        const projectParents = pi.typeBases.get(t);
+        return projectParents && projectParents.length > 0 ? projectParents : [];
+      }
+    };
+  }
+  resolveOverrides(tasks, classHierarchy, symbolMap, relationships, companion, getParents) {
+    const parentsOf = getParents ?? ((t) => classHierarchy.get(t) ?? []);
+    for (const task of tasks) {
+      let targetFqn = null;
+      let confidence = 1;
+      let reasonCode;
+      const queue = [];
+      const ownerH = classHierarchy.get(task.ownerFqn);
+      if (ownerH) {
+        for (let i = 0; i < ownerH.length; i++) queue.push(ownerH[i]);
+      }
+      const seen = /* @__PURE__ */ new Set();
+      while (queue.length > 0) {
+        const parentName = queue.shift();
+        if (seen.has(parentName)) continue;
+        seen.add(parentName);
+        const potentialTargetFqn = `${parentName}.${task.methodName}`;
+        if (symbolMap.has(potentialTargetFqn)) {
+          targetFqn = potentialTargetFqn;
+          break;
+        }
+        for (const next of parentsOf(parentName)) queue.push(next);
+      }
+      if (!targetFqn && companion && ownerH && ownerH.length > 0) {
+        const declaring = findDeclaringParent(task.methodName, ownerH, companion, parentsOf);
+        if (declaring) {
+          targetFqn = `${declaring}.${task.methodName}`;
+          confidence = 0.9;
+          reasonCode = "companion-index";
+        }
+      }
+      if (!targetFqn && ownerH && ownerH.length > 0) {
+        targetFqn = `${ownerH[0]}.${task.methodName}`;
+        confidence = 0.5;
+        reasonCode = "first-parent-guess";
+      }
+      if (targetFqn) {
+        relationships.push({
+          type: ASTEngine.RelationshipType.Overrides,
+          source: task.fqn,
+          target: targetFqn,
+          isExternal: true,
+          weight: 0.8,
+          confidence,
+          ...typeof task.line === "number" ? { line_number: task.line } : {},
+          metadata: { relationshipType: "method_override", isSwiftOverride: true, ...reasonCode ? { reasonCode } : {} }
+        });
+      }
+    }
+  }
+  // ==========================================================================
+  // Symbol creation / helpers
+  // ==========================================================================
+  /**
+   * #924 (swift half): Swift's keyword-escape quoting is NOT part of a name.
+   * ``case `continue` `` declares the identifier `continue`; ``static var
+   * `default` `` declares `default` — and every REFERENCE in the corpus spells
+   * them without backticks (`flags: Flags = .default`), so a published name that
+   * keeps the syntax is a name no reference can ever match. Measured at full
+   * extent (`script/m14/tmp/sw-name-census.ts`): 29 symbols and 40 targets
+   * carried the backticks. Exactly one surrounding pair is stripped; a name
+   * that merely contains a backtick keeps it.
+   */
+  stripNameQuoting(text) {
+    if (text.length >= 2 && text.charCodeAt(0) === 96 && text.charCodeAt(text.length - 1) === 96) {
+      return text.slice(1, -1);
+    }
+    return text;
+  }
+  createSymbol(name, kind, node, parent, symbols, meta = {}, visibility = "internal", declaredVisibility = null, localScope = false) {
+    name = this.stripNameQuoting(name);
+    if (parent && parent.kind === ASTEngine.SymbolKind.Extension && declaredVisibility === null && parent.visibility) {
+      visibility = parent.visibility;
+    }
+    const functionScoped = localScope || !!parent && (parent.kind === ASTEngine.SymbolKind.Function || parent.kind === ASTEngine.SymbolKind.Method || parent.kind === ASTEngine.SymbolKind.Constructor);
+    const owner = functionScoped ? null : parent;
+    const symbol = {
+      id: parent ? `${parent.id}.${name}` : name,
+      name,
+      kind,
+      range: {
+        startLine: node.startPosition.row + 1,
+        startColumn: node.startPosition.column + 1,
+        endLine: node.endPosition.row + 1,
+        endColumn: node.endPosition.column + 1,
+        startIndex: node.startIndex,
+        endIndex: node.endIndex
+      },
+      parentId: owner ? owner.id : void 0,
+      ownerName: owner ? owner.name : void 0,
+      parent: owner ? owner.name : void 0,
+      metadata: meta,
+      visibility
+    };
+    if (meta.isAsync) symbol.isAsync = true;
+    if (meta.throws) symbol.throws = "true";
+    if (meta.annotations) symbol.annotations = JSON.stringify(meta.annotations);
+    symbols.push(symbol);
+    return symbol;
+  }
+  collectFunctionMeta(node, meta, symbol) {
+    let isAsync = false;
+    let throws = false;
+    const nodeQueue = [node];
+    while (nodeQueue.length > 0) {
+      const c = nodeQueue.pop();
+      if (c.text === "async" || c.type === "async") isAsync = true;
+      if (c.type === "throw_keyword" || c.text === "throws" || c.type === "throws") throws = true;
+      for (let i = c.childCount - 1; i >= 0; i--) {
+        if (c.child(i)) nodeQueue.push(c.child(i));
+      }
+    }
+    if (isAsync) {
+      meta.isAsync = true;
+      symbol.isAsync = true;
+    }
+    if (throws) {
+      meta.throws = true;
+      symbol.throws = "true";
+    }
+  }
+  /**
+   * The declaration's OWN access-level modifier, or null when it states none.
+   *
+   * The null case is load-bearing (DERIV_EXPORTS_SWIFT4): a member of an
+   * extension INHERITS the extension's level only when it declares none of its
+   * own, so "no modifier" and "explicitly internal" must be distinguishable —
+   * `getVisibility` returns "internal" for both, which is right for the symbol
+   * field and wrong for the inheritance rule.
+   */
+  getDeclaredVisibility(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && child.type === "modifiers") {
+        for (let j = 0; j < child.namedChildCount; j++) {
+          const mod = child.namedChild(j);
+          if (mod) {
+            if (mod.text === "public") return "public";
+            if (mod.text === "private") return "private";
+            if (mod.text === "fileprivate") return "fileprivate";
+            if (mod.text === "internal") return "internal";
+            if (mod.text === "open") return "open";
+            if (mod.text === "package") return "package";
+          }
+        }
+      }
+    }
+    return null;
+  }
+  getVisibility(node) {
+    return this.getDeclaredVisibility(node) ?? "internal";
+  }
+  /**
+   * The EXPORTING access levels, or null when the declaration is not part of the
+   * module's interface. Swift has no `export` keyword (measured: 150 node types
+   * over 400 corpus files, none an export declaration, 0 anonymous `export`
+   * tokens) — its export construct IS access control. What counts as an export
+   * is measured, over 3,656 files (script/m14/swift-import-export-probe.ts) with
+   * 52,113 file-scope declarations as the denominator: 5,708 `public`, 43
+   * `open`, against 1,325 explicit `internal`, 1,470 `private`, 195
+   * `fileprivate` and 43,368 with no modifier at all — 5,751 of 52,113 (11.04%).
+   * `internal`, `private`, `fileprivate` and the no-modifier default are the
+   * ABSENCE of an export, so they are not in this set. `package` IS in the
+   * condition below as a declared grammar-version boundary, not a measured one:
+   * the pinned grammar (npm tree-sitter-swift 0.7.1) cannot reduce it — all six
+   * synthetic shapes parse to an ERROR while `public func` reduces cleanly, and
+   * the corpus probe finds 0 `package` visibility_modifier nodes in 3,656 files
+   * — so it cannot fire on this corpus and this lane does not claim it does.
+   */
+  exportingVisibility(node) {
+    const vis = this.getDeclaredVisibility(node);
+    if (vis === "public" || vis === "open" || vis === "package") return vis;
+    return null;
+  }
+  /**
+   * The MODULE-LEVEL SOURCE of an `exports` edge: the file's own leaf name
+   * (typescript's moduleLeafName() convention), e.g.
+   * `…/fixtures/swift/exports-visibility.swift` -> `exports-visibility`.
+   *
+   * FOREIGN ON PURPOSE: never `root`. `root` is in parallel-indexer's
+   * SYMBOL_NAME_DENYLIST, so an edge sourced there can never bind to a stored
+   * symbol; the leaf name is what every other lane spells for a file-as-module
+   * endpoint (go's packageName, python's moduleName). This is a NAME for the
+   * file the edge was read from, not a claim about SwiftPM's module name, which
+   * no Swift source file contains.
+   */
+  moduleLeafName(filePath) {
+    let start = 0;
+    for (let i = filePath.length - 1; i >= 0; i--) {
+      if (filePath[i] === "/") {
+        start = i + 1;
+        break;
+      }
+    }
+    let end = filePath.length;
+    for (let i = start; i < filePath.length; i++) {
+      if (filePath[i] === ".") {
+        end = i;
+        break;
+      }
+    }
+    return filePath.slice(start, end);
+  }
+  /**
+   * DERIV_EXPORTS_SWIFT4 — does this declaration publish a name for the module?
+   *
+   * Returns the kind the export row carries, or null when the declaration
+   * exports nothing. Three gates, in order:
+   *
+   *   1. an EXPORTING access level (`exportingVisibility`): `public`/`open`/
+   *      `package` and nothing else;
+   *   2. NOT an extension: an extension symbol is named after the EXTENDED type
+   *      (`public extension Array`), so exporting it would name a declaration
+   *      this file does not contain — measured at 54 file-scope sites in a
+   *      3,656-file draw, all of which would be fabrications;
+   *   3. the declaration KINDS that can carry a level: a nominal
+   *      (`class`/`struct`/`enum`/`actor`), a protocol, a function, a
+   *      property binding and a typealias.
+   *
+   * The caller gates on `parentSymbol === null` (file scope) — a member and a
+   * function-local type never reach here.
+   */
+  isExportingDeclaration(node) {
+    if (this.exportingVisibility(node) === null) return null;
+    if (node.type === "class_declaration" && this.hasAnonToken(node, "extension")) return null;
+    if (node.type === "ERROR") {
+      if (!this.isNominalRecovery(node)) return null;
+      return this.recoveryKind(node);
+    }
+    if (node.type === "class_declaration") {
+      const valueType = this.hasAnonToken(node, "struct") || this.hasAnonToken(node, "enum");
+      if (valueType) {
+        if (this.hasAnonToken(node, "struct")) return ASTEngine.SymbolKind.Struct;
+        if (this.hasAnonToken(node, "enum")) return ASTEngine.SymbolKind.Enum;
+      }
+      if (this.hasAnonToken(node, "actor")) return ASTEngine.SymbolKind.Actor;
+      return ASTEngine.SymbolKind.Class;
+    }
+    if (node.type === "protocol_declaration") return ASTEngine.SymbolKind.Interface;
+    if (node.type === "function_declaration" || node.type === "protocol_function_declaration") {
+      return ASTEngine.SymbolKind.Function;
+    }
+    if (node.type === "property_declaration" || node.type === "protocol_property_declaration") {
+      return ASTEngine.SymbolKind.Variable;
+    }
+    if (node.type === "typealias_declaration") return ASTEngine.SymbolKind.Type;
+    return null;
+  }
+  /**
+   * The NAME (and its node, for the line rule) a declaration publishes — one
+   * entry per binding, because a multi-binding declaration (`var a = 1, b = 2`)
+   * carries a sibling `pattern` per binding (SWIFTD18) and publishing only the
+   * first would silently drop the rest.
+   *
+   * Polled by the export emission only: the symbol table already carries these
+   * names, but the export LINE must come from the declaration's own name node
+   * (a decorated declaration's line is its NAME's line, never the
+   * decorator's — pinned by the `Decorated` row of swift/exports-visibility and
+   * mutant SW-EXP-14).
+   */
+  exportedDeclarationNames(node) {
+    const out = [];
+    if (node.type === "property_declaration" || node.type === "protocol_property_declaration") {
+      const pat = this.findChildByType(node, "pattern");
+      if (pat) {
+        const pats = [];
+        for (let i = 0; i < node.namedChildCount; i++) {
+          const c = node.namedChild(i);
+          if (c && c.type === "pattern") pats.push(c);
+        }
+        for (const pn of pats) {
+          const idNode = this.findChildByType(pn, "simple_identifier") || this.findChildByType(pn, "identifier") || this.firstNamedChild(pn);
+          if (idNode) out.push({ name: idNode.text, node: idNode });
+        }
+      }
+      return out;
+    }
+    if (node.type === "protocol_declaration") {
+      const nm = this.findChildByType(node, "type_identifier");
+      if (nm) out.push({ name: nm.text, node: nm });
+      return out;
+    }
+    if (node.type === "class_declaration") {
+      const nm = this.findChildByType(node, "type_identifier") || this.findChildByType(node, "user_type");
+      if (nm) {
+        const leaf = nm.type === "user_type" ? this.lastTypeIdentifier(nm) : nm;
+        if (leaf) out.push({ name: leaf.text, node: leaf });
+      }
+      return out;
+    }
+    if (node.type === "function_declaration" || node.type === "protocol_function_declaration") {
+      const nm = this.findChildByType(node, "simple_identifier") || this.findChildByType(node, "identifier");
+      if (nm) out.push({ name: nm.text, node: nm });
+      else {
+        const opName = this.operatorName(node);
+        if (opName) out.push({ name: opName, node });
+      }
+      return out;
+    }
+    if (node.type === "typealias_declaration") {
+      const nm = this.findChildByType(node, "type_identifier") || this.firstNamedChild(node);
+      if (nm) out.push({ name: nm.text, node: nm });
+      return out;
+    }
+    if (node.type === "ERROR") {
+      const nm = this.recoveryNameNode(node);
+      if (nm) out.push({ name: nm.text, node: nm });
+      return out;
+    }
+    return out;
+  }
+  /**
+   * DERIV_EXPORTS_SWIFT4 — publish ONE file-scope declaration as an `exports`
+   * edge and an `ExportInfo` row.
+   *
+   * `swiftExport: true` is the marker the CLASSIFICATION keys on indirectly
+   * (`reExport` absent -> structural): the access level is a grammar clause read
+   * off the declaration's own `modifiers` node, so nothing here is inferred and
+   * no reason code is owed (honesty contract ).
+   */
+  emitDeclarationExport(node, moduleSource, relationships, exports, emitted) {
+    const vis = this.exportingVisibility(node);
+    if (!vis) return;
+    const kind = this.isExportingDeclaration(node) ?? ASTEngine.SymbolKind.Class;
+    for (const resolved of this.exportedDeclarationNames(node)) {
+      this.publishDeclarationExport(node, resolved, kind, vis, moduleSource, relationships, exports, emitted);
+    }
+  }
+  /** One published NAME: the row, the edge, and the (source, name) dedupe. */
+  publishDeclarationExport(node, resolved, kind, vis, moduleSource, relationships, exports, emitted) {
+    const name = this.stripNameQuoting(resolved.name);
+    if (!name || emitted.has(name)) return;
+    const nameNode = resolved.node;
+    if (nameNode.startIndex < node.startIndex || nameNode.endIndex > node.endIndex) return;
+    emitted.add(name);
+    exports.push({
+      name,
+      kind,
+      range: {
+        startLine: nameNode.startPosition.row + 1,
+        startColumn: nameNode.startPosition.column + 1,
+        endLine: nameNode.endPosition.row + 1,
+        endColumn: nameNode.endPosition.column + 1,
+        startIndex: nameNode.startIndex,
+        endIndex: nameNode.endIndex
+      },
+      visibility: vis,
+      metadata: { exportForm: "visibility_modifier", accessLevel: vis }
+    });
+    relationships.push({
+      type: ASTEngine.RelationshipType.Exports,
+      source: moduleSource,
+      target: name,
+      isExternal: false,
+      weight: 1,
+      confidence: 1,
+      ...typeof this.nodeLine(nameNode) === "number" ? { line_number: this.nodeLine(nameNode) } : {},
+      metadata: { exportForm: "visibility_modifier", accessLevel: vis, swiftExport: true }
+    });
+  }
+  /** `@_exported` — the underscored re-export attribute, by its NAME node. */
+  hasExportedAttribute(node) {
+    return this.hasAttributeNamed(node, "_exported");
+  }
+  /**
+   * The form in which an import RE-PUBLISHES its module, or null for an
+   * ordinary import (which is a dependency and nothing else).
+   *
+   * Two forms, both pinned by swift/exports-visibility:
+   *   - `public import M` (SE-0409) — the `public` modifier on the import;
+   *   - `@_exported import M` — Swift's literal re-export attribute.
+   * `public` is checked first so a hypothetical `@_exported public import M`
+   * keeps the access-controlled form; both publish the same fact.
+   */
+  importReExportForm(node) {
+    let reExportForm = null;
+    if (node.type === "import_declaration") {
+      if (this.exportingVisibility(node) === "public") reExportForm = "public_import";
+      else if (this.hasExportedAttribute(node)) reExportForm = "underscored_exported_import";
+    }
+    return reExportForm;
+  }
+  extractAttributes(node) {
+    const attrs = [];
+    const queue = [node];
+    while (queue.length > 0) {
+      const c = queue.pop();
+      if (c.type === "attribute") {
+        const text = c.text.trim();
+        if (text.startsWith("@")) attrs.push(text);
+      }
+      for (let i = c.childCount - 1; i >= 0; i--) {
+        if (c.child(i)) queue.push(c.child(i));
+      }
+    }
+    return attrs;
+  }
+  handleImport(node, imports, frameworksObj, reExports) {
+    let spelled = "";
+    let moduleNode = null;
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && (c.type === "simple_identifier" || c.type === "type_identifier" || c.type === "identifier")) {
+        spelled = c.text;
+        moduleNode = c;
+        break;
+      }
+    }
+    const moduleName = spelled.split(".")[0] ?? "";
+    let scopeKind = "";
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (!c || c.isNamed) continue;
+      if (c.type === "import") continue;
+      scopeKind = c.type;
+      break;
+    }
+    if (moduleName) {
+      const site = moduleNode ?? node;
+      const range = {
+        startLine: site.startPosition.row + 1,
+        startColumn: site.startPosition.column + 1,
+        endLine: site.endPosition.row + 1,
+        endColumn: site.endPosition.column + 1,
+        startIndex: site.startIndex,
+        endIndex: site.endIndex
+      };
+      const importMd = {
+        module: moduleName,
+        moduleSpecifier: spelled,
+        isModuleDependency: true
+      };
+      if (spelled !== moduleName) importMd.submodulePath = spelled;
+      if (scopeKind.length > 0) {
+        importMd.isScopedImport = true;
+        importMd.scopedKind = scopeKind;
+        const item = spelled.split(".").slice(1).join(".");
+        if (item.length > 0) importMd.scopedItem = item;
+      }
+      const reExportForm = this.importReExportForm(node);
+      if (reExportForm) {
+        importMd.isModuleReExport = true;
+        importMd.reExportForm = reExportForm;
+        importMd.reExport = true;
+      }
+      imports.push({ module: spelled, isExternal: true, range, metadata: importMd });
+      if (reExportForm) {
+        reExports.push({ module: spelled, node: site, form: reExportForm });
+      }
+      if (moduleName === "SwiftUI") frameworksObj["SwiftUI"] = true;
+      if (moduleName === "Combine") frameworksObj["Combine"] = true;
+      if (moduleName === "UIKit") frameworksObj["UIKit"] = true;
+      if (moduleName === "Foundation") frameworksObj["Foundation"] = true;
+    }
+  }
+  /**
+   * The NAME of an `attribute` node: its first named child.
+   *
+   * The attribute arrives as `import_declaration > modifiers > attribute`, and
+   * the pinned grammar spells it `('@' (user_type (type_identifier)))` — so the
+   * attribute's NAME is its first named child's text, never the attribute node's
+   * own text and never the file's text. Reading the name node is what stops
+   * `@objc(name: "_exported")` and a comment from producing a hit, and it is the
+   * same rule the census's probe P2 uses on the other side of the comparison.
+   */
+  attributeName(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c) return c.text;
+    }
+    return null;
+  }
+  hasAttributeNamed(node, want) {
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "attribute" && this.attributeName(n) === want) return true;
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return false;
+  }
+  // ---- tree helpers (pure AST, no source scanning) ----
+  findChildByType(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type === type) return c;
+    }
+    return null;
+  }
+  /**
+   * Depth-first (pre-order) first named descendant of the given type. Needed
+   * where the node of interest is wrapped: a type declaration's name sits in a
+   * direct `type_identifier` child for `struct Foo`, but under `user_type` for
+   * `extension Foo` — so a shallow search finds nothing and the declaration
+   * reads as nameless (#754 corpus finding).
+   */
+  firstDescendantOfType(node, type) {
+    const stack = [node];
+    while (stack.length > 0) {
+      const x = stack.pop();
+      if (x.type === type) return x;
+      for (let i = x.namedChildCount - 1; i >= 0; i--) {
+        const c = x.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return null;
+  }
+  hasChildType(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type === type) return true;
+    }
+    return false;
+  }
+  firstNamedChild(node) {
+    return node.namedChildCount > 0 ? node.namedChild(0) : null;
+  }
+  /**
+   * Per-symbol cyclomatic complexity (managed-OO family contract — csharp
+   * #264 wave precedent). Mirrors the file-level counter's node set, adapted
+   * to the pinned swift grammar (switch_entry per case, guard_statement,
+   * catch_block, conjunction/disjunction/ternary expressions); base 1.
+   */
+  calculateCyclomaticComplexity(node) {
+    let complexity = 1;
+    const complexityNodes = /* @__PURE__ */ new Set([
+      "if_statement",
+      "for_statement",
+      "while_statement",
+      "repeat_while_statement",
+      "switch_entry",
+      "guard_statement",
+      "catch_block",
+      "conjunction_expression",
+      "disjunction_expression",
+      "ternary_expression"
+    ]);
+    const stack = [node];
+    let guard = 0;
+    while (stack.length > 0 && guard++ < 2e5) {
+      const n = stack.pop();
+      if (complexityNodes.has(n.type)) complexity++;
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return complexity;
+  }
+  /** `x[key]` parses as call_expression with a `[key]` call_suffix. */
+  isSubscriptRead(node) {
+    const suffix = this.findChildByType(node, "call_suffix");
+    if (!suffix) return false;
+    const args = this.findChildByType(suffix, "value_arguments");
+    return !!args && this.hasAnonToken(args, "[");
+  }
+  /**
+   * Operator overload name: the token immediately after `func`.
+   *
+   * The grammar reads most operator tokens as ANONYMOUS children (`==`, `+`,
+   * `<`, `===`) but falls back to a NAMED `custom_operator` node for sequences
+   * it has no reserved token for — measured on the pinned wasm: `func !==` and
+   * `func ~=` both parse as `custom_operator`, `func ===`/`func <`/`func ==` as
+   * anonymous tokens. The pre-fix loop accepted only anonymous children, so the
+   * named forms fell through to the first anonymous child that was not a paren
+   * — the parameter comma — and minted `operator ,`: measured in the corpus as
+   * a symbol and an `exports` edge naming `operator ,` in
+   * swift-corpus/SwiftCompilerSources/Sources/SIL/ApplySite.swift (the `~=`
+   * overload), SIL/Instruction.swift and COM/IUnknown+Identity.swift (the `!==`
+   * overloads). A comma is not an operator Swift can declare, so that endpoint
+   * was FABRICATED, the defect class INCOMING_SWIFT JOB 2 forbids.
+   *
+   * `custom_operator` is the only named node accepted here; a named
+   * `simple_identifier` is a normal function name (return null), and anything
+   * else before the first paren is not a name token.
+   */
+  operatorName(node) {
+    let sawFunc = false;
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (!c) continue;
+      if (!c.isNamed && c.type === "func") {
+        sawFunc = true;
+        continue;
+      }
+      if (sawFunc) {
+        if (c.isNamed && c.type === "simple_identifier") return null;
+        if (c.isNamed && c.type === "custom_operator") return `operator ${c.text}`;
+        if (!c.isNamed && c.type !== "(" && c.type !== ")" && c.type !== "{") {
+          return `operator ${c.text}`;
+        }
+      }
+    }
+    return null;
+  }
+  /** `defer { ... }` parses as call_expression(simple_identifier "defer", call_suffix > lambda_literal). */
+  isDeferCall(node) {
+    const fn = this.findChildByType(node, "simple_identifier") || this.findChildByType(node, "identifier");
+    if (!fn || fn.text !== "defer") return false;
+    const suffix = this.findChildByType(node, "call_suffix");
+    return !!suffix && this.findChildByType(suffix, "lambda_literal") !== null;
+  }
+  /** Match an anonymous keyword token (`struct`, `enum`, `extension`, `actor`, `override`, `self`). */
+  hasAnonToken(node, tokenType) {
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && !c.isNamed && c.type === tokenType) return true;
+    }
+    return false;
+  }
+  /**
+   * Walk the navigation RECEIVER chain: navigation_expression > (nested
+   * navigation_expression | self_expression | anonymous self token). Stops at
+   * the first non-receiver child (a call_expression/try_expression) — the
+   * suffix then applies to that call's RESULT, not to self.
+   */
+  hasSelfReceiver(node) {
+    let cur = node;
+    let guard = 0;
+    while (cur && guard++ < 64) {
+      if (cur.type === "self_expression" || cur.type === "self" && !cur.isNamed) return true;
+      let next = null;
+      for (let i = 0; i < cur.namedChildCount; i++) {
+        const c = cur.namedChild(i);
+        if (!c) continue;
+        if (c.type === "navigation_expression" || c.type === "self_expression") {
+          next = c;
+          break;
+        }
+      }
+      if (!next && cur.type === "navigation_expression") {
+        const spine = cur.namedChild(0);
+        if (spine && (spine.type === "additive_expression" || spine.type === "prefix_expression")) {
+          let selfChild = null;
+          for (let i = 0; i < spine.namedChildCount; i++) {
+            const c = spine.namedChild(i);
+            if (c?.type === "self_expression") {
+              selfChild = c;
+              break;
+            }
+          }
+          if (selfChild) return true;
+          next = spine;
+        }
+      }
+      if (!next) return false;
+      cur = next;
+    }
+    return false;
+  }
+  /** Match an anonymous keyword token anywhere in the subtree (nested modifier tokens). */
+  hasDescendantAnonToken(node, tokenType) {
+    const stack = [node];
+    while (stack.length > 0) {
+      const c = stack.pop();
+      if (c.type === tokenType && !c.isNamed) return true;
+      for (let i = c.childCount - 1; i >= 0; i--) {
+        const child = c.child(i);
+        if (child) stack.push(child);
+      }
+    }
+    return false;
+  }
+  /** For extensions: the type_identifier inside the user_type (the extended type). */
+  findDescendantTypeIdentifier(node) {
+    const stack = [node];
+    while (stack.length > 0) {
+      const c = stack.pop();
+      if (c.type === "type_identifier") return c;
+      for (let i = c.namedChildCount - 1; i >= 0; i--) {
+        const child = c.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    return null;
+  }
+  findEnumRawType(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type === "inheritance_specifier") {
+        const inner = this.findChildByType(c, "user_type") || this.findChildByType(c, "type_identifier");
+        return inner ? inner.text : c.text;
+      }
+    }
+    return null;
+  }
+  /** Base type names from the inheritance specifier (class/struct/actor). */
+  /**
+   * SW-D21 (#938): `case .X(let y)` recovery — the callee navigation's first
+   * token is the reserved `case` keyword (parsed as a simple_identifier).
+   * Swift never lets `case` name a value, so this is always grammar recovery.
+   */
+  isCasePatternRecovery(callNode) {
+    for (let i = 0; i < callNode.namedChildCount; i++) {
+      const c = callNode.namedChild(i);
+      if (!c || c.type !== "navigation_expression") continue;
+      const head = this.firstNamedChild(c);
+      if (head && (head.type === "simple_identifier" || head.type === "identifier") && head.text === "case") return true;
+    }
+    return false;
+  }
+  /**
+   * SW-D23 (#940): is this ERROR node a nominal DECLARATION the pinned grammar
+   * failed to reduce? True when its FIRST child is the anonymous nominal
+   * keyword token and its own next named child is the type name (`user_type`
+   * for an extension, an identifier otherwise). The name must be the
+   * recovery's own name node — never a nested declaration's — so a top-level
+   * `ERROR` that merely contains declarations somewhere below is not treated
+   * as one itself.
+   */
+  /**
+   * The nominal kind of an ERROR-recovered header, read from the TOKENS: the
+   * first anonymous nominal keyword child, provided nothing but header material
+   * (`modifiers` / `attribute` / `comment`) precedes it. Declaration content
+   * before a keyword means the keyword belongs to a nested declaration that the
+   * recovery left as a SIBLING (measured: `extension SocketAddressError { ...
+   * struct UnknownHost ... }` carries the nested `struct` token as a direct
+   * child of the recovery, so a plain "does any child token say struct" test
+   * names the extension a struct).
+   */
+  recoveryKind(node) {
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (!c) continue;
+      if (!c.isNamed) {
+        if (c.type === "class") return ASTEngine.SymbolKind.Class;
+        if (c.type === "struct") return ASTEngine.SymbolKind.Struct;
+        if (c.type === "enum") return ASTEngine.SymbolKind.Enum;
+        if (c.type === "extension") return ASTEngine.SymbolKind.Extension;
+        if (c.type === "actor") return ASTEngine.SymbolKind.Actor;
+        continue;
+      }
+      if (c.type === "modifiers" || c.type === "attribute" || c.type === "comment") continue;
+      return null;
+    }
+    return null;
+  }
+  /**
+   * The recovery's OWN name node: the first non-header child, which is the
+   * extended `user_type` for an extension and an identifier otherwise. Anything
+   * else (a nested declaration's type_identifier, a parameter type) is not this
+   * header's name.
+   */
+  recoveryNameNode(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (c.type === "modifiers" || c.type === "attribute" || c.type === "comment") continue;
+      if (c.type === "user_type" || c.type === "type_identifier" || c.type === "simple_identifier" || c.type === "identifier") return c;
+      return null;
+    }
+    return null;
+  }
+  recoveryName(node) {
+    const n = this.recoveryNameNode(node);
+    if (!n) return null;
+    if (n.type === "user_type") {
+      const leaf = this.lastTypeIdentifier(n);
+      return leaf ? leaf.text : null;
+    }
+    return n.text;
+  }
+  isNominalRecovery(node) {
+    if (node.type !== "ERROR") return false;
+    return this.recoveryKind(node) !== null && this.recoveryNameNode(node) !== null;
+  }
+  /**
+   * (#825 lineage): base sites WITH their name nodes, because a heritage
+   * edge must name the base specifier's own line — the declaration's line is a
+   * different site, and borrowing it is the fabrication the line rule forbids.
+   */
+  extractBaseSites(node) {
+    const sites = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type === "inheritance_specifier") {
+        const site = this.extractBaseSite(c);
+        if (site) sites.push(site);
+      }
+    }
+    return sites;
+  }
+  /**
+   * The store's `line_number` for a node: its 1-based start row.
+   * `undefined` when there is no node — the field's ruled absence state, never
+   * a fabricated 0 and never an enclosing declaration's line (/ R6).
+   */
+  nodeLine(node) {
+    if (!node) return void 0;
+    return node.startPosition.row + 1;
+  }
+  /**
+   * Leaf of a (possibly dotted) user_type: the LAST sibling type_identifier
+   * (`Outer.Inner` -> Inner, `Foundation.URLSession` -> URLSession). The
+   * user_type node holds its dotted segments as sibling type_identifier
+   * children in source order (probe-verified 2026-09), so the leaf is simply
+   * the last one. SWIFTD19: the pre-fix code returned the FIRST segment,
+   * fabricating extends/implements edges to the wrong (module/container)
+   * name — e.g. `class Sub2: Foundation.URLSession` became extends Sub2 ->
+   * Foundation, and `extension Foo: SomeMod.Proto` became implements Foo ->
+   * SomeMod.
+   */
+  lastTypeIdentifier(ut) {
+    let last = null;
+    for (let i = 0; i < ut.namedChildCount; i++) {
+      const c = ut.namedChild(i);
+      if (c && c.type === "type_identifier") last = c;
+    }
+    if (last) return last;
+    const stack = [ut];
+    let best = null;
+    while (stack.length > 0) {
+      const c = stack.pop();
+      if (c.type === "type_identifier") {
+        if (!best || c.startIndex >= best.startIndex) best = c;
+      }
+      for (let i = c.namedChildCount - 1; i >= 0; i--) {
+        const child = c.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    return best;
+  }
+  extractBaseSite(spec) {
+    for (let i = 0; i < spec.namedChildCount; i++) {
+      const c = spec.namedChild(i);
+      if (!c) continue;
+      if (c.type === "type_identifier") return { name: c.text, node: c };
+      if (c.type === "user_type") {
+        const leaf = this.lastTypeIdentifier(c);
+        if (leaf) return { name: leaf.text, node: leaf };
+      }
+    }
+    const txt = spec.text.trim();
+    return txt && !txt.includes(" ") ? { name: txt, node: spec } : null;
+  }
+  /** SW-F: all-ASCII-digits check without regex (family contract). */
+  isAllDigits(text) {
+    if (text.length === 0) return false;
+    for (let i = 0; i < text.length; i++) {
+      const c = text.charCodeAt(i);
+      if (c < 48 || c > 57) return false;
+    }
+    return true;
+  }
+  /** SW-G: receiver head of a navigation (`super`/`self`/`Self`/identifier). */
+  navigationReceiver(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (c.type === "self_expression") return "self";
+      if (c.type === "super_expression") return "super";
+      if (c.type === "simple_identifier" || c.type === "identifier" || c.type === "type_identifier") return c.text;
+      if (c.type === "navigation_expression") return this.navigationReceiver(c);
+      return null;
+    }
+    return null;
+  }
+  /**
+   * SW-B: document-order member texts of a navigation chain
+   * (`P.Foo.bar` -> [P, Foo, bar]). The DIRECT receiver of the leaf method
+   * is second-to-last — the ultimate head is wrong for 3+ chains. Never
+   * descends into nested call_expressions (arguments are not chain
+   * members: `a.b[x]` must yield [a, b], never [a, b, x]).
+   */
+  navigationChain(node) {
+    const out = [];
+    const stack = [node];
+    const seen = [];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n !== node && n.type === "call_expression") continue;
+      seen.push(n);
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    seen.sort((a, b) => a.startIndex - b.startIndex);
+    for (const n of seen) {
+      if (n.type === "simple_identifier" || n.type === "identifier" || n.type === "type_identifier") {
+        out.push(n.text);
+      }
+    }
+    return out;
+  }
+  /** SW-B: capitalized type-name signal (SWIFTD17 rule, shared). */
+  isTypeName(text) {
+    if (text.length === 0) return false;
+    const code = text.charCodeAt(0);
+    return code >= 65 && code <= 90;
+  }
+  /**
+   * SW-A (ultimate review): NON-self navigation member reads. Every
+   * navigation_suffix member reads unless (a) it is the invoked callee (its
+   * navigation is the func of a non-subscript call and it is the last
+   * suffix), (b) the chain is self-rooted (handleSelfUse owns those),
+   * (c) it sits in an assignment-LHS span (SCD1), (d) it is an implicit-dot
+   * member (`.regular` — base inferred, bare-uses parity), or (e) it names
+   * self/Self/$0. Shares emittedUses with handleSelfUse (first metadata
+   * wins) and sources identically (method > type > owner > name > root).
+   */
+  handleMemberUses(node, relationships, parent, typeName, emittedUses) {
+    if (this.hasSelfReceiver(node)) return;
+    const source = (parent && (parent.kind === ASTEngine.SymbolKind.Method || parent.kind === ASTEngine.SymbolKind.Constructor) ? parent.name : null) || typeName || (parent?.ownerName ? parent.ownerName : null) || parent?.name || "root";
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c || c.type !== "navigation_suffix") continue;
+      const m = this.findChildByType(c, "simple_identifier") || this.findChildByType(c, "identifier");
+      if (!m || !m.text) continue;
+      const member = this.stripNameQuoting(m.text);
+      if (member === "$0" || member === "self" || member === "Self") continue;
+      const par = node.parent;
+      if (par && par.type === "call_expression" && !this.isSubscriptRead(par)) {
+        let last = false;
+        for (let j = node.namedChildCount - 1; j >= 0; j--) {
+          const s = node.namedChild(j);
+          if (s && s.type === "navigation_suffix") {
+            last = s.startIndex === c.startIndex && s.endIndex === c.endIndex;
+            break;
+          }
+        }
+        if (last) continue;
+      }
+      let outer = node;
+      while (outer && outer.parent && outer.parent.type === "navigation_expression") outer = outer.parent;
+      const firstTok = outer ? outer.child(0) : null;
+      if (firstTok && !firstTok.isNamed && firstTok.type === ".") continue;
+      let a = node.parent;
+      while (a && (a.type === "directly_assignable_expression" || a.type === "postfix_expression" || a.type === "navigation_expression" || a.type === "navigation_suffix")) a = a.parent;
+      if (a && a.type === "assignment") {
+        const lhs = a.namedChild(0);
+        if (lhs && lhs.startIndex <= c.startIndex && lhs.endIndex >= c.endIndex) continue;
+      }
+      const key = `${source}\0uses\0${member}`;
+      if (emittedUses.has(key)) continue;
+      emittedUses.add(key);
+      relationships.push({
+        type: ASTEngine.RelationshipType.Uses,
+        source,
+        target: member,
+        isExternal: false,
+        weight: 0.7,
+        confidence: 0.9,
+        // The member identifier node inside this suffix.
+        line_number: this.nodeLine(m),
+        metadata: { isMemberRead: true }
+      });
+    }
+  }
+  /**
+   * SW-D (ultimate review): key-path members (`\.name`, `\C.name`) always
+   * read the member identity.
+   */
+  handleKeyPathUses(node, relationships, parent, typeName, emittedUses) {
+    const source = (parent && (parent.kind === ASTEngine.SymbolKind.Method || parent.kind === ASTEngine.SymbolKind.Constructor) ? parent.name : null) || typeName || (parent?.ownerName ? parent.ownerName : null) || parent?.name || "root";
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "navigation_suffix") {
+        const m = this.findChildByType(n, "simple_identifier") || this.findChildByType(n, "identifier");
+        if (m && m.text && m.text !== "self" && m.text !== "Self") {
+          const keyPathMember = this.stripNameQuoting(m.text);
+          const key = `${source}\0uses\0${keyPathMember}`;
+          if (!emittedUses.has(key)) {
+            emittedUses.add(key);
+            relationships.push({
+              type: ASTEngine.RelationshipType.Uses,
+              source,
+              target: keyPathMember,
+              isExternal: false,
+              weight: 0.7,
+              confidence: 0.9,
+              line_number: this.nodeLine(m),
+              metadata: { isMemberRead: true, isKeyPath: true }
+            });
+          }
+        }
+        continue;
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+  }
+  /**
+   * The leaf IDENTIFIER NODE of a navigation (`users.first` -> the `first`
+   * node) — the site a `uses`/`calls` edge's line must name. Paired with
+   * `navigationLeaf` (the string form) so no line is ever taken from a
+   * different segment of the chain.
+   */
+  navigationLeafNode(node) {
+    let leaf = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (c.type === "navigation_suffix") {
+        leaf = this.findChildByType(c, "simple_identifier") || this.findChildByType(c, "identifier") || c;
+      }
+    }
+    if (leaf) return leaf;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type === "simple_identifier") leaf = c;
+    }
+    return leaf;
+  }
+  /** Leaf name of a navigation_expression: `users.first` -> `first`. */
+  navigationLeaf(node) {
+    let leaf = null;
+    let sawSuffix = false;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (c.type === "navigation_suffix") {
+        sawSuffix = true;
+        leaf = this.findChildByType(c, "simple_identifier") || this.findChildByType(c, "identifier");
+      }
+    }
+    if (leaf) return this.stripNameQuoting(leaf.text);
+    if (sawSuffix) return null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type === "simple_identifier") leaf = c;
+    }
+    return leaf ? this.stripNameQuoting(leaf.text) : null;
+  }
+  /** Return type node after the `->` anonymous token (lightweight). */
+  findReturnType(node) {
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && !c.isNamed && c.type === "->") {
+        const nxt = node.child(i + 1);
+        if (nxt && nxt.isNamed) return nxt;
+      }
+    }
+    return null;
+  }
+};
+export {
+  RealSwiftAnalyzer
+};