@colbymchenry/codegraph-darwin-x64 0.9.6 → 0.9.8

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.synthesizeCallbackEdges = synthesizeCallbackEdges;
+const generated_detection_1 = require("../extraction/generated-detection");
+const strip_comments_1 = require("./strip-comments");
 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;
@@ -19,6 +21,18 @@ const VUE_HANDLER_RE = /(?:@|v-on:)([a-zA-Z][\w-]*)(?:\.[\w]+)*\s*=\s*"([^"]+)"/
 // 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;
+// Closure-collection dynamic dispatch (language-agnostic, Swift-first). A method
+// appends a closure to a collection property; another method iterates that
+// property *invoking each element* (`coll.forEach { $0() }` / `{ it() }`). The
+// element-invoke (`$0(` / `it(`) PROVES the collection holds closures, so pairing
+// a dispatcher to same-named registrars (`.append`/`.add`/`.push`/`.insert`,
+// incl. Swift `prop.write { $0.append }`) is high-precision. Cross-file/class by
+// design: Alamofire appends in `DataRequest.validate` but iterates in the base
+// `Request.didCompleteTask` — neither same-file nor same-class pairing reaches it.
+const CC_DISPATCH_RE = /(\w+)\.forEach\s*\{\s*(?:\$0|it)\s*\(/g;
+const CC_APPEND_WRITE_RE = /(\w+)\.write\s*\{\s*\$0(?:\.(\w+))?\.(?:append|add|push|insert)\s*\(/g;
+const CC_APPEND_DIRECT_RE = /(\w+)\.(?:append|add|push|insert)\s*\(/g;
+const CC_FANOUT_CAP = 8; // skip a field name with more dispatchers/registrars than this (too generic to pair confidently)
 function kebabToPascal(s) {
     return s.split('-').map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join('');
 }
@@ -127,6 +141,88 @@ function fieldChannelEdges(queries, ctx) {
     }
     return edges;
 }
+/**
+ * Closure-collection dispatch: dispatcher iterates a closure-collection property
+ * invoking each element; registrar appends a closure to the same-named property.
+ * Emits dispatcher → registrar so a flow reaches the registration site (where the
+ * appended closure's body — and its callers — live). High-precision: the
+ * dispatcher's element-invoke is the gate (a `.forEach` that does NOT invoke its
+ * element is ignored), so a repo with no closure-collection dispatch yields zero
+ * edges regardless of how many `.append`/`.push` sites it has.
+ *
+ * Pairs globally by field name (cross-file/class is required — see Alamofire's
+ * base-class `Request.didCompleteTask` iterating `validators` appended by the
+ * subclass `DataRequest.validate`), bounded by a fan-out cap so a generic field
+ * name shared across unrelated classes can't fan out into noise.
+ */
+function closureCollectionEdges(queries, ctx) {
+    const candidates = [...queries.getNodesByKind('method'), ...queries.getNodesByKind('function')];
+    const dispatchers = new Map(); // field → dispatcher methods + forEach line
+    const registrars = new Map(); // field → registrar methods + append line
+    const addReg = (field, node, absLine) => {
+        if (!field || /^\d+$/.test(field))
+            return; // `$0.append` mis-captures the `0`; the write-RE owns that field
+        const arr = registrars.get(field) ?? [];
+        if (!arr.some((r) => r.node.id === node.id))
+            arr.push({ node, line: absLine });
+        registrars.set(field, arr);
+    };
+    for (const m of candidates) {
+        const content = ctx.readFile(m.filePath);
+        const src = content && sliceLines(content, m.startLine, m.endLine);
+        if (!src)
+            continue;
+        const hasForEach = src.includes('.forEach');
+        const hasAppend = src.includes('.append(') || src.includes('.add(') || src.includes('.push(') || src.includes('.insert(');
+        if (!hasForEach && !hasAppend)
+            continue;
+        const lineAt = (idx) => (m.startLine ?? 1) + src.slice(0, idx).split('\n').length - 1;
+        if (hasForEach) {
+            CC_DISPATCH_RE.lastIndex = 0;
+            let d;
+            while ((d = CC_DISPATCH_RE.exec(src))) {
+                const arr = dispatchers.get(d[1]) ?? [];
+                if (!arr.some((n) => n.node.id === m.id))
+                    arr.push({ node: m, line: lineAt(d.index) });
+                dispatchers.set(d[1], arr);
+            }
+        }
+        if (hasAppend) {
+            CC_APPEND_WRITE_RE.lastIndex = 0;
+            let w;
+            while ((w = CC_APPEND_WRITE_RE.exec(src)))
+                addReg(w[2] || w[1], m, lineAt(w.index)); // nested `$0.streams` else the `.write` receiver
+            CC_APPEND_DIRECT_RE.lastIndex = 0;
+            let a;
+            while ((a = CC_APPEND_DIRECT_RE.exec(src)))
+                addReg(a[1], m, lineAt(a.index));
+        }
+    }
+    const edges = [];
+    const seen = new Set();
+    for (const [field, disps] of dispatchers) {
+        const regs = registrars.get(field);
+        if (!regs || regs.length === 0)
+            continue;
+        if (disps.length > CC_FANOUT_CAP || regs.length > CC_FANOUT_CAP)
+            continue; // generic field — can't pair confidently
+        for (const disp of disps)
+            for (const reg of regs) {
+                if (disp.node.id === reg.node.id)
+                    continue;
+                const key = `${disp.node.id}>${reg.node.id}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                edges.push({
+                    source: disp.node.id, target: reg.node.id, kind: 'calls', line: disp.line,
+                    provenance: 'heuristic',
+                    metadata: { synthesizedBy: 'closure-collection', field, registeredAt: `${reg.node.filePath}:${reg.line}` },
+                });
+            }
+    }
+    return edges;
+}
 /** Phase 2: string-keyed EventEmitter channels (on('e', fn) ↔ emit('e')). */
 function eventEmitterEdges(ctx) {
     const emitsByEvent = new Map(); // event → dispatcher node ids
@@ -342,7 +438,16 @@ function cppOverrideEdges(queries) {
  * 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']);
+// Languages whose static `implements`/`extends` edges should bridge an
+// interface (or abstract base) method to the matching concrete-class method.
+// The set is "languages with explicit nominal subtyping and a single class
+// kind that holds methods" — i.e. the shape this loop expects. Swift and
+// Scala fit shape-wise (Swift `protocol`/`class`, Scala `trait`/`class`)
+// and are added below; their concrete-side nodes can be a `struct` (Swift)
+// or an `object` (Scala) so the loop also iterates those kinds.
+const IFACE_OVERRIDE_LANGS = new Set([
+    'java', 'kotlin', 'csharp', 'typescript', 'javascript', 'swift', 'scala',
+]);
 function interfaceOverrideEdges(queries) {
     const edges = [];
     const seen = new Set();
@@ -350,46 +455,163 @@ function interfaceOverrideEdges(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)
+    // Concrete-side kinds vary by language: `class` covers Java / Kotlin /
+    // C# / TS / Swift-classes / Scala-classes; `struct` covers Swift value
+    // types that conform to protocols. Iterate both.
+    const concreteKinds = ['class', 'struct'];
+    for (const kind of concreteKinds) {
+        for (const cls of queries.getNodesByKind(kind)) {
+            const implMethods = methodsOf(cls.id).filter((n) => IFACE_OVERRIDE_LANGS.has(n.language));
+            if (implMethods.length === 0)
                 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]);
+            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;
+}
+/**
+ * Go gRPC stub → impl bridge. The protoc-gen-go-grpc codegen emits an
+ * `UnimplementedXxxServer` struct in `*_grpc.pb.go` carrying one method
+ * per service RPC; the real handler is a hand-written struct in another
+ * file (`x/bank/keeper/msg_server.go::msgServer.Send` in cosmos-sdk).
+ * Go's structural typing means no `implements` edge exists for our
+ * resolver to follow, so `trace("Send","SendCoins")` lands on the
+ * empty stub and reports "no path" (validated empirically — the cosmos
+ * Q1 r1 trace failure that drove this work).
+ *
+ * Bridge: for each `UnimplementedXxxServer` whose RPC-method names are
+ * a SUBSET of some other Go struct's method names, emit `calls` edges
+ * `stub.method → impl.method` (paired by name). Excludes the gRPC
+ * internal markers `mustEmbedUnimplementedXxxServer` and
+ * `testEmbeddedByValue`, and skips candidate impls that themselves
+ * live in a generated file (their `xxxClient` / sibling stubs would
+ * otherwise look like impls).
+ *
+ * Multiple candidates is allowed and capped at MAX_CALLBACKS_PER_CHANNEL —
+ * a service often has both a production impl and one or more test
+ * mocks; linking to all preserves trace utility without false-favoring.
+ *
+ * Provenance: `heuristic`, `synthesizedBy: 'go-grpc-stub-impl'`. The
+ * stub's source line is the wiring site shown in the trace trail.
+ */
+function goGrpcStubImplEdges(queries) {
+    const edges = [];
+    const seen = new Set();
+    const STUB_RE = /^Unimplemented.*Server$/;
+    // gRPC internal-helper methods that appear on every Unimplemented*Server;
+    // not part of the service contract, so exclude when computing the RPC-method
+    // signature used to match impls.
+    const isInternalMarker = (n) => n.startsWith('mustEmbed') || n === 'testEmbeddedByValue';
+    // Methods directly contained by each Go struct, name-only. Built once.
+    const methodNamesByStruct = new Map();
+    const methodNodesByStruct = new Map();
+    const goStructs = [];
+    for (const s of queries.getNodesByKind('struct')) {
+        if (s.language !== 'go')
+            continue;
+        goStructs.push(s);
+        const ms = queries
+            .getOutgoingEdges(s.id, ['contains'])
+            .map((e) => queries.getNodeById(e.target))
+            .filter((n) => !!n && n.kind === 'method');
+        methodNodesByStruct.set(s.id, ms);
+        methodNamesByStruct.set(s.id, new Set(ms.map((m) => m.name)));
+    }
+    for (const stub of goStructs) {
+        if (!STUB_RE.test(stub.name))
+            continue;
+        // The stub MUST live in a generated file — that's what tells us this is
+        // a protoc-emitted scaffold rather than someone naming a struct
+        // `UnimplementedXxxServer` by hand. Without this gate we'd also bridge
+        // such hand-written structs and create misleading edges.
+        if (!(0, generated_detection_1.isGeneratedFile)(stub.filePath))
+            continue;
+        const stubMethods = (methodNodesByStruct.get(stub.id) ?? []).filter((m) => !isInternalMarker(m.name));
+        if (stubMethods.length === 0)
+            continue;
+        const stubMethodNames = stubMethods.map((m) => m.name);
+        for (const cand of goStructs) {
+            if (cand.id === stub.id)
+                continue;
+            // Skip generated-file candidates — they're siblings (msgClient,
+            // UnsafeMsgServer, …) whose method sets coincidentally match.
+            if ((0, generated_detection_1.isGeneratedFile)(cand.filePath))
+                continue;
+            const candNames = methodNamesByStruct.get(cand.id);
+            if (!candNames)
+                continue;
+            // Subset: every RPC method must exist on the candidate by name.
+            // Signature-level match would tighten this further, but name-match
+            // alone already gives one-to-one pairing in real codebases because
+            // gRPC method-name sets are highly distinctive (Send + MultiSend +
+            // UpdateParams + SetSendEnabled is unique to bank's MsgServer).
+            if (!stubMethodNames.every((n) => candNames.has(n)))
+                continue;
+            const candMethods = methodNodesByStruct.get(cand.id) ?? [];
             let added = 0;
-            for (const bm of methodsOf(base.id)) {
+            for (const sm of stubMethods) {
                 if (added >= MAX_CALLBACKS_PER_CHANNEL)
                     break;
-                for (const m of implByName.get(bm.name) ?? []) {
+                for (const cm of candMethods) {
                     if (added >= MAX_CALLBACKS_PER_CHANNEL)
                         break;
-                    if (bm.id === m.id)
+                    if (cm.name !== sm.name)
                         continue;
-                    const key = `${bm.id}>${m.id}`;
+                    const key = `${sm.id}>${cm.id}`;
                     if (seen.has(key))
                         continue;
                     seen.add(key);
                     edges.push({
-                        source: bm.id,
-                        target: m.id,
+                        source: sm.id,
+                        target: cm.id,
                         kind: 'calls',
-                        line: bm.startLine,
+                        line: sm.startLine,
                         provenance: 'heuristic',
-                        metadata: { synthesizedBy: 'interface-impl', via: m.name, registeredAt: `${m.filePath}:${m.startLine}` },
+                        metadata: {
+                            synthesizedBy: 'go-grpc-stub-impl',
+                            via: cm.name,
+                            registeredAt: `${cm.filePath}:${cm.startLine}`,
+                        },
                     });
                     added++;
                 }
@@ -878,14 +1100,153 @@ function mybatisJavaXmlEdges(queries) {
     }
     return edges;
 }
+/**
+ * Gin middleware chain. Gin runs its entire handler chain through one dynamic
+ * line in `(*Context).Next`:
+ *     for c.index < len(c.handlers) { c.handlers[c.index](c); c.index++ }
+ * `c.handlers` is a `HandlersChain` (`[]HandlerFunc`) assembled at registration
+ * time by `combineHandlers` from the funcs passed to `r.Use(...)` /
+ * `r.GET("/path", h...)` / `r.Handle(...)`. Because the call is a computed index
+ * into a runtime-built slice, tree-sitter resolves `c.handlers[c.index](c)` to
+ * NOTHING — so `callees(Next)` is just the `len()` helper and the flow
+ * `ServeHTTP → handleHTTPRequest → Next` dead-ends at the exact symbol the
+ * "how do requests flow through the middleware chain" question is about. The
+ * agent then re-queries Next and falls back to Read/grep (validated: the gin
+ * WITH-arm rabbit-holed on precisely this dead-end).
+ *
+ * Bridge it: find the chain DISPATCHER (a Go method whose body invokes a
+ * `handlers` slice by index) and link it → every HandlerFunc registered via a
+ * gin registration call, so `callees(Next)` and `trace(ServeHTTP, <handler>)`
+ * connect end-to-end. Named handlers only (`gin.Logger()` → `Logger`,
+ * `authMiddleware`); inline closures are anonymous and skipped. Like
+ * react-render / interface-impl this is a deliberate over-approximation —
+ * reachability-correct (any registered handler CAN run for some route), capped,
+ * and gated on the dispatcher existing so it never runs on non-gin Go repos.
+ * Provenance `heuristic`, `synthesizedBy:'gin-middleware-chain'`; `registeredAt`
+ * is the `.Use`/`.GET` site an agent would otherwise grep for.
+ */
+const GIN_DISPATCH_RE = /\.handlers\s*\[[^\]]*\]\s*\(/; // c.handlers[c.index](c)
+const GIN_REG_RE = /\.(?:Use|GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD|Any|Handle)\s*\(/g;
+/** Balanced `(...)` body starting at the '(' index; null if unbalanced. */
+function goBalancedArgs(s, openIdx) {
+    let depth = 0;
+    for (let i = openIdx; i < s.length; i++) {
+        const c = s[i];
+        if (c === '(')
+            depth++;
+        else if (c === ')') {
+            depth--;
+            if (depth === 0)
+                return s.slice(openIdx + 1, i);
+        }
+    }
+    return null;
+}
+/** Split a top-level comma list, respecting nested () [] {}. */
+function goSplitArgs(args) {
+    const out = [];
+    let depth = 0, cur = '';
+    for (const c of args) {
+        if (c === '(' || c === '[' || c === '{') {
+            depth++;
+            cur += c;
+        }
+        else if (c === ')' || c === ']' || c === '}') {
+            depth--;
+            cur += c;
+        }
+        else if (c === ',' && depth === 0) {
+            out.push(cur);
+            cur = '';
+        }
+        else
+            cur += c;
+    }
+    if (cur.trim())
+        out.push(cur);
+    return out;
+}
+/** Tail ident of a handler arg: `gin.Logger()`→`Logger`, `mw`→`mw`; null for string paths / closures. */
+function goHandlerIdent(expr) {
+    const cleaned = expr.trim().replace(/\(\s*\)$/, ''); // drop a trailing call ()
+    if (!cleaned || cleaned.startsWith('"') || cleaned.startsWith('`') || cleaned.startsWith('func'))
+        return null;
+    const m = cleaned.match(/(?:\.|^)([A-Za-z_]\w*)$/);
+    return m ? m[1] : null;
+}
+function ginMiddlewareChainEdges(queries, ctx) {
+    // 1. Find the chain dispatcher(s): a Go method that invokes a `handlers` slice by index.
+    const dispatchers = queries.getNodesByKind('method').filter((n) => {
+        if (n.language !== 'go')
+            return false;
+        const content = ctx.readFile(n.filePath);
+        const src = content && sliceLines(content, n.startLine, n.endLine);
+        return !!src && GIN_DISPATCH_RE.test(src);
+    });
+    if (dispatchers.length === 0)
+        return []; // not a gin repo — bail
+    // 2. Collect handler identifiers registered via gin registration calls
+    //    (.Use / .GET / … / .Handle). String args (paths/methods) and inline
+    //    closures are dropped by goHandlerIdent; the rest are HandlerFuncs.
+    const registered = new Map(); // name → registeredAt (file:line)
+    for (const file of ctx.getAllFiles()) {
+        if (!file.endsWith('.go'))
+            continue;
+        const content = ctx.readFile(file);
+        if (!content || (!content.includes('.Use(') && !/\.(?:GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD|Any|Handle)\(/.test(content)))
+            continue;
+        const safe = (0, strip_comments_1.stripCommentsForRegex)(content, 'go');
+        GIN_REG_RE.lastIndex = 0;
+        let m;
+        while ((m = GIN_REG_RE.exec(safe))) {
+            const parenIdx = m.index + m[0].length - 1;
+            const argStr = goBalancedArgs(safe, parenIdx);
+            if (!argStr)
+                continue;
+            const line = safe.slice(0, m.index).split('\n').length;
+            for (const arg of goSplitArgs(argStr)) {
+                const name = goHandlerIdent(arg);
+                if (name && !registered.has(name))
+                    registered.set(name, `${file}:${line}`);
+            }
+        }
+    }
+    if (registered.size === 0)
+        return [];
+    // 3. Link each dispatcher → each registered handler node (dedup, capped).
+    const edges = [];
+    const seen = new Set();
+    for (const disp of dispatchers) {
+        let added = 0;
+        for (const [name, registeredAt] of registered) {
+            if (added >= MAX_CALLBACKS_PER_CHANNEL)
+                break;
+            const handler = ctx.getNodesByName(name).find((n) => (n.kind === 'function' || n.kind === 'method') && n.language === 'go');
+            if (!handler || handler.id === disp.id)
+                continue;
+            const key = `${disp.id}>${handler.id}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            edges.push({
+                source: disp.id, target: handler.id, kind: 'calls', line: disp.startLine,
+                provenance: 'heuristic',
+                metadata: { synthesizedBy: 'gin-middleware-chain', via: name, registeredAt },
+            });
+            added++;
+        }
+    }
+    return edges;
+}
 /**
  * Synthesize dispatcher→callback edges (field observers + EventEmitters +
  * React re-render + JSX children + Vue templates + RN event channel +
- * Fabric native-impl + MyBatis Java↔XML). Returns the count added. Never
- * throws into indexing — callers wrap in try/catch.
+ * Fabric native-impl + MyBatis Java↔XML + Gin middleware chain). Returns the
+ * count added. Never throws into indexing — callers wrap in try/catch.
  */
 function synthesizeCallbackEdges(queries, ctx) {
     const fieldEdges = fieldChannelEdges(queries, ctx);
+    const closureCollEdges = closureCollectionEdges(queries, ctx);
     const emitterEdges = eventEmitterEdges(ctx);
     const renderEdges = reactRenderEdges(queries, ctx);
     const jsxEdges = reactJsxChildEdges(ctx);
@@ -893,13 +1254,16 @@ function synthesizeCallbackEdges(queries, ctx) {
     const flutterEdges = flutterBuildEdges(queries, ctx);
     const cppEdges = cppOverrideEdges(queries);
     const ifaceEdges = interfaceOverrideEdges(queries);
+    const goGrpcEdges = goGrpcStubImplEdges(queries);
     const rnEventEdgesList = rnEventEdges(ctx);
     const fabricNativeEdges = fabricNativeImplEdges(ctx);
     const mybatisEdges = mybatisJavaXmlEdges(queries);
+    const ginEdges = ginMiddlewareChainEdges(queries, ctx);
     const merged = [];
     const seen = new Set();
     for (const e of [
         ...fieldEdges,
+        ...closureCollEdges,
         ...emitterEdges,
         ...renderEdges,
         ...jsxEdges,
@@ -907,9 +1271,11 @@ function synthesizeCallbackEdges(queries, ctx) {
         ...flutterEdges,
         ...cppEdges,
         ...ifaceEdges,
+        ...goGrpcEdges,
         ...rnEventEdgesList,
         ...fabricNativeEdges,
         ...mybatisEdges,
+        ...ginEdges,
     ]) {
         const key = `${e.source}>${e.target}`;
         if (seen.has(key))