testeranto 0.202.0 → 0.205.0

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

@@ -1,8 +1,170 @@
 import express from "express";
+import Docker from "dockerode";
 const app = express();
+app.use(express.json());
+const docker = new Docker();
+// Track running services
+const runningServices = new Map();
+// Service to build file mapping
+const serviceBuildFiles = {
+    'node-build': 'src/builders/node.ts',
+    'web-build': 'src/builders/web.ts',
+    'golang-build': 'src/builders/golang.ts',
+    'python-build': 'src/builders/python.ts'
+};
+// Automatically start build services on mothership startup
+async function initializeServices() {
+    console.log('Initializing build services...');
+    for (const serviceName of Object.keys(serviceBuildFiles)) {
+        try {
+            // Get all containers
+            const containers = await docker.listContainers({ all: true });
+            // Find the container for the requested service
+            const containerInfo = containers.find(container => container.Names.some(name => name.includes(serviceName)));
+            if (containerInfo) {
+                const container = docker.getContainer(containerInfo.Id);
+                // Start the container if it's not running
+                if (containerInfo.State !== 'running') {
+                    console.log(`Starting ${serviceName}...`);
+                    await container.start();
+                }
+                else {
+                    console.log(`${serviceName} is already running`);
+                }
+                runningServices.set(serviceName, containerInfo.Id);
+            }
+            else {
+                console.warn(`Container for ${serviceName} not found`);
+            }
+        }
+        catch (error) {
+            console.error(`Error initializing ${serviceName}:`, error);
+        }
+    }
+    console.log('Build services initialization complete');
+}
+// Initialize services when mothership starts
+initializeServices();
 app.get("/", (req, res) => {
-    res.send("Hello World!");
+    res.send("Mothership is running");
+});
+// Start a specific service
+app.post("/services/:serviceName/start", async (req, res) => {
+    const { serviceName } = req.params;
+    try {
+        // Get all containers
+        const containers = await docker.listContainers({ all: true });
+        // Find the container for the requested service
+        const containerInfo = containers.find(container => container.Names.some(name => name.includes(serviceName)));
+        if (!containerInfo) {
+            return res.status(404).json({ error: `Service ${serviceName} not found` });
+        }
+        const container = docker.getContainer(containerInfo.Id);
+        // Start the container if it's not running
+        if (containerInfo.State !== 'running') {
+            await container.start();
+        }
+        runningServices.set(serviceName, containerInfo.Id);
+        res.status(200).json({
+            status: 'started',
+            service: serviceName,
+            containerId: containerInfo.Id
+        });
+    }
+    catch (error) {
+        console.error(`Error starting service ${serviceName}:`, error);
+        res.status(500).json({ error: `Failed to start service: ${error.message}` });
+    }
+});
+// Stop a specific service
+app.post("/services/:serviceName/stop", async (req, res) => {
+    const { serviceName } = req.params;
+    try {
+        const containerId = runningServices.get(serviceName);
+        if (!containerId) {
+            return res.status(404).json({ error: `Service ${serviceName} is not running` });
+        }
+        const container = docker.getContainer(containerId);
+        await container.stop();
+        runningServices.delete(serviceName);
+        res.status(200).json({
+            status: 'stopped',
+            service: serviceName
+        });
+    }
+    catch (error) {
+        console.error(`Error stopping service ${serviceName}:`, error);
+        res.status(500).json({ error: `Failed to stop service: ${error.message}` });
+    }
+});
+// Get status of all services
+app.get("/services", async (req, res) => {
+    try {
+        const containers = await docker.listContainers({ all: true });
+        const services = containers
+            .filter(container => container.Names.some(name => name.match(/_(node-build|web-build|golang-build|python-build|mothership)_/)))
+            .map(container => ({
+            name: container.Names[0].replace('/', ''),
+            id: container.Id,
+            status: container.State,
+            image: container.Image
+        }));
+        res.status(200).json({ services });
+    }
+    catch (error) {
+        console.error("Error listing services:", error);
+        res.status(500).json({ error: `Failed to list services: ${error.message}` });
+    }
+});
+// Trigger a build in a specific service
+app.post("/build/:serviceName", async (req, res) => {
+    const { serviceName } = req.params;
+    try {
+        const containerId = runningServices.get(serviceName);
+        if (!containerId) {
+            return res.status(404).json({ error: `Service ${serviceName} is not running` });
+        }
+        const container = docker.getContainer(containerId);
+        // Execute the build command in the container
+        const buildFile = serviceBuildFiles[serviceName];
+        if (!buildFile) {
+            return res.status(400).json({ error: `No build file configured for ${serviceName}` });
+        }
+        // Run the TypeScript build file using ts-node
+        const exec = await container.exec({
+            Cmd: ['npx', 'ts-node', '--transpile-only', buildFile],
+            AttachStdout: true,
+            AttachStderr: true
+        });
+        // Start the exec instance
+        const stream = await exec.start({ hijack: true, stdin: false });
+        // Collect output
+        let output = '';
+        stream.on('data', (chunk) => {
+            output += chunk.toString();
+        });
+        stream.on('end', () => {
+            res.status(200).json({
+                status: 'build completed',
+                service: serviceName,
+                output: output
+            });
+        });
+        stream.on('error', (error) => {
+            console.error(`Stream error for ${serviceName}:`, error);
+            res.status(500).json({ error: `Build stream error: ${error.message}` });
+        });
+    }
+    catch (error) {
+        console.error(`Error triggering build for ${serviceName}:`, error);
+        res.status(500).json({ error: `Failed to trigger build: ${error.message}` });
+    }
+});
+// Get build file for each service
+app.get("/build-files", (req, res) => {
+    res.status(200).json(serviceBuildFiles);
 });
+// Claim resource endpoint
 app.get("/claim", (req, res) => {
     const { resource } = req.query;
     console.log(`Resource claimed: ${resource}`);
@@ -10,7 +172,7 @@ app.get("/claim", (req, res) => {
 });
 export default (port) => {
     app.listen(port, () => {
-        console.log(`Example app listening on port ${port}`);
+        console.log(`Mothership listening on port ${port}`);
     });
     return app;
 };

package/dist/module/src/mothership/test.js

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import Testeranto from "../Node";
 import appFactory from "./index";
 const specification = (Suite, Given, When, Then) => {
@@ -5,11 +7,11 @@ const specification = (Suite, Given, When, Then) => {
     return [
         Suite.TheMothership("the mothership allows the coordination of test resources", {
             test0: Given.ItIsRunning([`a resource can be claimed`], [When.IClaimTheResource("test")], [Then.TheResourceIsClaimed("test")]),
-        }, []),
+        }),
     ];
 };
 const implementation = {
-    suites: { TheMothership: (x) => x },
+    suites: { TheMothership: "idk" },
     givens: { ItIsRunning: () => undefined },
     whens: {
         IClaimTheResource: (resource) => async (app, tr, pm) => {

package/dist/module/src/testeranto.js

@@ -2,19 +2,19 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import ansiC from "ansi-colors";
 import fs from "fs";
-import path from "path";
 import readline from "readline";
-import { getRunnables } from "./utils";
 import { AppHtml } from "./utils/buildTemplates";
-import webHtmlFrame from "./web.html";
-if (!process.env.GITHUB_CLIENT_ID) {
-    console.error(`env var "GITHUB_CLIENT_ID" needs to be set!`);
-    process.exit(-1);
-}
-if (!process.env.GITHUB_CLIENT_SECRET) {
-    console.error(`env var "GITHUB_CLIENT_SECRET" needs to be set!`);
-    process.exit(-1);
-}
+import { PitonoBuild } from "./PM/pitonoBuild";
+import { getRunnables } from "./app/backend/utils";
+const { GolingvuBuild } = await import("./PM/golingvuBuild");
+// if (!process.env.GITHUB_CLIENT_ID) {
+//   console.error(`env var "GITHUB_CLIENT_ID" needs to be set!`);
+//   process.exit(-1);
+// }
+// if (!process.env.GITHUB_CLIENT_SECRET) {
+//   console.error(`env var "GITHUB_CLIENT_SECRET" needs to be set!`);
+//   process.exit(-1);
+// }
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
     process.stdin.setRawMode(true);
@@ -24,9 +24,8 @@ if (mode !== "once" && mode !== "dev") {
     console.error(`The 3rd argument should be 'dev' or 'once', not '${mode}'.`);
     process.exit(-1);
 }
-const f = process.cwd() + "/" + "testeranto.config.ts";
-console.log("config file:", f);
-import(f).then(async (module) => {
+const configFilePath = process.cwd() + "/" + "testeranto.config.ts";
+import(configFilePath).then(async (module) => {
     const pckge = (await import(`${process.cwd()}/package.json`)).default;
     const bigConfig = module.default;
     const project = bigConfig.projects[testName];
@@ -48,7 +47,7 @@ import(f).then(async (module) => {
         process.exit(-1);
     }
     if (!rawConfig.tests) {
-        console.error(testName, "appears to have no tests: ", f);
+        console.error(testName, "appears to have no tests: ", configFilePath);
         console.error(`here is the config:`);
         console.log(JSON.stringify(rawConfig));
         process.exit(-1);
@@ -62,116 +61,116 @@ import(f).then(async (module) => {
             process.exit(-1);
         }
     });
+    //////////////////////////////////////////////////////////////////////////////////////////////////
     let pm = null;
     // Start PM_Main immediately - it will handle the build processes internally
-    const { PM_Main } = await import("./PM/main");
+    const { PM_Main } = await import("./app/backend/main");
     pm = new PM_Main(config, testName, mode);
     await pm.start();
-    fs.writeFileSync(`${process.cwd()}/testeranto/projects.html`, AppHtml());
+    fs.writeFileSync(`${process.cwd()}/testeranto/index.html`, AppHtml());
     Object.keys(bigConfig.projects).forEach((projectName) => {
-        console.log(`testeranto/reports/${projectName}`);
+        // console.log(`testeranto/reports/${projectName}`);
         if (!fs.existsSync(`testeranto/reports/${projectName}`)) {
             fs.mkdirSync(`testeranto/reports/${projectName}`);
         }
         fs.writeFileSync(`testeranto/reports/${projectName}/config.json`, JSON.stringify(config, null, 2));
     });
-    const getSecondaryEndpointsPoints = (runtime) => {
-        const meta = (ts, st) => {
-            ts.forEach((t) => {
-                if (t[1] === runtime) {
-                    st.add(t[0]);
-                }
-                if (Array.isArray(t[3])) {
-                    meta(t[3], st);
-                }
-            });
-            return st;
-        };
-        return Array.from(meta(config.tests, new Set()));
-    };
+    // const getSecondaryEndpointsPoints = (runtime?: IRunTime): string[] => {
+    //   const meta = (ts: ITestTypes[], st: Set<string>): Set<string> => {
+    //     ts.forEach((t) => {
+    //       if (t[1] === runtime) {
+    //         st.add(t[0]);
+    //       }
+    //       if (Array.isArray(t[3])) {
+    //         meta(t[3], st);
+    //       }
+    //     });
+    //     return st;
+    //   };
+    //   return Array.from(meta(config.tests, new Set()));
+    // };
     // Also handle pitono endpoints for HTML generation if needed
-    [...getSecondaryEndpointsPoints("python")].forEach(async (sourceFilePath) => {
-        // You might want to generate specific files for pitono tests here
-        console.log(`Pitono test found: ${sourceFilePath}`);
-    });
-    // Handle golang tests by generating their metafiles
+    // [...getSecondaryEndpointsPoints("python")].forEach(async (sourceFilePath) => {
+    //   // You might want to generate specific files for pitono tests here
+    //   console.log(`Pitono test found: ${sourceFilePath}`);
+    // });
+    // Promise.resolve(
+    //   Promise.all(
+    //     [...getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
+    //       const sourceFileSplit = sourceFilePath.split("/");
+    //       const sourceDir = sourceFileSplit.slice(0, -1);
+    //       const sourceFileName = sourceFileSplit[sourceFileSplit.length - 1];
+    //       const sourceFileNameMinusJs = sourceFileName
+    //         .split(".")
+    //         .slice(0, -1)
+    //         .join(".");
+    //       const htmlFilePath = path.normalize(
+    //         `${process.cwd()}/testeranto/bundles/web/${testName}/${sourceDir.join(
+    //           "/"
+    //         )}/${sourceFileNameMinusJs}.html`
+    //       );
+    //       const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
+    //       const cssFilePath = `./${sourceFileNameMinusJs}.css`;
+    //       return fs.promises
+    //         .mkdir(path.dirname(htmlFilePath), { recursive: true })
+    //         .then((x) =>
+    //           fs.writeFileSync(
+    //             htmlFilePath,
+    //             webHtmlFrame(jsfilePath, htmlFilePath, cssFilePath)
+    //           )
+    //         );
+    //     })
+    //   )
+    // );
+    const { nodeEntryPoints, nodeEntryPointSidecars, webEntryPoints, webEntryPointSidecars, pureEntryPoints, pureEntryPointSidecars, pythonEntryPoints, pythonEntryPointSidecars, golangEntryPoints, golangEntryPointSidecars, } = getRunnables(config.tests, testName);
+    // Debug logging to check if entry points are being found
+    console.log("Node entry points:", Object.keys(nodeEntryPoints));
+    console.log("Web entry points:", Object.keys(webEntryPoints));
+    console.log("Pure entry points:", Object.keys(pureEntryPoints));
+    // Handle golang tests using GolingvuBuild
     const golangTests = config.tests.filter((test) => test[1] === "golang");
     const hasGolangTests = golangTests.length > 0;
     if (hasGolangTests) {
-        // Import and use the golang metafile utilities
-        const { generateGolangMetafile, writeGolangMetafile } = await import("./utils/golingvuMetafile");
-        // Get the entry points (first element of each test tuple)
-        const golangEntryPoints = golangTests.map((test) => test[0]);
-        const metafile = await generateGolangMetafile(testName, golangEntryPoints);
-        writeGolangMetafile(testName, metafile);
-        // Mark golang as done after writing the metafile
-        // onGolangDone();
+        const golingvuBuild = new GolingvuBuild(config, testName);
+        const golangEntryPoints = await golingvuBuild.build();
+        golingvuBuild.onBundleChange(() => {
+            Object.keys(golangEntryPoints).forEach((entryPoint) => {
+                if (pm) {
+                    pm.addToQueue(entryPoint, "golang");
+                }
+            });
+        });
     }
     // Handle pitono (Python) tests by generating their metafiles
     const pitonoTests = config.tests.filter((test) => test[1] === "python");
     const hasPitonoTests = pitonoTests.length > 0;
     if (hasPitonoTests) {
-        // Import and use the pitono metafile utilities
-        const { generatePitonoMetafile } = await import("./utils/pitonoMetafile");
-        // Get the entry points (first element of each test tuple)
-        const pitonoEntryPoints = pitonoTests.map((test) => test[0]);
-        const metafile = await generatePitonoMetafile(testName, pitonoEntryPoints);
-        // Ensure the directory exists
-        const pitonoMetafilePath = `${process.cwd()}/testeranto/metafiles/python`;
-        await fs.promises.mkdir(pitonoMetafilePath, { recursive: true });
-        // Write the metafile to the specified path
-        fs.writeFileSync(`${pitonoMetafilePath}/core.json`, JSON.stringify(metafile, null, 2));
-        console.log(ansiC.green(ansiC.inverse(`Python metafile written to: ${pitonoMetafilePath}/core.json`)));
-        // Add Python tests to the processing queue
-        pitonoEntryPoints.forEach((entryPoint) => {
-            if (pm) {
-                // For Python tests, the source file is the entry point itself
-                pm.addToQueue(entryPoint, "python");
-            }
+        const pitonoBuild = new PitonoBuild(config, testName);
+        const pitonoEntryPoints = await pitonoBuild.build();
+        pitonoBuild.onBundleChange(() => {
+            Object.keys(pitonoEntryPoints).forEach((entryPoint) => {
+                if (pm) {
+                    pm.addToQueue(entryPoint, "python");
+                }
+            });
         });
     }
-    Promise.resolve(Promise.all([...getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
-        const sourceFileSplit = sourceFilePath.split("/");
-        const sourceDir = sourceFileSplit.slice(0, -1);
-        const sourceFileName = sourceFileSplit[sourceFileSplit.length - 1];
-        const sourceFileNameMinusJs = sourceFileName
-            .split(".")
-            .slice(0, -1)
-            .join(".");
-        const htmlFilePath = path.normalize(`${process.cwd()}/testeranto/bundles/web/${testName}/${sourceDir.join("/")}/${sourceFileNameMinusJs}.html`);
-        const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
-        const cssFilePath = `./${sourceFileNameMinusJs}.css`;
-        return fs.promises
-            .mkdir(path.dirname(htmlFilePath), { recursive: true })
-            .then((x) => fs.writeFileSync(htmlFilePath, webHtmlFrame(jsfilePath, htmlFilePath, cssFilePath)));
-    })));
-    const { nodeEntryPoints, nodeEntryPointSidecars, webEntryPoints, webEntryPointSidecars, pureEntryPoints, pureEntryPointSidecars, pythonEntryPoints, pythonEntryPointSidecars, } = getRunnables(config.tests, testName);
-    const x = [
+    // create the necessary folders for all tests
+    [
         ["pure", Object.keys(pureEntryPoints)],
         ["node", Object.keys(nodeEntryPoints)],
         ["web", Object.keys(webEntryPoints)],
         ["python", Object.keys(pythonEntryPoints)],
-    ];
-    x.forEach(async ([runtime, keys]) => {
+        ["golang", Object.keys(golangEntryPoints)],
+    ].forEach(async ([runtime, keys]) => {
         keys.forEach(async (k) => {
-            const folder = `testeranto/reports/${testName}/${k
+            fs.mkdirSync(`testeranto/reports/${testName}/${k
                 .split(".")
                 .slice(0, -1)
-                .join(".")}/${runtime}`;
-            await fs.mkdirSync(folder, { recursive: true });
-        });
-    });
-    [
-        [pureEntryPoints, pureEntryPointSidecars, "pure"],
-        [webEntryPoints, webEntryPointSidecars, "web"],
-        [nodeEntryPoints, nodeEntryPointSidecars, "node"],
-        [pythonEntryPoints, pythonEntryPointSidecars, "python"],
-    ].forEach(([eps, eps2, runtime]) => {
-        [...Object.keys(eps), ...Object.keys(eps2)].forEach((ep) => {
-            const fp = path.resolve(`testeranto`, `reports`, testName, ep.split(".").slice(0, -1).join("."), runtime);
-            fs.mkdirSync(fp, { recursive: true });
+                .join(".")}/${runtime}`, { recursive: true });
         });
     });
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
     process.stdin.on("keypress", (str, key) => {
         if (key.name === "q") {
             console.log("Testeranto is shutting down gracefully...");

package/dist/module/src/utils/generateGolingvuMetafile.js

@@ -0,0 +1,151 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import path from "path";
+import fs from "fs";
+import { findProjectRoot } from "./golingvuMetafile/helpers";
+import { collectGoDependencies } from "./golingvuMetafile/fileDiscovery";
+import { parseGoImports } from "./golingvuMetafile/importParser";
+let generationQueue = null;
+export async function generateGolingvuMetafile(testName, entryPoints) {
+    // If there's already a generation in progress, wait for it to complete
+    if (generationQueue) {
+        return generationQueue;
+    }
+    generationQueue = (async () => {
+        const inputs = {};
+        const outputs = {};
+        const signature = Date.now().toString(36);
+        // If entry points are provided, use them directly
+        // For test generation, we want to include test files
+        const filteredEntryPoints = [];
+        for (const entryPoint of entryPoints) {
+            // Skip if it's not a .go file
+            if (!entryPoint.endsWith(".go")) {
+                console.warn(`Skipping non-Go file: ${entryPoint}`);
+                continue;
+            }
+            // Check if the file exists and is a file
+            let resolvedPath = entryPoint;
+            if (!path.isAbsolute(entryPoint)) {
+                resolvedPath = path.join(process.cwd(), entryPoint);
+            }
+            if (!fs.existsSync(resolvedPath)) {
+                console.warn(`Entry point does not exist: ${resolvedPath}`);
+                continue;
+            }
+            if (!fs.statSync(resolvedPath).isFile()) {
+                console.warn(`Entry point is not a file: ${resolvedPath}`);
+                continue;
+            }
+            // Add to filtered entry points - don't skip test files for test generation
+            filteredEntryPoints.push(resolvedPath);
+        }
+        entryPoints = filteredEntryPoints;
+        // If no valid entry points remain, try to find Go files automatically
+        // For test generation, include all files including test files
+        // if (entryPoints.length === 0) {
+        //   const allGoFiles = findGoFilesInProject();
+        //   // Don't filter out test files
+        //   entryPoints = allGoFiles.filter((file) => {
+        //     const fileName = path.basename(file);
+        //     // Only exclude our generated files
+        //     return (
+        //       !fileName.endsWith(".golingvu.test.go") &&
+        //       !fileName.endsWith(".golingvu.go")
+        //     );
+        //   });
+        //   if (entryPoints.length === 0) {
+        //     console.warn("No Go files found in the project");
+        //   } else {
+        //     console.log(`Found ${entryPoints.length} Go files:`, entryPoints);
+        //   }
+        // }
+        // Process all valid entry points to collect their dependencies
+        const allDependencies = new Set();
+        const validEntryPoints = [];
+        for (let i = 0; i < entryPoints.length; i++) {
+            let entryPoint = entryPoints[i];
+            // Resolve and validate the entry point path
+            let resolvedPath = entryPoint;
+            if (!path.isAbsolute(entryPoint)) {
+                resolvedPath = path.join(process.cwd(), entryPoint);
+            }
+            if (!fs.existsSync(resolvedPath)) {
+                console.warn(`Entry point ${entryPoint} does not exist at ${resolvedPath}`);
+                continue;
+            }
+            // Update the entry point to use the resolved path
+            entryPoints[i] = resolvedPath;
+            entryPoint = resolvedPath;
+            // Don't skip test files for test generation
+            validEntryPoints.push(entryPoint);
+            // Collect dependencies for this entry point
+            const entryPointDependencies = collectGoDependencies(entryPoint);
+            entryPointDependencies.forEach((dep) => allDependencies.add(dep));
+        }
+        // Process all dependencies to add to inputs
+        for (const dep of allDependencies) {
+            if (!inputs[dep]) {
+                const bytes = fs.statSync(dep).size;
+                const imports = parseGoImports(dep);
+                // Check if this is a test file
+                const isTestFile = path.basename(dep).includes("_test.go") ||
+                    path.basename(dep).includes(".golingvu.test.go");
+                inputs[dep] = Object.assign({ bytes,
+                    imports, format: "esm" }, (isTestFile ? { testeranto: { isTest: true } } : {}));
+            }
+        }
+        // Generate the output path based on the project structure
+        // Always use the project root as the base
+        const projectRoot = findProjectRoot();
+        let outputKey = "";
+        if (validEntryPoints.length > 0) {
+            const firstEntryPoint = validEntryPoints[0];
+            // Get the relative path from project root to the entry point
+            const relativePath = path.relative(projectRoot, path.dirname(firstEntryPoint));
+            // Get the base name without extension
+            const baseName = path.basename(firstEntryPoint, ".go");
+            // Construct the output key
+            // Ensure relativePath is not empty
+            const outputPath = relativePath === "" ? baseName : path.join(relativePath, baseName);
+            outputKey = `golang/${path.basename(projectRoot)}/${outputPath}.golingvu.go`;
+        }
+        else {
+            // Fallback if no valid entry points
+            outputKey = `golang/core/main.golingvu.go`;
+        }
+        // Calculate total bytes from all inputs
+        const inputBytes = {};
+        let totalBytes = 0;
+        for (const inputPath in inputs) {
+            const bytes = inputs[inputPath].bytes;
+            inputBytes[inputPath] = { bytesInOutput: bytes };
+            totalBytes += bytes;
+        }
+        // Store the first valid entry point for use in the wrapper generation
+        const firstEntryPoint = validEntryPoints.length > 0 ? validEntryPoints[0] : "";
+        outputs[outputKey] = {
+            imports: [],
+            exports: [],
+            entryPoint: firstEntryPoint,
+            inputs: inputBytes,
+            bytes: totalBytes,
+            signature,
+        };
+        // If no valid entry points were found, log a warning
+        if (validEntryPoints.length === 0) {
+            console.warn("No valid Go files found to process");
+        }
+        const result = {
+            errors: [],
+            warnings: [],
+            metafile: {
+                inputs,
+                outputs,
+            },
+        };
+        generationQueue = null;
+        return result;
+    })();
+    return generationQueue;
+}