@codeflow-map/core 0.1.0

package/dist/analyzer/languages/typescript.js

@@ -0,0 +1,351 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typescriptAnalyzer = void 0;
+const extractorUtils_1 = require("../extractorUtils");
+exports.typescriptAnalyzer = {
+    functionQuery: `
+(function_declaration
+  name: (identifier) @fn.name
+  parameters: (formal_parameters) @fn.params
+  return_type: (type_annotation)? @fn.return_type) @fn.decl
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @fn.name
+    value: [(arrow_function) (function_expression)] @fn.decl))
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @fn.name
+      value: [(arrow_function) (function_expression)] @fn.decl)))
+
+(method_definition
+  name: (property_identifier) @fn.name
+  parameters: (formal_parameters) @fn.params
+  return_type: (type_annotation)? @fn.return_type) @fn.decl
+
+(call_expression
+  function: (identifier) @hook.name
+  arguments: (arguments
+    [(arrow_function) (function_expression)] @fn.decl)
+  (#match? @hook.name "^use"))
+
+(generator_function_declaration
+  name: (identifier) @fn.name
+  parameters: (formal_parameters) @fn.params
+  return_type: (type_annotation)? @fn.return_type) @fn.decl
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @fn.name
+    value: (generator_function) @fn.decl))
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @fn.name
+      value: (generator_function) @fn.decl)))
+
+(function_expression
+  name: (identifier) @fn.name
+  parameters: (formal_parameters) @fn.params) @fn.decl
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @fn.name
+    value: (call_expression
+      function: [(parenthesized_expression
+                   [(function_expression)(arrow_function)] @fn.decl)
+                 (arrow_function) @fn.decl
+                 (function_expression) @fn.decl])))
+
+(expression_statement
+  (call_expression
+    function: (parenthesized_expression
+      [(function_expression)(arrow_function)] @fn.decl)))
+
+(assignment_expression
+  left: (member_expression
+    object: (identifier) @worker.obj
+    property: (property_identifier) @worker.prop)
+  right: [(arrow_function) (function_expression)] @worker.fn
+  (#match? @worker.obj "^self$")
+  (#match? @worker.prop "^onmessage$"))
+
+(call_expression
+  function: (member_expression
+    object: (identifier) @worker.obj
+    property: (property_identifier) @worker.method)
+  arguments: (arguments
+    (string) @worker.event
+    [(arrow_function) (function_expression)] @worker.fn)
+  (#match? @worker.obj "^self$")
+  (#match? @worker.method "^addEventListener$")
+  (#match? @worker.event "message"))
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @fn.name
+    value: (call_expression
+      function: (identifier) @wrapper.name
+      arguments: (arguments
+        [(arrow_function) (function_expression)] @fn.decl)
+      (#match? @wrapper.name "^(forwardRef|memo)$"))))
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @fn.name
+    value: (call_expression
+      function: (identifier) @wrapper.outer
+      arguments: (arguments
+        (call_expression
+          function: (identifier) @wrapper.inner
+          arguments: (arguments
+            [(arrow_function) (function_expression)] @fn.decl)))
+      (#match? @wrapper.outer "^(memo|forwardRef)$"))))
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @fn.name
+      value: (call_expression
+        function: (identifier) @wrapper.name
+        arguments: (arguments
+          [(arrow_function) (function_expression)] @fn.decl)
+        (#match? @wrapper.name "^(forwardRef|memo)$")))))
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @fn.name
+      value: (call_expression
+        function: (identifier) @wrapper.outer
+        arguments: (arguments
+          (call_expression
+            function: (identifier) @wrapper.inner
+            arguments: (arguments
+              [(arrow_function) (function_expression)] @fn.decl)))
+        (#match? @wrapper.outer "^(memo|forwardRef)$")))))
+
+(public_field_definition
+  name: (property_identifier) @fn.name
+  value: [(arrow_function)(function_expression)] @fn.decl)
+  `,
+    callQuery: `
+(call_expression
+  function: [(identifier)(member_expression)] @call.name) @call.expr
+
+(new_expression
+  constructor: (identifier) @call.name) @call.expr
+
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @call.name
+    (#match? @call.name "^(then|catch|finally)$"))) @call.expr
+  `,
+    extractFunction(match, filePath, languageId) {
+        const declCapture = match.captures.find((c) => c.name === 'fn.decl');
+        if (!declCapture) {
+            const workerFn = match.captures.find((c) => c.name === 'worker.fn');
+            if (workerFn) {
+                const workerProp = match.captures.find((c) => c.name === 'worker.prop');
+                const node = workerFn.node;
+                const rawName = workerProp ? 'onmessage_handler' : `message_handler_${node.startPosition.row}`;
+                const paramsList = (0, extractorUtils_1.getParamsFromFunctionNode)(node, true);
+                return {
+                    id: `${filePath}::${rawName}::${node.startPosition.row}`,
+                    name: rawName,
+                    filePath,
+                    startLine: node.startPosition.row,
+                    endLine: node.endPosition.row,
+                    params: paramsList,
+                    returnType: null,
+                    isAsync: (0, extractorUtils_1.checkIsAsync)(node),
+                    isExported: false,
+                    isEntryPoint: true,
+                    language: languageId,
+                    kind: 'function'
+                };
+            }
+            return null;
+        }
+        const nameCapture = match.captures.find((c) => c.name === 'fn.name');
+        const hookNameCapture = match.captures.find((c) => c.name === 'hook.name');
+        // For wrapper patterns (memo, forwardRef), only capture the first argument
+        const wrapperCapture = match.captures.find((c) => c.name === 'wrapper.name' || c.name === 'wrapper.outer');
+        if (wrapperCapture) {
+            const argsParent = declCapture.node.parent;
+            if (argsParent?.type === 'arguments') {
+                const firstArg = argsParent.namedChildren[0];
+                if (firstArg.id !== declCapture.node.id) {
+                    return null;
+                }
+            }
+        }
+        let rawName = "anonymous";
+        let kind = 'function';
+        let parentFunctionId;
+        if (nameCapture) {
+            rawName = nameCapture.node.text;
+            if (declCapture.node.type === 'function_expression' && nameCapture.node.parent?.id === declCapture.node.id) {
+                if (declCapture.node.parent?.type === 'variable_declarator') {
+                    return null;
+                }
+                parentFunctionId = (0, extractorUtils_1.getEnclosingFunctionId)(declCapture.node, filePath) ?? undefined;
+            }
+            if (declCapture.node.type === 'method_definition') {
+                kind = 'method';
+            }
+        }
+        else if (hookNameCapture) {
+            const startLine = declCapture.node.startPosition.row;
+            rawName = `${hookNameCapture.node.text}_callback_${startLine}`;
+            kind = 'hook';
+        }
+        // Detect IIFE: fn.decl is inside a call_expression (the IIFE invocation)
+        // Skip IIFE detection for wrapper patterns (forwardRef, memo)
+        const declParent = declCapture.node.parent;
+        const isParenWrapped = declParent?.type === 'parenthesized_expression';
+        const callParent = isParenWrapped ? declParent.parent : declParent;
+        if (callParent?.type === 'call_expression' && !wrapperCapture) {
+            if (rawName === 'anonymous') {
+                rawName = `iife_${declCapture.node.startPosition.row}`;
+            }
+            kind = 'iife';
+        }
+        else if (rawName === "anonymous" && !hookNameCapture) {
+            return null;
+        }
+        // Prefix with enclosing scope chain (parent functions, classes, and object literals)
+        const scopeChain = (0, extractorUtils_1.getEnclosingScopeChain)(declCapture.node, extractorUtils_1.JS_FN_SCOPE_TYPES, extractorUtils_1.JS_CLASS_SCOPE_TYPES);
+        if (scopeChain.length > 0) {
+            rawName = `${scopeChain.map(s => s.name).join('.')}.${rawName}`;
+            if (kind === 'method' && scopeChain[scopeChain.length - 1].type === 'object') {
+                // method_definition inside object literal is still a method
+            }
+        }
+        // For wrapper patterns, use the outermost wrapper call_expression range
+        let rangeNode = declCapture.node;
+        if (wrapperCapture) {
+            let target = declCapture.node.parent;
+            while (target?.type === 'arguments') {
+                const callExpr = target.parent;
+                if (callExpr?.type !== 'call_expression')
+                    break;
+                const fn = callExpr.childForFieldName('function');
+                const isKnownWrapper = fn && ((fn.type === 'identifier' && /^(forwardRef|memo)$/.test(fn.text)) ||
+                    (fn.type === 'member_expression' && /^(forwardRef|memo)$/.test(fn.childForFieldName('property')?.text ?? '')));
+                if (!isKnownWrapper)
+                    break;
+                rangeNode = callExpr;
+                target = callExpr.parent;
+            }
+        }
+        const paramsCapture = match.captures.find((c) => c.name === 'fn.params');
+        const returnCapture = match.captures.find((c) => c.name === 'fn.return_type');
+        const isExported = (0, extractorUtils_1.checkExportedByParentWalk)(declCapture.node);
+        const paramsList = paramsCapture
+            ? (0, extractorUtils_1.buildJsParams)(paramsCapture.node, true)
+            : (0, extractorUtils_1.getParamsFromFunctionNode)(declCapture.node, true);
+        let finalReturnType = returnCapture ? returnCapture.node.text.replace(/^:\s*/, '') : null;
+        if (!finalReturnType) {
+            const returnValues = (0, extractorUtils_1.getReturnValues)(declCapture.node, extractorUtils_1.JS_NESTED_FN_TYPES);
+            if (returnValues.length > 0) {
+                finalReturnType = returnValues.join(' | ');
+            }
+        }
+        return {
+            id: `${filePath}::${rawName}::${rangeNode.startPosition.row}`,
+            name: rawName,
+            filePath,
+            startLine: rangeNode.startPosition.row,
+            endLine: rangeNode.endPosition.row,
+            params: paramsList,
+            returnType: finalReturnType,
+            isAsync: (0, extractorUtils_1.checkIsAsync)(declCapture.node),
+            isExported,
+            isEntryPoint: false,
+            language: languageId,
+            kind,
+            ...(parentFunctionId ? { parentFunctionId } : {})
+        };
+    },
+    extractCall(match, filePath) {
+        const nameCapture = match.captures.find((c) => c.name === 'call.name');
+        const exprCapture = match.captures.find((c) => c.name === 'call.expr');
+        if (nameCapture && exprCapture) {
+            let calleeName = nameCapture.node.text;
+            if (nameCapture.node.type === 'member_expression') {
+                const prop = nameCapture.node.childForFieldName('property');
+                if (prop)
+                    calleeName = prop.text;
+            }
+            // Unwrap .bind(): handleWorkerMessage.bind(this) → ref to handleWorkerMessage
+            if (calleeName === 'bind' && nameCapture.node.type === 'member_expression') {
+                const obj = nameCapture.node.childForFieldName('object');
+                if (obj?.type === 'identifier') {
+                    return {
+                        callerFilePath: filePath,
+                        calleeName: obj.text,
+                        line: exprCapture.node.startPosition.row,
+                        callType: (0, extractorUtils_1.isInsidePromiseCombinator)(exprCapture.node) ? 'concurrent' : 'ref',
+                        isRef: true
+                    };
+                }
+            }
+            const callType = (0, extractorUtils_1.isInsidePromiseCombinator)(exprCapture.node) ? 'concurrent' : undefined;
+            const directCall = {
+                callerFilePath: filePath,
+                calleeName,
+                line: exprCapture.node.startPosition.row,
+                ...(callType ? { callType } : {})
+            };
+            // Extract function reference arguments from any call
+            const refCalls = [];
+            const callNode = exprCapture.node;
+            const argsNode = callNode.childForFieldName('arguments');
+            if (argsNode) {
+                for (const arg of argsNode.namedChildren) {
+                    let refName = null;
+                    if (arg.type === 'identifier') {
+                        refName = arg.text;
+                    }
+                    else if (arg.type === 'member_expression') {
+                        const obj = arg.childForFieldName('object');
+                        const prop = arg.childForFieldName('property');
+                        if (obj?.type === 'this' && prop) {
+                            refName = prop.text;
+                        }
+                    }
+                    else if (arg.type === 'call_expression') {
+                        // Unwrap .bind(): handleWorkerMessage.bind(this) -> handleWorkerMessage
+                        const fn = arg.childForFieldName('function');
+                        if (fn?.type === 'member_expression') {
+                            const prop = fn.childForFieldName('property');
+                            const obj = fn.childForFieldName('object');
+                            if (prop?.text === 'bind' && obj?.type === 'identifier') {
+                                refName = obj.text;
+                            }
+                        }
+                    }
+                    if (refName) {
+                        const refCallType = (0, extractorUtils_1.isInsidePromiseCombinator)(callNode) ? 'concurrent' : 'ref';
+                        refCalls.push({
+                            callerFilePath: filePath,
+                            calleeName: refName,
+                            line: callNode.startPosition.row,
+                            callType: refCallType,
+                            isRef: true
+                        });
+                    }
+                }
+            }
+            if (refCalls.length > 0) {
+                return [directCall, ...refCalls];
+            }
+            return directCall;
+        }
+        return null;
+    }
+};

package/dist/analyzer/treeSitter.d.ts

@@ -0,0 +1,4 @@
+import Parser from 'web-tree-sitter';
+import { SupportedLanguage } from '../types';
+export declare function initTreeSitter(wasmDirectory: string): Promise<void>;
+export declare function loadLanguage(lang: SupportedLanguage, wasmDirectory: string): Promise<Parser.Language>;

package/dist/analyzer/treeSitter.js

@@ -0,0 +1,62 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initTreeSitter = initTreeSitter;
+exports.loadLanguage = loadLanguage;
+const web_tree_sitter_1 = __importDefault(require("web-tree-sitter"));
+const path = __importStar(require("path"));
+let initialized = false;
+const languageCache = new Map();
+async function initTreeSitter(wasmDirectory) {
+    if (initialized)
+        return;
+    await web_tree_sitter_1.default.init({
+        locateFile: () => path.join(wasmDirectory, 'tree-sitter.wasm'),
+    });
+    initialized = true;
+}
+async function loadLanguage(lang, wasmDirectory) {
+    if (languageCache.has(lang)) {
+        return languageCache.get(lang);
+    }
+    const wasmName = lang === 'jsx' ? 'javascript' : lang;
+    const wasmPath = path.join(wasmDirectory, `tree-sitter-${wasmName}.wasm`);
+    const language = await web_tree_sitter_1.default.Language.load(wasmPath);
+    languageCache.set(lang, language);
+    return language;
+}

package/dist/graph/callGraphBuilder.d.ts

@@ -0,0 +1,2 @@
+import { FunctionNode, RawCall, CallEdge } from '../types';
+export declare function buildCallGraph(nodes: FunctionNode[], rawCalls: RawCall[]): CallEdge[];

package/dist/graph/callGraphBuilder.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCallGraph = buildCallGraph;
+function buildCallGraph(nodes, rawCalls) {
+    const byName = new Map();
+    const bySuffix = new Map();
+    for (const n of nodes) {
+        byName.set(n.name, n);
+        const dotIdx = n.name.lastIndexOf('.');
+        if (dotIdx >= 0) {
+            const suffix = n.name.substring(dotIdx + 1);
+            if (!bySuffix.has(suffix))
+                bySuffix.set(suffix, []);
+            bySuffix.get(suffix).push(n);
+        }
+    }
+    const edges = [];
+    for (const call of rawCalls) {
+        let callee = byName.get(call.calleeName);
+        // Find the innermost function whose range contains the call line,
+        // excluding the callee itself to avoid self-loops (e.g. go func(){...}())
+        const callerCandidates = nodes.filter(n => n.filePath === call.callerFilePath &&
+            call.line >= n.startLine &&
+            call.line <= n.endLine &&
+            n !== callee);
+        const caller = callerCandidates.length > 0
+            ? callerCandidates.reduce((best, n) => (n.endLine - n.startLine) < (best.endLine - best.startLine) ? n : best)
+            : undefined;
+        if (!caller)
+            continue;
+        if (!callee) {
+            const candidates = bySuffix.get(call.calleeName);
+            if (candidates && candidates.length === 1) {
+                const candidate = candidates[0];
+                // Suffix matching requires shared receiver prefix between caller and callee
+                const callerDot = caller.name.lastIndexOf('.');
+                const calleeDot = candidate.name.lastIndexOf('.');
+                if (callerDot >= 0 && calleeDot >= 0) {
+                    const callerPrefix = caller.name.substring(0, callerDot);
+                    const calleePrefix = candidate.name.substring(0, calleeDot);
+                    if (callerPrefix === calleePrefix) {
+                        callee = candidate;
+                    }
+                }
+            }
+        }
+        if (!callee)
+            continue;
+        // Deduplicate: skip if an edge with same from, to, and line already exists
+        if (edges.some(e => e.from === caller.id && e.to === callee.id && e.line === call.line))
+            continue;
+        const edge = { from: caller.id, to: callee.id, line: call.line };
+        if (call.callType)
+            edge.callType = call.callType;
+        edges.push(edge);
+    }
+    return edges;
+}

package/dist/graph/entryPointDetector.d.ts

@@ -0,0 +1,2 @@
+import { FunctionNode, CallEdge } from '../types';
+export declare function detectEntryPoints(nodes: FunctionNode[], edges: CallEdge[]): void;

package/dist/graph/entryPointDetector.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectEntryPoints = detectEntryPoints;
+function detectEntryPoints(nodes, edges) {
+    const nonSelfEdges = edges.filter(e => e.from !== e.to);
+    const calledIds = new Set(nonSelfEdges.map(e => e.to));
+    const callerIds = new Set(nonSelfEdges.map(e => e.from));
+    for (const node of nodes) {
+        node.isEntryPoint = node.isEntryPoint || (!calledIds.has(node.id) && callerIds.has(node.id));
+    }
+}

package/dist/graph/flowPartitioner.d.ts

@@ -0,0 +1,5 @@
+import { FunctionNode, CallEdge, Flow } from '../types';
+export declare function partitionFlows(nodes: FunctionNode[], edges: CallEdge[]): {
+    flows: Flow[];
+    orphans: string[];
+};

package/dist/graph/flowPartitioner.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.partitionFlows = partitionFlows;
+function partitionFlows(nodes, edges) {
+    const flows = [];
+    const visited = new Set();
+    const nonSelfEdges = edges.filter(e => e.from !== e.to);
+    // 1. BFS from every entry point (in-degree=0, out-degree>0)
+    const entryIds = findEntryIds(new Set(nodes.map(n => n.id)), nonSelfEdges);
+    for (const eid of entryIds) {
+        const reachable = bfs(eid, nonSelfEdges);
+        flows.push({ id: eid, entryPoint: eid, nodeIds: [...reachable] });
+        reachable.forEach(id => visited.add(id));
+    }
+    // 2. Iteratively find mini-flows in unvisited subgraph
+    let remaining = new Set(nodes.map(n => n.id).filter(id => !visited.has(id)));
+    while (remaining.size > 0) {
+        const subEdges = nonSelfEdges.filter(e => remaining.has(e.from) && remaining.has(e.to));
+        const subEntries = findEntryIds(remaining, subEdges);
+        if (subEntries.length === 0)
+            break;
+        for (const eid of subEntries) {
+            const reachable = bfs(eid, subEdges);
+            flows.push({ id: eid, entryPoint: eid, nodeIds: [...reachable] });
+            reachable.forEach(id => visited.add(id));
+        }
+        remaining = new Set([...remaining].filter(id => !visited.has(id)));
+    }
+    // 3. Remaining nodes with edges (pure cycles) → pick one per component
+    remaining = new Set([...remaining]);
+    if (remaining.size > 0) {
+        const subEdges = nonSelfEdges.filter(e => remaining.has(e.from) && remaining.has(e.to));
+        const nodesWithEdges = new Set();
+        for (const e of subEdges) {
+            nodesWithEdges.add(e.from);
+            nodesWithEdges.add(e.to);
+        }
+        const componentVisited = new Set();
+        for (const nid of nodesWithEdges) {
+            if (componentVisited.has(nid))
+                continue;
+            // BFS bidirectional to find connected component
+            const component = bfsBidirectional(nid, subEdges);
+            component.forEach(id => componentVisited.add(id));
+            // Pick the first node as synthetic entry
+            const syntheticEntry = nid;
+            const reachable = bfs(syntheticEntry, subEdges);
+            // Include all component members even if not forward-reachable
+            component.forEach(id => reachable.add(id));
+            flows.push({ id: syntheticEntry, entryPoint: syntheticEntry, nodeIds: [...reachable] });
+            reachable.forEach(id => visited.add(id));
+        }
+        remaining = new Set([...remaining].filter(id => !visited.has(id)));
+    }
+    // 4. True orphans — zero edges in the full graph
+    const orphans = [...remaining];
+    return { flows, orphans };
+}
+function findEntryIds(nodeIds, edges) {
+    const calledIds = new Set();
+    const callerIds = new Set();
+    for (const e of edges) {
+        if (nodeIds.has(e.from) && nodeIds.has(e.to)) {
+            calledIds.add(e.to);
+            callerIds.add(e.from);
+        }
+    }
+    return [...nodeIds].filter(id => !calledIds.has(id) && callerIds.has(id));
+}
+function bfs(startId, edges) {
+    const visited = new Set([startId]);
+    const queue = [startId];
+    while (queue.length) {
+        const current = queue.shift();
+        for (const edge of edges) {
+            if (edge.from === current && !visited.has(edge.to)) {
+                visited.add(edge.to);
+                queue.push(edge.to);
+            }
+        }
+    }
+    return visited;
+}
+function bfsBidirectional(startId, edges) {
+    const visited = new Set([startId]);
+    const queue = [startId];
+    while (queue.length) {
+        const current = queue.shift();
+        for (const edge of edges) {
+            if (edge.from === current && !visited.has(edge.to)) {
+                visited.add(edge.to);
+                queue.push(edge.to);
+            }
+            if (edge.to === current && !visited.has(edge.from)) {
+                visited.add(edge.from);
+                queue.push(edge.from);
+            }
+        }
+    }
+    return visited;
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './analyzer/treeSitter';
+export * from './analyzer/index';
+export * from './graph/callGraphBuilder';
+export * from './graph/entryPointDetector';
+export * from './graph/flowPartitioner';

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./analyzer/treeSitter"), exports);
+__exportStar(require("./analyzer/index"), exports);
+__exportStar(require("./graph/callGraphBuilder"), exports);
+__exportStar(require("./graph/entryPointDetector"), exports);
+__exportStar(require("./graph/flowPartitioner"), exports);