testeranto 0.62.0 → 0.73.0

package/src/Project.ts

@@ -1,11 +1,9 @@
 import esbuild from "esbuild";
 import fs from "fs";
 import path from "path";
-import readline from 'readline';
+import readline from "readline";
 import { glob } from "glob";
 
-import { IBaseConfig, IRunTime, ITestTypes } from "./Types";
-
 import esbuildNodeConfiger from "./esbuildConfigs/node.js";
 import esbuildWebConfiger from "./esbuildConfigs/web.js";
 import esbuildFeaturesConfiger from "./esbuildConfigs/features.js";
@@ -13,31 +11,62 @@ import esbuildFeaturesConfiger from "./esbuildConfigs/features.js";
 import webHtmlFrame from "./web.html.js";
 import reportHtmlFrame from "./report.html.js";
 
-import childProcess from 'child_process';
+import { ITestTypes, IBaseConfig, IRunTime } from "./lib/types.js";
+
+var mode: "DEV" | "PROD" = process.argv[2] === "-dev" ? "DEV" : "PROD";
 
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY) process.stdin.setRawMode(true);
 
-const getRunnables = (
-  tests: ITestTypes[],
-  payload = [new Set<string>(), new Set<string>()]
-): [Set<string>, Set<string>] => {
-  return tests.reduce((pt, cv, cndx, cry) => {
-
-    if (cv[1] === "node") {
-      pt[0].add(cv[0]);
-    } else if (cv[1] === "web") {
-      pt[1].add(cv[0]);
-    }
-
-    if (cv[2].length) {
-      getRunnables(cv[2], payload);
-    }
-
-    return pt;
-  }, payload as [Set<string>, Set<string>]);
-
-}
+process.stdin.on("keypress", (str, key) => {
+  if (key.name === "q") {
+    console.log("Testeranto-EsBuild is shutting down...");
+    mode = "PROD";
+    onDone();
+  }
+});
+
+// setInterval(() => {
+//   const memoryUsage = process.memoryUsage();
+//   console.log("Memory usage:", memoryUsage);
+// }, 10000); // Check every 10 seconds
+
+let featuresDone,
+  nodeDone,
+  webDone = false;
+const onFeaturesDone = () => {
+  featuresDone = true;
+  onDone();
+};
+const onNodeDone = () => {
+  nodeDone = true;
+  onDone();
+};
+const onWebDone = () => {
+  webDone = true;
+  onDone();
+};
+
+const onDone = () => {
+  console.log(
+    JSON.stringify(
+      {
+        featuresDone,
+        nodeDone,
+        webDone,
+        mode,
+      },
+      null,
+      2
+    )
+  );
+  if (featuresDone && nodeDone && webDone && mode === "PROD") {
+    console.log("Testeranto-EsBuild is all done. Goodbye!");
+    process.exit();
+  } else {
+    console.log("Testeranto-EsBuild is still working...");
+  }
+};
 
 export class ITProject {
   config: IBaseConfig;
@@ -46,107 +75,137 @@ export class ITProject {
   constructor(config: IBaseConfig) {
     this.config = config;
 
-    process.stdin.on('keypress', (str, key) => {
-      if (key.name === 'q') {
-        this.initiateShutdown("'q' command")
-      }
-    });
-    process.stdin.on('keypress', (str, key) => {
-      if (key.name === 'x') {
-        console.log("Shutting down hard!")
-        process.exit(-1)
-      }
-    });
-
-    const childElectron = childProcess.spawn("yarn", ["electron", "node_modules/testeranto/dist/common/electron.js"]);
-    // childElectron.stdout.on('data', function (msg) {
-    //   console.log(msg.toString())
-    // });
-    const fileStream = fs.createWriteStream(`./${this.config.outdir}/electron.log`);
-    childElectron.stdout?.pipe(fileStream);
-
-    Promise.resolve(Promise.all(
-      [
-        ...this.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()}/${config.outdir}/web/${sourceDir.join("/")}/${sourceFileNameMinusJs}.html`);
-          const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
-
-          return fs.promises.mkdir(path.dirname(htmlFilePath), { recursive: true }).then(x => fs.writeFileSync(htmlFilePath, webHtmlFrame(jsfilePath, htmlFilePath)
-          ))
-        })
-    ));
+    Promise.resolve(
+      Promise.all(
+        [...this.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()}/${config.outdir}/web/${sourceDir.join(
+                "/"
+              )}/${sourceFileNameMinusJs}.html`
+            );
+            const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
+
+            return fs.promises
+              .mkdir(path.dirname(htmlFilePath), { recursive: true })
+              .then((x) =>
+                fs.writeFileSync(
+                  htmlFilePath,
+                  webHtmlFrame(jsfilePath, htmlFilePath)
+                )
+              );
+          }
+        )
+      )
+    );
 
     const [nodeEntryPoints, webEntryPoints] = getRunnables(this.config.tests);
 
-    glob(`./${config.outdir}/chunk-*.mjs`, { ignore: 'node_modules/**' }).then((chunks) => {
-      console.log("deleting chunks", chunks)
-      chunks.forEach((chunk) => {
-        console.log("deleting chunk", chunk)
-        fs.unlinkSync(chunk);
-      })
+    // nodeEntryPoints.forEach((nep) => {
+    //   const f = `${process.cwd()}/${nep}`;
+    //   console.log("nep", f);
+    //   import(f).then((module) => {
+    //     return module.default.then((defaultModule) => {
+    //       console.log("defaultModule", defaultModule);
+    //       // defaultModule
+    //       //   .receiveTestResourceConfig(argz)
+    //       //   .then((x) => {
+    //       //     console.log("then", x);
+    //       //     return x;
+    //       //   })
+    //       //   .catch((e) => {
+    //       //     console.log("catch", e);
+    //       //   });
+    //     });
+    //   });
+    // });
 
-    })
+    glob(`./${config.outdir}/chunk-*.mjs`, { ignore: "node_modules/**" }).then(
+      (chunks) => {
+        chunks.forEach((chunk) => {
+          fs.unlinkSync(chunk);
+        });
+      }
+    );
 
-    fs.copyFileSync("node_modules/testeranto/dist/prebuild/report.js", "./docs/Report.js")
-    fs.copyFileSync("node_modules/testeranto/dist/prebuild/report.css", "./docs/Report.css")
+    fs.copyFileSync(
+      "./node_modules/testeranto/dist/prebuild/Report.js",
+      "./docs/Report.js"
+    );
+    fs.copyFileSync(
+      "./node_modules/testeranto/dist/prebuild/Report.css",
+      "./docs/Report.css"
+    );
 
     fs.writeFileSync(`${config.outdir}/report.html`, reportHtmlFrame());
 
     Promise.all([
-      esbuild.context(esbuildFeaturesConfiger(config))
+      fs.promises.writeFile(
+        `${config.outdir}/testeranto.json`,
+        JSON.stringify(
+          {
+            ...config,
+            buildDir: process.cwd() + "/" + config.outdir,
+          },
+          null,
+          2
+        )
+      ),
+      esbuild
+        .context(esbuildFeaturesConfiger(config))
         .then(async (featuresContext) => {
-          console.log("features entry points", config.features);
-          await featuresContext.watch();
+          if (mode == "DEV") {
+            await featuresContext.watch();
+            onFeaturesDone();
+          } else {
+            featuresContext.rebuild().then((v) => {
+              onFeaturesDone();
+            });
+          }
+
           return featuresContext;
         }),
-      esbuild.context(esbuildNodeConfiger(config, nodeEntryPoints))
+      esbuild
+        .context(esbuildNodeConfiger(config, nodeEntryPoints))
         .then(async (nodeContext) => {
-          console.log("node entry points", nodeEntryPoints);
-          await nodeContext.watch();
+          if (mode == "DEV") {
+            await nodeContext.watch().then((v) => {
+              onNodeDone();
+            });
+          } else {
+            nodeContext.rebuild().then((v) => {
+              onNodeDone();
+            });
+          }
+
           return nodeContext;
         }),
-      esbuild.context(esbuildWebConfiger(config, webEntryPoints))
-        .then(async (esbuildWeb) => {
-          console.log("web entry points", webEntryPoints);
-          await esbuildWeb.watch();
-          return esbuildWeb;
+      esbuild
+        .context(esbuildWebConfiger(config, webEntryPoints))
+        .then(async (webContext) => {
+          if (mode == "DEV") {
+            await webContext.watch().then((v) => {
+              onWebDone();
+            });
+          } else {
+            webContext.rebuild().then((v) => {
+              onWebDone();
+            });
+          }
+          return webContext;
         }),
-
-    ]).then(async (contexts) => {
-      Promise.all(
-        config.tests.map(async ([test, runtime]) => {
-          return {
-            test,
-            runtime
-          };
-        })
-      ).then(async (modules) => {
-        fs.writeFileSync(`${config.outdir}/testeranto.json`, JSON.stringify(
-          {
-            modules,
-            buildDir: process.cwd() + "/" + config.outdir
-          }, null, 2));
-      });
-
-      if (config.devMode === false) {
-        console.log("Your tests were built but not run because devMode was false. Exiting gracefully");
-        process.exit(0);
-
-      } else {
-        // no-op
-      }
-    })
+    ]);
   }
 
   public getSecondaryEndpointsPoints(runtime?: IRunTime): string[] {
-
     const meta = (ts: ITestTypes[], st: Set<string>): Set<string> => {
       ts.forEach((t) => {
         if (t[1] === runtime) {
@@ -155,523 +214,28 @@ export class ITProject {
         if (Array.isArray(t[2])) {
           meta(t[2], st);
         }
-      })
+      });
       return st;
-    }
+    };
     return Array.from(meta(this.config.tests, new Set()));
   }
-
-  public initiateShutdown(reason: string) {
-    console.log("Shutdown initiated because", reason);
-    this.mode = "down";
-  }
-
-  // private shutdown() {
-  //   let i = 0;
-  //   new Promise((res, reh) => {
-  //     console.log("final results: ");
-  //     const procsTable: any[] = [];
-  //     // pm2.list((err, procs) => {
-  //     //   procs.forEach((proc, ndx) => {
-  //     //     const exitCode = this.exitCodes[proc.name as string]
-  //     //     if (exitCode !== 0) {
-  //     //       i++;
-  //     //     }
-  //     //     procsTable.push({
-  //     //       name: proc.name,
-  //     //       pm_id: proc.pm_id,
-  //     //       exitCode
-  //     //     })
-
-  //     //     if (ndx === procs.length - 1) {
-  //     //       console.table(procsTable);
-  //     //       res(i)
-  //     //     }
-  //     //   })
-  //     // })
-  //   }).then((failures: number) => {
-  //     // pm2.stop("all", (e) => console.error(e));
-  //     // pm2.disconnect();
-  //     console.log(`gracefully exiting with ${failures} failures`)
-  //     process.exit(failures);
-  //   })
-  // }
-
-  // private spinner() {
-  //   this.spinCycle = (this.spinCycle + 1) % this.spinAnimation.length;
-  //   return this.spinAnimation[this.spinCycle];
-  // }
-
-  // private async releaseTestResourceWs(payload: any) {
-  //   const name = payload.data.testResourceConfiguration.name;
-  //   const failed = payload.data.failed;
-
-  //   this.exitCodes[name] = failed;
-
-  //   Object.keys(this.ports).forEach((port: string) => {
-  //     if (this.ports[port] === name) {
-  //       this.ports[port] = OPEN_PORT;
-  //     }
-  //   });
-  // }
-
-  // private async releaseTestResourcePm2(payload: IAdios) {
-  //   const name = payload.testResourceConfiguration.name;
-  //   const failed = payload.failed;
-
-  //   this.exitCodes[name] = failed;
-
-  //   // pm2.list((err, processes) => {
-  //   //   processes.forEach((proc: pm2.ProcessDescription) => {
-  //   //     if (proc.name === name) {
-  //   //       Object.keys(this.ports).forEach((port: string) => {
-  //   //         if (this.ports[port] === name) {
-  //   //           this.ports[port] = OPEN_PORT;
-  //   //         }
-  //   //       });
-  //   //     }
-  //   //   });
-  //   // });
-  // }
-
-  // private allocateViaWs(resourceRequest: {
-  //   requirement: ITTestResourceRequirement;
-  //   protocol: ISchedulerProtocols;
-  // }) {
-
-  //   const name = resourceRequest.requirement.name;
-  //   const testResourceRequirement = resourceRequest.requirement;
-
-  //   const websocket = this.websockets[name];
-
-  //   if (testResourceRequirement?.ports === 0) {
-  //     websocket.send(JSON.stringify({
-  //       data: {
-  //         testResourceConfiguration: {
-  //           ports: [],
-  //         },
-  //       }
-  //     }));
-  //   } else if ((testResourceRequirement?.ports || 0) > 0) {
-  //     // clear any port-slots associated with this job
-  //     Object.values(this.ports).forEach((jobMaybe, portNumber) => {
-  //       if (jobMaybe && jobMaybe === name) {
-  //         this.ports[portNumber] = OPEN_PORT;
-  //       }
-  //     });
-
-  //     // find a list of open ports
-  //     const foundOpenPorts = Object.keys(this.ports).filter(
-  //       (p) => this.ports[p] === OPEN_PORT
-  //     );
-
-  //     if (foundOpenPorts.length >= testResourceRequirement.ports) {
-  //       const selectionOfPorts = foundOpenPorts.slice(
-  //         0,
-  //         testResourceRequirement.ports
-  //       );
-
-  //       websocket.send(JSON.stringify({
-  //         data: {
-  //           testResourceConfiguration: {
-  //             ports: selectionOfPorts,
-  //           },
-  //         }
-  //       }));
-
-  //       // mark the selected ports as occupied
-  //       for (const foundOpenPort of selectionOfPorts) {
-  //         this.ports[foundOpenPort] = name;
-  //       }
-  //     } else {
-  //       console.log(
-  //         `no port was open so send the ${name} job to the back of the resourceQueue`
-  //       );
-  //       this.resourceQueue.push(resourceRequest);
-  //     }
-  //   }
-  // }
-
-  // private allocateViaIpc(resourceRequest: {
-  //   requirement: ITTestResourceRequirement;
-  //   protocol: ISchedulerProtocols;
-  // }) {
-  //   const pName = resourceRequest.requirement.name;
-  //   const testResourceRequirement = resourceRequest.requirement;
-
-  //   // pm2.list((err, processes) => {
-  //   //   console.error(err);
-  //   //   processes.forEach((p) => {
-  //   //     if (p.name === pName && p.pid) {
-  //   //       const message = {
-  //   //         // these fields must be present
-  //   //         id: p.pid,
-  //   //         topic: "some topic",
-  //   //         type: "process:msg",
-
-  //   //         // Data to be sent
-  //   //         data: {
-  //   //           testResourceConfiguration: {
-  //   //             ports: [],
-  //   //             // fs: fPath,
-  //   //           },
-  //   //           id: p.pm_id,
-  //   //         },
-  //   //       };
-
-  //   //       if (testResourceRequirement?.ports === 0) {
-  //   //         pm2.sendDataToProcessId(
-  //   //           p.pm_id as number,
-  //   //           message,
-  //   //           function (err, res) {
-  //   //             // console.log("sendDataToProcessId", err, res, message);
-  //   //           }
-  //   //         );
-  //   //       }
-
-  //   //       if ((testResourceRequirement?.ports || 0) > 0) {
-  //   //         // clear any port-slots associated with this job
-  //   //         Object.values(this.ports).forEach((jobMaybe, portNumber) => {
-  //   //           if (jobMaybe && jobMaybe === pName) {
-  //   //             this.ports[portNumber] = OPEN_PORT;
-  //   //           }
-  //   //         });
-
-  //   //         // find a list of open ports
-  //   //         const foundOpenPorts = Object.keys(this.ports).filter(
-  //   //           (p) => this.ports[p] === OPEN_PORT
-  //   //         );
-  //   //         // if there are enough open port-slots...
-  //   //         if (foundOpenPorts.length >= testResourceRequirement.ports) {
-  //   //           const selectionOfPorts = foundOpenPorts.slice(
-  //   //             0,
-  //   //             testResourceRequirement.ports
-  //   //           );
-
-  //   //           const message = {
-  //   //             // these fields must be present
-  //   //             id: p.pid, // id of process from "pm2 list" command or from pm2.list(errback) method
-  //   //             topic: "some topic",
-  //   //             // process:msg will be send as 'message' on target process
-  //   //             type: "process:msg",
-
-  //   //             // Data to be sent
-  //   //             data: {
-  //   //               testResourceConfiguration: {
-  //   //                 // fs: fPath,
-  //   //                 ports: selectionOfPorts,
-  //   //               },
-  //   //               id: p.pid,
-  //   //             },
-  //   //           };
-  //   //           pm2.sendDataToProcessId(
-  //   //             p.pm_id as number,
-  //   //             message,
-  //   //             function (err, res) {
-  //   //               // no-op
-  //   //             }
-  //   //           );
-  //   //           // mark the selected ports as occupied
-  //   //           for (const foundOpenPort of selectionOfPorts) {
-  //   //             this.ports[foundOpenPort] = p.pid.toString();
-  //   //           }
-  //   //         } else {
-  //   //           console.log(
-  //   //             `no port was open so send the ${p.pid} job to the back of the resourceQueue`
-  //   //           );
-  //   //           this.resourceQueue.push(resourceRequest);
-  //   //         }
-  //   //       }
-  //   //     }
-  //   //   })
-  //   // })
-  // }
-
-  // private mainLoop = async () => {
-  //   if (this.clearScreen) {
-  //     console.clear();
-  //   }
-
-  //   const procsTable: any[] = [];
-  //   //     pm2.list((err, procs) => {
-  //   //       procs.forEach((proc) => {
-  //   //         procsTable.push({
-  //   //           name: proc.name,
-  //   //           pid: proc.pid,
-  //   //           pm_id: proc.pm_id,
-  //   //           mem: proc.monit?.memory,
-  //   //           cpu: proc.monit?.cpu,
-  //   //           "exit code": this.exitCodes[proc.name as string]
-  //   //         })
-  //   //       })
-  //   //       console.table(procsTable);
-
-  //   //       console.table(this.resourceQueue);
-  //   //       console.log("webSocketServer.clients", Object.keys(this.websockets));
-
-  //   //       const resourceRequest = this.resourceQueue.pop();
-
-  //   //       if (!resourceRequest) {
-  //   //         if (!this.devMode && this.mode === "up") {
-  //   //           this.initiateShutdown("resource request queue is empty");
-  //   //         }
-
-  //   //         if (
-  //   //           this.mode === "down" &&
-  //   //           (
-  //   //             procsTable.every(
-  //   //               (p) => p.pid === 0 || p.pid === undefined
-  //   //             ) ||
-  //   //             procsTable.length === 0
-  //   //           )
-  //   //         ) {
-  //   //           this.shutdown();
-  //   //         }
-  //   //       } else {
-  //   //         if (resourceRequest.protocol === "ipc") {
-  //   //           this.allocateViaIpc(resourceRequest)
-  //   //         } else if (resourceRequest.protocol === "ws") {
-  //   //           this.allocateViaWs(resourceRequest)
-  //   //         }
-  //   //       }
-
-  //   //       const upMessage = `
-  //   //   Running tests while watching for changes.
-  //   //   Use 'q' to initiate shutdown and 'x' to kill.
-  //   //   esbuild web server - ${JSON.stringify(this.esWebServerDetails)}
-  //   // `;
-  //   //       const downMessage = "Shutdown is in progress. Please wait.";
-  //   //       if (this.devMode) {
-  //   //         if (this.mode === "up") {
-  //   //           console.log(this.spinner(), upMessage);
-  //   //         } else {
-  //   //           console.log(this.spinner(), downMessage);
-  //   //         }
-
-  //   //       } else {
-  //   //         if (this.mode === "up") {
-  //   //           console.log(this.spinner(), upMessage);
-  //   //         } else {
-  //   //           console.log(this.spinner(), downMessage);
-  //   //         }
-  //   //       }
-  //   //     });
-  // };
 }
 
-// pm2.connect(async (err) => {
-//   if (err) {
-//     console.error(err);
-//     process.exit(-1);
-//   } else {
-//     console.log(`pm2 is connected`);
-//   }
-
-//   // run a websocket as an alternative to node IPC
-//   webSocketServer = new WebSocketServer({
-//     port: 8080,
-//     host: "localhost",
-//   });
-
-//   webSocketServer.on('open', () => {
-//     console.log('open');
-//   });
-
-//   webSocketServer.on('close', (data) => {
-//     console.log('webSocketServer close: %s', data);
-//   });
-
-//   webSocketServer.on('listening', () => {
-//     console.log("webSocketServer listening", webSocketServer.address());
-//   });
-
-//   webSocketServer.on('connection', (webSocket: WebSocket) => {
-//     webSocket.on('message', (webSocketData) => {
-//       const payload = JSON.parse(webSocketData.valueOf().toString() as any);
-//       const messageType = payload.type;
-
-//       if (messageType === "testeranto:hola") {
-//         const name = payload.data.requirement.name;
-//         const requestedResources = payload.data;
-
-//         this.websockets[name] = webSocket
-//         console.log('hola WS! connected: ' + name + ' in ' + Object.getOwnPropertyNames(this.websockets))
-//         this.requestResource(requestedResources.requirement, 'ws');
-
-//       } else if (messageType === "testeranto:adios") {
-//         console.log("adios WS", payload.data.testResourceConfiguration.name);
-//         this.releaseTestResourceWs(payload as any);
-//       }
-
-//     });
-//   });
-
-//   const makePath = (fPath: string, rt: IRunTime): string => {
-//     return path.resolve("./" + config.outdir + "/" +
-//       rt +
-//       // (rt === "electron" || rt === "chromium" ? "web" : "node") +
-//       "/" + fPath.replace(path.extname(fPath), "") + ".mjs");
-//   };
-
-//   const bootInterval = setInterval(async () => {
-//     const filesToLookup = this.tests
-//       .map(([p, rt]) => {
-//         const filepath = makePath(p, rt);
-//         return {
-//           filepath,
-//           exists: fsExists(filepath),
-//         };
-//       });
-//     const allFilesExist = (
-//       await Promise.all(filesToLookup.map((f) => f.exists))
-//     ).every((b) => b);
-
-//     if (!allFilesExist) {
-//       console.log(this.spinner(), "waiting for files to build...")
-//       filesToLookup.forEach((f) => {
-//         console.log(f.exists, "\t", f.filepath);
-//       })
-
-//     } else {
-//       clearInterval(bootInterval);
-
-//       pm2.launchBus((err, pm2_bus) => {
-//         pm2_bus.on("testeranto:hola", (packet: { data: { requirement: ITTestResourceRequirement } }) => {
-//           this.requestResource(
-//             packet.data.requirement,
-//             'ipc'
-//           );
-//         });
-
-//         pm2_bus.on("testeranto:adios", (payload: IAdiosIPC) => {
-//           this.releaseTestResourcePm2(payload.data);
-//         });
-//       });
-
-//       this
-//         .tests
-//         .reduce((m, [inputFilePath, runtime]) => {
-//           const script = makePath(inputFilePath, runtime);
-//           const partialTestResourceByCommandLineArg = `${script} '${JSON.stringify(
-//             {
-//               name: inputFilePath,
-//               ports: [],
-//               fs: path.resolve(
-//                 process.cwd(),
-//                 config.outdir,
-//                 inputFilePath
-//               ),
-//             }
-//           )}'`;
-
-//           if (runtime === "web") {
-//             pm2.start(electron_pm2_StartOptions(
-//               partialTestResourceByCommandLineArg,
-//               inputFilePath,
-//               config
-//             ),
-//               (err, proc) => {
-//                 if (err) {
-//                   console.error(err);
-//                   return pm2.disconnect();
-//                 }
-//               }
-//             );
-
-//             // } else if (runtime === "chromium") {
-//             //   pm2.start(
-//             //     chromium_pm2_StartOptions(
-//             //       partialTestResourceByCommandLineArg,
-//             //       inputFilePath,
-//             //       config,
-//             //     ),
-//             //     (err, proc) => {
-//             //       if (err) {
-//             //         console.error(err);
-//             //         return pm2.disconnect();
-//             //       }
-//             //     }
-//             //   );
-
-//           } else if (runtime === "node") {
-//             const resolvedPath = path.resolve(script);
-
-//             console.log("watching", resolvedPath);
-//             pm2.start(node_pm2_StartOptions(
-//               partialTestResourceByCommandLineArg,
-//               inputFilePath,
-//               config,
-//               resolvedPath
-//             ), (err, proc) => {
-//               if (err) {
-//                 console.error(err);
-//                 return pm2.disconnect();
-//               }
-//             });
-//           }
-
-//           this.exitCodes[inputFilePath] = null;
-//           return [inputFilePath, ...m];
-//         }, []);
-//       setInterval(this.mainLoop, TIMEOUT).unref();
-//     }
-//   }, TIMEOUT).unref();
-// });
-// public requestResource(
-//   requirement: ITTestResourceRequirement,
-//   protocol: ISchedulerProtocols
-// ) {
-//   this.resourceQueue.push({ requirement, protocol });
-// }
-// const OPEN_PORT = "";
-
-// type ISchedulerProtocols = `ipc` | `ws`;
-
-// type IAdios = {
-//   name: string;
-//   failed: any;
-//   testResourceConfiguration: {
-//     name: string;
-//   };
-//   results: {
-//     fails: any[];
-//     givens: any[];
-//     name: string;
-//   };
-// };
-
-// type IAdiosIPC = {
-//   process: {
-//     namespace: string;
-//     versioning: object;
-//     name: string;
-//     pm_id: number;
-//   };
-//   data: IAdios
-//   at: string;
-// };
-// clearScreen: boolean;
-// devMode: boolean;
-// exitCodes: Record<number, string> = {};
-// features: TesterantoFeatures;
-
-// ports: Record<string, string> = {};
-// tests: ITestTypes[];
-// websockets: Record<string, WebSocket> = {};
-
-// resourceQueue: {
-//   requirement: ITTestResourceRequirement,
-//   protocol: ISchedulerProtocols,
-// }[] = [];
+const getRunnables = (
+  tests: ITestTypes[],
+  payload = [new Set<string>(), new Set<string>()]
+): [Set<string>, Set<string>] => {
+  return tests.reduce((pt, cv, cndx, cry) => {
+    if (cv[1] === "node") {
+      pt[0].add(cv[0]);
+    } else if (cv[1] === "web") {
+      pt[1].add(cv[0]);
+    }
 
-// private spinCycle = 0;
-// private spinAnimation = "←↖↑↗→↘↓↙";
-// console.log("sending", JSON.stringify(this.tests));
-// childElectron.stdin.write(JSON.stringify(this.tests));
-// not necessary
-// this.esWebServerDetails = await eWeb.serve({
-//   servedir: jsonConfig.outdir,
-// });
+    if (cv[3].length) {
+      getRunnables(cv[3], payload);
+    }
 
-// fs.copyFileSync("node_modules/testeranto/dist/index.css", "index.css")
-// 
+    return pt;
+  }, payload as [Set<string>, Set<string>]);
+};