testeranto 0.202.0 → 0.203.0

package/dist/module/src/components/stateful/SingleProcessPage.js

@@ -1,100 +0,0 @@
-import React, { useState, useEffect, useCallback } from "react";
-import { useNavigate, useParams } from "react-router-dom";
-import { SingleProcessView } from "../pure/SingleProcessView";
-import { useWebSocket } from '../../App';
-export const SingleProcessPage = () => {
-    const [process, setProcess] = useState(null);
-    const ws = useWebSocket();
-    const [loading, setLoading] = useState(true);
-    const navigate = useNavigate();
-    const { processId } = useParams();
-    // Handle WebSocket messages
-    useEffect(() => {
-        if (!ws)
-            return;
-        // Set a timeout to handle cases where we don't get a response
-        const timeoutId = setTimeout(() => {
-            if (loading) {
-                setLoading(false);
-                // If we're still loading after 3 seconds, show an error
-                setProcess(null);
-            }
-        }, 3000);
-        const handleMessage = (event) => {
-            try {
-                const data = JSON.parse(event.data);
-                // Handle process data response - this should include all captured logs
-                if (data.type === "processData" && data.processId === processId) {
-                    setProcess({
-                        processId: data.processId,
-                        command: data.command,
-                        pid: data.pid,
-                        timestamp: data.timestamp,
-                        status: data.status || "running",
-                        exitCode: data.exitCode,
-                        error: data.error,
-                        // Use the logs sent from the server, which should include all captured logs
-                        logs: data.logs || [],
-                    });
-                    setLoading(false);
-                    clearTimeout(timeoutId);
-                }
-                // Handle new log messages that come after the initial data
-                else if ((data.type === "processStdout" || data.type === "processStderr") &&
-                    data.processId === processId) {
-                    setProcess((prev) => prev
-                        ? Object.assign(Object.assign({}, prev), { logs: [...(prev.logs || []), data.data] }) : null);
-                }
-                // Handle process completion
-                else if ((data.type === "processExited" || data.type === "processError") &&
-                    data.processId === processId) {
-                    setProcess((prev) => prev
-                        ? Object.assign(Object.assign({}, prev), { status: data.type === "processExited" ? "exited" : "error", exitCode: data.exitCode, error: data.error }) : null);
-                }
-            }
-            catch (error) {
-                console.error("Error parsing process message:", error);
-                setLoading(false);
-                setProcess(null);
-                clearTimeout(timeoutId);
-            }
-        };
-        ws.addEventListener("message", handleMessage);
-        // Request specific process when connected
-        if (ws.readyState === WebSocket.OPEN && processId) {
-            setLoading(true);
-            ws.send(JSON.stringify({
-                type: "getProcess",
-                processId,
-            }));
-        }
-        return () => {
-            ws.removeEventListener("message", handleMessage);
-            clearTimeout(timeoutId);
-        };
-    }, [ws, processId]);
-    // Try to find the process in the global state if WebSocket doesn't respond
-    useEffect(() => {
-        // This is a fallback - in a real implementation, you'd want to get this from a global state
-        // or through some other means
-    }, []);
-    const handleBack = useCallback(() => {
-        navigate("/processes");
-    }, [navigate]);
-    const handleKillProcess = useCallback((processId) => {
-        if (ws && ws.readyState === WebSocket.OPEN) {
-            console.log("Sending killProcess for:", processId);
-            ws.send(JSON.stringify({
-                type: "killProcess",
-                processId,
-            }));
-        }
-        else {
-            console.log("Cannot send killProcess - WebSocket not ready:", {
-                wsExists: !!ws,
-                wsReady: ws === null || ws === void 0 ? void 0 : ws.readyState,
-            });
-        }
-    }, [ws]);
-    return (React.createElement(SingleProcessView, { process: process, onBack: handleBack, loading: loading, onKillProcess: handleKillProcess, ws: ws }));
-};

package/dist/module/src/components/stateful/TestPage.js

@@ -1,233 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import React, { useEffect, useState } from 'react';
-import { useLocation, useNavigate, useParams } from 'react-router-dom';
-import { fetchTestData, summaryDotJson } from '../../utils/api';
-import { useWebSocket } from '../../App';
-import { TestPageView } from '../pure/TestPageView';
-export const TestPage = () => {
-    const navigate = useNavigate();
-    const location = useLocation();
-    const [route, setRoute] = useState('results');
-    const { isConnected } = useWebSocket();
-    // Sync route with hash changes
-    useEffect(() => {
-        const hash = location.hash.replace('#', '');
-        if (hash && ['results', 'logs', 'types', 'lint', 'coverage'].includes(hash)) {
-            setRoute(hash);
-        }
-        else {
-            setRoute('results');
-        }
-    }, [location.hash]);
-    const [testName, setTestName] = useState('');
-    // const [testData, setTestData] = useState(null);
-    const [logs, setLogs] = useState({});
-    // const [typeErrors, setTypeErrors] = useState('');
-    // const [lintErrors, setLintErrors] = useState('');
-    const [loading, setLoading] = useState(true);
-    const [error, setError] = useState(null);
-    const [testsExist, setTestsExist] = useState(true);
-    const [errorCounts, setErrorCounts] = useState({
-        typeErrors: 0,
-        staticErrors: 0,
-        runTimeErrors: 0
-    });
-    const [summary, setSummary] = useState(null);
-    const { projectName, '*': splat } = useParams();
-    const pathParts = splat ? splat.split('/') : [];
-    const runtime = pathParts.pop() || '';
-    const testPath = pathParts.join('/');
-    const decodedTestPath = testPath ? decodeURIComponent(testPath) : '';
-    useEffect(() => {
-        if (!projectName || !testPath || !runtime)
-            return;
-        setTestName(testPath);
-        const fetchData = async () => {
-            var _a;
-            try {
-                const [testResponse, metafileRes] = await Promise.all([
-                    fetchTestData(projectName, testPath, runtime),
-                    fetch(`metafiles/${runtime}/${projectName}.json`)
-                ]);
-                // console.log('Fetching test data for:', { projectName, testPath, runtime });
-                const receivedLogs = await testResponse.logs;
-                // console.log('Received logs:', Object.keys(receivedLogs));
-                let sourceFiles = {};
-                let buildLogs = {};
-                if (metafileRes.ok) {
-                    const metafile = await metafileRes.json();
-                    if ((_a = metafile === null || metafile === void 0 ? void 0 : metafile.metafile) === null || _a === void 0 ? void 0 : _a.outputs) {
-                        // Find input files only for this test's entry point
-                        const tsSources = new Set();
-                        const testEntryPoint = `src/${testPath}`;
-                        // First find all outputs that match this test
-                        const matchingOutputs = Object.entries(metafile.metafile.outputs)
-                            .filter(([outputPath, output]) => {
-                            const normalizedTestPath = testPath.replace(/\./g, '_');
-                            const testFileName = testPath.split('/').pop();
-                            const testBaseName = testFileName === null || testFileName === void 0 ? void 0 : testFileName.split('.').slice(0, -1).join('.');
-                            // Also check outputPath normalized for slashes replaced by underscores
-                            const normalizedOutputPath = outputPath.replace(/\//g, '_');
-                            return output.entryPoint === testEntryPoint ||
-                                outputPath.includes(normalizedTestPath) ||
-                                normalizedOutputPath.includes(normalizedTestPath) ||
-                                (testBaseName && outputPath.includes(testBaseName));
-                        });
-                        // Then collect all inputs from matching outputs
-                        matchingOutputs.forEach(([_, output]) => {
-                            Object.keys(output.inputs).forEach(inputPath => {
-                                // Check if this input is a source file (TypeScript or Go) and not in node_modules
-                                if ((inputPath.endsWith('.ts') || inputPath.endsWith('.tsx') || inputPath.endsWith('.go')) &&
-                                    !inputPath.includes('node_modules')) {
-                                    // Get the full input details from metafile.inputs
-                                    const inputDetails = metafile.metafile.inputs[inputPath];
-                                    if (inputDetails) {
-                                        tsSources.add(inputPath);
-                                        // Also include any imported source files (for TypeScript)
-                                        // Go files don't have imports in the same way, so we'll only process for TypeScript
-                                        if (inputPath.endsWith('.ts') || inputPath.endsWith('.tsx')) {
-                                            inputDetails.imports.forEach(imp => {
-                                                if ((imp.path.endsWith('.ts') || imp.path.endsWith('.tsx')) &&
-                                                    !imp.path.includes('node_modules') &&
-                                                    !imp.external) {
-                                                    tsSources.add(imp.path);
-                                                }
-                                            });
-                                        }
-                                    }
-                                }
-                            });
-                        });
-                        // Organize source files into directory tree structure
-                        const fileTree = {};
-                        const filesList = await Promise.all(Array.from(tsSources).map(async (filePath) => {
-                            try {
-                                const fetchPath = filePath.startsWith('/')
-                                    ? filePath
-                                    : `/${filePath.replace(/^\.\//, '')}`;
-                                const res = await fetch(fetchPath);
-                                if (res.ok) {
-                                    return {
-                                        path: filePath,
-                                        content: await res.text()
-                                    };
-                                }
-                                return null;
-                            }
-                            catch (err) {
-                                console.warn(`Failed to fetch source file ${filePath}:`, err);
-                                return null;
-                            }
-                        }));
-                        filesList.forEach(file => {
-                            if (!file)
-                                return;
-                            const parts = file.path.split('/');
-                            let currentLevel = fileTree;
-                            parts.forEach((part, index) => {
-                                if (!currentLevel[part]) {
-                                    if (index === parts.length - 1) {
-                                        currentLevel[part] = {
-                                            __isFile: true,
-                                            content: file.content
-                                        };
-                                    }
-                                    else {
-                                        currentLevel[part] = {};
-                                    }
-                                }
-                                currentLevel = currentLevel[part];
-                            });
-                        });
-                        sourceFiles = fileTree;
-                        buildLogs = metafile;
-                    }
-                }
-                // Add source files and build logs to logs
-                receivedLogs['source_files'] = sourceFiles;
-                receivedLogs['build_logs'] = buildLogs;
-                console.log('Source files structure:', sourceFiles);
-                console.log('Build logs:', buildLogs);
-                // Ensure tests.json is properly formatted
-                if (receivedLogs['tests.json']) {
-                    console.log('tests.json content type:', typeof receivedLogs['tests.json']);
-                    try {
-                        // Handle both string and already-parsed JSON
-                        if (typeof receivedLogs['tests.json'] === 'string') {
-                            receivedLogs['tests.json'] = JSON.parse(receivedLogs['tests.json']);
-                        }
-                        // If it's already an object, leave it as is
-                    }
-                    catch (e) {
-                        console.error('Failed to parse tests.json:', e);
-                        // Keep the original content but don't replace it with an error object
-                    }
-                }
-                setLogs(receivedLogs);
-                // setTypeErrors(testResponse.typeErrors);
-                // setLintErrors(testResponse.lintErrors);
-                try {
-                    const summaryResponse = await fetch(summaryDotJson(projectName));
-                    if (!summaryResponse.ok)
-                        throw new Error('Failed to fetch summary');
-                    const allSummaries = await summaryResponse.json();
-                    const testSummary = allSummaries[testPath];
-                    if (testSummary) {
-                        const counts = {
-                            typeErrors: Number(testSummary.typeErrors) || 0,
-                            staticErrors: Number(testSummary.staticErrors) || 0,
-                            runTimeErrors: Number(testSummary.runTimeErrors) || 0
-                        };
-                        setSummary(testSummary);
-                        setErrorCounts(counts);
-                        setTestsExist(testSummary.testsExist !== false);
-                    }
-                }
-                catch (err) {
-                    console.error('Failed to load summary:', err);
-                }
-                // Fetch build.json to get build errors and warnings
-                try {
-                    // The build.json is in the runtime directory directly under the test path
-                    // testPath is "src/lib/pmProxy.test/index.ts"
-                    // We need to use the directory path without the filename
-                    const pathParts = testPath.split('/');
-                    const fileName = pathParts.pop();
-                    const directoryPath = pathParts.join('/');
-                    // Construct the path without the filename without extension
-                    const buildUrl = `/reports/${projectName}/${directoryPath}/${runtime}/build.json`;
-                    console.log(`Fetching build.json from: ${buildUrl}`);
-                    const buildResponse = await fetch(buildUrl);
-                    if (buildResponse.ok) {
-                        const buildData = await buildResponse.json();
-                        console.log('Build data received:', buildData);
-                        // Add build errors and warnings to logs
-                        receivedLogs['build.json'] = buildData;
-                    }
-                    else {
-                        console.log('Build.json not found or not accessible, status:', buildResponse.status);
-                        // Add an empty build.json to logs to prevent errors
-                        receivedLogs['build.json'] = { errors: [], warnings: [] };
-                    }
-                }
-                catch (err) {
-                    console.log('No build.json found or error fetching it:', err);
-                    // Add an empty build.json to logs to prevent errors
-                    receivedLogs['build.json'] = { errors: [], warnings: [] };
-                }
-            }
-            catch (err) {
-                setError(err instanceof Error ? err.message : 'Unknown error');
-                setTestsExist(false);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        fetchData();
-    }, []);
-    if (!logs)
-        return React.createElement("div", null, "loading...");
-    return (React.createElement(React.Fragment, null,
-        React.createElement(TestPageView, { route: route, setRoute: setRoute, navigate: navigate, projectName: projectName, testName: testName, decodedTestPath: decodedTestPath, runtime: runtime, logs: logs, testsExist: testsExist, errorCounts: errorCounts, isWebSocketConnected: isConnected })));
-};

package/dist/module/src/components/stateful/TextEditorPage.js

@@ -1,117 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { Editor } from '@monaco-editor/react';
-import { FileTree } from './FileTree';
-export const TextEditorPage = () => {
-    const [files, setFiles] = useState([]);
-    const [activeFile, setActiveFile] = useState(null);
-    const [editorTheme, setEditorTheme] = useState('vs-dark');
-    // Initialize with sample files
-    useEffect(() => {
-        const sampleFiles = [
-            {
-                path: 'src/index.ts',
-                content: '// TypeScript code here\nconst message = "Hello World";\nconsole.log(message);',
-                language: 'typescript'
-            },
-            {
-                path: 'package.json',
-                content: '{\n  "name": "my-project",\n  "version": "1.0.0"\n}',
-                language: 'json'
-            }
-        ];
-        setFiles(sampleFiles);
-        setActiveFile(sampleFiles[0]);
-    }, []);
-    const handleFileSelect = (filePath) => {
-        const selectedFile = files.find(f => f.path === filePath);
-        if (selectedFile) {
-            setActiveFile(selectedFile);
-        }
-    };
-    const handleEditorChange = (value) => {
-        if (activeFile && value !== undefined) {
-            setFiles(files.map(f => f.path === activeFile.path ? Object.assign(Object.assign({}, f), { content: value }) : f));
-        }
-    };
-    const [widths, setWidths] = useState({
-        fileTree: 250,
-        editor: window.innerWidth - 550, // Initial editor width (total width minus side panels)
-        preview: 300
-    });
-    const containerStyle = {
-        display: 'flex',
-        height: '100vh',
-        width: '100%'
-    };
-    const panelStyle = {
-        height: '100%',
-        overflow: 'hidden',
-        position: 'relative'
-    };
-    const [isResizing, setIsResizing] = useState(false);
-    const [startX, setStartX] = useState(0);
-    const [startWidth, setStartWidth] = useState(0);
-    const startResizing = (e, panel) => {
-        setIsResizing(true);
-        setStartX(e.clientX);
-        setStartWidth(widths[panel]);
-    };
-    const resize = (e) => {
-        if (isResizing) {
-            const dx = e.clientX - startX;
-            const newFileTreeWidth = Math.max(200, Math.min(400, startWidth + dx));
-            setWidths({
-                fileTree: newFileTreeWidth,
-                editor: window.innerWidth - newFileTreeWidth - widths.preview,
-                preview: widths.preview
-            });
-        }
-    };
-    const stopResizing = () => {
-        setIsResizing(false);
-    };
-    useEffect(() => {
-        window.addEventListener('mousemove', resize);
-        window.addEventListener('mouseup', stopResizing);
-        return () => {
-            window.removeEventListener('mousemove', resize);
-            window.removeEventListener('mouseup', stopResizing);
-        };
-    }, [isResizing, startX, startWidth]);
-    return (React.createElement("div", { style: containerStyle },
-        React.createElement("div", { style: Object.assign(Object.assign({}, panelStyle), { width: widths.fileTree }) },
-            React.createElement(FileTree, { files: files, onSelect: handleFileSelect, activeFile: activeFile === null || activeFile === void 0 ? void 0 : activeFile.path }),
-            React.createElement("div", { style: {
-                    width: '4px',
-                    height: '100%',
-                    cursor: 'col-resize',
-                    backgroundColor: isResizing ? '#aaa' : '#ddd',
-                    position: 'absolute',
-                    right: 0,
-                    top: 0,
-                    zIndex: 1
-                }, onMouseDown: (e) => startResizing(e, 'fileTree') })),
-        React.createElement("div", { style: Object.assign(Object.assign({}, panelStyle), { width: widths.editor }) }, activeFile && (React.createElement(Editor, { height: "100%", path: activeFile.path, defaultLanguage: activeFile.language, defaultValue: activeFile.content, onChange: handleEditorChange, theme: editorTheme, options: {
-                minimap: { enabled: false },
-                fontSize: 14,
-                wordWrap: 'on',
-                automaticLayout: true
-            } }))),
-        React.createElement("div", { style: Object.assign(Object.assign({}, panelStyle), { width: widths.preview }) },
-            React.createElement("div", { style: {
-                    width: '4px',
-                    height: '100%',
-                    cursor: 'col-resize',
-                    backgroundColor: isResizing ? '#aaa' : '#ddd',
-                    position: 'absolute',
-                    left: 0,
-                    top: 0,
-                    zIndex: 1
-                }, onMouseDown: (e) => startResizing(e, 'editor') }),
-            activeFile && (React.createElement("div", null)
-            // <FilePreview 
-            //   content={activeFile.content}
-            //   language={activeFile.language}
-            // />
-            ))));
-};

package/dist/module/src/defaultConfig.js

@@ -1,17 +0,0 @@
-const config = {
-    src: "src",
-    tests: [],
-    debugger: true,
-    clearScreen: false,
-    minify: false,
-    ports: ["3001"],
-    externals: [],
-    nodePlugins: [],
-    webPlugins: [],
-    importPlugins: [],
-    webLoaders: {},
-    featureIngestor: function (s) {
-        throw new Error("Function not implemented.");
-    },
-};
-export default config;

package/dist/module/src/esbuildConfigs/consoleDetectorPlugin.js

@@ -1,32 +0,0 @@
-import fs from "fs";
-export const consoleDetectorPlugin = {
-    name: "console-detector",
-    setup(build) {
-        build.onLoad({ filter: /\.(js|ts)$/ }, async (args) => {
-            const contents = await fs.promises.readFile(args.path, "utf8");
-            const consolePattern = /console\.(log|error|warn|info|debug|trace|dir|dirxml|table|group|groupEnd|clear|count|countReset|assert|profile|profileEnd|time|timeLog|timeEnd|timeStamp|context|memory)/g;
-            const matches = contents.match(consolePattern);
-            if (matches) {
-                const uniqueMethods = [...new Set(matches)];
-                return {
-                    warnings: uniqueMethods.map((method) => ({
-                        text: `call of "${method}" was detected, which is not supported in the pure runtime.`,
-                        // location: {
-                        //   file: args.path,
-                        //   line:
-                        //     contents
-                        //       .split("\n")
-                        //       .findIndex((line) => line.includes(method)) + 1,
-                        //   column: 0,
-                        // },
-                    })),
-                };
-            }
-            return null;
-        });
-        build.onEnd((buildResult) => {
-            if (buildResult.warnings.find((br) => br.pluginName === "console-detector"))
-                console.warn(`Warning: An unsupported method call was detected in a source file used to build for the pure runtime. It is possible that this method call is in a comment block. If you really want to use this function, change this test to the "node" runtime.`);
-        });
-    },
-};

package/dist/module/src/esbuildConfigs/eslint-formatter-testeranto.js

@@ -1,18 +0,0 @@
-export default function (results) {
-    return results
-        .filter((r) => r.messages.length)
-        .map((r) => {
-        const path = r.filePath.replace(process.cwd() + "/", "");
-        return [
-            path,
-            ...r.messages.map((m) => {
-                var _a;
-                return [
-                    `${m.line}:${m.column} ${m.message} (${m.ruleId || ""})`,
-                    ...(((_a = m.suggestions) === null || _a === void 0 ? void 0 : _a.map((s) => `- ${s.message}${s.fix ? " (fix)" : ""}`)) || []),
-                ].join("\n");
-            }),
-        ].join("\n");
-    })
-        .join("\n\n");
-}

package/dist/module/src/esbuildConfigs/featuresPlugin.js

@@ -1,34 +0,0 @@
-import path from "path";
-export default {
-    name: "feature-markdown",
-    setup(build) {
-        build.onResolve({ filter: /\.md$/ }, (args) => {
-            if (args.resolveDir === "")
-                return;
-            return {
-                path: path.isAbsolute(args.path)
-                    ? args.path
-                    : path.join(args.resolveDir, args.path),
-                namespace: "feature-markdown",
-            };
-        });
-        build.onLoad({ filter: /.*/, namespace: "feature-markdown" }, async (args) => {
-            // const markdownContent = new TextDecoder().decode(
-            //   await fs.readFileSync(args.path)
-            // );
-            // markdownHTML = marked(markdownContent, options?.markedOptions);
-            return {
-                contents: `file://${args.path}`,
-                loader: "text",
-                // contents: JSON.stringify({ path: args.path }),
-                // loader: "json",
-                // contents: JSON.stringify({
-                //   // html: markdownHTML,
-                //   raw: markdownContent,
-                //   filename: args.path, //path.basename(args.path),
-                // }),
-                // loader: "json",
-            };
-        });
-    },
-};

package/dist/module/src/esbuildConfigs/index.js

@@ -1,19 +0,0 @@
-export default (config) => {
-    return {
-        // packages: "external",
-        target: "esnext",
-        format: "esm",
-        splitting: true,
-        outExtension: { ".js": ".mjs" },
-        outbase: ".",
-        jsx: "transform",
-        bundle: true,
-        minify: config.minify === true,
-        write: true,
-        loader: {
-            ".js": "jsx",
-            ".png": "binary",
-            ".jpg": "binary",
-        },
-    };
-};

package/dist/module/src/esbuildConfigs/inputFilesPlugin.js

@@ -1,25 +0,0 @@
-import fs from "fs";
-const otherInputs = {};
-const register = (entrypoint, sources) => {
-    if (!otherInputs[entrypoint]) {
-        otherInputs[entrypoint] = new Set();
-    }
-    sources.forEach((s) => otherInputs[entrypoint].add(s));
-};
-export default (platform, testName) => {
-    const f = `testeranto/metafiles/${platform}/${testName}.json`;
-    if (!fs.existsSync(`testeranto/metafiles/${platform}`)) {
-        fs.mkdirSync(`testeranto/metafiles/${platform}`, { recursive: true });
-    }
-    return {
-        register,
-        inputFilesPluginFactory: {
-            name: "metafileWriter",
-            setup(build) {
-                build.onEnd((result) => {
-                    fs.writeFileSync(f, JSON.stringify(result, null, 2));
-                });
-            },
-        },
-    };
-};

package/dist/module/src/esbuildConfigs/nativeImportDetectorPlugin.js

@@ -1,21 +0,0 @@
-import { isBuiltin } from "node:module";
-export const nativeImportDetectorPlugin = {
-    name: "native-node-import-filter",
-    setup(build) {
-        build.onResolve({ filter: /fs/ }, (args) => {
-            if (isBuiltin(args.path)) {
-                return {
-                    warnings: [
-                        {
-                            text: `cannot use native node package "${args.path}" in a "pure" test. If you really want to use this package, convert this test from "pure" to "node"`,
-                        },
-                    ],
-                };
-                // throw new Error(
-                //   `cannot use native node package "${args.path}" in a "pure" test. If you really want to use this package, convert this test from "pure" to "node"`
-                // );
-            }
-            return { path: args.path };
-        });
-    },
-};

package/dist/module/src/esbuildConfigs/node.js

@@ -1,19 +0,0 @@
-import baseEsBuildConfig from "./index.js";
-import inputFilesPlugin from "./inputFilesPlugin.js";
-import featuresPlugin from "./featuresPlugin";
-import rebuildPlugin from "./rebuildPlugin.js";
-export default (config, entryPoints, testName) => {
-    const { inputFilesPluginFactory, register } = inputFilesPlugin("node", testName);
-    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { splitting: true, outdir: `testeranto/bundles/node/${testName}/`, inject: [`./node_modules/testeranto/dist/cjs-shim.js`], metafile: true, supported: {
-            "dynamic-import": true,
-        }, define: {
-            "process.env.FLUENTFFMPEG_COV": "0",
-        }, absWorkingDir: process.cwd(), banner: {
-            js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
-        }, platform: "node", external: ["react", ...config.externals], entryPoints: [...entryPoints], plugins: [
-            featuresPlugin,
-            inputFilesPluginFactory,
-            rebuildPlugin("node"),
-            ...(config.nodePlugins.map((p) => p(register, entryPoints)) || []),
-        ] });
-};