@synergenius/flow-weaver 0.2.0

package/dist/mcp/workflow-executor.js

@@ -0,0 +1,133 @@
+/**
+ * Workflow executor for MCP-side compilation and execution.
+ * Copies source to a temp file, compiles all workflows in-place, then dynamically imports and executes.
+ */
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+import ts from 'typescript';
+import { compileWorkflow } from '../api/index.js';
+import { getAvailableWorkflows } from '../api/workflow-file-operations.js';
+/**
+ * Compiles and executes a workflow from a TypeScript source file.
+ * Copies the source to a temp file, compiles all workflows in-place (preserving sibling
+ * functions for workflow composition), injects a trace-capturing debugger, and dynamically
+ * imports and runs the target workflow function.
+ * @param filePath - Path to the workflow `.ts` source file.
+ * @param params - Parameters to pass to the workflow function.
+ * @param options - Execution options.
+ * @param options.workflowName - Name of a specific exported workflow function to execute.
+ *   If omitted, the first exported function is used.
+ * @param options.production - Enable production mode (no debug events). Defaults to `!includeTrace`.
+ * @param options.includeTrace - Whether to capture and return execution trace events. Defaults to `true`.
+ * @returns The workflow result, function name, execution time, and optional trace.
+ * @throws If no exported workflow function is found in the compiled module.
+ */
+export async function executeWorkflowFromFile(filePath, params, options) {
+    const resolvedPath = path.resolve(filePath);
+    const includeTrace = options?.includeTrace !== false;
+    // Copy source to temp file and compile ALL workflows in-place there.
+    // In-place compilation preserves all functions in the module (node types,
+    // sibling workflows), which is required for workflow composition where one
+    // workflow calls another as a node type.
+    const tmpBase = path.join(os.tmpdir(), `fw-exec-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    const tmpTsFile = `${tmpBase}.ts`;
+    const tmpFile = `${tmpBase}.mjs`;
+    try {
+        fs.copyFileSync(resolvedPath, tmpTsFile);
+        // Discover all workflows in the file
+        const source = fs.readFileSync(resolvedPath, 'utf8');
+        const allWorkflows = getAvailableWorkflows(source);
+        // Compile each workflow in-place so all function bodies are generated
+        for (const wf of allWorkflows) {
+            await compileWorkflow(tmpTsFile, {
+                write: true,
+                inPlace: true,
+                parse: { workflowName: wf.functionName },
+                generate: { production: options?.production ?? !includeTrace },
+            });
+        }
+        // Inject debugger binding: replace the TypeScript-only `declare const`
+        // with an actual assignment from globalThis so the executor can pass
+        // a trace-capturing debugger at runtime.
+        let compiledCode = fs.readFileSync(tmpTsFile, 'utf8');
+        compiledCode = compiledCode.replace('declare const __flowWeaverDebugger__: TDebugger | undefined;', 'const __flowWeaverDebugger__ = (globalThis as any).__fw_debugger__;');
+        // Transpile TypeScript to JavaScript so Node.js can import it directly
+        const jsOutput = ts.transpileModule(compiledCode, {
+            compilerOptions: {
+                module: ts.ModuleKind.ESNext,
+                target: ts.ScriptTarget.ESNext,
+                esModuleInterop: true,
+            },
+        });
+        fs.writeFileSync(tmpFile, jsOutput.outputText, 'utf8');
+        // Create debugger to capture trace events
+        const trace = [];
+        const debugger_ = includeTrace
+            ? {
+                sendEvent: (event) => {
+                    trace.push({
+                        type: event.type || 'UNKNOWN',
+                        timestamp: Date.now(),
+                        data: event,
+                    });
+                },
+                innerFlowInvocation: false,
+            }
+            : undefined;
+        // Set global debugger before import so compiled code picks it up
+        globalThis.__fw_debugger__ = debugger_;
+        // Set mock config for built-in nodes (delay, waitForEvent, invokeWorkflow)
+        if (options?.mocks) {
+            globalThis.__fw_mocks__ = options.mocks;
+        }
+        // Dynamic import (tsx runtime supports .ts imports)
+        const mod = await import(tmpFile);
+        // Find the target exported function
+        const exportedFn = findExportedFunction(mod, options?.workflowName);
+        if (!exportedFn) {
+            throw new Error(`No exported workflow function found${options?.workflowName ? ` named "${options.workflowName}"` : ''}`);
+        }
+        const startTime = Date.now();
+        // Execute the workflow function: (execute, params, abortSignal?)
+        // In-place compiled functions use the module-level debugger, not a parameter.
+        const result = await exportedFn.fn(true, params ?? {});
+        const executionTime = Date.now() - startTime;
+        return {
+            result,
+            functionName: exportedFn.name,
+            executionTime,
+            ...(includeTrace && { trace }),
+        };
+    }
+    finally {
+        // Clean up globals
+        delete globalThis.__fw_debugger__;
+        delete globalThis.__fw_mocks__;
+        // Clean up temp files
+        try {
+            fs.unlinkSync(tmpFile);
+        }
+        catch { /* ignore */ }
+        try {
+            fs.unlinkSync(tmpTsFile);
+        }
+        catch { /* ignore */ }
+    }
+}
+function findExportedFunction(mod, preferredName) {
+    // If a preferred name is specified, try it first
+    if (preferredName && typeof mod[preferredName] === 'function') {
+        return { name: preferredName, fn: mod[preferredName] };
+    }
+    // Find first exported function (skip default if it's not a function)
+    for (const [key, value] of Object.entries(mod)) {
+        if (key === '__esModule')
+            continue;
+        if (typeof value === 'function') {
+            return { name: key, fn: value };
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=workflow-executor.js.map

package/dist/migration/registry.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Edge-Case Migration Registry
+ *
+ * The parse → generate round-trip handles ~95% of migrations automatically:
+ * the parser adds defaults for missing fields, and the generator writes
+ * current syntax. This registry is only for rare cases where that
+ * round-trip can't handle a change (e.g., semantic renames, removed features).
+ *
+ * Expected growth: ~1-2 entries per year.
+ */
+import type { TWorkflowAST } from '../ast/types.js';
+export type MigrationFn = (ast: TWorkflowAST) => TWorkflowAST;
+export interface Migration {
+    /** Short descriptive name (e.g., "rename-executeWhen-to-branchingStrategy") */
+    name: string;
+    /** The migration transform */
+    apply: MigrationFn;
+}
+/**
+ * Apply all registered edge-case migrations to a workflow AST.
+ * Called after parsing, before regeneration.
+ */
+export declare function applyMigrations(ast: TWorkflowAST): TWorkflowAST;
+/**
+ * Get the list of registered migrations (for diagnostics/logging).
+ */
+export declare function getRegisteredMigrations(): ReadonlyArray<{
+    name: string;
+}>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/migration/registry.js

@@ -0,0 +1,29 @@
+/**
+ * Edge-Case Migration Registry
+ *
+ * The parse → generate round-trip handles ~95% of migrations automatically:
+ * the parser adds defaults for missing fields, and the generator writes
+ * current syntax. This registry is only for rare cases where that
+ * round-trip can't handle a change (e.g., semantic renames, removed features).
+ *
+ * Expected growth: ~1-2 entries per year.
+ */
+/**
+ * Registry of edge-case migrations. Starts empty.
+ * Add entries only when the parse→generate round-trip can't handle a change.
+ */
+const migrations = [];
+/**
+ * Apply all registered edge-case migrations to a workflow AST.
+ * Called after parsing, before regeneration.
+ */
+export function applyMigrations(ast) {
+    return migrations.reduce((current, migration) => migration.apply(current), ast);
+}
+/**
+ * Get the list of registered migrations (for diagnostics/logging).
+ */
+export function getRegisteredMigrations() {
+    return migrations.map((m) => ({ name: m.name }));
+}
+//# sourceMappingURL=registry.js.map

package/dist/node-types-generator.d.ts

@@ -0,0 +1,49 @@
+import type { TNodeTypeAST } from "./ast/types.js";
+export interface TNodeTypePort {
+    name: string;
+    defaultLabel: string;
+    reference: string;
+    type: string;
+    direction: "INPUT" | "OUTPUT";
+    defaultOrder: number;
+    defaultHidden?: boolean;
+    failure?: boolean;
+    defaultPlacement?: "TOP" | "BOTTOM" | "LEFT" | "RIGHT";
+    scope?: string;
+}
+export interface TPortConfig {
+    portName: string;
+    direction: "INPUT" | "OUTPUT";
+    order?: number;
+    label?: string;
+    expression?: string;
+}
+export interface TLocalFunctionNodeType {
+    name: string;
+    variant: "LOCAL_FUNCTION";
+    synchronicity: "SYNC" | "ASYNC" | "BOTH" | "UNKNOWN";
+    defaultLabel: string;
+    description: string;
+    category: string;
+    scopes: string[];
+    portConfigs: TPortConfig[];
+    ports: TNodeTypePort[];
+    defaultPullExecutionConfig?: {
+        method: string;
+    };
+    path: string;
+    projectPath: string;
+    function: string;
+    parameters: string[];
+}
+export declare class NodeTypesGenerator {
+    generateNodeType(node: TNodeTypeAST, filePath: string, projectPath: string): TLocalFunctionNodeType;
+    generateAllNodeTypes(nodes: TNodeTypeAST[], filePath: string, projectPath: string): TLocalFunctionNodeType[];
+    generateNodeTypesModule(nodes: TNodeTypeAST[], filePath: string, projectPath: string): string;
+    private formatLabel;
+    private extractDescription;
+    private extractParameters;
+    private determineSynchronicity;
+}
+export declare const nodeTypesGenerator: NodeTypesGenerator;
+//# sourceMappingURL=node-types-generator.d.ts.map

package/dist/node-types-generator.js

@@ -0,0 +1,139 @@
+import { RESERVED_PORT_NAMES, isExecutePort, isSuccessPort, isFailurePort, } from "./constants.js";
+export class NodeTypesGenerator {
+    generateNodeType(node, filePath, projectPath) {
+        const ports = [];
+        let portOrder = 0;
+        ports.push({
+            name: RESERVED_PORT_NAMES.EXECUTE,
+            defaultLabel: "Execute",
+            reference: RESERVED_PORT_NAMES.EXECUTE,
+            type: "STEP",
+            direction: "INPUT",
+            defaultOrder: portOrder++,
+        });
+        ports.push({
+            name: RESERVED_PORT_NAMES.ON_SUCCESS,
+            defaultLabel: "On Success",
+            reference: RESERVED_PORT_NAMES.ON_SUCCESS,
+            type: "STEP",
+            direction: "OUTPUT",
+            defaultOrder: portOrder++,
+        });
+        ports.push({
+            name: RESERVED_PORT_NAMES.ON_FAILURE,
+            defaultLabel: "On Failure",
+            reference: RESERVED_PORT_NAMES.ON_FAILURE,
+            type: "STEP",
+            direction: "OUTPUT",
+            failure: true,
+            defaultPlacement: "BOTTOM",
+            defaultOrder: portOrder++,
+        });
+        Object.entries(node.inputs).forEach(([portName, portConfig]) => {
+            if (isExecutePort(portName))
+                return;
+            ports.push({
+                name: portName,
+                defaultLabel: portConfig.label || this.formatLabel(portName),
+                reference: portName,
+                type: portConfig.dataType,
+                direction: "INPUT",
+                defaultOrder: portOrder++,
+                defaultHidden: portConfig.hidden,
+                ...(portConfig.scope && { scope: portConfig.scope }),
+            });
+        });
+        Object.entries(node.outputs).forEach(([portName, portConfig]) => {
+            if (isSuccessPort(portName) || isFailurePort(portName))
+                return;
+            ports.push({
+                name: portName,
+                defaultLabel: portConfig.label || this.formatLabel(portName),
+                reference: portName,
+                type: portConfig.dataType,
+                direction: "OUTPUT",
+                defaultOrder: portOrder++,
+                defaultHidden: portConfig.hidden,
+                ...(portConfig.scope && { scope: portConfig.scope }),
+            });
+        });
+        const functionText = node.functionText || '';
+        const parameters = this.extractParameters(functionText);
+        const synchronicity = this.determineSynchronicity(functionText);
+        const label = node.label || this.formatLabel(node.functionName);
+        const description = node.description ||
+            this.extractDescription(functionText) ||
+            `Node: ${label}`;
+        const category = "Custom";
+        return {
+            name: node.functionName,
+            variant: "LOCAL_FUNCTION",
+            synchronicity,
+            defaultLabel: label,
+            description,
+            category,
+            scopes: node.scope ? [node.scope] : node.scopes || [],
+            portConfigs: [],
+            ports,
+            defaultPullExecutionConfig: {
+                method: RESERVED_PORT_NAMES.EXECUTE,
+            },
+            path: filePath,
+            projectPath,
+            function: node.functionName,
+            parameters,
+        };
+    }
+    generateAllNodeTypes(nodes, filePath, projectPath) {
+        return nodes.map((node) => this.generateNodeType(node, filePath, projectPath));
+    }
+    generateNodeTypesModule(nodes, filePath, projectPath) {
+        const nodeTypes = this.generateAllNodeTypes(nodes, filePath, projectPath);
+        const lines = [];
+        lines.push("");
+        lines.push("");
+        lines.push("");
+        lines.push("import type { TLocalFunctionNodeType } from '@synergenius/flow-weaver';");
+        lines.push("");
+        lines.push("export const nodeTypes: TLocalFunctionNodeType[] = [");
+        nodeTypes.forEach((nodeType, idx) => {
+            lines.push(`  ${JSON.stringify(nodeType, null, 2)}${idx < nodeTypes.length - 1 ? "," : ""}`);
+        });
+        lines.push("];");
+        lines.push("");
+        nodeTypes.forEach((nodeType) => {
+            lines.push(`export const ${nodeType.name}NodeType = nodeTypes.find(n => n.name === '${nodeType.name}')!;`);
+        });
+        return lines.join("\n");
+    }
+    formatLabel(name) {
+        return name
+            .replace(/([A-Z])/g, " $1")
+            .replace(/^./, (str) => str.toUpperCase())
+            .trim();
+    }
+    extractDescription(functionText) {
+        const match = functionText.match(/\/\*\*\s*\n\s*\*\s*(.+?)\s*\n/);
+        return match ? match[1] : null;
+    }
+    extractParameters(functionText) {
+        const match = functionText.match(/function\s+\w+\s*\(([^)]*)\)/);
+        if (!match || !match[1])
+            return [];
+        return match[1]
+            .split(",")
+            .map((param) => param.trim().split(":")[0].trim())
+            .filter((p) => p.length > 0);
+    }
+    determineSynchronicity(functionText) {
+        if (functionText.includes("async function")) {
+            return "ASYNC";
+        }
+        if (!functionText.includes("await") && !functionText.includes("Promise")) {
+            return "SYNC";
+        }
+        return "BOTH";
+    }
+}
+export const nodeTypesGenerator = new NodeTypesGenerator();
+//# sourceMappingURL=node-types-generator.js.map

package/dist/npm-packages.d.ts

@@ -0,0 +1,56 @@
+/**
+ * NPM Package Type Resolution
+ *
+ * Functions for discovering and extracting type information from npm packages
+ * that have TypeScript declaration files (.d.ts).
+ */
+import type { TDataType } from './ast/types.js';
+/**
+ * Port definition compatible with TNodeType.ports
+ */
+export type TNpmPackagePort = {
+    name: string;
+    defaultLabel?: string;
+    reference?: string;
+    type: TDataType;
+    direction: 'INPUT' | 'OUTPUT';
+    scope?: string;
+};
+/**
+ * Node type for npm package functions
+ */
+export type TNpmNodeType = {
+    name: string;
+    variant: 'FUNCTION';
+    category: string;
+    function: string;
+    label: string;
+    importSource: string;
+    ports: TNpmPackagePort[];
+    synchronicity: 'SYNC' | 'ASYNC';
+    description: string;
+};
+/**
+ * Get list of packages that have TypeScript declarations (.d.ts files).
+ * Excludes @types/* packages as they are type augmentations.
+ *
+ * @param workdir - Directory to start searching from
+ * @param nodeModulesOverride - Optional explicit node_modules path (for testing)
+ * @returns Object with packages array, each containing name and typesPath
+ */
+export declare function getTypedPackages(workdir: string, nodeModulesOverride?: string): {
+    packages: Array<{
+        name: string;
+        typesPath: string | null;
+    }>;
+};
+/**
+ * Get function exports from a package's .d.ts file and return as TNodeType[].
+ *
+ * @param packageName - The npm package name
+ * @param workdir - Directory to start searching from
+ * @param nodeModulesOverride - Optional explicit node_modules path (for testing)
+ * @returns Array of node types for the package's exported functions
+ */
+export declare function getPackageExports(packageName: string, workdir: string, nodeModulesOverride?: string): TNpmNodeType[];
+//# sourceMappingURL=npm-packages.d.ts.map

package/dist/npm-packages.js

@@ -0,0 +1,255 @@
+/**
+ * NPM Package Type Resolution
+ *
+ * Functions for discovering and extracting type information from npm packages
+ * that have TypeScript declaration files (.d.ts).
+ */
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { resolvePackageTypesPath } from './resolve-package-types.js';
+import { extractFunctionLikes } from './function-like.js';
+import { inferDataTypeFromTS } from './type-mappings.js';
+import { getSharedProject } from './shared-project.js';
+/**
+ * Find all node_modules directories starting from fromDir and walking up.
+ */
+function findNodeModulesDirs(fromDir) {
+    const dirs = [];
+    let current = path.resolve(fromDir);
+    const root = path.parse(current).root;
+    while (current !== root) {
+        const candidate = path.join(current, 'node_modules');
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+            dirs.push(candidate);
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return dirs;
+}
+/**
+ * List all packages in a node_modules directory (including scoped packages).
+ */
+function listPackagesInNodeModules(nmDir) {
+    const packages = [];
+    if (!fs.existsSync(nmDir))
+        return packages;
+    try {
+        const entries = fs.readdirSync(nmDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            // Handle scoped packages (@scope/pkg)
+            if (entry.name.startsWith('@')) {
+                const scopeDir = path.join(nmDir, entry.name);
+                try {
+                    const scopedEntries = fs.readdirSync(scopeDir, { withFileTypes: true });
+                    for (const scopedEntry of scopedEntries) {
+                        if (scopedEntry.isDirectory()) {
+                            packages.push(`${entry.name}/${scopedEntry.name}`);
+                        }
+                    }
+                }
+                catch {
+                    // Ignore permission errors
+                }
+            }
+            else {
+                // Regular package
+                packages.push(entry.name);
+            }
+        }
+    }
+    catch {
+        // Ignore permission errors
+    }
+    return packages;
+}
+/**
+ * Get list of packages that have TypeScript declarations (.d.ts files).
+ * Excludes @types/* packages as they are type augmentations.
+ *
+ * @param workdir - Directory to start searching from
+ * @param nodeModulesOverride - Optional explicit node_modules path (for testing)
+ * @returns Object with packages array, each containing name and typesPath
+ */
+export function getTypedPackages(workdir, nodeModulesOverride) {
+    const nodeModulesDirs = nodeModulesOverride
+        ? [nodeModulesOverride]
+        : findNodeModulesDirs(workdir);
+    const typed = [];
+    const seenPackages = new Set();
+    for (const nmDir of nodeModulesDirs) {
+        const packages = listPackagesInNodeModules(nmDir);
+        for (const pkg of packages) {
+            // Skip @types/* packages - they are type augmentations, not actual packages
+            if (pkg.startsWith('@types/'))
+                continue;
+            // Skip if already seen (from a closer node_modules)
+            if (seenPackages.has(pkg))
+                continue;
+            seenPackages.add(pkg);
+            // Check if package has types
+            const typesPath = resolvePackageTypesPath(pkg, workdir, nodeModulesOverride);
+            if (typesPath) {
+                typed.push({ name: pkg, typesPath });
+            }
+        }
+    }
+    return { packages: typed };
+}
+/**
+ * Capitalize first letter of a string.
+ */
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * Infer node type from a function declaration in a .d.ts file.
+ */
+function inferNodeTypeFromDtsFunction(fn, packageName, _dtsPath) {
+    const fnName = fn.getName();
+    if (!fnName)
+        return null;
+    const ports = [];
+    // Add execute input port (mandatory)
+    ports.push({
+        name: 'execute',
+        defaultLabel: 'Execute',
+        reference: 'execute',
+        type: 'STEP',
+        direction: 'INPUT',
+    });
+    // Infer inputs from parameters
+    for (const param of fn.getParameters()) {
+        const paramName = param.getName();
+        const tsType = param.getType().getText(param);
+        const dataType = inferDataTypeFromTS(tsType);
+        ports.push({
+            name: paramName,
+            defaultLabel: capitalize(paramName),
+            reference: paramName,
+            type: dataType,
+            direction: 'INPUT',
+        });
+    }
+    // Infer outputs from return type
+    let returnType = fn.getReturnType();
+    const returnTypeText = returnType.getText();
+    let isAsync = false;
+    // Unwrap Promise<T>
+    if (returnTypeText.startsWith('Promise<')) {
+        isAsync = true;
+        const typeArgs = returnType.getTypeArguments();
+        if (typeArgs && typeArgs.length > 0) {
+            returnType = typeArgs[0];
+        }
+    }
+    const unwrappedText = returnType.getText();
+    if (unwrappedText !== 'void' && unwrappedText !== 'undefined') {
+        const primitiveTypes = new Set(['string', 'number', 'boolean', 'any', 'unknown', 'never']);
+        const isPrimitive = primitiveTypes.has(unwrappedText);
+        const isArray = unwrappedText.endsWith('[]') || unwrappedText.startsWith('Array<');
+        const properties = returnType.getProperties();
+        const isObjectLike = !isPrimitive && !isArray && returnType.isObject() && properties.length > 0;
+        if (isObjectLike) {
+            // Multiple output ports from object properties
+            for (const prop of properties) {
+                const propName = prop.getName();
+                if (propName === 'onSuccess' || propName === 'onFailure')
+                    continue;
+                const propType = prop.getTypeAtLocation(fn.getTypeResolutionNode());
+                const propTypeText = propType.getText();
+                const dataType = inferDataTypeFromTS(propTypeText);
+                ports.push({
+                    name: propName,
+                    defaultLabel: capitalize(propName),
+                    reference: propName,
+                    type: dataType,
+                    direction: 'OUTPUT',
+                });
+            }
+        }
+        else {
+            // Single result output port
+            const dataType = inferDataTypeFromTS(unwrappedText);
+            ports.push({
+                name: 'result',
+                defaultLabel: 'Result',
+                reference: 'result',
+                type: dataType,
+                direction: 'OUTPUT',
+            });
+        }
+    }
+    // Add mandatory control flow output ports
+    ports.push({
+        name: 'onSuccess',
+        defaultLabel: 'On Success',
+        reference: 'onSuccess',
+        type: 'STEP',
+        direction: 'OUTPUT',
+    });
+    ports.push({
+        name: 'onFailure',
+        defaultLabel: 'On Failure',
+        reference: 'onFailure',
+        type: 'STEP',
+        direction: 'OUTPUT',
+    });
+    return {
+        name: `npm/${packageName}/${fnName}`,
+        variant: 'FUNCTION',
+        category: 'NPM Packages',
+        function: fnName,
+        label: fnName,
+        importSource: packageName,
+        ports,
+        synchronicity: isAsync ? 'ASYNC' : 'SYNC',
+        description: `${fnName} from ${packageName}`,
+    };
+}
+/**
+ * Get function exports from a package's .d.ts file and return as TNodeType[].
+ *
+ * @param packageName - The npm package name
+ * @param workdir - Directory to start searching from
+ * @param nodeModulesOverride - Optional explicit node_modules path (for testing)
+ * @returns Array of node types for the package's exported functions
+ */
+export function getPackageExports(packageName, workdir, nodeModulesOverride) {
+    const typesPath = resolvePackageTypesPath(packageName, workdir, nodeModulesOverride);
+    if (!typesPath) {
+        return [];
+    }
+    try {
+        const project = getSharedProject();
+        const dtsContent = fs.readFileSync(typesPath, 'utf-8');
+        // Create source file with unique path to avoid conflicts
+        const virtualPath = `__npm_exports__/${packageName}/${Date.now()}.d.ts`;
+        const dtsFile = project.createSourceFile(virtualPath, dtsContent, { overwrite: true });
+        const functions = extractFunctionLikes(dtsFile);
+        const nodeTypes = [];
+        const seenFunctionNames = new Set();
+        for (const fn of functions) {
+            const fnName = fn.getName();
+            // Skip duplicates (can happen with re-exports or declaration merging)
+            if (!fnName || seenFunctionNames.has(fnName))
+                continue;
+            seenFunctionNames.add(fnName);
+            const nodeType = inferNodeTypeFromDtsFunction(fn, packageName, typesPath);
+            if (nodeType) {
+                nodeTypes.push(nodeType);
+            }
+        }
+        // Clean up the temporary source file
+        project.removeSourceFile(dtsFile);
+        return nodeTypes;
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=npm-packages.js.map