docs: prepare release notes for v3.12.0 (#1430)

* docs: prepare release notes for v3.12.0

* docs: fix v3.12.0 release notes accuracy issues

- CHANGELOG: correct Phase 8 completion claim from "8.5" to "8.6";
  qualify 8.3 as substantially complete with one stretch-goal item
  deferred; add note explaining why resolver items use fix: prefixes
- ROADMAP: add explicit 8.3e entry noting constructor-assigned property
  types scope was folded into the 8.3 family without a separate label

Author: carlos-alm

CHANGELOG.md

@@ -2,6 +2,66 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [3.12.0](https://github.com/optave/ops-codegraph-tool/compare/v3.11.2...v3.12.0) (2026-06-10)
+
+**Phase 8 Analysis Depth lands in full, plus a 30-technique JavaScript/TypeScript resolution sweep.** Sub-phases 8.1 through 8.6 are now complete, with 8.3 substantially complete (one stretch-goal item — full allocation-site abstraction with fixed-point iteration — deferred to a future release): TypeScript compiler API type resolution (`typescriptResolver` opt-in in `.codegraphrc.json`) upgrades confidence-0.7 heuristic edges to compiler-verified 1.0; inter-procedural return-type propagation resolves method chains and factory patterns up to 3 hops; field-based points-to analysis (Phases 8.3 through 8.3f) covers callbacks, event handlers, parameter flows, object property writes, and object destructuring rest parameters in both WASM and native engines; barrel re-export chain resolution traces symbols through `index.ts` re-exports to their actual declaration files; CHA+RTA dynamic dispatch resolves interface method calls to all instantiated concrete implementations; and Phase 8.6 adds a `byTechnique` breakdown to `codegraph stats --json` showing edges attributed to each resolver technique. Beyond the Phase 8 work, a parallel accuracy sweep adds resolution for prototype-based method calls, `Object.defineProperty` accessor this-dispatch, `super.method()` dispatch via class expressions and static blocks, `.call/.apply/.bind` receiver rebinding, `for-of`/`Set`/`Array.from` iteration callbacks, inline-array spread call edges, and constructor-assigned property types. C# call graphs improve with same-class bare static call resolution and `var`-typed local type inference. Six native engine parity issues in the incremental rebuild path are fixed. Caller coverage for real-world TypeScript projects is substantially higher after this release. Note: most resolver improvements appear under Bug Fixes below — they used `fix:` commit prefixes because they corrected missing edges in existing resolution logic rather than introducing entirely new CLI capabilities.
+
+### Features
+
+* **stats:** add `byTechnique` breakdown to `codegraph stats` — `codegraph stats --json` now includes `caller_coverage.byTechnique` with edge counts per resolution technique (`ts-native`, `points-to`); displayed in human-readable stats output under the caller coverage line; DB migration v17 adds `technique` column to `edges` table ([#1303](https://github.com/optave/ops-codegraph-tool/pull/1303))
+* **config:** new `typescriptResolver` option in `.codegraphrc.json` — set `"build": { "typescriptResolver": true }` to enable the TypeScript compiler API enrichment pass; compiler-verified edges (confidence 1.0) replace heuristic typeMap values for factory calls, generic constructors, and other patterns tree-sitter can't resolve alone ([#1278](https://github.com/optave/ops-codegraph-tool/pull/1278))
+
+### Bug Fixes
+
+* **resolver:** TypeScript-native type resolution via `ts.createProgram` + type checker (Phase 8.1) — upgrades heuristic typeMap entries to compiler-verified confidence 1.0 for `.ts`/`.tsx` files; resolves `container.get<MyService>()` → `MyService.doThing()` class of edges that tree-sitter cannot see ([#1278](https://github.com/optave/ops-codegraph-tool/pull/1278))
+* **resolver:** inter-procedural return-type propagation (Phase 8.2) — `const x = createUser()` propagates return type to `x` for downstream method-call resolution; chain propagation up to 3 hops with confidence decay (1.0 → 0.9 → 0.8 → 0.7); `analysis.typePropagationDepth` config knob ([#1279](https://github.com/optave/ops-codegraph-tool/pull/1279))
+* **resolver:** field-based points-to analysis for higher-order calls (Phase 8.3) — tracks callback assignments, event-handler registrations, and strategy-pattern wiring; resolves `app.use(handler)` and `events.on('click', handler)` call edges ([#1289](https://github.com/optave/ops-codegraph-tool/pull/1289))
+* **resolver:** cross-module points-to propagation (Phase 8.3 + 8.3b) — WASM + native parity; inter-module flows through import edges now propagate type bindings across file boundaries ([#1296](https://github.com/optave/ops-codegraph-tool/pull/1296))
+* **resolver:** parameter-flow tracking in points-to analysis (Phase 8.3c) — function parameters tracked through the call graph; typed parameters seed the receiver typeMap for downstream method resolution ([#1294](https://github.com/optave/ops-codegraph-tool/pull/1294), [#1308](https://github.com/optave/ops-codegraph-tool/pull/1308))
+* **resolver:** object property write tracking in points-to analysis (Phase 8.3d) — `obj.handler = fn` assignments tracked so `obj.handler()` resolves to the assigned function ([#1295](https://github.com/optave/ops-codegraph-tool/pull/1295))
+* **resolver:** constructor-assigned property types for receiver-typed resolution (JS/TS) — `this.svc = new Service()` in constructors seeds the typeMap so `this.svc.call()` resolves to `Service.call` ([#1314](https://github.com/optave/ops-codegraph-tool/pull/1314))
+* **resolver:** object destructuring rest parameter resolution (Phase 8.3f) — `const { a, ...rest } = obj; rest.method()` now resolves `method` via the rest binding's source type; WASM + native parity ([#1355](https://github.com/optave/ops-codegraph-tool/pull/1355))
+* **resolver:** barrel re-export chain resolution — imports via `components/index.ts` barrel files now trace to the actual declaration file rather than mapping to the barrel; both WASM `buildImportedNamesMap` and `buildBarrelEdges` updated (Phase 8.4) ([#1298](https://github.com/optave/ops-codegraph-tool/pull/1298), [#1302](https://github.com/optave/ops-codegraph-tool/pull/1302))
+* **resolver:** CHA + RTA enhanced dynamic dispatch (Phase 8.5) — interface method calls emit edges to all instantiated concrete implementations; `new X()` calls tracked for RTA filtering; `this.method()` resolved through the class's own method table and parent hierarchy ([#1302](https://github.com/optave/ops-codegraph-tool/pull/1302))
+* **resolver:** prototype-based method calls, func-prop this-dispatch, and spread/iteration callback resolution — `Dog.prototype.bark = function()` definitions extracted; `fn.method = function(){ this.other() }` this-dispatch wired; object-rest param dispatch ([#1331](https://github.com/optave/ops-codegraph-tool/pull/1331))
+* **resolver:** `Object.defineProperty` accessor this-dispatch — `this.method()` calls inside `defineProperty` getter/setter callbacks resolve through the enclosing class ([#1346](https://github.com/optave/ops-codegraph-tool/pull/1346), [#1351](https://github.com/optave/ops-codegraph-tool/pull/1351))
+* **resolver:** calls through `Object.defineProperty` / `defineProperties` / `Object.create` — accessor definitions emit call edges to the object's own prototype chain ([#1328](https://github.com/optave/ops-codegraph-tool/pull/1328))
+* **resolver:** generator functions extracted as definitions (JS/TS) — `function* gen()` and `async function* gen()` now emit definition nodes so callers that iterate them appear in the call graph ([#1333](https://github.com/optave/ops-codegraph-tool/pull/1333))
+* **resolver:** `super.method()` dispatch via class expression, static block, and field def — `super.f()` in class bodies, `class Foo extends Bar { static { super.f() } }`, and field-level assignments now resolve to the parent class method ([#1399](https://github.com/optave/ops-codegraph-tool/pull/1399))
+* **resolver:** `.call()/.apply()` this-rebinding — `fn.call(obj, ...)` and `fn.apply(obj, [...])` patterns now resolve the call to `fn` with `obj`'s type as receiver ([#1405](https://github.com/optave/ops-codegraph-tool/pull/1405))
+* **resolver:** `Function.bind/call/apply` receiver-typed resolution — `bound = fn.bind(obj)` seeds the typeMap so `bound()` resolves as a method call on `obj`'s type ([#1330](https://github.com/optave/ops-codegraph-tool/pull/1330))
+* **resolver:** `for-of`, `Set`, and `Array.from` iteration-callback edges — `for (const x of items) x.method()` and `new Set([...]).forEach(item => item.method())` patterns emit call edges ([#1397](https://github.com/optave/ops-codegraph-tool/pull/1397))
+* **resolver:** inline-array spread call edges — `fn(...[a, b, c])` unwraps the spread array and emits call edges to each element's method ([#1394](https://github.com/optave/ops-codegraph-tool/pull/1394))
+* **extractor:** inline-new expression recognized as receiver type in `extractReceiverName` — `(new Dog()).bark()` directly infers `Dog` as the receiver type without a prior assignment ([#1415](https://github.com/optave/ops-codegraph-tool/pull/1415))
+* **resolver:** this.prop typeMap key scoped to enclosing class — prevents false edges in multi-class files where two classes define a property of the same name ([#1382](https://github.com/optave/ops-codegraph-tool/pull/1382))
+* **parity:** C# same-class bare static calls resolved + confidence filter for static receiver fallback — `MyClass.StaticMethod()` from within the same class now resolves; heuristic static-receiver fallback gated on confidence ≥ 0.75 to reduce false positives ([#1417](https://github.com/optave/ops-codegraph-tool/pull/1417), [#1427](https://github.com/optave/ops-codegraph-tool/pull/1427))
+* **parity:** C# `var`-typed local types inferred from `new`-expression initializers — `var svc = new MyService()` now seeds the typeMap with `MyService` for downstream method-call resolution ([#1424](https://github.com/optave/ops-codegraph-tool/pull/1424))
+* **parity:** C# static receiver calls in WASM engine — static method resolution aligned with the native engine for same-class and qualified receiver patterns ([#1395](https://github.com/optave/ops-codegraph-tool/pull/1395))
+* **native:** extract parameters for prototype method definitions — `Dog.prototype.bark = function(name) {}` now emits `name` as a parameter node in the native engine ([#1345](https://github.com/optave/ops-codegraph-tool/pull/1345))
+* **native:** complexity/CFG computed for prototype method definitions — Rust engine now calculates cyclomatic complexity and control-flow graph for prototype-assigned functions ([#1347](https://github.com/optave/ops-codegraph-tool/pull/1347))
+* **native:** persist this/super dispatch via hybrid WASM post-pass — when native engine cannot persist this/super typeMap entries inline, a WASM supplementary pass writes them to the DB ([#1337](https://github.com/optave/ops-codegraph-tool/pull/1337))
+* **native:** return-type and call-assignment extraction in Rust engine — `returnTypeMap` and `callAssignments` now extracted by the Rust extractor, closing the parity gap with WASM for inter-procedural type propagation ([#1283](https://github.com/optave/ops-codegraph-tool/pull/1283))
+* **native:** prefer local dev binary over npm package in load order — `CODEGRAPH_NATIVE_PATH` env var and local `codegraph-core.node` are now checked before falling back to the npm optional package ([#1389](https://github.com/optave/ops-codegraph-tool/pull/1389))
+* **incremental:** seed callee::restName typeMap keys and pass callerName in buildCallEdges — aligns incremental call resolver with the full-build authoritative path for Phase 8.3f rest-param dispatch ([#1404](https://github.com/optave/ops-codegraph-tool/pull/1404))
+* **incremental:** port same-class this.method() and defineProperty fallbacks into buildCallEdges — incremental rebuilds now match full-build resolution for `this.`-dispatch and `Object.defineProperty` accessor patterns ([#1401](https://github.com/optave/ops-codegraph-tool/pull/1401))
+* **resolver:** qualified callerName mismatch in class-scoped typeMap lookup — `ClassName.method` keys now match consistently across full and incremental build paths ([#1403](https://github.com/optave/ops-codegraph-tool/pull/1403))
+* **resolver:** callerName parity + func-prop cross-file edges + O(n) Phase 8.3f algorithm — fixes qualified callerName dispatch on native path and makes rest-param post-pass linear-time ([#1383](https://github.com/optave/ops-codegraph-tool/pull/1383))
+* **resolver:** Phase 8.3f typeMap key scoped by callee to avoid same-name rest-param collision — two different rest parameters in the same file with the same property name no longer share the same typeMap key ([#1368](https://github.com/optave/ops-codegraph-tool/pull/1368))
+* **edge_builder:** same-file this-dispatch fallback restricted to caller's own class — prevents false `this.method()` edges being emitted to methods of other classes defined in the same file ([#1343](https://github.com/optave/ops-codegraph-tool/pull/1343))
+* **wasm-worker:** wire paramBindings, returnTypeMap, callAssignments through worker boundary — new `SerializedExtractorOutput` fields propagate through the WASM worker thread protocol so type-propagation data isn't silently dropped ([#1352](https://github.com/optave/ops-codegraph-tool/pull/1352))
+* **extractor:** narrow `.call/.apply/.bind` skip in `extractCallbackReferenceCalls` — only skip the bound function itself, not call-sites inside its body ([#1420](https://github.com/optave/ops-codegraph-tool/pull/1420))
+
+### Refactors
+
+* **extractor:** align `typeMapWalk` currentClass reset with `returnTypeMapWalk` — removes a latent divergence between the two AST walkers that could cause stale class context in multi-class files ([#1408](https://github.com/optave/ops-codegraph-tool/pull/1408))
+
+### Chores
+
+* **deps-dev:** bump vitest from 4.1.7 to 4.1.8 ([#1367](https://github.com/optave/ops-codegraph-tool/pull/1367), [#1366](https://github.com/optave/ops-codegraph-tool/pull/1366))
+* **deps-dev:** bump tree-sitter-erlang from 0.0.0 to 0.19 ([#1365](https://github.com/optave/ops-codegraph-tool/pull/1365))
+* **deps-dev:** bump tree-sitter-gleam ([#1364](https://github.com/optave/ops-codegraph-tool/pull/1364))
+* **deps:** bump anthropics/claude-code-action from 0.0.63 to 1.0.139 ([#1363](https://github.com/optave/ops-codegraph-tool/pull/1363))
+
 ## [3.11.2](https://github.com/optave/ops-codegraph-tool/compare/v3.11.1...v3.11.2) (2026-06-01)
 
 **Watch mode correctness sweep.** Five independent bugs in the incremental rebuild path are fixed: the call resolver had drifted from the full-build authoritative version, causing inflated `calls` edges on any watch rebuild touching a widely-imported file; a missing dedup set let the same `(caller, target)` pair be inserted multiple times; `receiver`, `extends`, `implements`, and `dynamic-import` edges were silently absent from watch-mode rebuilds; top-level Ruby constants and program-level Python assignments were dropped by the native extractor while WASM captured them; and 10 native grammar crate versions had drifted from their WASM npm counterparts. A new shared `call-resolver.ts` module now backs both the full-build and incremental paths, closing the structural gap that let these bugs accumulate.