@colbymchenry/codegraph-darwin-arm64 0.9.3 → 0.9.5

package/lib/dist/resolution/callback-synthesizer.js

@@ -0,0 +1,847 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synthesizeCallbackEdges = synthesizeCallbackEdges;
+const REGISTRAR_NAME = /^(on[A-Z]\w*|subscribe|addListener|addEventListener|register|watch|listen|addCallback)$/;
+const DISPATCHER_NAME = /(emit|trigger|notify|dispatch|fire|publish|flush)/i;
+const MAX_CALLBACKS_PER_CHANNEL = 40;
+const EVENT_FANOUT_CAP = 6; // skip events with more handlers/dispatchers than this (too generic without type info)
+const ON_RE = /\.(?:on|once|addListener)\(\s*['"]([^'"]+)['"]\s*,\s*(?:function\s+(\w+)|(?:this\.)?(\w+))/g;
+const EMIT_RE = /\.(?:emit|fire|dispatchEvent)\(\s*['"]([^'"]+)['"]/g;
+const SETSTATE_RE = /this\.setState\s*\(/;
+const FLUTTER_SETSTATE_RE = /\bsetState\s*\(/; // Flutter: setState((){…}) / this.setState
+const JSX_TAG_RE = /<([A-Z][A-Za-z0-9_]*)[\s/>]/g;
+const MAX_JSX_CHILDREN = 30;
+// Vue SFC templates: kebab-case child components (<el-button> → ElButton) and
+// event bindings (@click="fn" / v-on:click="fn"). PascalCase children (<VPNav/>)
+// are already caught by JSX_TAG_RE via the SFC component node.
+const VUE_KEBAB_RE = /<([a-z][a-z0-9]*(?:-[a-z0-9]+)+)[\s/>]/g;
+const VUE_HANDLER_RE = /(?:@|v-on:)([a-zA-Z][\w-]*)(?:\.[\w]+)*\s*=\s*"([^"]+)"/g;
+// Composable/hook destructure: `const { close: closeSidebar } = useSidebarControl()`.
+// Captures the destructure body + the called composable; only `use*` calls qualify.
+const VUE_DESTRUCTURE_RE = /(?:const|let|var)\s*\{([^}]+)\}\s*=\s*(\w+)\s*\(/g;
+function kebabToPascal(s) {
+    return s.split('-').map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join('');
+}
+function sliceLines(content, startLine, endLine) {
+    if (!startLine || !endLine)
+        return null;
+    return content.split('\n').slice(startLine - 1, endLine).join('\n');
+}
+function registrarField(src) {
+    const m = src.match(/this\.(\w+)\.(?:add|push|set)\(/);
+    return m ? m[1] : null;
+}
+function dispatcherField(src) {
+    const forOf = src.match(/\bof\s+(?:Array\.from\(\s*)?this\.(\w+)/);
+    if (forOf && /\b\w+\s*\(/.test(src))
+        return forOf[1];
+    const forEach = src.match(/this\.(\w+)\.forEach\(/);
+    if (forEach)
+        return forEach[1];
+    return null;
+}
+const FN_KINDS = new Set(['method', 'function', 'component']);
+/** Innermost function/method node whose line range contains `line`. */
+function enclosingFn(nodesInFile, line) {
+    let best = null;
+    for (const n of nodesInFile) {
+        if (!FN_KINDS.has(n.kind))
+            continue;
+        const end = n.endLine ?? n.startLine;
+        if (n.startLine <= line && end >= line) {
+            if (!best || n.startLine >= best.startLine)
+                best = n; // prefer the tightest (latest-starting) encloser
+        }
+    }
+    return best;
+}
+/** Phase 1: field-backed observer channels (registrar/dispatcher share a store). */
+function fieldChannelEdges(queries, ctx) {
+    const candidates = [...queries.getNodesByKind('method'), ...queries.getNodesByKind('function')];
+    const registrars = [];
+    const dispatchers = [];
+    for (const m of candidates) {
+        const isReg = REGISTRAR_NAME.test(m.name);
+        const isDisp = DISPATCHER_NAME.test(m.name);
+        if (!isReg && !isDisp)
+            continue;
+        const content = ctx.readFile(m.filePath);
+        const src = content && sliceLines(content, m.startLine, m.endLine);
+        if (!src)
+            continue;
+        if (isReg) {
+            const f = registrarField(src);
+            if (f)
+                registrars.push({ node: m, field: f });
+        }
+        if (isDisp) {
+            const f = dispatcherField(src);
+            if (f)
+                dispatchers.push({ node: m, field: f });
+        }
+    }
+    const edges = [];
+    const seen = new Set();
+    for (const reg of registrars) {
+        const chDispatchers = dispatchers.filter((d) => d.node.filePath === reg.node.filePath && d.field === reg.field);
+        if (chDispatchers.length === 0)
+            continue;
+        const argRe = new RegExp(`${reg.node.name}\\s*\\(\\s*(?:this\\.)?(\\w+)`);
+        let added = 0;
+        for (const e of queries.getIncomingEdges(reg.node.id, ['calls'])) {
+            if (added >= MAX_CALLBACKS_PER_CHANNEL)
+                break;
+            if (!e.line)
+                continue;
+            const caller = queries.getNodeById(e.source);
+            if (!caller)
+                continue;
+            const line = ctx.readFile(caller.filePath)?.split('\n')[e.line - 1];
+            const am = line?.match(argRe);
+            if (!am)
+                continue;
+            const fn = ctx.getNodesByName(am[1]).find((n) => n.kind === 'method' || n.kind === 'function');
+            if (!fn)
+                continue;
+            for (const disp of chDispatchers) {
+                if (disp.node.id === fn.id)
+                    continue;
+                const key = `${disp.node.id}>${fn.id}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                edges.push({
+                    source: disp.node.id, target: fn.id, kind: 'calls', line: disp.node.startLine,
+                    provenance: 'heuristic',
+                    metadata: {
+                        synthesizedBy: 'callback', via: reg.node.name, field: reg.field,
+                        // Where the callback was wired up (`scene.onUpdate(this.triggerRender)`).
+                        // This is the #1 thing an agent reads/greps to explain the flow — surface
+                        // it so node/trace/context can show it without a callers() + Read round-trip.
+                        registeredAt: `${caller.filePath}:${e.line}`,
+                    },
+                });
+                added++;
+            }
+        }
+    }
+    return edges;
+}
+/** Phase 2: string-keyed EventEmitter channels (on('e', fn) ↔ emit('e')). */
+function eventEmitterEdges(ctx) {
+    const emitsByEvent = new Map(); // event → dispatcher node ids
+    const handlersByEvent = new Map(); // event → handler id → registration site (file:line)
+    for (const file of ctx.getAllFiles()) {
+        const content = ctx.readFile(file);
+        if (!content)
+            continue;
+        const hasEmit = content.includes('.emit(') || content.includes('.fire(') || content.includes('.dispatchEvent(');
+        const hasOn = content.includes('.on(') || content.includes('.once(') || content.includes('.addListener(');
+        if (!hasEmit && !hasOn)
+            continue;
+        const nodesInFile = ctx.getNodesInFile(file);
+        const lineOf = (idx) => content.slice(0, idx).split('\n').length;
+        if (hasEmit) {
+            EMIT_RE.lastIndex = 0;
+            let m;
+            while ((m = EMIT_RE.exec(content))) {
+                const disp = enclosingFn(nodesInFile, lineOf(m.index));
+                if (!disp)
+                    continue;
+                const set = emitsByEvent.get(m[1]) ?? new Set();
+                set.add(disp.id);
+                emitsByEvent.set(m[1], set);
+            }
+        }
+        if (hasOn) {
+            ON_RE.lastIndex = 0;
+            let m;
+            while ((m = ON_RE.exec(content))) {
+                const handlerName = m[2] || m[3];
+                if (!handlerName)
+                    continue;
+                const handler = ctx.getNodesByName(handlerName).find((n) => n.kind === 'function' || n.kind === 'method');
+                if (!handler)
+                    continue;
+                const map = handlersByEvent.get(m[1]) ?? new Map();
+                map.set(handler.id, `${file}:${lineOf(m.index)}`);
+                handlersByEvent.set(m[1], map);
+            }
+        }
+    }
+    const edges = [];
+    const seen = new Set();
+    for (const [event, dispatchers] of emitsByEvent) {
+        const handlers = handlersByEvent.get(event);
+        if (!handlers)
+            continue;
+        // Precision guard: a generic event name with many handlers/dispatchers can't
+        // be matched without receiver-type info (Phase 3) — skip rather than over-link.
+        if (dispatchers.size > EVENT_FANOUT_CAP || handlers.size > EVENT_FANOUT_CAP)
+            continue;
+        for (const d of dispatchers)
+            for (const [h, registeredAt] of handlers) {
+                if (d === h)
+                    continue;
+                const key = `${d}>${h}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                edges.push({ source: d, target: h, kind: 'calls', provenance: 'heuristic', metadata: { synthesizedBy: 'event-emitter', event, registeredAt } });
+            }
+    }
+    return edges;
+}
+/**
+ * Phase 4: React class-component re-render. `this.setState(...)` re-runs the
+ * component's `render()`, but that hop is React-internal — no static edge — so a
+ * flow like "mutation → setState → canvas repaint" dead-ends at setState even
+ * though `render → getRenderableElements → …` is fully call-connected after it.
+ * Bridge it: for each class that has a `render` method, link every sibling method
+ * whose body calls `this.setState(` → `render`. The setState gate keeps this to
+ * React class components (a non-React class with a `render` method won't call
+ * `this.setState`). Over-approximation (all setState methods reach render) is
+ * accepted — it's reachability-correct, like the callback channels.
+ */
+function reactRenderEdges(queries, ctx) {
+    const edges = [];
+    const seen = new Set();
+    for (const cls of queries.getNodesByKind('class')) {
+        const children = queries.getOutgoingEdges(cls.id, ['contains'])
+            .map((e) => queries.getNodeById(e.target))
+            .filter((n) => !!n && n.kind === 'method');
+        const render = children.find((n) => n.name === 'render');
+        if (!render)
+            continue;
+        let added = 0;
+        for (const m of children) {
+            if (added >= MAX_CALLBACKS_PER_CHANNEL)
+                break;
+            if (m.id === render.id)
+                continue;
+            const content = ctx.readFile(m.filePath);
+            const src = content && sliceLines(content, m.startLine, m.endLine);
+            if (!src || !SETSTATE_RE.test(src))
+                continue;
+            const key = `${m.id}>${render.id}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            edges.push({
+                source: m.id, target: render.id, kind: 'calls', line: m.startLine,
+                provenance: 'heuristic',
+                metadata: { synthesizedBy: 'react-render', via: 'setState', registeredAt: `${render.filePath}:${render.startLine}` },
+            });
+            added++;
+        }
+    }
+    return edges;
+}
+/**
+ * Phase 4b: Flutter setState → build (the Dart analog of react-render). In a
+ * StatefulWidget's State class, `setState(() {…})` re-runs `build(context)`, but
+ * that hop is framework-internal (Flutter calls build), so a flow like
+ * "onPressed → _increment → setState → rebuilt UI" dead-ends at setState. Bridge
+ * it: for each Dart class with a `build` method, link every sibling method whose
+ * body calls `setState(` → `build`. The setState gate + `.dart` file keep this to
+ * Flutter State classes. Over-approximation accepted (reachability-correct).
+ */
+function flutterBuildEdges(queries, ctx) {
+    const edges = [];
+    const seen = new Set();
+    for (const cls of queries.getNodesByKind('class')) {
+        const children = queries.getOutgoingEdges(cls.id, ['contains'])
+            .map((e) => queries.getNodeById(e.target))
+            .filter((n) => !!n && n.kind === 'method');
+        const build = children.find((n) => n.name === 'build');
+        if (!build || !build.filePath.endsWith('.dart'))
+            continue;
+        let added = 0;
+        for (const m of children) {
+            if (added >= MAX_CALLBACKS_PER_CHANNEL)
+                break;
+            if (m.id === build.id)
+                continue;
+            const content = ctx.readFile(m.filePath);
+            const src = content && sliceLines(content, m.startLine, m.endLine);
+            if (!src || !FLUTTER_SETSTATE_RE.test(src))
+                continue;
+            const key = `${m.id}>${build.id}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            edges.push({
+                source: m.id, target: build.id, kind: 'calls', line: m.startLine,
+                provenance: 'heuristic',
+                metadata: { synthesizedBy: 'flutter-build', via: 'setState', registeredAt: `${build.filePath}:${build.startLine}` },
+            });
+            added++;
+        }
+    }
+    return edges;
+}
+/**
+ * Phase 4c: C++ virtual override. A call through a base/interface pointer
+ * (`db->Get(...)`, `iter->Next()`) dispatches at runtime to a subclass override,
+ * but that hop is a vtable indirection — no static call edge — so a flow stops at
+ * the abstract base method. Bridge it like react-render: for each C++ class that
+ * `extends` a base, link each base method → the subclass method of the same name
+ * (the override), so trace/callees from the interface method reach the
+ * implementation(s). Over-approximation accepted (reachability-correct); capped
+ * per class and gated to C++ to avoid touching other languages' dispatch.
+ */
+function cppOverrideEdges(queries) {
+    const edges = [];
+    const seen = new Set();
+    const methodsOf = (classId) => queries
+        .getOutgoingEdges(classId, ['contains'])
+        .map((e) => queries.getNodeById(e.target))
+        .filter((n) => !!n && n.kind === 'method');
+    for (const cls of queries.getNodesByKind('class')) {
+        const subMethods = methodsOf(cls.id).filter((n) => n.language === 'cpp');
+        if (subMethods.length === 0)
+            continue;
+        for (const ext of queries.getOutgoingEdges(cls.id, ['extends'])) {
+            const base = queries.getNodeById(ext.target);
+            if (!base || base.language !== 'cpp' || base.id === cls.id)
+                continue;
+            const baseMethods = new Map(methodsOf(base.id).map((m) => [m.name, m]));
+            let added = 0;
+            for (const m of subMethods) {
+                if (added >= MAX_CALLBACKS_PER_CHANNEL)
+                    break;
+                const bm = baseMethods.get(m.name);
+                if (!bm || bm.id === m.id)
+                    continue;
+                const key = `${bm.id}>${m.id}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                edges.push({
+                    source: bm.id,
+                    target: m.id,
+                    kind: 'calls',
+                    line: bm.startLine,
+                    provenance: 'heuristic',
+                    metadata: { synthesizedBy: 'cpp-override', via: m.name, registeredAt: `${m.filePath}:${m.startLine}` },
+                });
+                added++;
+            }
+        }
+    }
+    return edges;
+}
+/**
+ * Phase 5.5: interface / abstract dispatch (Java, Kotlin). A call through an
+ * injected interface (`@Autowired FooService svc; svc.list()`) or an abstract
+ * base dispatches at runtime to the implementing class's override — a vtable
+ * indirection with no static call edge — so a request→service flow stops at the
+ * interface method. Bridge it like cpp-override: for each class that
+ * `implements` an interface (or `extends` an abstract base), link each
+ * base/interface method → the class's same-name method (the override) so
+ * trace/callees reach the implementation. Over-approximation accepted
+ * (reachability-correct); capped per class, gated to JVM languages.
+ */
+const IFACE_OVERRIDE_LANGS = new Set(['java', 'kotlin']);
+function interfaceOverrideEdges(queries) {
+    const edges = [];
+    const seen = new Set();
+    const methodsOf = (classId) => queries
+        .getOutgoingEdges(classId, ['contains'])
+        .map((e) => queries.getNodeById(e.target))
+        .filter((n) => !!n && n.kind === 'method');
+    for (const cls of queries.getNodesByKind('class')) {
+        const implMethods = methodsOf(cls.id).filter((n) => IFACE_OVERRIDE_LANGS.has(n.language));
+        if (implMethods.length === 0)
+            continue;
+        for (const sup of queries.getOutgoingEdges(cls.id, ['implements', 'extends'])) {
+            const base = queries.getNodeById(sup.target);
+            if (!base || !IFACE_OVERRIDE_LANGS.has(base.language) || base.id === cls.id)
+                continue;
+            // Group impl methods by name to handle OVERLOADS: an interface `list()` and
+            // `list(params)` are distinct nodes and a call may resolve to either, so
+            // link every base overload → every same-name impl overload (keying by name
+            // alone would drop all but one and miss the resolved overload).
+            const implByName = new Map();
+            for (const m of implMethods) {
+                const arr = implByName.get(m.name);
+                if (arr)
+                    arr.push(m);
+                else
+                    implByName.set(m.name, [m]);
+            }
+            let added = 0;
+            for (const bm of methodsOf(base.id)) {
+                if (added >= MAX_CALLBACKS_PER_CHANNEL)
+                    break;
+                for (const m of implByName.get(bm.name) ?? []) {
+                    if (added >= MAX_CALLBACKS_PER_CHANNEL)
+                        break;
+                    if (bm.id === m.id)
+                        continue;
+                    const key = `${bm.id}>${m.id}`;
+                    if (seen.has(key))
+                        continue;
+                    seen.add(key);
+                    edges.push({
+                        source: bm.id,
+                        target: m.id,
+                        kind: 'calls',
+                        line: bm.startLine,
+                        provenance: 'heuristic',
+                        metadata: { synthesizedBy: 'interface-impl', via: m.name, registeredAt: `${m.filePath}:${m.startLine}` },
+                    });
+                    added++;
+                }
+            }
+        }
+    }
+    return edges;
+}
+/**
+ * Phase 5: React JSX child rendering. A component that returns `<Child .../>`
+ * mounts Child — React calls it — but JSX instantiation isn't a static call edge,
+ * so a render tree (App.render → StaticCanvas → renderStaticScene) breaks at the
+ * JSX hop. Link parent → each capitalized JSX child it renders. File-oriented
+ * (read each JSX file once). Precision gate: the child name must resolve to a
+ * component/function/class node — TS generics like `Array<Foo>` resolve to a type
+ * (or nothing) and are dropped.
+ */
+function reactJsxChildEdges(ctx) {
+    const edges = [];
+    const seen = new Set();
+    const PARENT_KINDS = new Set(['method', 'function', 'component']);
+    for (const file of ctx.getAllFiles()) {
+        const content = ctx.readFile(file);
+        if (!content || (!content.includes('</') && !content.includes('/>')))
+            continue; // JSX-file gate
+        const parents = ctx.getNodesInFile(file).filter((n) => PARENT_KINDS.has(n.kind));
+        for (const parent of parents) {
+            const src = sliceLines(content, parent.startLine, parent.endLine);
+            if (!src || (!src.includes('</') && !src.includes('/>')))
+                continue;
+            const names = new Set();
+            JSX_TAG_RE.lastIndex = 0;
+            let m;
+            while ((m = JSX_TAG_RE.exec(src)))
+                names.add(m[1]);
+            let added = 0;
+            for (const name of names) {
+                if (added >= MAX_JSX_CHILDREN)
+                    break;
+                const child = ctx.getNodesByName(name).find((n) => n.kind === 'component' || n.kind === 'function' || n.kind === 'class');
+                if (!child || child.id === parent.id)
+                    continue;
+                const key = `${parent.id}>${child.id}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                edges.push({
+                    source: parent.id, target: child.id, kind: 'calls', line: parent.startLine,
+                    provenance: 'heuristic',
+                    metadata: { synthesizedBy: 'jsx-render', via: name },
+                });
+                added++;
+            }
+        }
+    }
+    return edges;
+}
+/**
+ * Phase 6: Vue SFC templates. The `.vue` extractor only parses `<script>`, so
+ * template usage is invisible — child components and event handlers used ONLY in
+ * the template have no edge to them. PascalCase children (`<VPNav/>`) are already
+ * caught by reactJsxChildEdges (which scans the SFC component node), so this adds
+ * the two Vue-specific shapes:
+ *   - kebab-case children: `<el-button>` → `ElButton` component (renders).
+ *   - event bindings: `@click="onClick"` / `v-on:submit="save"` → handler method.
+ * Scoped to the `<template>` block of `.vue` files; resolution gate (kebab→
+ * component, handler→function/method) keeps precision; inline arrows / `$emit`
+ * skipped.
+ */
+function vueTemplateEdges(ctx) {
+    const edges = [];
+    const seen = new Set();
+    const COMPONENT_KINDS = new Set(['component', 'function', 'class']);
+    const HANDLER_KINDS = new Set(['method', 'function']);
+    // A composable's returned member may be a fn (`function close(){}`) or an
+    // arrow assigned to a const (`const close = () => {}`).
+    const RETURN_KINDS = new Set(['method', 'function', 'variable', 'constant']);
+    for (const file of ctx.getAllFiles()) {
+        if (!file.endsWith('.vue'))
+            continue;
+        const content = ctx.readFile(file);
+        const tpl = content && content.match(/<template[^>]*>([\s\S]*)<\/template>/i)?.[1];
+        if (!tpl)
+            continue;
+        const comp = ctx.getNodesInFile(file).find((n) => n.kind === 'component');
+        if (!comp)
+            continue;
+        // Composable-destructure map: alias → { composable, key }. Lets us resolve a
+        // template handler that isn't a local function but a destructured composable
+        // return (`@click="closeSidebar"` ← `const { close: closeSidebar } = useSidebarControl()`).
+        const script = content.match(/<script[^>]*>([\s\S]*?)<\/script>/i)?.[1] ?? '';
+        const destructured = new Map();
+        VUE_DESTRUCTURE_RE.lastIndex = 0;
+        let dm;
+        while ((dm = VUE_DESTRUCTURE_RE.exec(script))) {
+            if (!/^use[A-Z]/.test(dm[2]))
+                continue; // composables / hooks only
+            for (const part of dm[1].split(',')) {
+                const pm = part.trim().match(/^(\w+)\s*(?::\s*(\w+))?$/); // key | key: alias
+                if (pm)
+                    destructured.set(pm[2] || pm[1], { composable: dm[2], key: pm[1] });
+            }
+        }
+        let added = 0;
+        const addEdge = (target, meta) => {
+            if (added >= MAX_JSX_CHILDREN || !target || target.id === comp.id)
+                return;
+            const k = `${comp.id}>${target.id}>${meta.synthesizedBy}`;
+            if (seen.has(k))
+                return;
+            seen.add(k);
+            edges.push({ source: comp.id, target: target.id, kind: 'calls', line: comp.startLine, provenance: 'heuristic', metadata: meta });
+            added++;
+        };
+        // Prefer a target in THIS SFC (handlers live in the same file's script) —
+        // avoids cross-file mis-match when a name repeats across a monorepo.
+        const resolve = (name, kinds) => {
+            const matches = ctx.getNodesByName(name).filter((n) => kinds.has(n.kind));
+            return matches.find((n) => n.filePath === file) ?? matches[0];
+        };
+        let m;
+        VUE_KEBAB_RE.lastIndex = 0;
+        while ((m = VUE_KEBAB_RE.exec(tpl)))
+            addEdge(resolve(kebabToPascal(m[1]), COMPONENT_KINDS), { synthesizedBy: 'jsx-render', via: m[1] });
+        VUE_HANDLER_RE.lastIndex = 0;
+        while ((m = VUE_HANDLER_RE.exec(tpl))) {
+            const event = m[1];
+            const expr = m[2].trim();
+            if (expr.includes('=>') || expr.startsWith('$'))
+                continue; // inline arrow / $emit
+            const name = expr.match(/^([A-Za-z_]\w*)/)?.[1];
+            if (!name)
+                continue;
+            const direct = resolve(name, HANDLER_KINDS);
+            if (direct) {
+                addEdge(direct, { synthesizedBy: 'vue-handler', event });
+                continue;
+            }
+            // Composable-destructure handler → resolve to the composable's returned fn.
+            const d = destructured.get(name);
+            if (!d)
+                continue;
+            const composable = resolve(d.composable, HANDLER_KINDS);
+            // Resolve to the SPECIFIC returned member (e.g. `close`) defined in the
+            // composable's file. No fallback to the composable itself — the component
+            // already has a static `useX()` call edge, so that would just be redundant
+            // and less precise.
+            const keyFn = composable
+                ? ctx.getNodesByName(d.key).find((n) => RETURN_KINDS.has(n.kind) && n.filePath === composable.filePath)
+                : undefined;
+            if (keyFn)
+                addEdge(keyFn, { synthesizedBy: 'vue-handler', event, via: d.composable });
+        }
+    }
+    return edges;
+}
+/**
+ * React Native cross-language event channel (Phase 3 of the mixed-iOS/RN
+ * bridging effort). Same shape as `eventEmitterEdges` but cross-language:
+ *
+ *   Native (ObjC, on RCTEventEmitter subclass):
+ *     [self sendEventWithName:@"locationUpdate" body:@{...}];
+ *
+ *   Native (Java/Kotlin, via the JS module dispatcher):
+ *     emitter.emit("locationUpdate", body);
+ *     reactContext.getJSModule(RCTDeviceEventEmitter.class).emit("locationUpdate", body);
+ *
+ *   JS (subscriber):
+ *     new NativeEventEmitter(NativeModules.Geo).addListener("locationUpdate", handler);
+ *     DeviceEventEmitter.addListener("locationUpdate", handler);
+ *
+ * Synthesize: native dispatch site → JS handler, keyed by the literal
+ * event name. Only matches NAMED handlers (the existing `ON_RE` named-
+ * capture form). Inline arrow handlers like `addListener('x', d => …)`
+ * aren't named at extraction time and would need link-through-body
+ * support; matches the deliberate scope of the in-language synthesizer.
+ *
+ * Provenance `'heuristic'`, synthesizedBy `'rn-event-channel'`.
+ */
+// ObjC's `[self sendEventWithName:@"X" body:...]` shape (bracket syntax,
+// `@` string literals).
+const RN_OBJC_SEND_RE = /\bsendEventWithName\s*:\s*@"([^"]+)"/g;
+// Swift's `sendEvent(withName: "X", body: ...)` shape — same RCTEventEmitter
+// method, different call syntax. Both Objective-C and Swift subclass
+// RCTEventEmitter so this catches the Swift-side equivalent emission sites
+// (e.g. RNFusedLocation.swift's `sendEvent(withName: "geolocationDidChange",
+// body: locationData)`).
+const RN_SWIFT_SEND_RE = /\bsendEvent\s*\(\s*withName\s*:\s*"([^"]+)"/g;
+// JVM-side emitter calls: `emitter.emit("X", body)`. Matches both Java
+// and Kotlin syntax because the call form is identical. Restricted to
+// JVM source files in the consumer so we don't re-process JS emits
+// (which `eventEmitterEdges` already handles).
+const RN_JVM_EMIT_RE = /\.emit\s*\(\s*"([^"]+)"\s*,/g;
+function rnEventEdges(ctx) {
+    // Native dispatchers (source = the native method whose body sends the
+    // event) and JS handlers (target = the function/method registered as
+    // the listener) keyed by event name.
+    const nativeDispatchersByEvent = new Map();
+    const jsHandlersByEvent = new Map();
+    for (const file of ctx.getAllFiles()) {
+        const content = ctx.readFile(file);
+        if (!content)
+            continue;
+        const nodesInFile = ctx.getNodesInFile(file);
+        const lineOf = (idx) => content.slice(0, idx).split('\n').length;
+        const addDispatcher = (event, line) => {
+            const disp = enclosingFn(nodesInFile, line);
+            if (!disp)
+                return;
+            const set = nativeDispatchersByEvent.get(event) ?? new Set();
+            set.add(disp.id);
+            nativeDispatchersByEvent.set(event, set);
+        };
+        // ObjC side: `sendEventWithName:@"X"` only fires inside `.m`/`.mm`
+        // files (RCTEventEmitter subclasses).
+        if (file.endsWith('.m') || file.endsWith('.mm')) {
+            RN_OBJC_SEND_RE.lastIndex = 0;
+            let m;
+            while ((m = RN_OBJC_SEND_RE.exec(content))) {
+                if (m[1])
+                    addDispatcher(m[1], lineOf(m.index));
+            }
+        }
+        // Swift side: same RCTEventEmitter method, parens/named-args syntax.
+        if (file.endsWith('.swift')) {
+            RN_SWIFT_SEND_RE.lastIndex = 0;
+            let m;
+            while ((m = RN_SWIFT_SEND_RE.exec(content))) {
+                if (m[1])
+                    addDispatcher(m[1], lineOf(m.index));
+            }
+        }
+        // JVM side: `.emit("X", …)` in Java/Kotlin. (We pattern-match
+        // anywhere in the file; the JS in-language path uses a separate
+        // emitter object pattern and is already handled by eventEmitterEdges.)
+        if (file.endsWith('.java') || file.endsWith('.kt')) {
+            RN_JVM_EMIT_RE.lastIndex = 0;
+            let m;
+            while ((m = RN_JVM_EMIT_RE.exec(content))) {
+                if (m[1])
+                    addDispatcher(m[1], lineOf(m.index));
+            }
+        }
+        // JS subscribers (.addListener("X", handler)). Restrict to JS-family
+        // files so a native file's `addListener:` (the ObjC method) doesn't
+        // get mistaken for a JS subscription — they're entirely different
+        // things despite sharing a name.
+        if (file.endsWith('.js') ||
+            file.endsWith('.jsx') ||
+            file.endsWith('.ts') ||
+            file.endsWith('.tsx') ||
+            file.endsWith('.mjs') ||
+            file.endsWith('.cjs')) {
+            // Match BOTH the named-handler form (`.addListener('x', fn)`) and
+            // an unnamed-handler form (`.addListener('x', listener)` where
+            // `listener` is a parameter — common in RN wrapper APIs like
+            // RNFirebase's `messaging().onMessageReceived(listener)`). For the
+            // unnamed case we attribute the subscription to the ENCLOSING JS
+            // function (the abstraction layer), giving a reachability-correct
+            // hop even when the actual user-side handler lives one call up.
+            const ADDLISTENER_ANY = /\.(?:on|once|addListener)\(\s*['"]([^'"]+)['"]\s*,\s*([A-Za-z_][\w.]*)/g;
+            ADDLISTENER_ANY.lastIndex = 0;
+            let m;
+            while ((m = ADDLISTENER_ANY.exec(content))) {
+                const event = m[1];
+                const arg = m[2];
+                if (!event || !arg)
+                    continue;
+                const bareName = arg.includes('.') ? arg.slice(arg.lastIndexOf('.') + 1) : arg;
+                // Try a named-symbol match first (matches the in-language semantic).
+                const namedHandler = ctx
+                    .getNodesByName(bareName)
+                    .find((n) => n.kind === 'function' || n.kind === 'method');
+                let targetId = namedHandler?.id ?? null;
+                if (!targetId) {
+                    // Fall back to the enclosing function — the subscribe-wrapper
+                    // pattern means the event fires THROUGH this function on its
+                    // way to user code. Reachability-correct attribution.
+                    const enclosing = enclosingFn(nodesInFile, lineOf(m.index));
+                    targetId = enclosing?.id ?? null;
+                }
+                if (!targetId) {
+                    // Broader fallback for JS object-literal API shape
+                    // (`const Foo = { watchX(...) { … addListener(...) … } }`):
+                    // method shorthand inside an object literal isn't extracted
+                    // as a method node, so enclosingFn returns null. Attribute to
+                    // the smallest enclosing `constant` / `variable` node — that's
+                    // the API surface a downstream caller would `import` and
+                    // invoke. Reachability-correct.
+                    const line = lineOf(m.index);
+                    let smallest = null;
+                    for (const n of nodesInFile) {
+                        if (n.kind !== 'constant' && n.kind !== 'variable')
+                            continue;
+                        const end = n.endLine ?? n.startLine;
+                        if (n.startLine <= line && end >= line) {
+                            if (!smallest || n.startLine >= smallest.startLine)
+                                smallest = n;
+                        }
+                    }
+                    targetId = smallest?.id ?? null;
+                }
+                if (!targetId)
+                    continue;
+                const map = jsHandlersByEvent.get(event) ?? new Map();
+                map.set(targetId, `${file}:${lineOf(m.index)}`);
+                jsHandlersByEvent.set(event, map);
+            }
+        }
+    }
+    const edges = [];
+    const seen = new Set();
+    for (const [event, dispatchers] of nativeDispatchersByEvent) {
+        const handlers = jsHandlersByEvent.get(event);
+        if (!handlers)
+            continue;
+        // Same fan-out guard as the in-language channel: generic event names
+        // (e.g. 'change', 'error', 'data') with many handlers/dispatchers
+        // can't be matched precisely without receiver-type info.
+        if (dispatchers.size > EVENT_FANOUT_CAP || handlers.size > EVENT_FANOUT_CAP)
+            continue;
+        for (const d of dispatchers) {
+            for (const [h, registeredAt] of handlers) {
+                if (d === h)
+                    continue;
+                const key = `${d}>${h}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                edges.push({
+                    source: d,
+                    target: h,
+                    kind: 'calls',
+                    provenance: 'heuristic',
+                    metadata: { synthesizedBy: 'rn-event-channel', event, registeredAt },
+                });
+            }
+        }
+    }
+    return edges;
+}
+/**
+ * Phase 6 — React Native Fabric/Codegen view component bridge.
+ *
+ * The Fabric framework extractor (`frameworks/fabric.ts`) emits
+ * `component` nodes named after the JS-visible component (e.g.
+ * `RNSScreenStack`) from each `codegenNativeComponent<Props>('Name')`
+ * spec declaration. The native implementation lives in an ObjC++/.mm or
+ * Kotlin/Java class whose name follows one of RN's conventions:
+ *
+ *   - Exact: `RNSScreenStack`
+ *   - With suffix: `RNSScreenStackView`, `RNSScreenStackViewManager`,
+ *     `RNSScreenStackComponentView`, `RNSScreenStackManager`
+ *
+ * This synthesizer walks every Fabric component node and looks for a
+ * native class matching one of those names; when found, emits a
+ * `calls` edge `component → native class` (provenance `'heuristic'`,
+ * `synthesizedBy:'fabric-native-impl'`) so trace from JSX usage of the
+ * component continues into native.
+ *
+ * The convention-based suffix lookup is precise: there's no name
+ * collision in RN view-manager codebases by design (Codegen output would
+ * conflict otherwise).
+ */
+const FABRIC_NATIVE_SUFFIXES = ['', 'View', 'ViewManager', 'ComponentView', 'Manager'];
+function fabricNativeImplEdges(ctx) {
+    const edges = [];
+    const seen = new Set();
+    // The Fabric extractor IDs are prefixed `fabric-component:` so we can
+    // filter to just those without iterating all `component` nodes.
+    const components = ctx.getNodesByKind('component').filter((n) => n.id.startsWith('fabric-component:'));
+    if (components.length === 0)
+        return edges;
+    // Pre-index native classes by name for O(1) lookup.
+    const nativeClassesByName = new Map();
+    for (const n of ctx.getNodesByKind('class')) {
+        if (n.language !== 'objc' && n.language !== 'kotlin' && n.language !== 'java' && n.language !== 'cpp')
+            continue;
+        const arr = nativeClassesByName.get(n.name);
+        if (arr)
+            arr.push(n);
+        else
+            nativeClassesByName.set(n.name, [n]);
+    }
+    for (const component of components) {
+        for (const suffix of FABRIC_NATIVE_SUFFIXES) {
+            const candidate = component.name + suffix;
+            const matches = nativeClassesByName.get(candidate);
+            if (!matches || matches.length === 0)
+                continue;
+            // Link the component node to every matching native class (iOS +
+            // Android each have one).
+            for (const native of matches) {
+                const key = `${component.id}>${native.id}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                edges.push({
+                    source: component.id,
+                    target: native.id,
+                    kind: 'calls',
+                    provenance: 'heuristic',
+                    metadata: {
+                        synthesizedBy: 'fabric-native-impl',
+                        viaSuffix: suffix || '(exact)',
+                        componentName: component.name,
+                    },
+                });
+            }
+        }
+    }
+    return edges;
+}
+/**
+ * Synthesize dispatcher→callback edges (field observers + EventEmitters +
+ * React re-render + JSX children + Vue templates + RN event channel +
+ * Fabric native-impl). Returns the count added. Never throws into
+ * indexing — callers wrap in try/catch.
+ */
+function synthesizeCallbackEdges(queries, ctx) {
+    const fieldEdges = fieldChannelEdges(queries, ctx);
+    const emitterEdges = eventEmitterEdges(ctx);
+    const renderEdges = reactRenderEdges(queries, ctx);
+    const jsxEdges = reactJsxChildEdges(ctx);
+    const vueEdges = vueTemplateEdges(ctx);
+    const flutterEdges = flutterBuildEdges(queries, ctx);
+    const cppEdges = cppOverrideEdges(queries);
+    const ifaceEdges = interfaceOverrideEdges(queries);
+    const rnEventEdgesList = rnEventEdges(ctx);
+    const fabricNativeEdges = fabricNativeImplEdges(ctx);
+    const merged = [];
+    const seen = new Set();
+    for (const e of [
+        ...fieldEdges,
+        ...emitterEdges,
+        ...renderEdges,
+        ...jsxEdges,
+        ...vueEdges,
+        ...flutterEdges,
+        ...cppEdges,
+        ...ifaceEdges,
+        ...rnEventEdgesList,
+        ...fabricNativeEdges,
+    ]) {
+        const key = `${e.source}>${e.target}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        merged.push(e);
+    }
+    if (merged.length > 0)
+        queries.insertEdges(merged);
+    return merged.length;
+}
+//# sourceMappingURL=callback-synthesizer.js.map