@lzehrung/codegraph 2.3.18 → 2.3.19

package/dist/bin/cli.js

@@ -32938,7 +32938,7 @@ var init_options2 = __esm({
     init_projectFiles();
     init_treeSitterNative();
     init_languages();
-    CORE_ALGORITHM_EPOCH = 2;
+    CORE_ALGORITHM_EPOCH = 3;
     LANGUAGE_BEHAVIOR_EPOCH = 1;
   }
 });
@@ -57700,7 +57700,7 @@ function memberAccessTraversalTypes(sup) {
 }
 function isMemberAccessNode(sup, node) {
   const memberExpressionType = memberExpressionTypeFor(sup);
-  return node.type === memberExpressionType || sup.id === "go" && node.type === "qualified_type" || sup.id === "php" && (node.type === "member_call_expression" || node.type === "scoped_call_expression") || node.type === "member_access_expression" || node.type === "qualified_name" || node.type === "field_access" || node.type === "method_invocation" || node.type === "scoped_identifier" || node.type === "scoped_type_identifier" || node.type === "call" || node.type === "scope_resolution" || node.type === "field_expression" || node.type === "attribute" || node.type === "navigation_expression";
+  return node.type === memberExpressionType || sup.id === "go" && node.type === "qualified_type" || sup.id === "php" && (node.type === "member_call_expression" || node.type === "nullsafe_member_call_expression" || node.type === "scoped_call_expression") || node.type === "member_access_expression" || node.type === "qualified_name" || node.type === "field_access" || node.type === "method_invocation" || node.type === "scoped_identifier" || node.type === "scoped_type_identifier" || node.type === "qualified_identifier" || node.type === "call" || node.type === "scope_resolution" || node.type === "field_expression" || node.type === "attribute" || node.type === "navigation_expression";
 }
 function isMemberObjectIdentifier(nodeType) {
   return nodeType === "identifier" || nodeType === "type_identifier" || nodeType === "package_identifier" || nodeType === "constant" || nodeType === "namespace_identifier";
@@ -57721,6 +57721,12 @@ function fieldParts(node, objectField, propertyField) {
   };
 }
 function getMemberAccessParts(sup, memberNode) {
+  if (sup.id === "c" || sup.id === "cpp") {
+    if (memberNode.type === "field_expression")
+      return fieldParts(memberNode, "argument", "field");
+    if (memberNode.type === "qualified_identifier")
+      return fieldParts(memberNode, "scope", "name");
+  }
   if (sup.id === "python") {
     return fieldParts(memberNode, "object", "attribute");
   }
@@ -57745,7 +57751,7 @@ function getMemberAccessParts(sup, memberNode) {
     return fieldParts(memberNode, "receiver", "method");
   }
   if (sup.id === "php") {
-    if (memberNode.type === "member_call_expression") {
+    if (memberNode.type === "member_call_expression" || memberNode.type === "nullsafe_member_call_expression") {
       return fieldParts(memberNode, "object", "name");
     }
     if (memberNode.type === "scoped_call_expression") {
@@ -57824,6 +57830,23 @@ var init_memberAccess = __esm({
 });
 
 // dist/graphs/symbol-graph-detailed/ast.js
+function functionNameNode(node) {
+  const named = node.childForFieldName("name");
+  if (named)
+    return named;
+  let current = node.childForFieldName("declarator");
+  while (current) {
+    if (current.type === "identifier" || current.type === "field_identifier")
+      return current;
+    const nested = current.childForFieldName("declarator");
+    if (nested) {
+      current = nested;
+      continue;
+    }
+    return current.namedChildren.find((child) => child.type === "identifier" || child.type === "field_identifier") ?? null;
+  }
+  return node.childForFieldName("type");
+}
 function collectDetailedDeclarations(rootNode, sup, source, locals) {
   const functionNodes = [];
   const classNodes = [];
@@ -57841,6 +57864,7 @@ function collectDetailedDeclarations(rootNode, sup, source, locals) {
     "function_item",
     "function_signature_item",
     "method",
+    "protocol_function_declaration",
     "singleton_method"
   ]);
   const typeNodeTypes = /* @__PURE__ */ new Set([
@@ -57850,8 +57874,10 @@ function collectDetailedDeclarations(rootNode, sup, source, locals) {
     "class_definition",
     "class",
     "interface_declaration",
+    "module",
     "protocol_declaration",
     "trait_item",
+    "trait_declaration",
     "struct_item",
     "struct_declaration",
     "class_specifier",
@@ -57871,7 +57897,7 @@ function collectDetailedDeclarations(rootNode, sup, source, locals) {
   };
   const walk = (node) => {
     if (functionNodeTypes.has(node.type)) {
-      const nameNode = node.childForFieldName("name") ?? node.childForFieldName("type");
+      const nameNode = functionNameNode(node);
       const name = nameNode ? sliceText(nameNode, source) : void 0;
       if (name) {
         const def = findDefinition(name, nameNode);
@@ -57976,389 +58002,1375 @@ var init_ast2 = __esm({
   }
 });
 
-// dist/graphs/symbol-graph-detailed/edgePasses.js
-function ensureNode(context, def) {
-  const id = defNodeId(def);
-  if (!context.nodes.has(id))
-    context.nodes.set(id, nodeForDef(def));
-  return id;
-}
-function markImplementationTarget(context, id, declarationNode, def) {
-  const declaration = sliceText(declarationNode, context.source);
-  const nameIndex = declaration.indexOf(def.localName);
-  const prefix = nameIndex >= 0 ? declaration.slice(0, nameIndex) : declaration;
-  if (!/\b(?:abstract|virtual|override)\b/.test(prefix))
-    return;
-  const node = context.nodes.get(id);
-  if (node)
-    node.implementationTarget = true;
-}
-function markMemberArity(context, id, declarationNode) {
-  let parameters = declarationNode.childForFieldName("parameters");
-  if (!parameters) {
-    for (const type of [
-      "formal_parameters",
-      "parameter_list",
-      "parameters",
-      "method_parameters",
-      "function_parameter_clause"
-    ]) {
-      parameters = findFirstNodeByType(declarationNode, type);
-      if (parameters)
-        break;
-    }
+// dist/indexer/navigation-provenance.js
+function getNavigationBackend(index) {
+  if (index.nativeMode === "on") {
+    return "native";
   }
-  if (!parameters)
-    return;
-  const arity = (parameters.namedChildren ?? []).filter((child) => child.type !== "comment").length;
-  const node = context.nodes.get(id);
-  if (node)
-    node.memberArity = arity;
+  if (index.nativeMode === "off") {
+    return "graph-only";
+  }
+  return void 0;
 }
-function recordDefEdge(context, fromId, target, label, siteNode) {
-  const toId = ensureNode(context, target);
-  return context.recordEdge(fromId, toId, label, siteNode ? { file: context.moduleEntry.file, range: toRange(siteNode) } : void 0);
+function createNavigationProvenance(index, resolution, confidence) {
+  const backend = getNavigationBackend(index);
+  return {
+    ...backend ? { backend } : {},
+    ...resolution ? { resolution } : {},
+    ...confidence ? { confidence } : {}
+  };
 }
-function tryResolveChain(context, node, fromId, label = "uses") {
-  const targetDef = context.resolveMemberChainTarget(node);
-  if (targetDef && fromId) {
-    recordDefEdge(context, fromId, targetDef, label, node);
-    return true;
-  }
-  return !!targetDef;
+function okGoToResult(index, definition, options) {
+  return {
+    status: "ok",
+    definition,
+    ...options.via ? { via: options.via } : {},
+    provenance: createNavigationProvenance(index, options.resolution, options.confidence)
+  };
 }
-function tryResolveNode(context, node, fromId, label) {
-  if (isIdentifierType(context.sup, node.type) || node.type === "type_identifier") {
-    const name = sliceText(node, context.source);
-    const target = context.resolveIdentifier(name);
-    if (target) {
-      recordDefEdge(context, fromId, target, label, node);
-      return;
-    }
+var init_navigation_provenance = __esm({
+  "dist/indexer/navigation-provenance.js"() {
+    "use strict";
   }
-  if (context.optionalMemberTypes.has(node.type)) {
-    tryResolveChain(context, node, fromId, label);
+});
+
+// dist/indexer/navigation-goto.js
+async function resolveMemberAccessDefinition(params) {
+  const { index, mod: mod2, node, source, sup, resolveLexicalBinding } = params;
+  const parent = node.parent;
+  if (!parent || !sup.supportsCrossModuleSymbols || !isMemberAccessNode(sup, parent)) {
+    return null;
   }
-}
-function getCallTarget(node) {
-  const explicitTarget = node.childForFieldName("function") ?? node.childForFieldName("callee") ?? node.childForFieldName("name") ?? node.childForFieldName("method") ?? node.childForFieldName("member") ?? node.childForFieldName("expression");
-  if (explicitTarget)
-    return explicitTarget;
-  const nonArgumentChildren = node.namedChildren.filter((child) => child.type !== "argument_list");
-  return nonArgumentChildren.length === 1 ? nonArgumentChildren[0] ?? null : null;
-}
-function getNewTarget(node) {
-  return node.childForFieldName("constructor") ?? node.childForFieldName("type") ?? node.childForFieldName("name") ?? node.namedChildren.find((child) => child.type === "type_identifier") ?? node.child(0);
-}
-function emitPythonDecoratorEdges(context, rootNode) {
-  if (context.sup.id !== "python")
-    return;
-  const addDecoratorUses = (node) => {
-    if (node.type === "decorated_definition") {
-      const fn = node.namedChildren.find((child) => child.type === "function_definition");
-      if (fn)
-        addDecoratorUses(fn);
-      for (const decoratorChild of node.namedChildren) {
-        if (decoratorChild.type !== "decorator")
-          continue;
-        const nameNode = fn?.childForFieldName("name");
-        if (!nameNode)
-          continue;
-        const name = sliceText(nameNode, context.source);
-        const def = context.moduleEntry.locals.find((local) => local.localName === name);
-        if (!def)
-          continue;
-        const fromId = ensureNode(context, def);
-        const expr = decoratorChild.childForFieldName?.("name") ?? decoratorChild.namedChildren?.[0] ?? decoratorChild.child(1);
-        if (expr)
-          tryResolveNode(context, expr, fromId, "decorates");
-      }
-    } else if (node.type === "function_definition") {
-      const nameNode = node.childForFieldName("name");
-      if (nameNode) {
-        const name = sliceText(nameNode, context.source);
-        const def = context.moduleEntry.locals.find((local) => local.localName === name);
-        if (def) {
-          const fromId = ensureNode(context, def);
-          let prev = node.previousSibling;
-          while (prev) {
-            if (prev.type === "decorated_definition") {
-              for (const decoratorChild of prev.namedChildren) {
-                if (decoratorChild.type === "decorator") {
-                  const expr = decoratorChild.childForFieldName?.("name") ?? decoratorChild.namedChildren?.[0] ?? decoratorChild.child(1);
-                  if (expr)
-                    tryResolveNode(context, expr, fromId, "decorates");
-                } else if (decoratorChild.type === "attribute") {
-                  tryResolveNode(context, decoratorChild, fromId, "decorates");
-                }
-              }
-            } else if (prev.type === "decorator") {
-              const expr = prev.childForFieldName?.("name") ?? prev.namedChildren?.[0] ?? prev.child(1);
-              if (expr)
-                tryResolveNode(context, expr, fromId, "decorates");
-            }
-            prev = prev.previousSibling;
+  const memberNode = parent;
+  const { object: obj, property: prop } = getMemberAccessParts(sup, memberNode);
+  const optionalMemberTypes = memberAccessTraversalTypes(sup);
+  const resolveExpression = async (expr) => {
+    const exprIsId = sup.nodeTypes.identifier.includes(expr.type) && !isMemberAccessNode(sup, expr);
+    if (exprIsId || expr.type === "identifier" || expr.type === "type_identifier" || expr.type === "constant") {
+      const lexicalBinding = resolveLexicalBinding?.(expr);
+      if (lexicalBinding)
+        return { kind: "resolved", def: lexicalBinding };
+      const exprName = sliceText(expr, source);
+      const imp = mod2.imports.find((candidate) => candidate.kind === "named" && candidate.local === exprName || candidate.kind === "default" && candidate.local === exprName || candidate.kind === "namespace" && candidate.localNS === exprName);
+      if (imp) {
+        if (imp.kind === "namespace") {
+          return {
+            kind: "namespace",
+            file: typeof imp.resolved === "string" ? imp.resolved.replace(/\\/g, "/") : imp.resolved?.external || ""
+          };
+        }
+        const result = resolveImported(index, imp, imp.kind === "named" ? imp.imported : "default");
+        if (result) {
+          if ("namespace" in result) {
+            return { kind: "namespace", file: result.namespace };
           }
+          return { kind: "resolved", def: result };
         }
       }
-    }
-    for (const child of node.namedChildren)
-      addDecoratorUses(child);
-  };
-  addDecoratorUses(rootNode);
-}
-function emitMemberOwnershipEdges(context, functionNodes, classNodes) {
-  for (const fn of functionNodes) {
-    const owners = classNodes.filter((candidate) => candidate.node.startIndex <= fn.node.startIndex && candidate.node.endIndex >= fn.node.endIndex).sort((left, right) => left.node.endIndex - left.node.startIndex - (right.node.endIndex - right.node.startIndex));
-    const owner = owners[0];
-    if (!owner)
-      continue;
-    const memberId = ensureNode(context, fn.def);
-    markImplementationTarget(context, memberId, fn.node, fn.def);
-    markMemberArity(context, memberId, fn.node);
-    recordDefEdge(context, memberId, owner.def, "member_of");
-  }
-}
-function emitFunctionBodyEdges(context, functionNodes) {
-  const callNodeTypes = /* @__PURE__ */ new Set(["call_expression", "call", "method_invocation", "invocation_expression"]);
-  const newNodeTypes = /* @__PURE__ */ new Set([
-    "new_expression",
-    "object_creation_expression",
-    "struct_expression",
-    "composite_literal"
-  ]);
-  for (const fn of functionNodes) {
-    const fromId = ensureNode(context, fn.def);
-    const seenAliases = /* @__PURE__ */ new Set();
-    const nestedFunctions = new Set(functionNodes.filter((candidate) => candidate.node !== fn.node && candidate.node.startIndex >= fn.node.startIndex && candidate.node.endIndex <= fn.node.endIndex).map((candidate) => candidate.node));
-    const recordAliasUse = (node) => {
-      if (context.membersOnly || !isIdentifierType(context.sup, node.type))
-        return;
-      const name = sliceText(node, context.source);
-      if (seenAliases.has(name))
-        return;
-      let target = context.aliasToTargetDef.get(name) ?? null;
-      if (!target) {
-        const modFile = context.aliasToTargetModule.get(name);
-        if (modFile) {
-          let exportedName = null;
-          const parent = node.parent;
-          if (parent && (parent.type === context.memberExpressionType || parent.type === "optional_member_expression")) {
-            const { property: prop } = getMemberAccessParts(context.sup, parent);
-            if (prop && context.propertyIdentifierTypes.includes(prop.type)) {
-              exportedName = sliceText(prop, context.source);
-            }
-          }
-          if (exportedName) {
-            target = context.resolveExportFrom(modFile, exportedName);
-            if (!target) {
-              const targetModule = context.index.byFile.get(fileIdentityKey(modFile));
-              target = (targetModule?.locals ?? []).find((local) => local.localName === exportedName) ?? null;
-            }
+      const local = mod2.locals.find((candidate) => candidate.localName === exprName);
+      if (local)
+        return { kind: "resolved", def: local };
+      for (const starImport of mod2.imports.filter((candidate) => candidate.kind === "star")) {
+        const result = resolveImported(index, starImport, exprName);
+        if (result) {
+          if ("namespace" in result) {
+            return { kind: "namespace", file: result.namespace };
           }
+          return { kind: "resolved", def: result };
         }
       }
-      if (!target)
-        return;
-      seenAliases.add(name);
-      recordDefEdge(context, fromId, target, "uses");
-    };
-    const recordMemberUse = (node) => {
-      if (!context.optionalMemberTypes.has(node.type))
-        return;
-      const targetDef = context.resolveMemberChainTarget(node);
-      if (targetDef) {
-        recordDefEdge(context, fromId, targetDef, "uses");
+      return null;
+    }
+    if (optionalMemberTypes.has(expr.type)) {
+      const parts = getMemberAccessParts(sup, expr);
+      const subObj = parts.object;
+      let subProp = parts.property;
+      if (!subProp && expr.type === "navigation_expression") {
+        subProp = getNavigationExpressionProperty(expr);
       }
-    };
-    const recordCallOrInstantiation = (node) => {
-      if (callNodeTypes.has(node.type)) {
-        if (context.sup.id === "go") {
-          const callTarget = getCallTarget(node);
-          const calleeName = callTarget && isIdentifierType(context.sup, callTarget.type) ? sliceText(callTarget, context.source) : null;
-          if (calleeName === "new" || calleeName === "make") {
-            const argList = node.childForFieldName("arguments") ?? node.childForFieldName("argument_list");
-            const typeNode = argList?.namedChildren?.find((child) => child.type === "type_identifier") ?? null;
-            if (typeNode) {
-              tryResolveNode(context, typeNode, fromId, "instantiates");
-            }
-            return false;
-          }
+      if (subObj && subProp) {
+        const base = await resolveExpression(subObj);
+        const memberName = sliceText(subProp, source);
+        if (base?.kind === "namespace") {
+          return resolveExport(index, base.file, memberName, { allowLocalFallback: false });
         }
-        if (context.sup.id === "ruby" && node.type === "call") {
-          const methodNode = node.childForFieldName("method");
-          const receiverNode = node.childForFieldName("receiver");
-          const methodName = methodNode ? sliceText(methodNode, context.source) : null;
-          if (methodName === "new" && receiverNode) {
-            tryResolveNode(context, receiverNode, fromId, "instantiates");
-            return false;
+        if (base?.kind === "resolved") {
+          if (sup.id === "java") {
+            const memberDef = await resolveMemberDefinitionForBase(index, base.def, memberName);
+            return memberDef ? { kind: "resolved", def: memberDef } : null;
           }
-          if (methodNode) {
-            tryResolveNode(context, methodNode, fromId, "calls");
-            return false;
+          if (sup.id === "ruby") {
+            const memberDef = await resolveMemberDefinitionForBase(index, base.def, memberName);
+            if (memberDef)
+              return { kind: "resolved", def: memberDef };
+            const localHit = resolveExport(index, base.def.file, memberName);
+            if (localHit)
+              return localHit;
           }
+          return null;
         }
-        const callee = getCallTarget(node);
-        if (callee)
-          tryResolveNode(context, callee, fromId, "calls");
-      }
-      if (newNodeTypes.has(node.type)) {
-        const target = getNewTarget(node);
-        if (target)
-          tryResolveNode(context, target, fromId, "instantiates");
       }
-      return true;
-    };
-    const walkFunctionBody = (node, allowCallProcessing) => {
-      if (node !== fn.node && nestedFunctions.has(node))
-        return;
-      recordAliasUse(node);
-      recordMemberUse(node);
-      const allowChildCallProcessing = allowCallProcessing ? recordCallOrInstantiation(node) : false;
-      for (const child of node.namedChildren ?? [])
-        walkFunctionBody(child, allowChildCallProcessing);
-    };
-    walkFunctionBody(fn.node, true);
-  }
-}
-function recordIdentifierRelations(context, fromId, container, relationForTarget) {
-  const identifiers = [];
-  const collect = (node) => {
-    if (isIdentifierType(context.sup, node.type) || node.type === "type_identifier") {
-      identifiers.push(node);
-      return;
     }
-    for (const child of node.namedChildren ?? [])
-      collect(child);
-  };
-  collect(container);
-  const seen = /* @__PURE__ */ new Set();
-  for (const [index, identifier] of identifiers.entries()) {
-    const target = context.resolveIdentifier(sliceText(identifier, context.source));
-    if (!target)
-      continue;
-    const targetId = defNodeId(target);
-    if (seen.has(targetId))
-      continue;
-    seen.add(targetId);
-    recordDefEdge(context, fromId, target, relationForTarget(target, index), identifier);
-  }
-}
-function collectDirectCallsExcludingNestedScopes(node, out) {
-  for (const child of node.namedChildren ?? []) {
-    if (child.type === "call")
-      out.push(child);
-    if (RUBY_NESTED_SCOPE_TYPES.has(child.type))
-      continue;
-    collectDirectCallsExcludingNestedScopes(child, out);
-  }
-}
-function emitClassInheritanceEdges(context, classNodes) {
-  const interfaceIds = new Set(classNodes.filter((candidate) => candidate.node.type === "interface_declaration" || candidate.node.type === "protocol_declaration" || candidate.node.type === "trait_item" || /^(?:interface|protocol|trait)\b/.test(sliceText(candidate.node, context.source).trimStart())).map((candidate) => defNodeId(candidate.def)));
-  for (const cls of classNodes) {
-    const fromId = ensureNode(context, cls.def);
-    markImplementationTarget(context, fromId, cls.node, cls.def);
-    if (context.sup.id === "java") {
-      const superClass = findFirstNodeByType(cls.node, "superclass");
-      const superNode2 = superClass?.childForFieldName("name") ?? superClass?.namedChildren?.[0] ?? null;
-      if (superNode2)
-        tryResolveNode(context, superNode2, fromId, "extends");
-      const interfaces = findFirstNodeByType(cls.node, "super_interfaces");
-      if (interfaces) {
-        const names = [];
-        collectIdentifiers(interfaces, context.sup, context.source, names);
-        for (const name of names) {
-          const target = context.resolveIdentifier(name);
-          if (target)
-            recordDefEdge(context, fromId, target, "implements", interfaces);
+    if (sup.id === "java" && (expr.type === "scoped_identifier" || expr.type === "scoped_type_identifier")) {
+      const subObj = expr.childForFieldName("scope") ?? expr.child(0);
+      const subProp = expr.childForFieldName("name") ?? expr.child(2);
+      if (subObj && subProp) {
+        const base = await resolveExpression(subObj);
+        const memberName = sliceText(subProp, source);
+        if (base?.kind === "namespace") {
+          return resolveExport(index, base.file, memberName, { allowLocalFallback: false });
+        }
+        if (base?.kind === "resolved") {
+          const memberDef = await resolveMemberDefinitionForBase(index, base.def, memberName);
+          return memberDef ? { kind: "resolved", def: memberDef } : null;
         }
       }
-      continue;
-    }
-    if (context.sup.id === "csharp") {
-      const baseList = findFirstNodeByType(cls.node, "base_list");
-      if (baseList) {
-        recordIdentifierRelations(context, fromId, baseList, (target, index) => interfaceIds.has(defNodeId(target)) || index > 0 ? "implements" : "extends");
-      }
-      continue;
-    }
-    if (context.sup.id === "python") {
-      const bases = cls.node.childForFieldName("superclasses") ?? findFirstNodeByType(cls.node, "argument_list");
-      if (bases)
-        recordIdentifierRelations(context, fromId, bases, () => "extends");
-      continue;
-    }
-    if (context.sup.id === "php") {
-      const base = findFirstNodeByType(cls.node, "base_clause");
-      if (base)
-        recordIdentifierRelations(context, fromId, base, () => "extends");
-      const interfaces = findFirstNodeByType(cls.node, "class_interface_clause");
-      if (interfaces)
-        recordIdentifierRelations(context, fromId, interfaces, () => "implements");
-      const traitUses = [];
-      collectNodesByType(cls.node, "use_declaration", traitUses);
-      for (const traitUse of traitUses)
-        recordIdentifierRelations(context, fromId, traitUse, () => "trait");
-      continue;
-    }
-    if (context.sup.id === "ruby") {
-      const superclass = findFirstNodeByType(cls.node, "superclass");
-      if (superclass)
-        recordIdentifierRelations(context, fromId, superclass, () => "extends");
-      const calls = [];
-      collectDirectCallsExcludingNestedScopes(cls.node, calls);
-      for (const call of calls) {
-        if (call.childForFieldName("receiver"))
-          continue;
-        const methodNode = call.childForFieldName("method");
-        const methodName = methodNode ? sliceText(methodNode, context.source) : void 0;
-        if (methodName !== "include" && methodName !== "extend" && methodName !== "prepend")
-          continue;
-        const args = call.childForFieldName("arguments");
-        if (args)
-          recordIdentifierRelations(context, fromId, args, () => "mixin");
-      }
-      continue;
     }
-    if (context.sup.id === "cpp") {
-      const bases = findFirstNodeByType(cls.node, "base_class_clause");
-      if (bases)
-        recordIdentifierRelations(context, fromId, bases, () => "extends");
-      continue;
+    return null;
+  };
+  const chain = await resolveExpression(memberNode);
+  if (chain && prop && node.id === prop.id) {
+    if (chain.kind === "resolved") {
+      return okGoToResult(index, chain.def, {
+        via: { exportedName: sliceText(prop, source) },
+        resolution: "member-access",
+        confidence: "medium"
+      });
     }
-    if (context.sup.id === "kotlin") {
-      const bases = findFirstNodeByType(cls.node, "delegation_specifiers");
-      if (bases) {
-        recordIdentifierRelations(context, fromId, bases, (target, index) => interfaceIds.has(defNodeId(target)) || index > 0 ? "implements" : "extends");
+    if (chain.kind === "namespace") {
+      const targetMod = index.byFile.get(fileIdentityKey(chain.file));
+      const first = targetMod?.exports.find((entry) => entry.type === "local");
+      if (first) {
+        return okGoToResult(index, first.target, {
+          via: { exportedName: first.exportedAs },
+          resolution: "namespace",
+          confidence: "medium"
+        });
       }
-      continue;
     }
-    if (context.sup.id === "swift") {
-      const bases = [];
-      collectNodesByType(cls.node, "inheritance_specifier", bases);
-      for (const [index, base] of bases.entries()) {
-        recordIdentifierRelations(context, fromId, base, (target) => interfaceIds.has(defNodeId(target)) || index > 0 ? "implements" : "extends");
+  }
+  const receiverName = obj ? sliceText(obj, source) : "";
+  const implicitClassReceiver = isJsTsLanguage(sup.id) && receiverName === "this" || sup.id === "php" && /^(?:\$this|self|static)$/.test(receiverName) || sup.id === "rust" && /^(?:self|Self)$/.test(receiverName);
+  if (obj && prop && node.id === prop.id && (supportsReceiverMemberResolution(sup.id) || implicitClassReceiver)) {
+    const member = sliceText(prop, source);
+    if (!sup.membersAreImplicitlyInScope && implicitClassReceiver) {
+      const classContainer = findEnclosingClassContainer(node);
+      const memberDef = classContainer ? findLocalWithinNode(mod2.locals, member, classContainer, sup.normalizeIdentifier) : void 0;
+      if (memberDef) {
+        return okGoToResult(index, memberDef, {
+          via: { exportedName: member },
+          resolution: "member-access",
+          confidence: "medium"
+        });
       }
-      continue;
     }
-    const superClause = findFirstNodeByType(cls.node, "extends_clause");
-    const superNode = superClause?.namedChildren?.[0] ?? superClause?.child(1);
-    if (superNode)
-      tryResolveNode(context, superNode, fromId, "extends");
-    const implementsClauses = [];
-    collectNodesByType(cls.node, "implements_clause", implementsClauses);
-    for (const clause of implementsClauses) {
-      const names = [];
-      collectIdentifiers(clause, context.sup, context.source, names);
-      for (const name of names) {
-        const target = context.resolveIdentifier(name);
-        if (target)
-          recordDefEdge(context, fromId, target, "implements", clause);
+    const objDef = await resolveReceiverDefinition(obj, source, sup, resolveExpression);
+    if (objDef) {
+      const targetContext = await ensureParsedContext(objDef.file, void 0, index.languageExtensions);
+      const start = objDef.range.start;
+      const targetPosition = {
+        row: start.line - 1,
+        column: start.column - 1
+      };
+      const nameNode = targetContext.tree.rootNode.descendantForPosition(targetPosition, targetPosition);
+      const container = nameNode.parent;
+      if (container) {
+        const targetModule = index.byFile.get(fileIdentityKey(objDef.file));
+        if (targetModule) {
+          const normalizeIdentifier = targetContext.sup.normalizeIdentifier;
+          const memberDef = targetContext.sup.id === "java" ? findDirectLocalWithinNode(targetModule.locals, member, container, targetContext, normalizeIdentifier) : findReceiverMemberDefinition(targetModule.locals, member, objDef, container, targetContext, normalizeIdentifier);
+          if (memberDef) {
+            return okGoToResult(index, memberDef, {
+              via: { exportedName: member },
+              resolution: "member-access",
+              confidence: "medium"
+            });
+          }
+        }
       }
     }
   }
+  return null;
 }
-function emitRustImplEdges(context, rootNode) {
+function findEnclosingClassContainer(node) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "class_declaration" || current.type === "abstract_class_declaration" || current.type === "class_definition" || current.type === "impl_item") {
+      return current;
+    }
+    current = current.parent;
+  }
+  return null;
+}
+function supportsReceiverMemberResolution(languageId) {
+  return languageId === "csharp" || languageId === "python" || languageId === "js" || languageId === "java" || languageId === "javascript" || languageId === "jsx" || languageId === "rust" || languageId === "ts" || languageId === "typescript" || languageId === "tsx";
+}
+async function resolveReceiverDefinition(obj, source, sup, resolveExpression) {
+  const constructor = receiverConstructorExpression(obj, source, sup);
+  if (constructor) {
+    const result = await resolveExpression(constructor);
+    if (result?.kind === "resolved") {
+      return result.def;
+    }
+  }
+  if (isJsTsLanguage(sup.id)) {
+    if (sup.nodeTypes.identifier.includes(obj.type)) {
+      return null;
+    }
+  }
+  const direct = await resolveExpression(obj);
+  if (direct?.kind === "resolved") {
+    return direct.def;
+  }
+  return null;
+}
+function receiverConstructorExpression(obj, source, sup) {
+  if (obj.type === "new_expression" || obj.type === "object_creation_expression") {
+    return constructorNameNode(obj, sup);
+  }
+  if (sup.id === "ruby" && obj.type === "call") {
+    const rubyConstructor = rubyNewReceiverNameNode(obj, source, sup);
+    if (rubyConstructor)
+      return rubyConstructor;
+  }
+  if (!sup.nodeTypes.identifier.includes(obj.type)) {
+    return null;
+  }
+  const receiverName = sliceText(obj, source);
+  return findVisiblePriorNewConstructor(obj, receiverName, source, sup);
+}
+function constructorNameNode(node, sup) {
+  const constructor = node.childForFieldName("constructor") ?? node.child(0);
+  if (constructor && sup.nodeTypes.identifier.includes(constructor.type)) {
+    return constructor;
+  }
+  for (const child of node.namedChildren) {
+    if (sup.nodeTypes.identifier.includes(child.type) || child.type === "type_identifier" || child.type === "constant") {
+      return child;
+    }
+  }
+  return null;
+}
+function rubyNewReceiverNameNode(node, source, sup) {
+  if (!new RegExp(String.raw`^(?:${RUBY_CONSTANT_SOURCE})\.new$`, "u").test(sliceText(node, source)))
+    return null;
+  return node.namedChildren.find((child) => sup.nodeTypes.identifier.includes(child.type) || child.type === "constant") ?? null;
+}
+function rootOf(node) {
+  let current = node;
+  while (current.parent) {
+    current = current.parent;
+  }
+  return current;
+}
+function findVisiblePriorNewConstructor(receiver, receiverName, source, sup) {
+  let current = receiver;
+  while (current) {
+    if (BINDING_CONTAINER_TYPES.has(current.type)) {
+      const constructor = findPriorNewConstructorInContainer(current, receiver, receiverName, source, sup);
+      if (constructor || bindingContainerDeclaresNameBefore(current, receiver, receiverName, source, sup)) {
+        return constructor;
+      }
+    }
+    current = current.parent;
+  }
+  return findPriorNewConstructorInContainer(rootOf(receiver), receiver, receiverName, source, sup);
+}
+function findPriorNewConstructorInContainer(node, receiver, receiverName, source, sup) {
+  let constructor = null;
+  const visit = (current) => {
+    if (current.startIndex >= receiver.startIndex) {
+      return true;
+    }
+    if (current !== node && isSkippableBindingContainer(current, receiver)) {
+      return true;
+    }
+    if (current.type === "variable_declarator") {
+      const name = current.childForFieldName("name") ?? current.child(0);
+      const value = current.childForFieldName("value");
+      if (name && value && (value.type === "new_expression" || value.type === "object_creation_expression" || sup.nodeTypes.identifier.includes(value.type)) && sup.nodeTypes.identifier.includes(name.type) && sliceText(name, source) === receiverName) {
+        const candidate = constructorNameNode(value, sup);
+        if (!candidate) {
+          return true;
+        }
+        if (constructor && sliceText(constructor, source) !== sliceText(candidate, source)) {
+          constructor = null;
+          return false;
+        }
+        constructor = candidate;
+      }
+    }
+    if (current.type === "assignment" || current.type === "let_declaration") {
+      const candidate = constructorFromAssignmentLike(current, receiverName, source, sup);
+      if (candidate) {
+        if (constructor && sliceText(constructor, source) !== sliceText(candidate, source)) {
+          constructor = null;
+          return false;
+        }
+        constructor = candidate;
+      }
+    }
+    if (current.type === "local_variable_declaration" || current.type === "local_declaration_statement" || current.type === "variable_declaration") {
+      const candidate = constructorFromTypedLocalDeclaration(current, receiverName, source, sup);
+      if (candidate) {
+        if (constructor && sliceText(constructor, source) !== sliceText(candidate, source)) {
+          constructor = null;
+          return false;
+        }
+        constructor = candidate;
+      }
+    }
+    for (const child of current.namedChildren) {
+      if (!visit(child)) {
+        return false;
+      }
+    }
+    return true;
+  };
+  visit(node);
+  return constructor;
+}
+function constructorFromTypedLocalDeclaration(node, receiverName, source, sup) {
+  if (sup.id !== "csharp" && sup.id !== "java")
+    return null;
+  const text = sliceText(node, source);
+  const typeNameSource = sup.id === "java" ? JAVA_CONSTANT_SOURCE : CSHARP_CONSTANT_SOURCE;
+  const match = text.match(new RegExp(String.raw`^\s*(${typeNameSource})\s+${escapeRegExp(receiverName)}\s*=\s*new\s+(${typeNameSource})(?![\p{L}\p{Nl}\p{Sc}\p{Pc}\p{Nd}\p{Mn}\p{Mc}\p{Cf}])`, "u"));
+  const typeName = match?.[2] ?? match?.[1];
+  return typeName ? findNamedChildText(node, typeName, source, sup) : null;
+}
+function bindingContainerDeclaresNameBefore(node, receiver, receiverName, source, sup) {
+  const visit = (current) => {
+    if (current.startIndex >= receiver.startIndex) {
+      return false;
+    }
+    if (current !== node && isSkippableBindingContainer(current, receiver)) {
+      return false;
+    }
+    if (BINDING_DECLARATION_TYPES.has(current.type)) {
+      const name = current.childForFieldName("name") ?? current.child(0);
+      if (name && sup.nodeTypes.identifier.includes(name.type) && sliceText(name, source) === receiverName) {
+        return true;
+      }
+    }
+    for (const child of current.namedChildren) {
+      if (visit(child)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  return visit(node);
+}
+function isSkippableBindingContainer(node, receiver) {
+  return BINDING_CONTAINER_TYPES.has(node.type) && !nodeContainsIndex(node, receiver.startIndex);
+}
+function nodeContainsIndex(node, index) {
+  return node.startIndex <= index && node.endIndex >= index;
+}
+function constructorFromAssignmentLike(node, receiverName, source, sup) {
+  const text = sliceText(node, source);
+  if (!new RegExp(String.raw`(?<!${IDENTIFIER_BOUNDARY_SOURCE})${escapeRegExp(receiverName)}(?!${IDENTIFIER_BOUNDARY_SOURCE})`, "u").test(text))
+    return null;
+  if (sup.id === "ruby") {
+    const match = text.match(new RegExp(String.raw`^\s*${escapeRegExp(receiverName)}\s*=\s*(${RUBY_CONSTANT_SOURCE})\.new(?!${IDENTIFIER_BOUNDARY_SOURCE})`, "u"));
+    if (!match?.[1])
+      return null;
+    return findNamedChildText(node, match[1], source, sup);
+  }
+  if (sup.id === "rust") {
+    const match = text.match(new RegExp(String.raw`^\s*(?:let\s+)?${escapeRegExp(receiverName)}\s*=\s*(${RUST_CONSTANT_SOURCE})(?!${IDENTIFIER_BOUNDARY_SOURCE})`, "u"));
+    if (!match?.[1])
+      return null;
+    return findNamedChildText(node, match[1], source, sup);
+  }
+  return null;
+}
+function findNamedChildText(node, name, source, sup) {
+  const isNameNode = (candidate) => (sup.nodeTypes.identifier.includes(candidate.type) || candidate.type === "type_identifier" || candidate.type === "constant") && sliceText(candidate, source) === name;
+  const visit = (current) => {
+    if (isNameNode(current))
+      return current;
+    for (const child of current.namedChildren) {
+      const hit = visit(child);
+      if (hit)
+        return hit;
+    }
+    return null;
+  };
+  return visit(node);
+}
+async function resolveMemberDefinitionForBase(index, baseDef, member) {
+  const targetContext = await ensureParsedContext(baseDef.file, void 0, index.languageExtensions);
+  const start = baseDef.range.start;
+  const targetPosition = {
+    row: start.line - 1,
+    column: start.column - 1
+  };
+  const nameNode = targetContext.tree.rootNode.descendantForPosition(targetPosition, targetPosition);
+  const container = nameNode.parent;
+  if (!container)
+    return void 0;
+  const targetModule = index.byFile.get(fileIdentityKey(baseDef.file));
+  if (!targetModule)
+    return void 0;
+  const normalizeIdentifier = targetContext.sup.normalizeIdentifier;
+  const directHit = findDirectLocalWithinNode(targetModule.locals, member, container, targetContext, normalizeIdentifier);
+  if (directHit)
+    return directHit;
+  if (targetContext.sup.id === "java")
+    return void 0;
+  return findReceiverMemberDefinition(targetModule.locals, member, baseDef, container, targetContext, normalizeIdentifier);
+}
+function findReceiverMemberDefinition(locals, member, receiverDef, container, targetContext, normalizeIdentifier) {
+  const containerHit = findLocalWithinNode(locals, member, container, normalizeIdentifier);
+  if (containerHit)
+    return containerHit;
+  if (targetContext.sup.id !== "rust")
+    return void 0;
+  const implNode = findRustImplForType(targetContext.tree.rootNode, receiverDef.localName, targetContext.source);
+  return implNode ? findLocalWithinNode(locals, member, implNode, normalizeIdentifier) : void 0;
+}
+function findLocalWithinNode(locals, member, node, normalizeIdentifier = (name) => name) {
+  const containerStart = node.startIndex;
+  const containerEnd = node.endIndex;
+  const normalizedMember = normalizeIdentifier(member);
+  return locals.find((local) => {
+    const startIndex = local.range.start.index;
+    const endIndex = local.range.end.index;
+    return normalizeIdentifier(local.localName) === normalizedMember && startIndex !== void 0 && endIndex !== void 0 && startIndex >= containerStart && endIndex <= containerEnd;
+  });
+}
+function findDirectLocalWithinNode(locals, member, container, targetContext, normalizeIdentifier) {
+  const containerStart = container.startIndex;
+  const containerEnd = container.endIndex;
+  const normalizedMember = normalizeIdentifier(member);
+  for (const local of locals) {
+    const startIndex = local.range.start.index;
+    const endIndex = local.range.end.index;
+    if (normalizeIdentifier(local.localName) !== normalizedMember || startIndex === void 0 || endIndex === void 0 || startIndex < containerStart || endIndex > containerEnd) {
+      continue;
+    }
+    const start = local.range.start;
+    const position = {
+      row: start.line - 1,
+      column: start.column - 1
+    };
+    let current = targetContext.tree.rootNode.descendantForPosition(position, position).parent;
+    let isDeclarationParent = true;
+    while (current && current !== container) {
+      if (!isDeclarationParent && (current.type === "class_body" && current.parent !== container || NESTED_MEMBER_LOCAL_CONTAINERS.has(current.type))) {
+        current = null;
+        break;
+      }
+      isDeclarationParent = false;
+      current = current.parent;
+    }
+    if (current)
+      return local;
+  }
+  return void 0;
+}
+function findRustImplForType(root, typeName, source) {
+  let found = null;
+  const visit = (node) => {
+    if (node.type === "impl_item") {
+      const text = sliceText(node, source);
+      if (new RegExp(`^\\s*impl\\s+${escapeRegExp(typeName)}\\b`).test(text)) {
+        found = node;
+        return false;
+      }
+    }
+    for (const child of node.namedChildren) {
+      if (!visit(child))
+        return false;
+    }
+    return true;
+  };
+  visit(root);
+  return found;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var RUBY_CONSTANT_SOURCE, CSHARP_CONSTANT_SOURCE, JAVA_CONSTANT_SOURCE, RUST_CONSTANT_SOURCE, IDENTIFIER_BOUNDARY_SOURCE, BINDING_CONTAINER_TYPES, BINDING_DECLARATION_TYPES, NESTED_MEMBER_LOCAL_CONTAINERS;
+var init_navigation_goto = __esm({
+  "dist/indexer/navigation-goto.js"() {
+    "use strict";
+    init_js_family();
+    init_ast();
+    init_paths();
+    init_memberAccess();
+    init_identifiers();
+    init_parse_context();
+    init_navigation_provenance();
+    init_navigation_resolve();
+    RUBY_CONSTANT_SOURCE = String.raw`(?=\p{Lu})${XID_IDENTIFIER_SOURCE}`;
+    CSHARP_CONSTANT_SOURCE = String.raw`(?=@?\p{Lu})${CSHARP_IDENTIFIER_SOURCE}`;
+    JAVA_CONSTANT_SOURCE = String.raw`(?=\p{Lu})${JAVA_IDENTIFIER_SOURCE}`;
+    RUST_CONSTANT_SOURCE = String.raw`(?=\p{Lu})${XID_IDENTIFIER_SOURCE}`;
+    IDENTIFIER_BOUNDARY_SOURCE = String.raw`[$_\p{ID_Continue}\u200c\u200d]`;
+    BINDING_CONTAINER_TYPES = /* @__PURE__ */ new Set([
+      "program",
+      "compilation_unit",
+      "source_file",
+      "statement_block",
+      "block",
+      "function_declaration",
+      "function_item",
+      "function",
+      "function_expression",
+      "arrow_function",
+      "method_definition",
+      "method_declaration",
+      "method"
+    ]);
+    BINDING_DECLARATION_TYPES = /* @__PURE__ */ new Set([
+      "variable_declarator",
+      "let_declaration",
+      "assignment",
+      "formal_parameter",
+      "required_parameter",
+      "optional_parameter"
+    ]);
+    NESTED_MEMBER_LOCAL_CONTAINERS = /* @__PURE__ */ new Set([
+      "block",
+      "class",
+      "class_declaration",
+      "class_definition",
+      "constructor_declaration",
+      "enum_declaration",
+      "enum_item",
+      "enum_specifier",
+      "function_declaration",
+      "function_definition",
+      "function_item",
+      "interface_declaration",
+      "method",
+      "method_declaration",
+      "method_definition",
+      "module",
+      "statement_block"
+    ]);
+  }
+});
+
+// dist/graphs/symbol-graph-detailed/receiverCalls.js
+function receiverCallAccess(sup, callNode, callee) {
+  let accessNode = null;
+  if (RECEIVER_CALL_NODE_TYPES[callNode.type]) {
+    accessNode = callNode;
+  } else if (callee && isMemberAccessNode(sup, callee)) {
+    accessNode = callee;
+  } else if (isMemberAccessNode(sup, callNode)) {
+    accessNode = callNode;
+  }
+  if (!accessNode)
+    return null;
+  const parts = getMemberAccessParts(sup, accessNode);
+  const receiver = parts.object;
+  let property = parts.property;
+  if (!property && accessNode.type === "navigation_expression") {
+    property = getNavigationExpressionProperty(accessNode) ?? accessNode.namedChildren[1] ?? null;
+  }
+  if (!receiver || !property)
+    return null;
+  if (receiver.startIndex === property.startIndex)
+    return null;
+  if (!isMemberReferencePropertyIdentifier(sup, property.type))
+    return null;
+  return { accessNode, receiver, property };
+}
+function bindingIdentifier(node, sup) {
+  const named = node.childForFieldName("name");
+  if (named && (isIdentifierType(sup, named.type) || named.type === "identifier" || named.type === "field_identifier")) {
+    return named;
+  }
+  if (node.type === "assignment" || node.type === "assignment_expression" || node.type === "assignment_statement") {
+    const left = node.childForFieldName("left") ?? node.child(0);
+    if (left && (isIdentifierType(sup, left.type) || left.type === "identifier"))
+      return left;
+    return null;
+  }
+  let current = node.childForFieldName("declarator");
+  while (current) {
+    if (current.type === "identifier" || current.type === "field_identifier" || isIdentifierType(sup, current.type)) {
+      return current;
+    }
+    const nested = current.childForFieldName("declarator");
+    if (nested) {
+      current = nested;
+      continue;
+    }
+    return current.namedChildren.find((child) => child.type === "identifier" || child.type === "field_identifier") ?? null;
+  }
+  const identifiers = node.namedChildren.filter((child) => child.type === "identifier" || child.type === "field_identifier");
+  return identifiers.length > 0 ? identifiers[identifiers.length - 1] : null;
+}
+function bindsLocalValue(receiver, receiverName, source, sup) {
+  const declaresName = (node) => {
+    if (node.startIndex >= receiver.startIndex)
+      return false;
+    if (node !== receiver && BINDING_SCOPE_TYPES[node.type] && !containsIndex(node, receiver.startIndex))
+      return false;
+    if (PARAMETER_LIST_TYPES[node.type]) {
+      for (const child of node.namedChildren) {
+        if (child.startIndex >= receiver.startIndex)
+          continue;
+        const names = child.type === "ERROR" ? child.namedChildren : [child];
+        for (const name of names) {
+          if ((isIdentifierType(sup, name.type) || name.type === "identifier" || name.type === "constant") && sliceText(name, source) === receiverName) {
+            return true;
+          }
+        }
+      }
+    }
+    if (VALUE_BINDING_TYPES[node.type]) {
+      const name = bindingIdentifier(node, sup);
+      if (name && sliceText(name, source) === receiverName)
+        return true;
+    }
+    return node.namedChildren.some(declaresName);
+  };
+  for (let current = receiver.parent; current; current = current.parent) {
+    if (BINDING_SCOPE_TYPES[current.type] && current.namedChildren.some(declaresName))
+      return true;
+  }
+  return false;
+}
+function containsIndex(node, index) {
+  return node.startIndex <= index && node.endIndex >= index;
+}
+function classifyReceiver(sup, receiver, source, proofCache, cacheScope, accessNode) {
+  const keywords = RECEIVER_KEYWORDS[sup.id];
+  const text = sliceText(receiver, source).trim();
+  if (!text)
+    return null;
+  if (keywords?.own.includes(text))
+    return { kind: "own-type" };
+  if (keywords?.supertype.includes(text))
+    return { kind: "supertype" };
+  const receiverIsName = isIdentifierType(sup, receiver.type) || receiver.type === "type_identifier" || receiver.type === "constant";
+  const cacheKey3 = `${cacheScope}\0${text}`;
+  let proof = proofCache.get(cacheKey3);
+  if (!proof) {
+    const constructed = receiverConstructorExpression(receiver, source, sup);
+    proof = {
+      constructed,
+      locallyBound: !constructed && receiverIsName && bindsLocalValue(receiver, text, source, sup)
+    };
+    proofCache.set(cacheKey3, proof);
+  }
+  if (proof.constructed)
+    return { kind: "named-type", typeName: sliceText(proof.constructed, source) };
+  if (!receiverIsName)
+    return null;
+  if (proof.locallyBound)
+    return null;
+  const property = getMemberAccessParts(sup, accessNode).property;
+  const between = property ? source.slice(receiver.endIndex, property.startIndex) : "";
+  const typeScoped = TYPE_SCOPED_ACCESS_TYPES[accessNode.type] === true || between.includes("::");
+  if (receiver.type !== "type_identifier" && !typeScoped)
+    return null;
+  return { kind: "named-type", typeName: text };
+}
+function declaresMembers(def) {
+  return def.kind === SymbolKind.Class || def.kind === SymbolKind.Interface || def.kind === SymbolKind.TypeAlias;
+}
+function nearestMemberContainer(node) {
+  let current = node.parent;
+  while (current) {
+    if (MEMBER_CONTAINER_TYPES[current.type])
+      return current;
+    current = current.parent;
+  }
+  return null;
+}
+function callArgumentCount(callNode) {
+  const explicit = callNode.childForFieldName("arguments") ?? callNode.childForFieldName("argument_list");
+  let argumentNode = explicit ?? (callNode.namedChildren ?? []).find((child) => CALL_ARGUMENT_NODE_TYPES[child.type]) ?? null;
+  if (argumentNode?.type === "call_suffix") {
+    argumentNode = (argumentNode.namedChildren ?? []).find((child) => child.type === "value_arguments") ?? null;
+  }
+  if (!argumentNode)
+    return 0;
+  return (argumentNode.namedChildren ?? []).filter((argument) => argument.type !== "comment").length;
+}
+function emitReceiverCallEdges(graph, candidates, recordEdge) {
+  if (!candidates.length)
+    return;
+  const membersByOwner = /* @__PURE__ */ new Map();
+  const ownerByMember = /* @__PURE__ */ new Map();
+  const supertypesByOwner = /* @__PURE__ */ new Map();
+  const classAncestorsByOwner = /* @__PURE__ */ new Map();
+  const pushUnique2 = (map2, from, to) => {
+    const list = map2.get(from);
+    if (!list)
+      map2.set(from, [to]);
+    else if (!list.includes(to))
+      list.push(to);
+  };
+  for (const edge of graph.edges) {
+    const label = edge.label;
+    if (label === "member_of") {
+      pushUnique2(membersByOwner, edge.to, edge.from);
+      ownerByMember.set(edge.from, edge.to);
+      continue;
+    }
+    if (!label || !HIERARCHY_LABELS[label])
+      continue;
+    pushUnique2(supertypesByOwner, edge.from, edge.to);
+    if (label === "extends")
+      pushUnique2(classAncestorsByOwner, edge.from, edge.to);
+  }
+  const nextOwners = (ownerId, viaSupertypes) => {
+    if (!viaSupertypes)
+      return supertypesByOwner.get(ownerId) ?? [];
+    return (classAncestorsByOwner.get(ownerId) ?? []).filter((id) => graph.nodes.get(id)?.kind === "class");
+  };
+  for (const candidate of candidates) {
+    const owner = candidate.ownerId ?? ownerByMember.get(candidate.callerId);
+    if (!owner)
+      continue;
+    let level = candidate.viaSupertypes ? nextOwners(owner, true) : [owner];
+    const visited = new Set(level);
+    for (let depth = 0; depth < MAX_SUPERTYPE_DEPTH && level.length; depth += 1) {
+      const lookup = provenMemberTarget(graph, membersByOwner, level, candidate);
+      if (lookup.status === "unique") {
+        recordEdge(candidate.callerId, lookup.memberId, "calls", candidate.site);
+        break;
+      }
+      if (lookup.status === "ambiguous")
+        break;
+      const next = [];
+      for (const ownerId of level) {
+        for (const supertype of nextOwners(ownerId, candidate.viaSupertypes)) {
+          if (visited.has(supertype))
+            continue;
+          visited.add(supertype);
+          next.push(supertype);
+        }
+      }
+      level = next;
+    }
+  }
+}
+function provenMemberTarget(graph, membersByOwner, owners, candidate) {
+  const matches = /* @__PURE__ */ new Set();
+  for (const ownerId of owners) {
+    for (const memberId of membersByOwner.get(ownerId) ?? []) {
+      const node = graph.nodes.get(memberId);
+      if (!node || node.kind !== "function" || node.name !== candidate.memberName)
+        continue;
+      matches.add(memberId);
+    }
+  }
+  if (!matches.size)
+    return { status: "none" };
+  if (matches.size === 1) {
+    const [memberId] = matches;
+    return { status: "unique", memberId };
+  }
+  const byArity = [...matches].filter((memberId) => graph.nodes.get(memberId)?.memberArity === candidate.argumentCount);
+  if (byArity.length === 1)
+    return { status: "unique", memberId: byArity[0] };
+  return { status: "ambiguous" };
+}
+var THIS_SUPER_RECEIVERS, SELF_RECEIVERS, RECEIVER_KEYWORDS, RECEIVER_CALL_NODE_TYPES, MEMBER_CONTAINER_TYPES, CALL_ARGUMENT_NODE_TYPES, HIERARCHY_LABELS, VALUE_BINDING_TYPES, PARAMETER_LIST_TYPES, TYPE_SCOPED_ACCESS_TYPES, BINDING_SCOPE_TYPES, MAX_SUPERTYPE_DEPTH;
+var init_receiverCalls = __esm({
+  "dist/graphs/symbol-graph-detailed/receiverCalls.js"() {
+    "use strict";
+    init_navigation_goto();
+    init_types2();
+    init_ast();
+    init_memberAccess();
+    init_ast2();
+    THIS_SUPER_RECEIVERS = { own: ["this"], supertype: ["super"] };
+    SELF_RECEIVERS = { own: ["self"], supertype: ["super"] };
+    RECEIVER_KEYWORDS = {
+      cpp: { own: ["this"], supertype: [] },
+      csharp: { own: ["this"], supertype: ["base"] },
+      java: THIS_SUPER_RECEIVERS,
+      js: THIS_SUPER_RECEIVERS,
+      kotlin: THIS_SUPER_RECEIVERS,
+      php: { own: ["$this", "self", "static"], supertype: ["parent"] },
+      python: { own: ["self", "cls"], supertype: [] },
+      ruby: { own: ["self"], supertype: [] },
+      rust: { own: ["self", "Self"], supertype: [] },
+      svelte: THIS_SUPER_RECEIVERS,
+      swift: SELF_RECEIVERS,
+      ts: THIS_SUPER_RECEIVERS,
+      tsx: THIS_SUPER_RECEIVERS,
+      zig: { own: ["self"], supertype: [] }
+    };
+    RECEIVER_CALL_NODE_TYPES = {
+      member_call_expression: true,
+      method_invocation: true,
+      nullsafe_member_call_expression: true,
+      scoped_call_expression: true
+    };
+    MEMBER_CONTAINER_TYPES = {
+      abstract_class_declaration: true,
+      class: true,
+      class_declaration: true,
+      class_definition: true,
+      class_specifier: true,
+      enum_declaration: true,
+      extension_declaration: true,
+      impl_item: true,
+      interface_declaration: true,
+      module: true,
+      object_declaration: true,
+      protocol_declaration: true,
+      record_declaration: true,
+      singleton_class: true,
+      struct_declaration: true,
+      struct_item: true,
+      struct_specifier: true,
+      trait_declaration: true,
+      trait_item: true
+    };
+    CALL_ARGUMENT_NODE_TYPES = {
+      argument_list: true,
+      arguments: true,
+      // Swift wraps its argument list in a call suffix.
+      call_suffix: true,
+      value_arguments: true
+    };
+    HIERARCHY_LABELS = {
+      extends: true,
+      implements: true,
+      mixin: true,
+      trait: true
+    };
+    VALUE_BINDING_TYPES = {
+      assignment: true,
+      assignment_expression: true,
+      assignment_statement: true,
+      class_parameter: true,
+      formal_parameter: true,
+      init_declarator: true,
+      let_declaration: true,
+      optional_parameter: true,
+      parameter: true,
+      parameter_declaration: true,
+      property_declaration: true,
+      required_parameter: true,
+      short_var_declaration: true,
+      simple_parameter: true,
+      typed_parameter: true,
+      variable_declaration: true,
+      variable_declarator: true
+    };
+    PARAMETER_LIST_TYPES = {
+      block_parameters: true,
+      formal_parameters: true,
+      function_parameter_clause: true,
+      lambda_parameters: true,
+      method_parameters: true,
+      parameter_list: true,
+      parameters: true
+    };
+    TYPE_SCOPED_ACCESS_TYPES = {
+      qualified_identifier: true,
+      qualified_name: true,
+      scope_resolution: true,
+      scoped_call_expression: true,
+      scoped_identifier: true,
+      scoped_type_identifier: true
+    };
+    BINDING_SCOPE_TYPES = {
+      arrow_function: true,
+      block: true,
+      compilation_unit: true,
+      function: true,
+      function_body: true,
+      function_declaration: true,
+      function_definition: true,
+      function_expression: true,
+      function_item: true,
+      method: true,
+      method_declaration: true,
+      method_definition: true,
+      module: true,
+      program: true,
+      source_file: true,
+      statement_block: true,
+      compound_statement: true,
+      do_block: true,
+      impl_item: true,
+      translation_unit: true
+    };
+    MAX_SUPERTYPE_DEPTH = 16;
+  }
+});
+
+// dist/graphs/symbol-graph-detailed/edgePasses.js
+function ensureNode(context, def) {
+  const id = defNodeId(def);
+  if (!context.nodes.has(id))
+    context.nodes.set(id, nodeForDef(def));
+  return id;
+}
+function markImplementationTarget(context, id, declarationNode, def) {
+  const declaration = sliceText(declarationNode, context.source);
+  const nameIndex = declaration.indexOf(def.localName);
+  const prefix = nameIndex >= 0 ? declaration.slice(0, nameIndex) : declaration;
+  if (!/\b(?:abstract|virtual|override)\b/.test(prefix))
+    return;
+  const node = context.nodes.get(id);
+  if (node)
+    node.implementationTarget = true;
+}
+function markMemberArity(context, id, declarationNode) {
+  let parameters = declarationNode.childForFieldName("parameters");
+  if (!parameters) {
+    for (const type of [
+      "formal_parameters",
+      "parameter_list",
+      "parameters",
+      "method_parameters",
+      "function_parameter_clause"
+    ]) {
+      parameters = findFirstNodeByType(declarationNode, type);
+      if (parameters)
+        break;
+    }
+  }
+  if (!parameters)
+    return;
+  const arity = (parameters.namedChildren ?? []).filter((child) => child.type !== "comment").length;
+  const node = context.nodes.get(id);
+  if (node)
+    node.memberArity = arity;
+}
+function recordDefEdge(context, fromId, target, label, siteNode) {
+  const toId = ensureNode(context, target);
+  return context.recordEdge(fromId, toId, label, siteNode ? { file: context.moduleEntry.file, range: toRange(siteNode) } : void 0);
+}
+function tryResolveChain(context, node, fromId, label = "uses") {
+  const targetDef = context.resolveMemberChainTarget(node);
+  if (targetDef && fromId) {
+    recordDefEdge(context, fromId, targetDef, label, node);
+    return true;
+  }
+  return !!targetDef;
+}
+function tryResolveNode(context, node, fromId, label) {
+  if (isIdentifierType(context.sup, node.type) || node.type === "type_identifier") {
+    const name = sliceText(node, context.source);
+    const target = context.resolveIdentifier(name);
+    if (target) {
+      recordDefEdge(context, fromId, target, label, node);
+      return true;
+    }
+  }
+  if (context.optionalMemberTypes.has(node.type)) {
+    return tryResolveChain(context, node, fromId, label);
+  }
+  return false;
+}
+function getCallTarget(node) {
+  const explicitTarget = node.childForFieldName("function") ?? node.childForFieldName("callee") ?? node.childForFieldName("name") ?? node.childForFieldName("method") ?? node.childForFieldName("member") ?? node.childForFieldName("expression");
+  if (explicitTarget)
+    return explicitTarget;
+  const nonArgumentChildren = node.namedChildren.filter((child) => !CALL_ARGUMENT_NODE_TYPES[child.type]);
+  return nonArgumentChildren.length === 1 ? nonArgumentChildren[0] ?? null : null;
+}
+function getNewTarget(node) {
+  return node.childForFieldName("constructor") ?? node.childForFieldName("type") ?? node.childForFieldName("name") ?? node.namedChildren.find((child) => child.type === "type_identifier") ?? node.child(0);
+}
+function emitPythonDecoratorEdges(context, rootNode) {
+  if (context.sup.id !== "python")
+    return;
+  const addDecoratorUses = (node) => {
+    if (node.type === "decorated_definition") {
+      const fn = node.namedChildren.find((child) => child.type === "function_definition");
+      if (fn)
+        addDecoratorUses(fn);
+      for (const decoratorChild of node.namedChildren) {
+        if (decoratorChild.type !== "decorator")
+          continue;
+        const nameNode = fn?.childForFieldName("name");
+        if (!nameNode)
+          continue;
+        const name = sliceText(nameNode, context.source);
+        const def = context.moduleEntry.locals.find((local) => local.localName === name);
+        if (!def)
+          continue;
+        const fromId = ensureNode(context, def);
+        const expr = decoratorChild.childForFieldName?.("name") ?? decoratorChild.namedChildren?.[0] ?? decoratorChild.child(1);
+        if (expr)
+          tryResolveNode(context, expr, fromId, "decorates");
+      }
+    } else if (node.type === "function_definition") {
+      const nameNode = node.childForFieldName("name");
+      if (nameNode) {
+        const name = sliceText(nameNode, context.source);
+        const def = context.moduleEntry.locals.find((local) => local.localName === name);
+        if (def) {
+          const fromId = ensureNode(context, def);
+          let prev = node.previousSibling;
+          while (prev) {
+            if (prev.type === "decorated_definition") {
+              for (const decoratorChild of prev.namedChildren) {
+                if (decoratorChild.type === "decorator") {
+                  const expr = decoratorChild.childForFieldName?.("name") ?? decoratorChild.namedChildren?.[0] ?? decoratorChild.child(1);
+                  if (expr)
+                    tryResolveNode(context, expr, fromId, "decorates");
+                } else if (decoratorChild.type === "attribute") {
+                  tryResolveNode(context, decoratorChild, fromId, "decorates");
+                }
+              }
+            } else if (prev.type === "decorator") {
+              const expr = prev.childForFieldName?.("name") ?? prev.namedChildren?.[0] ?? prev.child(1);
+              if (expr)
+                tryResolveNode(context, expr, fromId, "decorates");
+            }
+            prev = prev.previousSibling;
+          }
+        }
+      }
+    }
+    for (const child of node.namedChildren)
+      addDecoratorUses(child);
+  };
+  addDecoratorUses(rootNode);
+}
+function emitMemberOwnershipEdges(context, functionNodes, classNodes) {
+  for (const fn of functionNodes) {
+    const owners = classNodes.filter((candidate) => candidate.node.startIndex <= fn.node.startIndex && candidate.node.endIndex >= fn.node.endIndex).sort((left, right) => left.node.endIndex - left.node.startIndex - (right.node.endIndex - right.node.startIndex));
+    const owner = owners[0];
+    if (!owner)
+      continue;
+    const memberId = ensureNode(context, fn.def);
+    markImplementationTarget(context, memberId, fn.node, fn.def);
+    markMemberArity(context, memberId, fn.node);
+    recordDefEdge(context, memberId, owner.def, "member_of");
+  }
+}
+function resolveNamedType(context, name) {
+  const fromAlias = context.aliasToTargetDef.get(name);
+  if (fromAlias && declaresMembers(fromAlias))
+    return fromAlias;
+  return context.moduleEntry.locals.find((local) => local.localName === name && declaresMembers(local)) ?? null;
+}
+function emitFunctionBodyEdges(context, functionNodes) {
+  const callNodeTypes = /* @__PURE__ */ new Set([
+    "call_expression",
+    "call",
+    "method_invocation",
+    "invocation_expression",
+    // PHP models plain calls and receiver calls as three distinct call nodes.
+    "function_call_expression",
+    "member_call_expression",
+    "nullsafe_member_call_expression",
+    "scoped_call_expression"
+  ]);
+  const newNodeTypes = /* @__PURE__ */ new Set([
+    "new_expression",
+    "object_creation_expression",
+    "struct_expression",
+    "composite_literal"
+  ]);
+  let membersByContainer;
+  const lexicalMembers = (container) => {
+    if (!membersByContainer) {
+      membersByContainer = /* @__PURE__ */ new Map();
+      for (const candidate of functionNodes) {
+        const owner = nearestMemberContainer(candidate.node);
+        if (!owner)
+          continue;
+        const members = membersByContainer.get(owner.startIndex);
+        if (members)
+          members.push(candidate);
+        else
+          membersByContainer.set(owner.startIndex, [candidate]);
+      }
+    }
+    return membersByContainer.get(container.startIndex) ?? [];
+  };
+  const receiverProofs = /* @__PURE__ */ new Map();
+  for (const fn of functionNodes) {
+    const fromId = ensureNode(context, fn.def);
+    const seenAliases = /* @__PURE__ */ new Set();
+    const nestedFunctions = new Set(functionNodes.filter((candidate) => candidate.node !== fn.node && candidate.node.startIndex >= fn.node.startIndex && candidate.node.endIndex <= fn.node.endIndex).map((candidate) => candidate.node));
+    const recordAliasUse = (node) => {
+      if (context.membersOnly || !isIdentifierType(context.sup, node.type))
+        return;
+      const name = sliceText(node, context.source);
+      if (seenAliases.has(name))
+        return;
+      let target = context.aliasToTargetDef.get(name) ?? null;
+      if (!target) {
+        const modFile = context.aliasToTargetModule.get(name);
+        if (modFile) {
+          let exportedName = null;
+          const parent = node.parent;
+          if (parent && (parent.type === context.memberExpressionType || parent.type === "optional_member_expression")) {
+            const { property: prop } = getMemberAccessParts(context.sup, parent);
+            if (prop && context.propertyIdentifierTypes.includes(prop.type)) {
+              exportedName = sliceText(prop, context.source);
+            }
+          }
+          if (exportedName) {
+            target = context.resolveExportFrom(modFile, exportedName);
+            if (!target) {
+              const targetModule = context.index.byFile.get(fileIdentityKey(modFile));
+              target = (targetModule?.locals ?? []).find((local) => local.localName === exportedName) ?? null;
+            }
+          }
+        }
+      }
+      if (!target)
+        return;
+      seenAliases.add(name);
+      recordDefEdge(context, fromId, target, "uses");
+    };
+    const recordMemberUse = (node) => {
+      if (!context.optionalMemberTypes.has(node.type))
+        return;
+      const targetDef = context.resolveMemberChainTarget(node);
+      if (targetDef) {
+        recordDefEdge(context, fromId, targetDef, "uses");
+      }
+    };
+    const recordReceiverCall = (node, access) => {
+      const memberName = sliceText(access.property, context.source);
+      if (!memberName || !context.hasCallableNamed(memberName))
+        return;
+      const binding = classifyReceiver(context.sup, access.receiver, context.source, receiverProofs, fn.node.startIndex, access.accessNode);
+      if (!binding)
+        return;
+      const site = { file: context.moduleEntry.file, range: toRange(access.property) };
+      const argumentCount = callArgumentCount(node);
+      if (binding.kind === "named-type") {
+        const typeDef = resolveNamedType(context, binding.typeName);
+        if (!typeDef)
+          return;
+        context.receiverCalls.push({
+          callerId: fromId,
+          ownerId: ensureNode(context, typeDef),
+          viaSupertypes: false,
+          memberName,
+          argumentCount,
+          site
+        });
+        return;
+      }
+      if (binding.kind === "own-type") {
+        const container = nearestMemberContainer(fn.node);
+        const declared = container ? lexicalMembers(container).filter((candidate) => candidate.def.localName === memberName) : [];
+        if (declared.length === 1) {
+          recordDefEdge(context, fromId, declared[0].def, "calls", access.property);
+          return;
+        }
+      }
+      context.receiverCalls.push({
+        callerId: fromId,
+        ownerId: null,
+        viaSupertypes: binding.kind === "supertype",
+        memberName,
+        argumentCount,
+        site
+      });
+    };
+    const resolveCallTarget = (node, callee) => {
+      const access = receiverCallAccess(context.sup, node, callee);
+      if (access) {
+        if (!tryResolveChain(context, access.accessNode, fromId, "calls"))
+          recordReceiverCall(node, access);
+        return;
+      }
+      if (callee)
+        tryResolveNode(context, callee, fromId, "calls");
+    };
+    const recordCallOrInstantiation = (node) => {
+      if (callNodeTypes.has(node.type)) {
+        if (context.sup.id === "go") {
+          const callTarget = getCallTarget(node);
+          const calleeName = callTarget && isIdentifierType(context.sup, callTarget.type) ? sliceText(callTarget, context.source) : null;
+          if (calleeName === "new" || calleeName === "make") {
+            const argList = node.childForFieldName("arguments") ?? node.childForFieldName("argument_list");
+            const typeNode = argList?.namedChildren?.find((child) => child.type === "type_identifier") ?? null;
+            if (typeNode) {
+              tryResolveNode(context, typeNode, fromId, "instantiates");
+            }
+            return false;
+          }
+        }
+        if (context.sup.id === "ruby" && node.type === "call") {
+          const methodNode = node.childForFieldName("method");
+          const receiverNode = node.childForFieldName("receiver");
+          const methodName = methodNode ? sliceText(methodNode, context.source) : null;
+          if (methodName === "new" && receiverNode) {
+            tryResolveNode(context, receiverNode, fromId, "instantiates");
+            return false;
+          }
+          if (methodNode) {
+            resolveCallTarget(node, methodNode);
+            return false;
+          }
+        }
+        resolveCallTarget(node, getCallTarget(node));
+      }
+      if (newNodeTypes.has(node.type)) {
+        const target = getNewTarget(node);
+        if (target)
+          tryResolveNode(context, target, fromId, "instantiates");
+      }
+      return true;
+    };
+    const walkFunctionBody = (node, allowCallProcessing) => {
+      if (node !== fn.node && nestedFunctions.has(node))
+        return;
+      recordAliasUse(node);
+      recordMemberUse(node);
+      const allowChildCallProcessing = allowCallProcessing ? recordCallOrInstantiation(node) : false;
+      for (const child of node.namedChildren ?? [])
+        walkFunctionBody(child, allowChildCallProcessing);
+    };
+    walkFunctionBody(fn.node, true);
+  }
+}
+function recordIdentifierRelations(context, fromId, container, relationForTarget) {
+  const identifiers = [];
+  const collect = (node) => {
+    if (isIdentifierType(context.sup, node.type) || node.type === "type_identifier") {
+      identifiers.push(node);
+      return;
+    }
+    for (const child of node.namedChildren ?? [])
+      collect(child);
+  };
+  collect(container);
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, identifier] of identifiers.entries()) {
+    const target = context.resolveIdentifier(sliceText(identifier, context.source));
+    if (!target)
+      continue;
+    const targetId = defNodeId(target);
+    if (seen.has(targetId))
+      continue;
+    seen.add(targetId);
+    recordDefEdge(context, fromId, target, relationForTarget(target, index), identifier);
+  }
+}
+function collectDirectCallsExcludingNestedScopes(node, out) {
+  for (const child of node.namedChildren ?? []) {
+    if (child.type === "call")
+      out.push(child);
+    if (RUBY_NESTED_SCOPE_TYPES.has(child.type))
+      continue;
+    collectDirectCallsExcludingNestedScopes(child, out);
+  }
+}
+function emitClassInheritanceEdges(context, classNodes) {
+  const interfaceIds = new Set(classNodes.filter((candidate) => candidate.node.type === "interface_declaration" || candidate.node.type === "protocol_declaration" || candidate.node.type === "trait_item" || /^(?:interface|protocol|trait)\b/.test(sliceText(candidate.node, context.source).trimStart())).map((candidate) => defNodeId(candidate.def)));
+  for (const cls of classNodes) {
+    const fromId = ensureNode(context, cls.def);
+    markImplementationTarget(context, fromId, cls.node, cls.def);
+    if (context.sup.id === "java") {
+      const superClass = findFirstNodeByType(cls.node, "superclass");
+      const superNode2 = superClass?.childForFieldName("name") ?? superClass?.namedChildren?.[0] ?? null;
+      if (superNode2)
+        tryResolveNode(context, superNode2, fromId, "extends");
+      const interfaces = findFirstNodeByType(cls.node, "super_interfaces");
+      if (interfaces) {
+        const names = [];
+        collectIdentifiers(interfaces, context.sup, context.source, names);
+        for (const name of names) {
+          const target = context.resolveIdentifier(name);
+          if (target)
+            recordDefEdge(context, fromId, target, "implements", interfaces);
+        }
+      }
+      continue;
+    }
+    if (context.sup.id === "csharp") {
+      const baseList = findFirstNodeByType(cls.node, "base_list");
+      if (baseList) {
+        recordIdentifierRelations(context, fromId, baseList, (target, index) => interfaceIds.has(defNodeId(target)) || index > 0 ? "implements" : "extends");
+      }
+      continue;
+    }
+    if (context.sup.id === "python") {
+      const bases = cls.node.childForFieldName("superclasses") ?? findFirstNodeByType(cls.node, "argument_list");
+      if (bases)
+        recordIdentifierRelations(context, fromId, bases, () => "extends");
+      continue;
+    }
+    if (context.sup.id === "php") {
+      const base = findFirstNodeByType(cls.node, "base_clause");
+      if (base)
+        recordIdentifierRelations(context, fromId, base, () => "extends");
+      const interfaces = findFirstNodeByType(cls.node, "class_interface_clause");
+      if (interfaces)
+        recordIdentifierRelations(context, fromId, interfaces, () => "implements");
+      const traitUses = [];
+      collectNodesByType(cls.node, "use_declaration", traitUses);
+      for (const traitUse of traitUses)
+        recordIdentifierRelations(context, fromId, traitUse, () => "trait");
+      continue;
+    }
+    if (context.sup.id === "ruby") {
+      const superclass = findFirstNodeByType(cls.node, "superclass");
+      if (superclass)
+        recordIdentifierRelations(context, fromId, superclass, () => "extends");
+      const calls = [];
+      collectDirectCallsExcludingNestedScopes(cls.node, calls);
+      for (const call of calls) {
+        if (call.childForFieldName("receiver"))
+          continue;
+        const methodNode = call.childForFieldName("method");
+        const methodName = methodNode ? sliceText(methodNode, context.source) : void 0;
+        if (methodName !== "include" && methodName !== "extend" && methodName !== "prepend")
+          continue;
+        const args = call.childForFieldName("arguments");
+        if (args)
+          recordIdentifierRelations(context, fromId, args, () => "mixin");
+      }
+      continue;
+    }
+    if (context.sup.id === "cpp") {
+      const bases = findFirstNodeByType(cls.node, "base_class_clause");
+      if (bases)
+        recordIdentifierRelations(context, fromId, bases, () => "extends");
+      continue;
+    }
+    if (context.sup.id === "kotlin") {
+      const bases = findFirstNodeByType(cls.node, "delegation_specifiers");
+      if (bases) {
+        recordIdentifierRelations(context, fromId, bases, (target, index) => interfaceIds.has(defNodeId(target)) || index > 0 ? "implements" : "extends");
+      }
+      continue;
+    }
+    if (context.sup.id === "swift") {
+      const bases = [];
+      collectNodesByType(cls.node, "inheritance_specifier", bases);
+      for (const [index, base] of bases.entries()) {
+        recordIdentifierRelations(context, fromId, base, (target) => interfaceIds.has(defNodeId(target)) || index > 0 ? "implements" : "extends");
+      }
+      continue;
+    }
+    const superClause = findFirstNodeByType(cls.node, "extends_clause");
+    const superNode = superClause?.namedChildren?.[0] ?? superClause?.child(1);
+    if (superNode)
+      tryResolveNode(context, superNode, fromId, "extends");
+    const implementsClauses = [];
+    collectNodesByType(cls.node, "implements_clause", implementsClauses);
+    for (const clause of implementsClauses) {
+      const names = [];
+      collectIdentifiers(clause, context.sup, context.source, names);
+      for (const name of names) {
+        const target = context.resolveIdentifier(name);
+        if (target)
+          recordDefEdge(context, fromId, target, "implements", clause);
+      }
+    }
+  }
+}
+function emitRustImplEdges(context, rootNode) {
   if (context.sup.id !== "rust")
     return;
   const walkImpls = (node) => {
@@ -58436,6 +59448,7 @@ var init_edgePasses = __esm({
     init_paths();
     init_symbol_graph();
     init_ast2();
+    init_receiverCalls();
     RUBY_NESTED_SCOPE_TYPES = /* @__PURE__ */ new Set(["class", "module", "method", "singleton_method", "block", "do_block"]);
   }
 });
@@ -58600,6 +59613,20 @@ async function buildSymbolGraphDetailed(index, opts) {
     return moduleEntry?.locals.find((entry) => entry.localName === lastName) ?? null;
   };
   const resolveExportFrom = (file2, exportedName) => resolveExportDef(file2, exportedName);
+  const receiverCalls = [];
+  let callableNames;
+  const hasCallableNamed = (name) => {
+    if (!callableNames) {
+      callableNames = /* @__PURE__ */ new Set();
+      for (const entry of index.byFile.values()) {
+        for (const local of entry.locals) {
+          if (local.kind === SymbolKind.Function)
+            callableNames.add(local.localName);
+        }
+      }
+    }
+    return callableNames.has(name);
+  };
   const optionFileKeys = opts?.files ? new Set(Array.from(opts.files, fileIdentityKey)) : void 0;
   for (const moduleEntry of index.byFile.values()) {
     const file2 = moduleEntry.file;
@@ -58669,7 +59696,9 @@ async function buildSymbolGraphDetailed(index, opts) {
         resolveIdentifier,
         resolveExportFrom,
         resolveMemberChainTarget,
-        recordEdge
+        recordEdge,
+        receiverCalls,
+        hasCallableNamed
       };
       emitPythonDecoratorEdges(edgePassContext, tree.rootNode);
       emitFunctionBodyEdges(edgePassContext, functionNodes);
@@ -58686,6 +59715,7 @@ async function buildSymbolGraphDetailed(index, opts) {
       logWithLevel(opts?.logLevel, "warn", `Warning: Failed to build detailed symbol edges for ${file2}:`, error51);
     }
   }
+  emitReceiverCallEdges({ nodes, edges }, receiverCalls, recordEdge);
   emitMemberImplementationEdges({ nodes, edges }, recordEdge);
   if (skippedSyntaxTreeFiles > 0) {
     logWithLevel(opts?.logLevel, "warn", `Warning: Skipped detailed symbol edges for ${skippedSyntaxTreeFiles} file(s) because no syntax-tree backend was available.`);
@@ -58715,6 +59745,7 @@ var init_symbol_graph_detailed = __esm({
     init_edgePasses();
     init_importAliases();
     init_memberChains();
+    init_receiverCalls();
   }
 });
 
@@ -61717,8 +62748,8 @@ ${block}
 function removeMarkedTomlBlock(existing, configPath) {
   if (inspectCodexTomlOwnership(existing, configPath) === null)
     return existing;
-  const begin = escapeRegExp(CODEGRAPH_TOML_MARKER_BEGIN);
-  const end = escapeRegExp(CODEGRAPH_TOML_MARKER_END);
+  const begin = escapeRegExp2(CODEGRAPH_TOML_MARKER_BEGIN);
+  const end = escapeRegExp2(CODEGRAPH_TOML_MARKER_END);
   const pattern = new RegExp(`\\n?${begin}[\\s\\S]*?${end}\\n?`, "g");
   return existing.replace(pattern, "\n").replace(/\n{3,}/g, "\n\n");
 }
@@ -62143,7 +63174,7 @@ async function renameTemporaryFile(temporaryPath, filePath) {
     }
   }
 }
-function escapeRegExp(value) {
+function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 var InstallerCollisionError, TARGET_DEFINITIONS, CODEGRAPH_TOML_MARKER_BEGIN, CODEGRAPH_TOML_MARKER_END, DEFAULT_TARGET_IDS;
@@ -65268,806 +66299,253 @@ async function checkMarkdownLinksInFiles(projectRoot, files) {
       }
     }
   }
-  failures.sort(compareFailures);
-  return {
-    schemaVersion: 1,
-    root: normalizePath(root),
-    summary: {
-      filesScanned: markdownFiles.length,
-      linksChecked,
-      externalSkipped,
-      failures: failures.length
-    },
-    failures
-  };
-}
-async function recoverDisplayFileCasing(file2) {
-  const dir = path64.dirname(file2);
-  const base = path64.basename(file2);
-  try {
-    const entries = await fsp34.readdir(dir);
-    const match = entries.find((entry) => entry.toLowerCase() === base.toLowerCase());
-    return match ? path64.join(dir, match) : file2;
-  } catch {
-    return file2;
-  }
-}
-function parseLocalLinkTarget(destination) {
-  let trimmed = destination.trim();
-  if (trimmed.startsWith("<") && trimmed.endsWith(">")) {
-    trimmed = trimmed.slice(1, -1).trim();
-  }
-  if (!trimmed)
-    return null;
-  const hashIndex = trimmed.indexOf("#");
-  const pathWithQuery = hashIndex >= 0 ? trimmed.slice(0, hashIndex) : trimmed;
-  const queryIndex = pathWithQuery.indexOf("?");
-  const targetPath = queryIndex >= 0 ? pathWithQuery.slice(0, queryIndex) : pathWithQuery;
-  const fragment = hashIndex >= 0 ? decodeFragment(trimmed.slice(hashIndex + 1)) : void 0;
-  return {
-    path: decodeMarkdownPath(targetPath),
-    ...fragment ? { fragment } : {}
-  };
-}
-function decodeMarkdownPath(targetPath) {
-  return decodeUriComponent(unescapeMarkdownPunctuation(targetPath));
-}
-function decodeFragment(fragment) {
-  return decodeUriComponent(fragment);
-}
-function decodeUriComponent(value) {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-function unescapeMarkdownPunctuation(value) {
-  let unescaped = "";
-  for (let index = 0; index < value.length; index += 1) {
-    const character = value.charAt(index);
-    const escapedCharacter = value.charAt(index + 1);
-    if (character === "\\" && isMarkdownPunctuation(escapedCharacter)) {
-      unescaped += escapedCharacter;
-      index += 1;
-      continue;
-    }
-    unescaped += character;
-  }
-  return unescaped;
-}
-function isMarkdownPunctuation(value) {
-  const code = value.charCodeAt(0);
-  return code >= 33 && code <= 47 || code >= 58 && code <= 64 || code >= 91 && code <= 96 || code >= 123 && code <= 126;
-}
-function resolveMarkdownTarget(root, sourceFile, destination) {
-  if (!destination)
-    return sourceFile;
-  if (WINDOWS_ABSOLUTE_PATH.test(destination))
-    return path64.resolve(destination);
-  if (destination.startsWith("/"))
-    return path64.join(root, destination);
-  return path64.resolve(path64.dirname(sourceFile), destination);
-}
-async function cachedTargetStatus(target, targetStatusByPath) {
-  let status = targetStatusByPath.get(target);
-  if (!status) {
-    status = readTargetStatus(target);
-    targetStatusByPath.set(target, status);
-  }
-  return await status;
-}
-async function readTargetStatus(target) {
-  try {
-    const realPath = await fsp34.realpath(target);
-    const stats = await fsp34.stat(realPath);
-    return { status: "found", isDirectory: stats.isDirectory(), realPath };
-  } catch (error51) {
-    if (isMissingPathError3(error51))
-      return { status: "missing" };
-    throw new Error(`Failed to inspect Markdown link target ${normalizePath(target)}: ${error51 instanceof Error ? error51.message : String(error51)}`);
-  }
-}
-function isMissingPathError3(error51) {
-  return error51 instanceof Error && "code" in error51 && (error51.code === "ENOENT" || error51.code === "ENOTDIR");
-}
-async function cachedMarkdownAnchors(target, anchorsByPath) {
-  let anchors = anchorsByPath.get(target);
-  if (!anchors) {
-    anchors = readMarkdownFile(target).then(collectMarkdownAnchors);
-    anchorsByPath.set(target, anchors);
-  }
-  return await anchors;
-}
-async function readMarkdownFile(file2) {
-  try {
-    return await fsp34.readFile(file2, "utf8");
-  } catch (error51) {
-    if (error51 instanceof Error) {
-      throw new Error(`Failed to read Markdown file ${normalizePath(file2)}: ${error51.message}`);
-    }
-    throw error51;
-  }
-}
-function collectMarkdownAnchors(source) {
-  const anchors = /* @__PURE__ */ new Set();
-  const lines = source.split(/\r?\n/);
-  let fence = null;
-  for (let index = 0; index < lines.length; index += 1) {
-    const line = lines[index] ?? "";
-    const fenceMatch = line.match(/^ {0,3}(`{3,}|~{3,})/);
-    if (fenceMatch) {
-      const marker = fenceMatch[1]?.charAt(0);
-      if (marker === "`" || marker === "~") {
-        fence = fence === marker ? null : fence ?? marker;
-      }
-      continue;
-    }
-    if (fence || /^(?: {4}|\t)/.test(line))
-      continue;
-    const atx = line.match(/^ {0,3}#{1,6}[ \t]+(.+?)(?:[ \t]+#+[ \t]*)?$/);
-    if (atx?.[1]) {
-      addMarkdownAnchor(anchors, atx[1]);
-      continue;
-    }
-    const underline = lines[index + 1];
-    if (line.trim() && underline && /^ {0,3}(?:=+|-+)[ \t]*$/.test(underline)) {
-      addMarkdownAnchor(anchors, line);
-      index += 1;
-    }
-  }
-  return anchors;
-}
-function addMarkdownAnchor(anchors, heading) {
-  const baseSlug = markdownHeadingSlug(heading);
-  if (!baseSlug)
-    return;
-  let slug = baseSlug;
-  let suffix = 1;
-  while (anchors.has(slug)) {
-    slug = `${baseSlug}-${suffix}`;
-    suffix += 1;
-  }
-  anchors.add(slug);
-}
-function markdownHeadingSlug(heading) {
-  return renderMarkdownHeading(heading).trim().toLowerCase().replace(/[^\p{L}\p{N}_\-\s]/gu, "").replace(/\s+/g, "-");
-}
-function renderMarkdownHeading(heading) {
-  return unescapeMarkdownPunctuation(heading).replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/\[([^\]]+)\]\[[^\]]*\]/g, "$1").replace(/<[^>]*>/g, "").replace(/[\\`*~]/g, "").replace(/(^|[^\p{L}\p{N}])_+(?=\S)/gu, "$1").replace(/_+(?=\s|$)/g, "");
-}
-function toFailure(root, file2, occurrence, reason, target) {
-  return {
-    file: toProjectDisplayPath(root, file2),
-    range: {
-      start: { line: occurrence.range.start.line, column: occurrence.range.start.column },
-      end: { line: occurrence.range.end.line, column: occurrence.range.end.column }
-    },
-    raw: occurrence.raw,
-    reason,
-    ...target ? { target: toProjectDisplayPath(root, target) } : {}
-  };
-}
-function compareFailures(left, right) {
-  const fileOrder = left.file.localeCompare(right.file);
-  if (fileOrder)
-    return fileOrder;
-  const lineOrder = left.range.start.line - right.range.start.line;
-  if (lineOrder)
-    return lineOrder;
-  return left.range.start.column - right.range.start.column;
-}
-var URI_SCHEME, WINDOWS_ABSOLUTE_PATH;
-var init_check = __esm({
-  "dist/documentLinks/check.js"() {
-    "use strict";
-    init_markdown2();
-    init_languages();
-    init_paths();
-    init_projectFiles();
-    URI_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*:/;
-    WINDOWS_ABSOLUTE_PATH = /^[A-Za-z]:[\\/]/;
-  }
-});
-
-// dist/indexer/load-current-index.js
-var load_current_index_exports = {};
-__export(load_current_index_exports, {
-  createCurrentProjectIndexLoader: () => createCurrentProjectIndexLoader,
-  currentProjectIndexBuildOptions: () => currentProjectIndexBuildOptions,
-  loadCurrentProjectIndex: () => loadCurrentProjectIndex
-});
-function currentProjectIndexBuildOptions(scope, options) {
-  const buildOptions = { ...options };
-  for (const key of NON_CURRENT_STATE_OPTION_KEYS) {
-    delete buildOptions[key];
-  }
-  buildOptions.cache = options?.cache ?? "disk";
-  if (scope.kind === "resolved-files") {
-    buildOptions.files = [...scope.files];
-    buildOptions.filesAreProjectScope = true;
-    return buildOptions;
-  }
-  if (scope.additionalFiles?.length) {
-    buildOptions.additionalFiles = [...scope.additionalFiles];
-  }
-  return buildOptions;
-}
-async function loadCurrentProjectIndex(request) {
-  const { buildProjectIndexIncremental: buildProjectIndexIncremental2 } = await Promise.resolve().then(() => (init_build_index(), build_index_exports));
-  return await buildProjectIndexIncremental2(request.root, currentProjectIndexBuildOptions(request.scope, request.options));
-}
-function createCurrentProjectIndexLoader(root, options, scope = { kind: "project" }) {
-  return async () => await loadCurrentProjectIndex({ root, scope, ...options ? { options } : {} });
-}
-var NON_CURRENT_STATE_OPTION_KEYS;
-var init_load_current_index = __esm({
-  "dist/indexer/load-current-index.js"() {
-    "use strict";
-    NON_CURRENT_STATE_OPTION_KEYS = [
-      "files",
-      "additionalFiles",
-      "filesAreProjectScope",
-      "gitBase",
-      "gitHead",
-      "changedSince",
-      "reconciledManifestUpdatedAt",
-      "reconciledWorkingTreeDiffFiles",
-      "reconciledUntrackedFiles"
-    ];
-  }
-});
-
-// dist/indexer/navigation-provenance.js
-function getNavigationBackend(index) {
-  if (index.nativeMode === "on") {
-    return "native";
-  }
-  if (index.nativeMode === "off") {
-    return "graph-only";
-  }
-  return void 0;
-}
-function createNavigationProvenance(index, resolution, confidence) {
-  const backend = getNavigationBackend(index);
-  return {
-    ...backend ? { backend } : {},
-    ...resolution ? { resolution } : {},
-    ...confidence ? { confidence } : {}
-  };
-}
-function okGoToResult(index, definition, options) {
-  return {
-    status: "ok",
-    definition,
-    ...options.via ? { via: options.via } : {},
-    provenance: createNavigationProvenance(index, options.resolution, options.confidence)
-  };
-}
-var init_navigation_provenance = __esm({
-  "dist/indexer/navigation-provenance.js"() {
-    "use strict";
-  }
-});
-
-// dist/indexer/navigation-goto.js
-async function resolveMemberAccessDefinition(params) {
-  const { index, mod: mod2, node, source, sup, resolveLexicalBinding } = params;
-  const parent = node.parent;
-  if (!parent || !sup.supportsCrossModuleSymbols || !isMemberAccessNode(sup, parent)) {
-    return null;
-  }
-  const memberNode = parent;
-  const { object: obj, property: prop } = getMemberAccessParts(sup, memberNode);
-  const optionalMemberTypes = memberAccessTraversalTypes(sup);
-  const resolveExpression = async (expr) => {
-    const exprIsId = sup.nodeTypes.identifier.includes(expr.type) && !isMemberAccessNode(sup, expr);
-    if (exprIsId || expr.type === "identifier" || expr.type === "type_identifier" || expr.type === "constant") {
-      const lexicalBinding = resolveLexicalBinding?.(expr);
-      if (lexicalBinding)
-        return { kind: "resolved", def: lexicalBinding };
-      const exprName = sliceText(expr, source);
-      const imp = mod2.imports.find((candidate) => candidate.kind === "named" && candidate.local === exprName || candidate.kind === "default" && candidate.local === exprName || candidate.kind === "namespace" && candidate.localNS === exprName);
-      if (imp) {
-        if (imp.kind === "namespace") {
-          return {
-            kind: "namespace",
-            file: typeof imp.resolved === "string" ? imp.resolved.replace(/\\/g, "/") : imp.resolved?.external || ""
-          };
-        }
-        const result = resolveImported(index, imp, imp.kind === "named" ? imp.imported : "default");
-        if (result) {
-          if ("namespace" in result) {
-            return { kind: "namespace", file: result.namespace };
-          }
-          return { kind: "resolved", def: result };
-        }
-      }
-      const local = mod2.locals.find((candidate) => candidate.localName === exprName);
-      if (local)
-        return { kind: "resolved", def: local };
-      for (const starImport of mod2.imports.filter((candidate) => candidate.kind === "star")) {
-        const result = resolveImported(index, starImport, exprName);
-        if (result) {
-          if ("namespace" in result) {
-            return { kind: "namespace", file: result.namespace };
-          }
-          return { kind: "resolved", def: result };
-        }
-      }
-      return null;
-    }
-    if (optionalMemberTypes.has(expr.type)) {
-      const parts = getMemberAccessParts(sup, expr);
-      const subObj = parts.object;
-      let subProp = parts.property;
-      if (!subProp && expr.type === "navigation_expression") {
-        subProp = getNavigationExpressionProperty(expr);
-      }
-      if (subObj && subProp) {
-        const base = await resolveExpression(subObj);
-        const memberName = sliceText(subProp, source);
-        if (base?.kind === "namespace") {
-          return resolveExport(index, base.file, memberName, { allowLocalFallback: false });
-        }
-        if (base?.kind === "resolved") {
-          if (sup.id === "java") {
-            const memberDef = await resolveMemberDefinitionForBase(index, base.def, memberName);
-            return memberDef ? { kind: "resolved", def: memberDef } : null;
-          }
-          if (sup.id === "ruby") {
-            const memberDef = await resolveMemberDefinitionForBase(index, base.def, memberName);
-            if (memberDef)
-              return { kind: "resolved", def: memberDef };
-            const localHit = resolveExport(index, base.def.file, memberName);
-            if (localHit)
-              return localHit;
-          }
-          return null;
-        }
-      }
-    }
-    if (sup.id === "java" && (expr.type === "scoped_identifier" || expr.type === "scoped_type_identifier")) {
-      const subObj = expr.childForFieldName("scope") ?? expr.child(0);
-      const subProp = expr.childForFieldName("name") ?? expr.child(2);
-      if (subObj && subProp) {
-        const base = await resolveExpression(subObj);
-        const memberName = sliceText(subProp, source);
-        if (base?.kind === "namespace") {
-          return resolveExport(index, base.file, memberName, { allowLocalFallback: false });
-        }
-        if (base?.kind === "resolved") {
-          const memberDef = await resolveMemberDefinitionForBase(index, base.def, memberName);
-          return memberDef ? { kind: "resolved", def: memberDef } : null;
-        }
-      }
-    }
-    return null;
-  };
-  const chain = await resolveExpression(memberNode);
-  if (chain && prop && node.id === prop.id) {
-    if (chain.kind === "resolved") {
-      return okGoToResult(index, chain.def, {
-        via: { exportedName: sliceText(prop, source) },
-        resolution: "member-access",
-        confidence: "medium"
-      });
-    }
-    if (chain.kind === "namespace") {
-      const targetMod = index.byFile.get(fileIdentityKey(chain.file));
-      const first = targetMod?.exports.find((entry) => entry.type === "local");
-      if (first) {
-        return okGoToResult(index, first.target, {
-          via: { exportedName: first.exportedAs },
-          resolution: "namespace",
-          confidence: "medium"
-        });
-      }
-    }
-  }
-  const receiverName = obj ? sliceText(obj, source) : "";
-  const implicitClassReceiver = isJsTsLanguage(sup.id) && receiverName === "this" || sup.id === "php" && /^(?:\$this|self|static)$/.test(receiverName) || sup.id === "rust" && /^(?:self|Self)$/.test(receiverName);
-  if (obj && prop && node.id === prop.id && (supportsReceiverMemberResolution(sup.id) || implicitClassReceiver)) {
-    const member = sliceText(prop, source);
-    if (!sup.membersAreImplicitlyInScope && implicitClassReceiver) {
-      const classContainer = findEnclosingClassContainer(node);
-      const memberDef = classContainer ? findLocalWithinNode(mod2.locals, member, classContainer, sup.normalizeIdentifier) : void 0;
-      if (memberDef) {
-        return okGoToResult(index, memberDef, {
-          via: { exportedName: member },
-          resolution: "member-access",
-          confidence: "medium"
-        });
-      }
-    }
-    const objDef = await resolveReceiverDefinition(obj, source, sup, resolveExpression);
-    if (objDef) {
-      const targetContext = await ensureParsedContext(objDef.file, void 0, index.languageExtensions);
-      const start = objDef.range.start;
-      const targetPosition = {
-        row: start.line - 1,
-        column: start.column - 1
-      };
-      const nameNode = targetContext.tree.rootNode.descendantForPosition(targetPosition, targetPosition);
-      const container = nameNode.parent;
-      if (container) {
-        const targetModule = index.byFile.get(fileIdentityKey(objDef.file));
-        if (targetModule) {
-          const normalizeIdentifier = targetContext.sup.normalizeIdentifier;
-          const memberDef = targetContext.sup.id === "java" ? findDirectLocalWithinNode(targetModule.locals, member, container, targetContext, normalizeIdentifier) : findReceiverMemberDefinition(targetModule.locals, member, objDef, container, targetContext, normalizeIdentifier);
-          if (memberDef) {
-            return okGoToResult(index, memberDef, {
-              via: { exportedName: member },
-              resolution: "member-access",
-              confidence: "medium"
-            });
-          }
-        }
-      }
-    }
-  }
-  return null;
-}
-function findEnclosingClassContainer(node) {
-  let current = node.parent;
-  while (current) {
-    if (current.type === "class_declaration" || current.type === "abstract_class_declaration" || current.type === "class_definition" || current.type === "impl_item") {
-      return current;
-    }
-    current = current.parent;
-  }
-  return null;
-}
-function supportsReceiverMemberResolution(languageId) {
-  return languageId === "csharp" || languageId === "python" || languageId === "js" || languageId === "java" || languageId === "javascript" || languageId === "jsx" || languageId === "rust" || languageId === "ts" || languageId === "typescript" || languageId === "tsx";
-}
-async function resolveReceiverDefinition(obj, source, sup, resolveExpression) {
-  const constructor = receiverConstructorExpression(obj, source, sup);
-  if (constructor) {
-    const result = await resolveExpression(constructor);
-    if (result?.kind === "resolved") {
-      return result.def;
-    }
-  }
-  if (isJsTsLanguage(sup.id)) {
-    if (sup.nodeTypes.identifier.includes(obj.type)) {
-      return null;
-    }
-  }
-  const direct = await resolveExpression(obj);
-  if (direct?.kind === "resolved") {
-    return direct.def;
-  }
-  return null;
+  failures.sort(compareFailures);
+  return {
+    schemaVersion: 1,
+    root: normalizePath(root),
+    summary: {
+      filesScanned: markdownFiles.length,
+      linksChecked,
+      externalSkipped,
+      failures: failures.length
+    },
+    failures
+  };
 }
-function receiverConstructorExpression(obj, source, sup) {
-  if (obj.type === "new_expression" || obj.type === "object_creation_expression") {
-    return constructorNameNode(obj, sup);
+async function recoverDisplayFileCasing(file2) {
+  const dir = path64.dirname(file2);
+  const base = path64.basename(file2);
+  try {
+    const entries = await fsp34.readdir(dir);
+    const match = entries.find((entry) => entry.toLowerCase() === base.toLowerCase());
+    return match ? path64.join(dir, match) : file2;
+  } catch {
+    return file2;
   }
-  if (sup.id === "ruby" && obj.type === "call") {
-    const rubyConstructor = rubyNewReceiverNameNode(obj, source, sup);
-    if (rubyConstructor)
-      return rubyConstructor;
+}
+function parseLocalLinkTarget(destination) {
+  let trimmed = destination.trim();
+  if (trimmed.startsWith("<") && trimmed.endsWith(">")) {
+    trimmed = trimmed.slice(1, -1).trim();
   }
-  if (!sup.nodeTypes.identifier.includes(obj.type)) {
+  if (!trimmed)
     return null;
-  }
-  const receiverName = sliceText(obj, source);
-  return findVisiblePriorNewConstructor(obj, receiverName, source, sup);
+  const hashIndex = trimmed.indexOf("#");
+  const pathWithQuery = hashIndex >= 0 ? trimmed.slice(0, hashIndex) : trimmed;
+  const queryIndex = pathWithQuery.indexOf("?");
+  const targetPath = queryIndex >= 0 ? pathWithQuery.slice(0, queryIndex) : pathWithQuery;
+  const fragment = hashIndex >= 0 ? decodeFragment(trimmed.slice(hashIndex + 1)) : void 0;
+  return {
+    path: decodeMarkdownPath(targetPath),
+    ...fragment ? { fragment } : {}
+  };
 }
-function constructorNameNode(node, sup) {
-  const constructor = node.childForFieldName("constructor") ?? node.child(0);
-  if (constructor && sup.nodeTypes.identifier.includes(constructor.type)) {
-    return constructor;
+function decodeMarkdownPath(targetPath) {
+  return decodeUriComponent(unescapeMarkdownPunctuation(targetPath));
+}
+function decodeFragment(fragment) {
+  return decodeUriComponent(fragment);
+}
+function decodeUriComponent(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
   }
-  for (const child of node.namedChildren) {
-    if (sup.nodeTypes.identifier.includes(child.type) || child.type === "type_identifier" || child.type === "constant") {
-      return child;
+}
+function unescapeMarkdownPunctuation(value) {
+  let unescaped = "";
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value.charAt(index);
+    const escapedCharacter = value.charAt(index + 1);
+    if (character === "\\" && isMarkdownPunctuation(escapedCharacter)) {
+      unescaped += escapedCharacter;
+      index += 1;
+      continue;
     }
+    unescaped += character;
   }
-  return null;
+  return unescaped;
 }
-function rubyNewReceiverNameNode(node, source, sup) {
-  if (!new RegExp(String.raw`^(?:${RUBY_CONSTANT_SOURCE})\.new$`, "u").test(sliceText(node, source)))
-    return null;
-  return node.namedChildren.find((child) => sup.nodeTypes.identifier.includes(child.type) || child.type === "constant") ?? null;
+function isMarkdownPunctuation(value) {
+  const code = value.charCodeAt(0);
+  return code >= 33 && code <= 47 || code >= 58 && code <= 64 || code >= 91 && code <= 96 || code >= 123 && code <= 126;
 }
-function rootOf(node) {
-  let current = node;
-  while (current.parent) {
-    current = current.parent;
+function resolveMarkdownTarget(root, sourceFile, destination) {
+  if (!destination)
+    return sourceFile;
+  if (WINDOWS_ABSOLUTE_PATH.test(destination))
+    return path64.resolve(destination);
+  if (destination.startsWith("/"))
+    return path64.join(root, destination);
+  return path64.resolve(path64.dirname(sourceFile), destination);
+}
+async function cachedTargetStatus(target, targetStatusByPath) {
+  let status = targetStatusByPath.get(target);
+  if (!status) {
+    status = readTargetStatus(target);
+    targetStatusByPath.set(target, status);
   }
-  return current;
+  return await status;
 }
-function findVisiblePriorNewConstructor(receiver, receiverName, source, sup) {
-  let current = receiver;
-  while (current) {
-    if (BINDING_CONTAINER_TYPES.has(current.type)) {
-      const constructor = findPriorNewConstructorInContainer(current, receiver, receiverName, source, sup);
-      if (constructor || bindingContainerDeclaresNameBefore(current, receiver, receiverName, source, sup)) {
-        return constructor;
-      }
-    }
-    current = current.parent;
+async function readTargetStatus(target) {
+  try {
+    const realPath = await fsp34.realpath(target);
+    const stats = await fsp34.stat(realPath);
+    return { status: "found", isDirectory: stats.isDirectory(), realPath };
+  } catch (error51) {
+    if (isMissingPathError3(error51))
+      return { status: "missing" };
+    throw new Error(`Failed to inspect Markdown link target ${normalizePath(target)}: ${error51 instanceof Error ? error51.message : String(error51)}`);
   }
-  return findPriorNewConstructorInContainer(rootOf(receiver), receiver, receiverName, source, sup);
 }
-function findPriorNewConstructorInContainer(node, receiver, receiverName, source, sup) {
-  let constructor = null;
-  const visit = (current) => {
-    if (current.startIndex >= receiver.startIndex) {
-      return true;
-    }
-    if (current !== node && isSkippableBindingContainer(current, receiver)) {
-      return true;
-    }
-    if (current.type === "variable_declarator") {
-      const name = current.childForFieldName("name") ?? current.child(0);
-      const value = current.childForFieldName("value");
-      if (name && value && (value.type === "new_expression" || value.type === "object_creation_expression" || sup.nodeTypes.identifier.includes(value.type)) && sup.nodeTypes.identifier.includes(name.type) && sliceText(name, source) === receiverName) {
-        const candidate = constructorNameNode(value, sup);
-        if (!candidate) {
-          return true;
-        }
-        if (constructor && sliceText(constructor, source) !== sliceText(candidate, source)) {
-          constructor = null;
-          return false;
-        }
-        constructor = candidate;
-      }
-    }
-    if (current.type === "assignment" || current.type === "let_declaration") {
-      const candidate = constructorFromAssignmentLike(current, receiverName, source, sup);
-      if (candidate) {
-        if (constructor && sliceText(constructor, source) !== sliceText(candidate, source)) {
-          constructor = null;
-          return false;
-        }
-        constructor = candidate;
-      }
-    }
-    if (current.type === "local_variable_declaration" || current.type === "local_declaration_statement" || current.type === "variable_declaration") {
-      const candidate = constructorFromTypedLocalDeclaration(current, receiverName, source, sup);
-      if (candidate) {
-        if (constructor && sliceText(constructor, source) !== sliceText(candidate, source)) {
-          constructor = null;
-          return false;
-        }
-        constructor = candidate;
-      }
-    }
-    for (const child of current.namedChildren) {
-      if (!visit(child)) {
-        return false;
-      }
-    }
-    return true;
-  };
-  visit(node);
-  return constructor;
+function isMissingPathError3(error51) {
+  return error51 instanceof Error && "code" in error51 && (error51.code === "ENOENT" || error51.code === "ENOTDIR");
 }
-function constructorFromTypedLocalDeclaration(node, receiverName, source, sup) {
-  if (sup.id !== "csharp" && sup.id !== "java")
-    return null;
-  const text = sliceText(node, source);
-  const typeNameSource = sup.id === "java" ? JAVA_CONSTANT_SOURCE : CSHARP_CONSTANT_SOURCE;
-  const match = text.match(new RegExp(String.raw`^\s*(${typeNameSource})\s+${escapeRegExp2(receiverName)}\s*=\s*new\s+(${typeNameSource})(?![\p{L}\p{Nl}\p{Sc}\p{Pc}\p{Nd}\p{Mn}\p{Mc}\p{Cf}])`, "u"));
-  const typeName = match?.[2] ?? match?.[1];
-  return typeName ? findNamedChildText(node, typeName, source, sup) : null;
+async function cachedMarkdownAnchors(target, anchorsByPath) {
+  let anchors = anchorsByPath.get(target);
+  if (!anchors) {
+    anchors = readMarkdownFile(target).then(collectMarkdownAnchors);
+    anchorsByPath.set(target, anchors);
+  }
+  return await anchors;
 }
-function bindingContainerDeclaresNameBefore(node, receiver, receiverName, source, sup) {
-  const visit = (current) => {
-    if (current.startIndex >= receiver.startIndex) {
-      return false;
-    }
-    if (current !== node && isSkippableBindingContainer(current, receiver)) {
-      return false;
+async function readMarkdownFile(file2) {
+  try {
+    return await fsp34.readFile(file2, "utf8");
+  } catch (error51) {
+    if (error51 instanceof Error) {
+      throw new Error(`Failed to read Markdown file ${normalizePath(file2)}: ${error51.message}`);
     }
-    if (BINDING_DECLARATION_TYPES.has(current.type)) {
-      const name = current.childForFieldName("name") ?? current.child(0);
-      if (name && sup.nodeTypes.identifier.includes(name.type) && sliceText(name, source) === receiverName) {
-        return true;
+    throw error51;
+  }
+}
+function collectMarkdownAnchors(source) {
+  const anchors = /* @__PURE__ */ new Set();
+  const lines = source.split(/\r?\n/);
+  let fence = null;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    const fenceMatch = line.match(/^ {0,3}(`{3,}|~{3,})/);
+    if (fenceMatch) {
+      const marker = fenceMatch[1]?.charAt(0);
+      if (marker === "`" || marker === "~") {
+        fence = fence === marker ? null : fence ?? marker;
       }
+      continue;
     }
-    for (const child of current.namedChildren) {
-      if (visit(child)) {
-        return true;
-      }
+    if (fence || /^(?: {4}|\t)/.test(line))
+      continue;
+    const atx = line.match(/^ {0,3}#{1,6}[ \t]+(.+?)(?:[ \t]+#+[ \t]*)?$/);
+    if (atx?.[1]) {
+      addMarkdownAnchor(anchors, atx[1]);
+      continue;
+    }
+    const underline = lines[index + 1];
+    if (line.trim() && underline && /^ {0,3}(?:=+|-+)[ \t]*$/.test(underline)) {
+      addMarkdownAnchor(anchors, line);
+      index += 1;
     }
-    return false;
-  };
-  return visit(node);
-}
-function isSkippableBindingContainer(node, receiver) {
-  return BINDING_CONTAINER_TYPES.has(node.type) && !nodeContainsIndex(node, receiver.startIndex);
-}
-function nodeContainsIndex(node, index) {
-  return node.startIndex <= index && node.endIndex >= index;
-}
-function constructorFromAssignmentLike(node, receiverName, source, sup) {
-  const text = sliceText(node, source);
-  if (!new RegExp(String.raw`(?<!${IDENTIFIER_BOUNDARY_SOURCE})${escapeRegExp2(receiverName)}(?!${IDENTIFIER_BOUNDARY_SOURCE})`, "u").test(text))
-    return null;
-  if (sup.id === "ruby") {
-    const match = text.match(new RegExp(String.raw`^\s*${escapeRegExp2(receiverName)}\s*=\s*(${RUBY_CONSTANT_SOURCE})\.new(?!${IDENTIFIER_BOUNDARY_SOURCE})`, "u"));
-    if (!match?.[1])
-      return null;
-    return findNamedChildText(node, match[1], source, sup);
   }
-  if (sup.id === "rust") {
-    const match = text.match(new RegExp(String.raw`^\s*(?:let\s+)?${escapeRegExp2(receiverName)}\s*=\s*(${RUST_CONSTANT_SOURCE})(?!${IDENTIFIER_BOUNDARY_SOURCE})`, "u"));
-    if (!match?.[1])
-      return null;
-    return findNamedChildText(node, match[1], source, sup);
+  return anchors;
+}
+function addMarkdownAnchor(anchors, heading) {
+  const baseSlug = markdownHeadingSlug(heading);
+  if (!baseSlug)
+    return;
+  let slug = baseSlug;
+  let suffix = 1;
+  while (anchors.has(slug)) {
+    slug = `${baseSlug}-${suffix}`;
+    suffix += 1;
   }
-  return null;
+  anchors.add(slug);
 }
-function findNamedChildText(node, name, source, sup) {
-  const isNameNode = (candidate) => (sup.nodeTypes.identifier.includes(candidate.type) || candidate.type === "type_identifier" || candidate.type === "constant") && sliceText(candidate, source) === name;
-  const visit = (current) => {
-    if (isNameNode(current))
-      return current;
-    for (const child of current.namedChildren) {
-      const hit = visit(child);
-      if (hit)
-        return hit;
-    }
-    return null;
-  };
-  return visit(node);
+function markdownHeadingSlug(heading) {
+  return renderMarkdownHeading(heading).trim().toLowerCase().replace(/[^\p{L}\p{N}_\-\s]/gu, "").replace(/\s+/g, "-");
 }
-async function resolveMemberDefinitionForBase(index, baseDef, member) {
-  const targetContext = await ensureParsedContext(baseDef.file, void 0, index.languageExtensions);
-  const start = baseDef.range.start;
-  const targetPosition = {
-    row: start.line - 1,
-    column: start.column - 1
-  };
-  const nameNode = targetContext.tree.rootNode.descendantForPosition(targetPosition, targetPosition);
-  const container = nameNode.parent;
-  if (!container)
-    return void 0;
-  const targetModule = index.byFile.get(fileIdentityKey(baseDef.file));
-  if (!targetModule)
-    return void 0;
-  const normalizeIdentifier = targetContext.sup.normalizeIdentifier;
-  const directHit = findDirectLocalWithinNode(targetModule.locals, member, container, targetContext, normalizeIdentifier);
-  if (directHit)
-    return directHit;
-  if (targetContext.sup.id === "java")
-    return void 0;
-  return findReceiverMemberDefinition(targetModule.locals, member, baseDef, container, targetContext, normalizeIdentifier);
+function renderMarkdownHeading(heading) {
+  return unescapeMarkdownPunctuation(heading).replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/\[([^\]]+)\]\[[^\]]*\]/g, "$1").replace(/<[^>]*>/g, "").replace(/[\\`*~]/g, "").replace(/(^|[^\p{L}\p{N}])_+(?=\S)/gu, "$1").replace(/_+(?=\s|$)/g, "");
 }
-function findReceiverMemberDefinition(locals, member, receiverDef, container, targetContext, normalizeIdentifier) {
-  const containerHit = findLocalWithinNode(locals, member, container, normalizeIdentifier);
-  if (containerHit)
-    return containerHit;
-  if (targetContext.sup.id !== "rust")
-    return void 0;
-  const implNode = findRustImplForType(targetContext.tree.rootNode, receiverDef.localName, targetContext.source);
-  return implNode ? findLocalWithinNode(locals, member, implNode, normalizeIdentifier) : void 0;
+function toFailure(root, file2, occurrence, reason, target) {
+  return {
+    file: toProjectDisplayPath(root, file2),
+    range: {
+      start: { line: occurrence.range.start.line, column: occurrence.range.start.column },
+      end: { line: occurrence.range.end.line, column: occurrence.range.end.column }
+    },
+    raw: occurrence.raw,
+    reason,
+    ...target ? { target: toProjectDisplayPath(root, target) } : {}
+  };
 }
-function findLocalWithinNode(locals, member, node, normalizeIdentifier = (name) => name) {
-  const containerStart = node.startIndex;
-  const containerEnd = node.endIndex;
-  const normalizedMember = normalizeIdentifier(member);
-  return locals.find((local) => {
-    const startIndex = local.range.start.index;
-    const endIndex = local.range.end.index;
-    return normalizeIdentifier(local.localName) === normalizedMember && startIndex !== void 0 && endIndex !== void 0 && startIndex >= containerStart && endIndex <= containerEnd;
-  });
+function compareFailures(left, right) {
+  const fileOrder = left.file.localeCompare(right.file);
+  if (fileOrder)
+    return fileOrder;
+  const lineOrder = left.range.start.line - right.range.start.line;
+  if (lineOrder)
+    return lineOrder;
+  return left.range.start.column - right.range.start.column;
 }
-function findDirectLocalWithinNode(locals, member, container, targetContext, normalizeIdentifier) {
-  const containerStart = container.startIndex;
-  const containerEnd = container.endIndex;
-  const normalizedMember = normalizeIdentifier(member);
-  for (const local of locals) {
-    const startIndex = local.range.start.index;
-    const endIndex = local.range.end.index;
-    if (normalizeIdentifier(local.localName) !== normalizedMember || startIndex === void 0 || endIndex === void 0 || startIndex < containerStart || endIndex > containerEnd) {
-      continue;
-    }
-    const start = local.range.start;
-    const position = {
-      row: start.line - 1,
-      column: start.column - 1
-    };
-    let current = targetContext.tree.rootNode.descendantForPosition(position, position).parent;
-    let isDeclarationParent = true;
-    while (current && current !== container) {
-      if (!isDeclarationParent && (current.type === "class_body" && current.parent !== container || NESTED_MEMBER_LOCAL_CONTAINERS.has(current.type))) {
-        current = null;
-        break;
-      }
-      isDeclarationParent = false;
-      current = current.parent;
-    }
-    if (current)
-      return local;
+var URI_SCHEME, WINDOWS_ABSOLUTE_PATH;
+var init_check = __esm({
+  "dist/documentLinks/check.js"() {
+    "use strict";
+    init_markdown2();
+    init_languages();
+    init_paths();
+    init_projectFiles();
+    URI_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*:/;
+    WINDOWS_ABSOLUTE_PATH = /^[A-Za-z]:[\\/]/;
   }
-  return void 0;
+});
+
+// dist/indexer/load-current-index.js
+var load_current_index_exports = {};
+__export(load_current_index_exports, {
+  createCurrentProjectIndexLoader: () => createCurrentProjectIndexLoader,
+  currentProjectIndexBuildOptions: () => currentProjectIndexBuildOptions,
+  loadCurrentProjectIndex: () => loadCurrentProjectIndex
+});
+function currentProjectIndexBuildOptions(scope, options) {
+  const buildOptions = { ...options };
+  for (const key of NON_CURRENT_STATE_OPTION_KEYS) {
+    delete buildOptions[key];
+  }
+  buildOptions.cache = options?.cache ?? "disk";
+  if (scope.kind === "resolved-files") {
+    buildOptions.files = [...scope.files];
+    buildOptions.filesAreProjectScope = true;
+    return buildOptions;
+  }
+  if (scope.additionalFiles?.length) {
+    buildOptions.additionalFiles = [...scope.additionalFiles];
+  }
+  return buildOptions;
 }
-function findRustImplForType(root, typeName, source) {
-  let found = null;
-  const visit = (node) => {
-    if (node.type === "impl_item") {
-      const text = sliceText(node, source);
-      if (new RegExp(`^\\s*impl\\s+${escapeRegExp2(typeName)}\\b`).test(text)) {
-        found = node;
-        return false;
-      }
-    }
-    for (const child of node.namedChildren) {
-      if (!visit(child))
-        return false;
-    }
-    return true;
-  };
-  visit(root);
-  return found;
+async function loadCurrentProjectIndex(request) {
+  const { buildProjectIndexIncremental: buildProjectIndexIncremental2 } = await Promise.resolve().then(() => (init_build_index(), build_index_exports));
+  return await buildProjectIndexIncremental2(request.root, currentProjectIndexBuildOptions(request.scope, request.options));
 }
-function escapeRegExp2(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function createCurrentProjectIndexLoader(root, options, scope = { kind: "project" }) {
+  return async () => await loadCurrentProjectIndex({ root, scope, ...options ? { options } : {} });
 }
-var RUBY_CONSTANT_SOURCE, CSHARP_CONSTANT_SOURCE, JAVA_CONSTANT_SOURCE, RUST_CONSTANT_SOURCE, IDENTIFIER_BOUNDARY_SOURCE, BINDING_CONTAINER_TYPES, BINDING_DECLARATION_TYPES, NESTED_MEMBER_LOCAL_CONTAINERS;
-var init_navigation_goto = __esm({
-  "dist/indexer/navigation-goto.js"() {
+var NON_CURRENT_STATE_OPTION_KEYS;
+var init_load_current_index = __esm({
+  "dist/indexer/load-current-index.js"() {
     "use strict";
-    init_js_family();
-    init_ast();
-    init_paths();
-    init_memberAccess();
-    init_identifiers();
-    init_parse_context();
-    init_navigation_provenance();
-    init_navigation_resolve();
-    RUBY_CONSTANT_SOURCE = String.raw`(?=\p{Lu})${XID_IDENTIFIER_SOURCE}`;
-    CSHARP_CONSTANT_SOURCE = String.raw`(?=@?\p{Lu})${CSHARP_IDENTIFIER_SOURCE}`;
-    JAVA_CONSTANT_SOURCE = String.raw`(?=\p{Lu})${JAVA_IDENTIFIER_SOURCE}`;
-    RUST_CONSTANT_SOURCE = String.raw`(?=\p{Lu})${XID_IDENTIFIER_SOURCE}`;
-    IDENTIFIER_BOUNDARY_SOURCE = String.raw`[$_\p{ID_Continue}\u200c\u200d]`;
-    BINDING_CONTAINER_TYPES = /* @__PURE__ */ new Set([
-      "program",
-      "compilation_unit",
-      "source_file",
-      "statement_block",
-      "block",
-      "function_declaration",
-      "function_item",
-      "function",
-      "function_expression",
-      "arrow_function",
-      "method_definition",
-      "method_declaration",
-      "method"
-    ]);
-    BINDING_DECLARATION_TYPES = /* @__PURE__ */ new Set([
-      "variable_declarator",
-      "let_declaration",
-      "assignment",
-      "formal_parameter",
-      "required_parameter",
-      "optional_parameter"
-    ]);
-    NESTED_MEMBER_LOCAL_CONTAINERS = /* @__PURE__ */ new Set([
-      "block",
-      "class",
-      "class_declaration",
-      "class_definition",
-      "constructor_declaration",
-      "enum_declaration",
-      "enum_item",
-      "enum_specifier",
-      "function_declaration",
-      "function_definition",
-      "function_item",
-      "interface_declaration",
-      "method",
-      "method_declaration",
-      "method_definition",
-      "module",
-      "statement_block"
-    ]);
+    NON_CURRENT_STATE_OPTION_KEYS = [
+      "files",
+      "additionalFiles",
+      "filesAreProjectScope",
+      "gitBase",
+      "gitHead",
+      "changedSince",
+      "reconciledManifestUpdatedAt",
+      "reconciledWorkingTreeDiffFiles",
+      "reconciledUntrackedFiles"
+    ];
   }
 });