fix: resolve merge conflicts with main

Merge origin/main (16a1182, 34988f8) into feat/phase-8.3e:

- expected-edges.json: keep define-property edges (pts-define-property,
  pts-create-prototype) from this branch AND inheritance/prototypes edges
  from main's #1325; merged file now has 30 total edges
- embedding-regression.test.ts: use main's retry-backoff afterAll and
  TestContext/ctx.skip() pattern; import from src/db/index.js

Author: carlos-alm

CLAUDE.md

@@ -10,7 +10,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 > **Never silently skip verification.** If tests, builds, or any verification step cannot run or fails for any reason (compilation errors, platform issues, missing dependencies), STOP and report the issue to the user immediately. Never silently proceed with unverified changes. Let the user decide whether to proceed — do not make that decision yourself.
 
-> **Scope discipline — open issues, don't expand scope.** When you encounter a problem unrelated to the current task — pre-existing bugs, code that needs a bigger refactor, or any defect that does not directly affect the result of what you're doing — open a GitHub issue with `gh issue create` and keep going. Only fix it inline when it directly affects the correctness or outcome of the work in front of you. This keeps PRs focused (one concern per PR) while ensuring the finding is not lost.
+> **Scope discipline — open issues, don't expand scope.** When you encounter anything out of scope — a pre-existing bug, a refactor opportunity, a potential improvement, a missing feature, or any other finding that doesn't directly affect the correctness of the current task — **immediately open a GitHub issue with `gh issue create` before continuing**. Do not hold the finding in memory or defer it to a comment. Only address it inline when it directly blocks the result of the work in front of you. This keeps PRs focused (one concern per PR) while ensuring no finding is lost.
 
 > **Prioritize the best architecture, not the smallest diff.** Do not default to the simplest or most localized fix. Choose the approach that fits the codebase's architecture best, even when that means larger changes, moving code across modules, or restructuring an abstraction. Do not be afraid of bigger changes — a larger diff that leaves the design healthier is preferable to a small diff that entrenches a poor structure. Surface the architectural reasoning to the user; don't silently shrink the change to avoid the work.
 

src/domain/graph/builder/call-resolver.ts

@@ -73,15 +73,40 @@ export function resolveByMethodOrGlobal(
       ? call.receiver.slice('this.'.length)
       : call.receiver;
     const typeEntry = typeMap.get(effectiveReceiver) ?? typeMap.get(call.receiver);
-    const typeName = typeEntry
+    let typeName = typeEntry
       ? typeof typeEntry === 'string'
         ? typeEntry
         : (typeEntry as { type?: string }).type
       : null;
+
+    // Handle inline new-expression receivers: `(new Foo).bar()` or `(new Foo()).bar()`.
+    // extractReceiverName returns the raw node text for non-identifier nodes, so `(new A).t()`
+    // produces receiver='(new A)'. Extract the constructor name directly.
+    if (!typeName && call.receiver) {
+      const m = /^\(?\s*new\s+([A-Z_$][A-Za-z0-9_$]*)/.exec(call.receiver);
+      if (m?.[1]) typeName = m[1];
+    }
+
     if (typeName) {
       const typed = lookup.byName(`${typeName}.${call.name}`).filter((n) => n.kind === 'method');
       if (typed.length > 0) return typed;
+
+      // Prototype alias: `Foo.prototype.bar = identifier` seeds typeMap['Foo.bar'] = { type: identifier }.
+      // Checked after the symbol-DB lookup so an actual method definition always wins.
+      const protoEntry = typeMap.get(`${typeName}.${call.name}`);
+      const protoTarget = protoEntry
+        ? typeof protoEntry === 'string'
+          ? protoEntry
+          : (protoEntry as { type?: string }).type
+        : null;
+      if (protoTarget) {
+        const resolved = lookup
+          .byName(protoTarget)
+          .filter((t) => computeConfidence(relPath, t.file, null) >= 0.5);
+        if (resolved.length > 0) return resolved;
+      }
     }
+
     // Phase 8.3d: composite pts key — `obj.prop = fn` seeds typeMap['obj.prop'] = { type: 'fn' }.
     // When a call site references `obj.prop` as a callback, resolve directly to the target fn.
     const compositeEntry = typeMap.get(`${call.receiver}.${call.name}`);

src/domain/graph/builder/stages/build-edges.ts

@@ -78,7 +78,7 @@ interface NativeEdge {
 }
 
 /** Phase 8.5: confidence penalty applied to CHA-dispatch edges. */
-const CHA_DISPATCH_PENALTY = 0.1;
+export const CHA_DISPATCH_PENALTY = 0.1;
 
 // ── Node lookup setup ───────────────────────────────────────────────────
 

src/domain/graph/builder/stages/native-orchestrator.ts

@@ -52,6 +52,7 @@ import {
   readFileSafe,
 } from '../helpers.js';
 import { NativeDbProxy } from '../native-db-proxy.js';
+import { CHA_DISPATCH_PENALTY } from './build-edges.js';
 import { closeNativeDb } from './native-db-lifecycle.js';
 
 // ── Native orchestrator types ──────────────────────────────────────────
@@ -467,7 +468,7 @@ function runPostNativeCha(db: BetterSqlite3Database): Set<number> {
 
   // Find existing call edges targeting qualified methods (e.g., 'IWorker.doWork').
   // Include the caller node's file so confidence can be computed file-pair-aware,
-  // matching the WASM path's computeConfidence(callerFile, targetFile, null) - 0.1 formula.
+  // matching the WASM path's computeConfidence(callerFile, targetFile, null) - CHA_DISPATCH_PENALTY formula.
   const callToMethods = db
     .prepare(`
       SELECT e.source_id, tgt.name AS method_name, src.file AS caller_file
@@ -534,10 +535,11 @@ function runPostNativeCha(db: BetterSqlite3Database): Set<number> {
             const key = `${source_id}|${methodNode.id}`;
             if (seen.has(key)) continue;
             seen.add(key);
-            // Compute confidence file-pair-aware (mirrors WASM path: computeConfidence - 0.1 penalty)
+            // Compute confidence file-pair-aware (mirrors WASM path: computeConfidence - CHA_DISPATCH_PENALTY)
             // Skip zero-confidence edges to match buildFileCallEdges / buildChaPostPass behaviour.
             const conf =
-              computeConfidence(caller_file ?? '', methodNode.method_file ?? '', null) - 0.1;
+              computeConfidence(caller_file ?? '', methodNode.method_file ?? '', null) -
+              CHA_DISPATCH_PENALTY;
             if (conf <= 0) continue;
             newEdges.push([source_id, methodNode.id, 'calls', conf, 0, 'cha']);
             newTargetIds.add(methodNode.id);

src/extractors/javascript.ts

@@ -345,6 +345,9 @@ function extractSymbolsQuery(tree: TreeSitterTree, query: TreeSitterQuery): Extr
   // Extract typeMap with intra-file return-type propagation
   extractTypeMapWalk(tree.rootNode, typeMap, returnTypeMap, callAssignments, fnRefBindings);
 
+  // Prototype-based method definitions: `Foo.prototype.bar = fn` and `Foo.prototype = { bar: fn }`
+  extractPrototypeMethodsWalk(tree.rootNode, definitions, typeMap);
+
   // Phase 8.3c: Extract call-site argument bindings for parameter-flow pts analysis
   extractParamBindingsWalk(tree.rootNode, paramBindings);
 
@@ -612,6 +615,8 @@ function extractSymbolsWalk(tree: TreeSitterTree): ExtractorOutput {
     ctx.callAssignments,
     ctx.fnRefBindings,
   );
+  // Prototype-based method definitions: `Foo.prototype.bar = fn` and `Foo.prototype = { bar: fn }`
+  extractPrototypeMethodsWalk(tree.rootNode, ctx.definitions, ctx.typeMap!);
   // Phase 8.3c: Extract call-site argument bindings for parameter-flow pts analysis
   extractParamBindingsWalk(tree.rootNode, ctx.paramBindings!);
   // Phase 8.5: collect all `new X()` constructor names for RTA instantiation tracking
@@ -2197,3 +2202,152 @@ function extractDynamicImportNames(callNode: TreeSitterNode): string[] {
 
   return [];
 }
+
+// ── Phase 8.X: Prototype-based method extraction ────────────────────────────
+
+/**
+ * Walk the AST and extract prototype-based method definitions and aliases.
+ *
+ * Handles three patterns:
+ *   1. `Foo.prototype.bar = function(){...}` — emits Foo.bar as method definition
+ *   2. `Foo.prototype.bar = identifier`       — sets typeMap['Foo.bar'] = { type: identifier }
+ *   3. `Foo.prototype = { bar: fn, ... }`     — emits defs and typeMap entries per property
+ *
+ * Emitting definitions under the canonical `ClassName.methodName` name lets the
+ * existing typeMap-based call resolver find them when a typed receiver dispatches
+ * `instance.method()` (lookup.byName('C.foo') in resolveByMethodOrGlobal).
+ *
+ * typeMap entries for identifier aliases (`Foo.bar → { type: 'someId' }`) are
+ * consumed by the prototype-alias fallback added to resolveByMethodOrGlobal.
+ */
+function extractPrototypeMethodsWalk(
+  rootNode: TreeSitterNode,
+  definitions: Definition[],
+  typeMap: Map<string, TypeMapEntry>,
+): void {
+  function walk(node: TreeSitterNode, depth: number): void {
+    if (depth >= MAX_WALK_DEPTH) return;
+    if (node.type === 'expression_statement') {
+      const expr = node.child(0);
+      if (expr?.type === 'assignment_expression') {
+        const lhs = expr.childForFieldName('left');
+        const rhs = expr.childForFieldName('right');
+        if (lhs && rhs) handlePrototypeAssignment(lhs, rhs, definitions, typeMap);
+      }
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      walk(node.child(i)!, depth + 1);
+    }
+  }
+  walk(rootNode, 0);
+}
+
+/**
+ * Handle an assignment_expression that may be a prototype assignment.
+ *
+ * Matches:
+ *   - `Foo.prototype.bar = rhs`  (lhs ends in .prototype.bar)
+ *   - `Foo.prototype = { ... }`  (lhs ends in .prototype, rhs is object literal)
+ */
+function handlePrototypeAssignment(
+  lhs: TreeSitterNode,
+  rhs: TreeSitterNode,
+  definitions: Definition[],
+  typeMap: Map<string, TypeMapEntry>,
+): void {
+  if (lhs.type !== 'member_expression') return;
+
+  const lhsObj = lhs.childForFieldName('object');
+  const lhsProp = lhs.childForFieldName('property');
+  if (!lhsObj || !lhsProp) return;
+
+  // Pattern 1: `Foo.prototype.bar = rhs`
+  // lhs.object is `Foo.prototype` (member_expression), lhs.property is `bar`
+  if (
+    lhsObj.type === 'member_expression' &&
+    (lhsProp.type === 'property_identifier' || lhsProp.type === 'identifier')
+  ) {
+    const protoObj = lhsObj.childForFieldName('object');
+    const protoProp = lhsObj.childForFieldName('property');
+    if (
+      protoObj?.type === 'identifier' &&
+      protoProp?.text === 'prototype' &&
+      !BUILTIN_GLOBALS.has(protoObj.text)
+    ) {
+      emitPrototypeMethod(protoObj.text, lhsProp.text, rhs, definitions, typeMap);
+    }
+    return;
+  }
+
+  // Pattern 2: `Foo.prototype = { bar: fn, ... }`
+  // lhs.object is `Foo` (identifier), lhs.property is `prototype`
+  if (
+    lhsObj.type === 'identifier' &&
+    lhsProp.text === 'prototype' &&
+    !BUILTIN_GLOBALS.has(lhsObj.text) &&
+    rhs.type === 'object'
+  ) {
+    extractPrototypeObjectLiteral(lhsObj.text, rhs, definitions, typeMap);
+  }
+}
+
+/** Emit one prototype method definition or typeMap alias for `ClassName.methodName = rhs`. */
+function emitPrototypeMethod(
+  className: string,
+  methodName: string,
+  rhs: TreeSitterNode,
+  definitions: Definition[],
+  typeMap: Map<string, TypeMapEntry>,
+): void {
+  const fullName = `${className}.${methodName}`;
+  if (rhs.type === 'function_expression' || rhs.type === 'arrow_function') {
+    definitions.push({
+      name: fullName,
+      kind: 'method',
+      line: nodeStartLine(rhs),
+      endLine: nodeEndLine(rhs),
+    });
+  } else if (rhs.type === 'identifier' && !BUILTIN_GLOBALS.has(rhs.text)) {
+    // Prototype alias: `A.prototype.t = f` → typeMap['A.t'] = { type: 'f' }
+    // Consumed by the prototype-alias fallback in resolveByMethodOrGlobal.
+    setTypeMapEntry(typeMap, fullName, rhs.text, 0.9);
+  }
+}
+
+/** Iterate over an object literal assigned to `Foo.prototype` and emit defs/aliases. */
+function extractPrototypeObjectLiteral(
+  className: string,
+  objNode: TreeSitterNode,
+  definitions: Definition[],
+  typeMap: Map<string, TypeMapEntry>,
+): void {
+  for (let i = 0; i < objNode.childCount; i++) {
+    const child = objNode.child(i);
+    if (!child) continue;
+
+    if (child.type === 'method_definition') {
+      // Shorthand method: `Foo.prototype = { bar() {} }`
+      const nameNode = child.childForFieldName('name');
+      if (nameNode) {
+        definitions.push({
+          name: `${className}.${nameNode.text}`,
+          kind: 'method',
+          line: nodeStartLine(child),
+          endLine: nodeEndLine(child),
+        });
+      }
+      continue;
+    }
+
+    if (child.type !== 'pair') continue;
+
+    const keyNode = child.childForFieldName('key');
+    const valueNode = child.childForFieldName('value');
+    if (!keyNode || !valueNode) continue;
+
+    const methodName = keyNode.type === 'string' ? keyNode.text.replace(/['"]/g, '') : keyNode.text;
+    if (!methodName) continue;
+
+    emitPrototypeMethod(className, methodName, valueNode, definitions, typeMap);
+  }
+}

tests/benchmarks/resolution/fixtures/javascript/expected-edges.json

@@ -163,6 +163,55 @@
       "kind": "calls",
       "mode": "pts-create-prototype",
       "notes": "obj.f2() — resolved via Object.create({ f1, f2 })"
+    },
+    {
+      "source": { "name": "Dog.speak", "file": "inheritance.js" },
+      "target": { "name": "Animal.speak", "file": "inheritance.js" },
+      "kind": "calls",
+      "mode": "class-inheritance",
+      "notes": "super.speak() in Dog.speak resolves to Animal.speak via CHA parents map"
+    },
+    {
+      "source": { "name": "Puppy.speak", "file": "inheritance.js" },
+      "target": { "name": "Dog.speak", "file": "inheritance.js" },
+      "kind": "calls",
+      "mode": "class-inheritance",
+      "notes": "super.speak() in Puppy.speak resolves to Dog.speak (nearest parent), not Animal.speak"
+    },
+    {
+      "source": { "name": "DoubleCounter.count", "file": "inheritance.js" },
+      "target": { "name": "Counter.count", "file": "inheritance.js" },
+      "kind": "calls",
+      "mode": "class-inheritance",
+      "notes": "static super.count() in DoubleCounter.count resolves to Counter.count via CHA parents map"
+    },
+    {
+      "source": { "name": "runPrototypes", "file": "prototypes.js" },
+      "target": { "name": "C", "file": "prototypes.js" },
+      "kind": "calls",
+      "mode": "constructor",
+      "notes": "new C() — constructor call to function-based constructor"
+    },
+    {
+      "source": { "name": "runPrototypes", "file": "prototypes.js" },
+      "target": { "name": "C.foo", "file": "prototypes.js" },
+      "kind": "calls",
+      "mode": "receiver-typed",
+      "notes": "v.foo() — v typed as C via new C(), C.foo defined via C.prototype = { foo: fn }"
+    },
+    {
+      "source": { "name": "testPrototypeAlias", "file": "prototypes2.js" },
+      "target": { "name": "A", "file": "prototypes2.js" },
+      "kind": "calls",
+      "mode": "constructor",
+      "notes": "new A() — inline constructor call in new A().t()"
+    },
+    {
+      "source": { "name": "testPrototypeAlias", "file": "prototypes2.js" },
+      "target": { "name": "f", "file": "prototypes2.js" },
+      "kind": "calls",
+      "mode": "receiver-typed",
+      "notes": "new A().t() — A.prototype.t = f alias; inline new receiver resolved to type A, typeMap['A.t'] = f"
     }
   ]
 }

tests/benchmarks/resolution/fixtures/javascript/inheritance.js

@@ -0,0 +1,34 @@
+// Class hierarchy fixture — tests super.method() dispatch (class-inheritance resolution)
+
+export class Animal {
+  speak() {
+    return 'generic sound';
+  }
+}
+
+export class Dog extends Animal {
+  speak() {
+    super.speak(); // super.method() → Animal.speak
+    return 'woof';
+  }
+}
+
+export class Puppy extends Dog {
+  speak() {
+    super.speak(); // super.method() → Dog.speak (nearest parent, not Animal)
+    return 'yip';
+  }
+}
+
+// Static super.method() — same resolution path as instance methods
+export class Counter {
+  static count() {
+    return 0;
+  }
+}
+
+export class DoubleCounter extends Counter {
+  static count() {
+    return super.count() * 2; // static super.method() → Counter.count
+  }
+}

tests/benchmarks/resolution/fixtures/javascript/prototypes.js

@@ -0,0 +1,11 @@
+// Pre-ES6 OOP via constructor function + prototype object literal.
+function C() {}
+
+C.prototype = {
+  foo: () => {},
+};
+
+export function runPrototypes() {
+  var v = new C();
+  v.foo();
+}

tests/benchmarks/resolution/fixtures/javascript/prototypes2.js

@@ -0,0 +1,10 @@
+// Pre-ES6 OOP via prototype property assignment with identifier alias.
+const f = () => {};
+
+class A {}
+
+A.prototype.t = f;
+
+export function testPrototypeAlias() {
+  new A().t();
+}

tests/benchmarks/resolution/fixtures/typescript/expected-edges.json

@@ -303,6 +303,20 @@
       "kind": "calls",
       "mode": "receiver-typed",
       "notes": "svc.removeUser() — svc typed as UserService via createService() return"
+    },
+    {
+      "source": { "name": "TimestampLogger.log", "file": "super-dispatch.ts" },
+      "target": { "name": "Logger.log", "file": "super-dispatch.ts" },
+      "kind": "calls",
+      "mode": "class-inheritance",
+      "notes": "super.log() in TimestampLogger.log resolves to Logger.log via CHA parents map"
+    },
+    {
+      "source": { "name": "PrefixLogger.log", "file": "super-dispatch.ts" },
+      "target": { "name": "TimestampLogger.log", "file": "super-dispatch.ts" },
+      "kind": "calls",
+      "mode": "class-inheritance",
+      "notes": "super.log() in PrefixLogger.log resolves to TimestampLogger.log (nearest parent)"
     }
   ]
 }