testeranto 0.129.0 → 0.135.0

package/dist/prebuild/run.mjs

@@ -1,20 +1,17 @@
 import { createRequire } from 'module';const require = createRequire(import.meta.url);
 
 // src/run.ts
-import ansiC2 from "ansi-colors";
+import ansiC3 from "ansi-colors";
 import readline from "readline";
 
 // src/PM/main.ts
 import { spawn } from "node:child_process";
-import ts from "typescript";
 import net from "net";
-import fs2, { watch } from "fs";
-import path3 from "path";
+import fs3, { watch } from "fs";
+import path4 from "path";
 import puppeteer from "puppeteer-core";
-import ansiC from "ansi-colors";
+import ansiC2 from "ansi-colors";
 import crypto from "node:crypto";
-import { ESLint } from "eslint";
-import tsc from "tsc-prog";
 
 // src/utils.ts
 import path from "path";
@@ -50,8 +47,11 @@ var promptPather = (entryPoint, platform, projectName) => {
 };
 var getRunnables = (tests, projectName, payload = {
   nodeEntryPoints: {},
+  nodeEntryPointSidecars: {},
   webEntryPoints: {},
-  importEntryPoints: {}
+  webEntryPointSidecars: {},
+  pureEntryPoints: {},
+  pureEntryPointSidecars: {}
 }) => {
   return tests.reduce((pt, cv, cndx, cry) => {
     if (cv[1] === "node") {
@@ -63,14 +63,71 @@ var getRunnables = (tests, projectName, payload = {
         `./testeranto/bundles/web/${projectName}/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
       );
     } else if (cv[1] === "pure") {
-      pt.importEntryPoints[cv[0]] = path.resolve(
+      pt.pureEntryPoints[cv[0]] = path.resolve(
         `./testeranto/bundles/pure/${projectName}/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
       );
     }
+    cv[3].filter((t) => t[1] === "node").forEach((t) => {
+      pt.nodeEntryPointSidecars[`${t[0]}`] = path.resolve(
+        `./testeranto/bundles/node/${projectName}/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
+      );
+    });
+    cv[3].filter((t) => t[1] === "web").forEach((t) => {
+      pt.webEntryPointSidecars[`${t[0]}`] = path.resolve(
+        `./testeranto/bundles/web/${projectName}/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
+      );
+    });
+    cv[3].filter((t) => t[1] === "pure").forEach((t) => {
+      pt.pureEntryPointSidecars[`${t[0]}`] = path.resolve(
+        `./testeranto/bundles/pure/${projectName}/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
+      );
+    });
     return pt;
   }, payload);
 };
 
+// src/utils/queue.ts
+var Queue = class {
+  constructor() {
+    this.items = [];
+  }
+  enqueue(element) {
+    this.items.push(element);
+  }
+  dequeue() {
+    if (this.isEmpty()) {
+      return "Queue is empty";
+    }
+    return this.items.shift();
+  }
+  peek() {
+    if (this.isEmpty()) {
+      return "Queue is empty";
+    }
+    return this.items[0];
+  }
+  isEmpty() {
+    return this.items.length === 0;
+  }
+  size() {
+    return this.items.length;
+  }
+  clear() {
+    this.items = [];
+  }
+  print() {
+    console.log(this.items.join(" -> "));
+  }
+};
+
+// src/PM/PM_WithEslintAndTsc.ts
+import ts from "typescript";
+import fs2 from "fs";
+import path3 from "path";
+import ansiC from "ansi-colors";
+import { ESLint } from "eslint";
+import tsc from "tsc-prog";
+
 // src/PM/base.ts
 import fs from "fs";
 import path2 from "path";
@@ -84,7 +141,7 @@ var PM_Base = class {
     this.configs = configs;
   }
   customclose() {
-    throw new Error("Method not implemented.");
+    throw new Error("customclose not implemented.");
   }
   waitForSelector(p, s) {
     return new Promise((res) => {
@@ -103,8 +160,8 @@ var PM_Base = class {
       });
     });
   }
-  newPage() {
-    return this.browser.newPage();
+  async newPage() {
+    return (await this.browser.newPage()).mainFrame()._id;
   }
   goto(p, url) {
     return new Promise((res) => {
@@ -117,9 +174,9 @@ var PM_Base = class {
   $(selector, p) {
     return new Promise((res) => {
       this.doInPage(p, async (page) => {
-        const x = page.$(selector);
-        const y = await x;
-        res(y !== null);
+        const x = await page.$(selector);
+        const y = await x?.jsonValue();
+        res(y);
       });
     });
   }
@@ -149,7 +206,7 @@ var PM_Base = class {
     await sPromise;
     return sPromise;
   }
-  async customScreenShot(ssOpts, testName2, page) {
+  async customScreenShot(ssOpts, testName2, pageUid) {
     const p = ssOpts.path;
     const dir = path2.dirname(p);
     fs.mkdirSync(dir, {
@@ -159,6 +216,9 @@ var PM_Base = class {
       files[testName2] = /* @__PURE__ */ new Set();
     }
     files[testName2].add(ssOpts.path);
+    const page = (await this.browser.pages()).find(
+      (p2) => p2.mainFrame()._id === pageUid
+    );
     const sPromise = page.screenshot({
       ...ssOpts,
       path: p
@@ -266,8 +326,8 @@ var PM_Base = class {
       res(x);
     });
   }
-  page() {
-    throw new Error("Method not implemented.");
+  page(p) {
+    return p;
   }
   click(selector, page) {
     return page.click(selector);
@@ -282,14 +342,27 @@ var PM_Base = class {
       return page.keyboard.type(value);
     });
   }
-  getValue(value, p) {
+  // setValue(value: string, p: string) {
+  //   this.doInPage(p, (page) => {
+  //     return page.keyboard.type(value);
+  //   });
+  // }
+  getAttribute(selector, attribute, p) {
     this.doInPage(p, (page) => {
-      return page.keyboard.type(value);
+      return page.$eval(selector, (input) => input.getAttribute(attribute));
     });
   }
-  getAttribute(selector, attribute, p) {
-    this.doInPage(p, (page) => {
-      return page.$eval(selector, (input) => input.getAttribute("value"));
+  async getInnerHtml(selector, p) {
+    return new Promise((res, rej) => {
+      this.doInPage(p, async (page) => {
+        const e = await page.$(selector);
+        if (!e) {
+          rej();
+        } else {
+          const text = await (await e.getProperty("textContent")).jsonValue();
+          res(text);
+        }
+      });
     });
   }
   isDisabled(selector, p) {
@@ -304,93 +377,23 @@ var PM_Base = class {
   }
   async doInPage(p, cb) {
     (await this.browser.pages()).forEach((page) => {
-      if (page.mainFrame()._id === p) {
+      const frame = page.mainFrame();
+      if (frame._id === p) {
         return cb(page);
       }
     });
   }
 };
 
-// src/PM/main.ts
+// src/PM/PM_WithEslintAndTsc.ts
 var eslint = new ESLint();
 var formatter = await eslint.loadFormatter(
   "./node_modules/testeranto/dist/prebuild/esbuildConfigs/eslint-formatter-testeranto.mjs"
 );
-var changes = {};
-var fileHashes = {};
-var files2 = {};
-var screenshots2 = {};
-async function fileHash(filePath, algorithm = "md5") {
-  return new Promise((resolve, reject) => {
-    const hash = crypto.createHash(algorithm);
-    const fileStream = fs2.createReadStream(filePath);
-    fileStream.on("data", (data) => {
-      hash.update(data);
-    });
-    fileStream.on("end", () => {
-      const fileHash2 = hash.digest("hex");
-      resolve(fileHash2);
-    });
-    fileStream.on("error", (error) => {
-      reject(`Error reading file: ${error.message}`);
-    });
-  });
-}
-var statusMessagePretty = (failures, test) => {
-  if (failures === 0) {
-    console.log(
-      ansiC.green(ansiC.inverse(`> ${test} completed successfully?!?`))
-    );
-  } else {
-    console.log(ansiC.red(ansiC.inverse(`> ${test} failed ${failures} times`)));
-  }
-};
-async function writeFileAndCreateDir(filePath, data) {
-  const dirPath = path3.dirname(filePath);
-  try {
-    await fs2.promises.mkdir(dirPath, { recursive: true });
-    await fs2.appendFileSync(filePath, data);
-  } catch (error) {
-    console.error(`Error writing file: ${error}`);
-  }
-}
-var filesHash = async (files3, algorithm = "md5") => {
-  return new Promise((resolve, reject) => {
-    resolve(
-      files3.reduce(async (mm, f) => {
-        return await mm + await fileHash(f);
-      }, Promise.resolve(""))
-    );
-  });
-};
-function isValidUrl(string) {
-  try {
-    new URL(string);
-    return true;
-  } catch (err) {
-    return false;
-  }
-}
-function pollForFile(path4, timeout = 2e3) {
-  const intervalObj = setInterval(function() {
-    const file = path4;
-    const fileExists = fs2.existsSync(file);
-    if (fileExists) {
-      clearInterval(intervalObj);
-    }
-  }, timeout);
-}
-var PM_Main = class extends PM_Base {
+var PM_WithEslintAndTsc = class extends PM_Base {
   constructor(configs, name, mode2) {
     super(configs);
-    this.bigBoard = {};
-    this.getRunnables = (tests, testName2, payload = {
-      nodeEntryPoints: {},
-      webEntryPoints: {},
-      importEntryPoints: {}
-    }) => {
-      return getRunnables(tests, testName2, payload);
-    };
+    this.summary = {};
     this.tscCheck = async ({
       entrypoint,
       addableFiles,
@@ -415,15 +418,15 @@ var PM_Main = class extends PM_Base {
         // exclude: ["**/*.test.ts", "**/*.spec.ts"],
       });
       const tscPath = tscPather(entrypoint, platform, this.name);
-      let allDiagnostics = program.getSemanticDiagnostics();
+      const allDiagnostics = program.getSemanticDiagnostics();
       const results = [];
       allDiagnostics.forEach((diagnostic) => {
         if (diagnostic.file) {
-          let { line, character } = ts.getLineAndCharacterOfPosition(
+          const { line, character } = ts.getLineAndCharacterOfPosition(
             diagnostic.file,
             diagnostic.start
           );
-          let message = ts.flattenDiagnosticMessageText(
+          const message = ts.flattenDiagnosticMessageText(
             diagnostic.messageText,
             "\n"
           );
@@ -455,14 +458,14 @@ var PM_Main = class extends PM_Base {
       this.lintIsNowDone(entrypoint, results.length);
     };
     this.makePrompt = async (entryPoint, addableFiles, platform) => {
-      this.bigBoard[entryPoint].prompt = "?";
+      this.summary[entryPoint].prompt = "?";
       const promptPath = promptPather(entryPoint, platform, this.name);
       const testPaths = path3.join(
         "testeranto",
         "reports",
         this.name,
-        platform,
         entryPoint.split(".").slice(0, -1).join("."),
+        platform,
         `tests.json`
       );
       const featuresPath = path3.join(
@@ -473,6 +476,38 @@ var PM_Main = class extends PM_Base {
         entryPoint.split(".").slice(0, -1).join("."),
         `featurePrompt.txt`
       );
+      const logPath = path3.join(
+        "testeranto",
+        "reports",
+        this.name,
+        entryPoint.split(".").slice(0, -1).join("."),
+        platform,
+        `console_log.txt`
+      );
+      const lintPath = path3.join(
+        "testeranto",
+        "reports",
+        this.name,
+        entryPoint.split(".").slice(0, -1).join("."),
+        platform,
+        `lint_errors.json`
+      );
+      const typePath = path3.join(
+        "testeranto",
+        "reports",
+        this.name,
+        entryPoint.split(".").slice(0, -1).join("."),
+        platform,
+        `type_errors.txt`
+      );
+      const messagePath = path3.join(
+        "testeranto",
+        "reports",
+        this.name,
+        entryPoint.split(".").slice(0, -1).join("."),
+        platform,
+        `message`
+      );
       fs2.writeFileSync(
         promptPath,
         `
@@ -480,51 +515,77 @@ ${addableFiles.map((x) => {
           return `/add ${x}`;
         }).join("\n")}
 
-/read ${lintPather(entryPoint, platform, this.name)}
-/read ${tscPather(entryPoint, platform, this.name)}
 /read ${testPaths}
-
-/load ${featuresPath}
-
-/code Fix the failing tests described in ${testPaths}. Correct any type signature errors described in the files ${tscPather(
-          entryPoint,
-          platform,
-          this.name
-        )}. Implement any method which throws "Function not implemented. Resolve the lint errors described in ${lintPather(
-          entryPoint,
-          platform,
-          this.name
-        )}"
-          `
+/read ${logPath}
+/read ${typePath}
+/read ${lintPath}
+`
+      );
+      fs2.writeFileSync(
+        messagePath,
+        `Fix the failing tests described in ${testPaths} and ${logPath}. DO NOT refactor beyond what is necessary. Always prefer minimal changes, focusing mostly on keeping the BDD tests passing`
       );
-      this.bigBoard[entryPoint].prompt = `aider --model deepseek/deepseek-chat --load testeranto/${this.name}/reports/${platform}/${entryPoint.split(".").slice(0, -1).join(".")}/prompt.txt`;
+      this.summary[entryPoint].prompt = `aider --model deepseek/deepseek-chat --load testeranto/${this.name}/reports/${platform}/${entryPoint.split(".").slice(0, -1).join(".")}/prompt.txt`;
+      this.checkForShutdown();
+    };
+    this.typeCheckIsRunning = (src) => {
+      this.summary[src].typeErrors = "?";
+    };
+    this.typeCheckIsNowDone = (src, failures) => {
+      this.summary[src].typeErrors = failures;
+      this.writeBigBoard();
       this.checkForShutdown();
     };
+    this.lintIsRunning = (src) => {
+      this.summary[src].staticErrors = "?";
+      this.writeBigBoard();
+    };
+    this.lintIsNowDone = (src, failures) => {
+      this.summary[src].staticErrors = failures;
+      this.writeBigBoard();
+      this.checkForShutdown();
+    };
+    this.bddTestIsRunning = (src) => {
+      this.summary[src].runTimeError = "?";
+      this.writeBigBoard();
+    };
+    this.bddTestIsNowDone = (src, failures) => {
+      this.summary[src].runTimeError = failures;
+      this.writeBigBoard();
+      this.checkForShutdown();
+    };
+    this.writeBigBoard = () => {
+      fs2.writeFileSync(
+        `./testeranto/reports/${this.name}/summary.json`,
+        JSON.stringify(this.summary, null, 2)
+      );
+    };
     this.checkForShutdown = () => {
+      console.log(ansiC.inverse(`checkForShutdown`));
       this.writeBigBoard();
       if (this.mode === "dev")
         return;
       let inflight = false;
-      Object.keys(this.bigBoard).forEach((k) => {
-        if (this.bigBoard[k].prompt === "?") {
+      Object.keys(this.summary).forEach((k) => {
+        if (this.summary[k].prompt === "?") {
           console.log(ansiC.blue(ansiC.inverse(`\u{1F555} prompt ${k}`)));
           inflight = true;
         }
       });
-      Object.keys(this.bigBoard).forEach((k) => {
-        if (this.bigBoard[k].runTimeError === "?") {
+      Object.keys(this.summary).forEach((k) => {
+        if (this.summary[k].runTimeError === "?") {
           console.log(ansiC.blue(ansiC.inverse(`\u{1F555} runTimeError ${k}`)));
           inflight = true;
         }
       });
-      Object.keys(this.bigBoard).forEach((k) => {
-        if (this.bigBoard[k].staticErrors === "?") {
+      Object.keys(this.summary).forEach((k) => {
+        if (this.summary[k].staticErrors === "?") {
           console.log(ansiC.blue(ansiC.inverse(`\u{1F555} staticErrors ${k}`)));
           inflight = true;
         }
       });
-      Object.keys(this.bigBoard).forEach((k) => {
-        if (this.bigBoard[k].typeErrors === "?") {
+      Object.keys(this.summary).forEach((k) => {
+        if (this.summary[k].typeErrors === "?") {
           console.log(ansiC.blue(ansiC.inverse(`\u{1F555} typeErrors ${k}`)));
           inflight = true;
         }
@@ -537,38 +598,113 @@ ${addableFiles.map((x) => {
         });
       }
     };
-    this.typeCheckIsRunning = (src) => {
-      this.bigBoard[src].typeErrors = "?";
-    };
-    this.typeCheckIsNowDone = (src, failures) => {
-      this.bigBoard[src].typeErrors = failures;
-      this.writeBigBoard();
-      this.checkForShutdown();
-    };
-    this.lintIsRunning = (src) => {
-      this.bigBoard[src].staticErrors = "?";
-      this.writeBigBoard();
-    };
-    this.lintIsNowDone = (src, failures) => {
-      this.bigBoard[src].staticErrors = failures;
-      this.writeBigBoard();
-      this.checkForShutdown();
-    };
-    this.bddTestIsRunning = (src) => {
-      this.bigBoard[src].runTimeError = "?";
-      this.writeBigBoard();
-    };
-    this.bddTestIsNowDone = (src, failures) => {
-      this.bigBoard[src].runTimeError = failures;
-      this.writeBigBoard();
-      this.checkForShutdown();
+    this.name = name;
+    this.mode = mode2;
+    this.configs.tests.forEach(([t, rt, tr, sidecars]) => {
+      this.summary[t] = {
+        runTimeError: "?",
+        typeErrors: "?",
+        staticErrors: "?",
+        prompt: "?",
+        failingFeatures: {}
+      };
+      sidecars.forEach(([t2]) => {
+        this.summary[t2] = {
+          // runTimeError: "?",
+          typeErrors: "?",
+          staticErrors: "?"
+          // prompt: "?",
+          // failingFeatures: {},
+        };
+      });
+    });
+  }
+};
+
+// src/PM/main.ts
+var changes = {};
+var fileHashes = {};
+var files2 = {};
+var screenshots2 = {};
+async function fileHash(filePath, algorithm = "md5") {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash(algorithm);
+    const fileStream = fs3.createReadStream(filePath);
+    fileStream.on("data", (data) => {
+      hash.update(data);
+    });
+    fileStream.on("end", () => {
+      const fileHash2 = hash.digest("hex");
+      resolve(fileHash2);
+    });
+    fileStream.on("error", (error) => {
+      reject(`Error reading file: ${error.message}`);
+    });
+  });
+}
+var statusMessagePretty = (failures, test) => {
+  if (failures === 0) {
+    console.log(
+      ansiC2.green(ansiC2.inverse(`> ${test} completed successfully?!?`))
+    );
+  } else {
+    console.log(ansiC2.red(ansiC2.inverse(`> ${test} failed ${failures} times`)));
+  }
+};
+async function writeFileAndCreateDir(filePath, data) {
+  const dirPath = path4.dirname(filePath);
+  try {
+    await fs3.promises.mkdir(dirPath, { recursive: true });
+    await fs3.writeFileSync(filePath, data);
+  } catch (error) {
+    console.error(`Error writing file: ${error}`);
+  }
+}
+var filesHash = async (files3, algorithm = "md5") => {
+  return new Promise((resolve, reject) => {
+    resolve(
+      files3.reduce(async (mm, f) => {
+        return await mm + await fileHash(f);
+      }, Promise.resolve(""))
+    );
+  });
+};
+function isValidUrl(string) {
+  try {
+    new URL(string);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+async function pollForFile(path5, timeout = 2e3) {
+  const intervalObj = setInterval(function() {
+    const file = path5;
+    const fileExists = fs3.existsSync(file);
+    if (fileExists) {
+      clearInterval(intervalObj);
+    }
+  }, timeout);
+}
+var PM_Main = class extends PM_WithEslintAndTsc {
+  constructor(configs, name, mode2) {
+    super(configs, name, mode2);
+    this.getRunnables = (tests, testName2, payload = {
+      nodeEntryPoints: {},
+      nodeEntryPointSidecars: {},
+      webEntryPoints: {},
+      webEntryPointSidecars: {},
+      pureEntryPoints: {},
+      pureEntryPointSidecars: {}
+    }) => {
+      return getRunnables(tests, testName2, payload);
     };
     this.launchPure = async (src, dest) => {
-      console.log(ansiC.green(ansiC.inverse(`! pure, ${src}`)));
+      console.log(ansiC2.green(ansiC2.inverse(`! pure, ${src}`)));
       this.bddTestIsRunning(src);
       const reportDest = `testeranto/reports/${this.name}/${src.split(".").slice(0, -1).join(".")}/pure`;
-      if (!fs2.existsSync(reportDest)) {
-        fs2.mkdirSync(reportDest, { recursive: true });
+      if (!fs3.existsSync(reportDest)) {
+        fs3.mkdirSync(reportDest, { recursive: true });
       }
       const destFolder = dest.replace(".mjs", "");
       let argz = "";
@@ -576,11 +712,11 @@ ${addableFiles.map((x) => {
         return t[0] === src;
       });
       if (!testConfig) {
-        console.log(ansiC.inverse("missing test config! Exiting ungracefully!"));
+        console.log(ansiC2.inverse("missing test config! Exiting ungracefully!"));
         process.exit(-1);
       }
       const testConfigResource = testConfig[2];
-      let portsToUse = [];
+      const portsToUse = [];
       if (testConfigResource.ports === 0) {
         argz = JSON.stringify({
           scheduled: true,
@@ -619,21 +755,20 @@ ${addableFiles.map((x) => {
         await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
           return module.default.then((defaultModule) => {
             defaultModule.receiveTestResourceConfig(argz).then(async (results) => {
-              this.receiveFeatures(results.features, destFolder, src, "pure");
               statusMessagePretty(results.fails, src);
               this.bddTestIsNowDone(src, results.fails);
             }).catch((e) => {
               console.log(
-                ansiC.red(ansiC.inverse(`${src} errored with: ${e}`))
+                ansiC2.red(
+                  ansiC2.inverse(`launchPure - ${src} errored with: ${e}`)
+                )
               );
               this.bddTestIsNowDone(src, -1);
-            }).finally(() => {
-              webSideCares.forEach((webSideCar) => webSideCar.close());
             });
           }).catch((e) => {
             console.log(
-              ansiC.red(
-                ansiC.inverse(
+              ansiC2.red(
+                ansiC2.inverse(
                   `${src} errored with: ${e}. Check ${reportDest}/error.txt for more info`
                 )
               )
@@ -645,8 +780,8 @@ ${addableFiles.map((x) => {
         });
       } catch (e) {
         console.log(
-          ansiC.red(
-            ansiC.inverse(
+          ansiC2.red(
+            ansiC2.inverse(
               `${src} errored with: ${e}. Check ${reportDest}/error.txt for more info`
             )
           )
@@ -657,38 +792,39 @@ ${addableFiles.map((x) => {
       }
       for (let i = 0; i <= portsToUse.length; i++) {
         if (portsToUse[i]) {
-          this.ports[portsToUse[i]] = "true";
+          this.ports[portsToUse[i]] = true;
         }
       }
     };
     this.launchNode = async (src, dest) => {
-      console.log(ansiC.green(ansiC.inverse(`! node, ${src}`)));
+      console.log(ansiC2.green(ansiC2.inverse(`! node, ${src}`)));
       this.bddTestIsRunning(src);
       const reportDest = `testeranto/reports/${this.name}/${src.split(".").slice(0, -1).join(".")}/node`;
-      if (!fs2.existsSync(reportDest)) {
-        fs2.mkdirSync(reportDest, { recursive: true });
+      if (!fs3.existsSync(reportDest)) {
+        fs3.mkdirSync(reportDest, { recursive: true });
       }
-      const destFolder = dest.replace(".mjs", "");
       let testResources = "";
       const testConfig = this.configs.tests.find((t) => {
         return t[0] === src;
       });
       if (!testConfig) {
         console.log(
-          ansiC.inverse(`missing test config! Exiting ungracefully for '${src}'`)
+          ansiC2.inverse(`missing test config! Exiting ungracefully for '${src}'`)
         );
         process.exit(-1);
       }
       const testConfigResource = testConfig[2];
-      let portsToUse = [];
+      const portsToUse = [];
       if (testConfigResource.ports === 0) {
-        testResources = JSON.stringify({
-          scheduled: true,
+        console.error("portsToUse?!", []);
+        const t = {
           name: src,
-          ports: portsToUse,
+          // ports: portsToUse.map((v) => Number(v)),
+          ports: [],
           fs: reportDest,
           browserWSEndpoint: this.browser.wsEndpoint()
-        });
+        };
+        testResources = JSON.stringify(t);
       } else if (testConfigResource.ports > 0) {
         const openPorts = Object.entries(this.ports).filter(
           ([portnumber, portopen]) => portopen
@@ -698,14 +834,16 @@ ${addableFiles.map((x) => {
             portsToUse.push(openPorts[i][0]);
             this.ports[openPorts[i][0]] = false;
           }
+          console.error("portsToUse", portsToUse);
           testResources = JSON.stringify({
             scheduled: true,
             name: src,
             ports: portsToUse,
-            fs: destFolder,
+            fs: reportDest,
             browserWSEndpoint: this.browser.wsEndpoint()
           });
         } else {
+          console.log("Not enough ports! Enqueuing test job...");
           this.queue.push(src);
           return;
         }
@@ -715,67 +853,65 @@ ${addableFiles.map((x) => {
       }
       const builtfile = dest;
       let haltReturns = false;
+      const ipcfile = "/tmp/tpipe_" + Math.random();
+      const child = spawn(
+        "node",
+        // "node --inspect-brk ",
+        [builtfile, testResources, ipcfile],
+        {
+          stdio: ["pipe", "pipe", "pipe", "ipc"]
+        }
+      );
       let buffer = new Buffer("");
       const server = net.createServer((socket) => {
+        const queue = new Queue();
         socket.on("data", (data) => {
           buffer = Buffer.concat([buffer, data]);
-          let messages = [];
           for (let b = 0; b < buffer.length + 1; b++) {
-            let c = buffer.slice(0, b);
+            const c = buffer.slice(0, b);
             let d;
             try {
               d = JSON.parse(c.toString());
-              messages.push(d);
+              queue.enqueue(d);
               buffer = buffer.slice(b, buffer.length + 1);
               b = 0;
             } catch (e) {
             }
           }
-          messages.forEach(async (payload) => {
-            this.mapping().forEach(async ([command, func]) => {
-              if (payload[0] === command) {
-                const x = payload.slice(1, -1);
-                const r = await this[command](...x);
-                if (!haltReturns) {
-                  child.send(
-                    JSON.stringify({
-                      payload: r,
-                      key: payload[payload.length - 1]
-                    })
-                  );
+          while (queue.size() > 0) {
+            const message = queue.dequeue();
+            if (message) {
+              this.mapping().forEach(async ([command, func]) => {
+                if (message[0] === command) {
+                  const x = message.slice(1, -1);
+                  const r = await this[command](...x);
+                  if (!haltReturns) {
+                    child.send(
+                      JSON.stringify({
+                        payload: r,
+                        key: message[message.length - 1]
+                      })
+                    );
+                  }
                 }
-              }
-            });
-          });
+              });
+            }
+          }
         });
       });
-      const oStream = fs2.createWriteStream(`${reportDest}/console_log.txt`);
-      const child = spawn(
-        "node",
-        [builtfile, testResources, "--trace-warnings"],
-        {
-          stdio: ["pipe", "pipe", "pipe", "ipc"]
-          // silent: true
-        }
-      );
-      const p = destFolder + "/tpipe";
+      const oStream = fs3.createWriteStream(`${reportDest}/console_log.txt`);
       const errFile = `${reportDest}/error.txt`;
-      if (fs2.existsSync(errFile)) {
-        fs2.rmSync(errFile);
+      if (fs3.existsSync(errFile)) {
+        fs3.rmSync(errFile);
       }
-      server.listen(p, () => {
+      server.listen(ipcfile, () => {
         child.stderr?.on("data", (data) => {
-          oStream.write(`stderr data ${data}`);
+          oStream.write(`stderr > ${data}`);
         });
         child.stdout?.on("data", (data) => {
-          oStream.write(`stdout data ${data}`);
+          oStream.write(`stdout > ${data}`);
         });
         child.on("close", (code) => {
-          console.log("close");
-          console.log("deleting", p);
-          if (fs2.existsSync(p)) {
-            fs2.rmSync(p);
-          }
           oStream.close();
           server.close();
           if (code === null) {
@@ -791,23 +927,19 @@ ${addableFiles.map((x) => {
           haltReturns = true;
         });
         child.on("exit", (code) => {
-          console.log("exit");
-          console.log("deleting", p);
-          if (fs2.existsSync(p)) {
-            fs2.rmSync(p);
-          }
           haltReturns = true;
+          for (let i = 0; i <= portsToUse.length; i++) {
+            if (portsToUse[i]) {
+              this.ports[portsToUse[i]] = true;
+            }
+          }
         });
         child.on("error", (e) => {
           console.log("error");
-          console.log("deleting", p);
-          if (fs2.existsSync(p)) {
-            fs2.rmSync(p);
-          }
           haltReturns = true;
           console.log(
-            ansiC.red(
-              ansiC.inverse(
+            ansiC2.red(
+              ansiC2.inverse(
                 `${src} errored with: ${e.name}. Check ${errFile}for more info`
               )
             )
@@ -817,121 +949,237 @@ ${addableFiles.map((x) => {
           statusMessagePretty(-1, src);
         });
       });
-      child.send({ path: p });
-      for (let i = 0; i <= portsToUse.length; i++) {
-        if (portsToUse[i]) {
-          this.ports[portsToUse[i]] = "true";
-        }
-      }
     };
-    this.launchWebSideCar = async (src, dest, testConfig) => {
-      const d = dest + ".mjs";
-      console.log(ansiC.green(ansiC.inverse(`launchWebSideCar ${src}`)));
+    this.launchWebSideCar = async (testConfig) => {
+      const src = testConfig[0];
+      const dest = src.split(".").slice(0, -1).join(".");
+      const destFolder = dest.replace(".mjs", "");
+      console.log(ansiC2.green(ansiC2.inverse(`launchWebSideCar ${src}`)));
       const fileStreams2 = [];
       const doneFileStream2 = [];
+      const oStream = fs3.createWriteStream(`${destFolder}/console_log.txt`);
       return new Promise((res, rej) => {
-        this.browser.newPage().then((page) => {
-          page.exposeFunction(
-            "custom-screenshot",
-            async (ssOpts, testName2) => {
-              const p = ssOpts.path;
-              const dir = path3.dirname(p);
-              fs2.mkdirSync(dir, {
-                recursive: true
-              });
-              files2[testName2].add(ssOpts.path);
-              const sPromise = page.screenshot({
-                ...ssOpts,
-                path: p
-              });
-              if (!screenshots2[testName2]) {
-                screenshots2[testName2] = [];
-              }
-              screenshots2[testName2].push(sPromise);
-              await sPromise;
-              return sPromise;
-            }
-          );
-          page.exposeFunction(
-            "writeFileSync",
-            (fp, contents, testName2) => {
-              const dir = path3.dirname(fp);
-              fs2.mkdirSync(dir, {
-                recursive: true
-              });
-              const p = new Promise(async (res2, rej2) => {
-                fs2.writeFileSync(fp, contents);
-                res2(fp);
-              });
-              doneFileStream2.push(p);
-              if (!files2[testName2]) {
-                files2[testName2] = /* @__PURE__ */ new Set();
-              }
-              files2[testName2].add(fp);
-              return p;
-            }
-          );
-          page.exposeFunction("existsSync", (fp, contents) => {
-            return fs2.existsSync(fp);
+        this.browser.newPage().then(async (page) => {
+          this.mapping().forEach(async ([command, func]) => {
+            page.exposeFunction(command, func);
           });
-          page.exposeFunction("mkdirSync", (fp) => {
-            if (!fs2.existsSync(fp)) {
-              return fs2.mkdirSync(fp, {
-                recursive: true
-              });
+          const close = () => {
+            if (!files2[src]) {
+              files2[src] = /* @__PURE__ */ new Set();
             }
-            return false;
-          });
-          page.exposeFunction(
-            "createWriteStream",
-            (fp, testName2) => {
-              const f = fs2.createWriteStream(fp);
-              files2[testName2].add(fp);
-              const p = new Promise((res2, rej2) => {
-                res2(fp);
-              });
-              doneFileStream2.push(p);
-              f.on("close", async () => {
-                await p;
-              });
-              fileStreams2.push(f);
-              return {
-                ...JSON.parse(JSON.stringify(f)),
-                uid: fileStreams2.length - 1
-              };
+            delete files2[src];
+            Promise.all(screenshots2[src] || []).then(() => {
+              delete screenshots2[src];
+              page.close();
+              oStream.close();
+            });
+          };
+          page.on("pageerror", (err) => {
+            console.debug(`Error from ${src}: [${err.name}] `);
+            oStream.write(err.name);
+            oStream.write("\n");
+            if (err.cause) {
+              console.debug(`Error from ${src} cause: [${err.cause}] `);
+              oStream.write(err.cause);
+              oStream.write("\n");
             }
-          );
-          page.exposeFunction(
-            "write",
-            async (uid, contents) => {
-              return fileStreams2[uid].write(contents);
+            if (err.stack) {
+              console.debug(`Error from stack ${src}: [${err.stack}] `);
+              oStream.write(err.stack);
+              oStream.write("\n");
             }
-          );
-          page.exposeFunction("end", async (uid) => {
-            return fileStreams2[uid].end();
+            console.debug(`Error from message ${src}: [${err.message}] `);
+            oStream.write(err.message);
+            oStream.write("\n");
+            this.bddTestIsNowDone(src, -1);
+            close();
+          });
+          page.on("console", (log) => {
+            oStream.write(log.text());
+            oStream.write(JSON.stringify(log.location()));
+            oStream.write(JSON.stringify(log.stackTrace()));
+            oStream.write("\n");
+          });
+          await page.goto(`file://${`${destFolder}.html`}`, {});
+          const webArgz = JSON.stringify({
+            name: dest,
+            ports: [].toString(),
+            fs: dest,
+            browserWSEndpoint: this.browser.wsEndpoint()
+          });
+          const d = `${dest}?cacheBust=${Date.now()}`;
+          const evaluation = `
+    import('${d}').then(async (x) => {
+
+      try {
+        return await (await x.default).receiveTestResourceConfig(${webArgz})
+      } catch (e) {
+        console.log("fail", e.toString())
+      }
+    })`;
+          await page.evaluate(evaluation).then(async ({ fails, failed, features }) => {
+            statusMessagePretty(fails, src);
+            this.bddTestIsNowDone(src, fails);
+          }).catch((e) => {
+            console.log(
+              ansiC2.red(
+                ansiC2.inverse(`launchWebSidecar - ${src} errored with: ${e}`)
+              )
+            );
+          }).finally(() => {
+            this.bddTestIsNowDone(src, -1);
+            close();
           });
           return page;
         }).then(async (page) => {
           await page.goto(`file://${`${dest}.html`}`, {});
-          res(page);
+          res([Math.random(), page]);
         });
       });
     };
-    this.launchNodeSideCar = async (src, dest, testConfig) => {
+    this.launchNodeSideCar = async (sidecar) => {
+      const src = sidecar[0];
+      const dest = process.cwd() + `/testeranto/bundles/node/${this.name}/${sidecar[0]}`;
       const d = dest + ".mjs";
-      console.log(ansiC.green(ansiC.inverse(`launchNodeSideCar ${src}`)));
+      console.log(ansiC2.green(ansiC2.inverse(`launchNodeSideCar ${sidecar[0]}`)));
+      const destFolder = dest.replace(".ts", "");
+      const reportDest = `testeranto/reports/${this.name}/${src.split(".").slice(0, -1).join(".")}/node`;
+      const argz = {
+        name: sidecar[0],
+        ports: [],
+        fs: destFolder,
+        browserWSEndpoint: this.browser.wsEndpoint()
+      };
+      const testReq = sidecar[2];
+      const portsToUse = [];
+      if (testReq.ports === 0) {
+      } else if (testReq.ports > 0) {
+        const openPorts = Object.entries(this.ports).filter(
+          ([portnumber, portopen]) => portopen
+        );
+        if (openPorts.length >= testReq.ports) {
+          for (let i = 0; i < testReq.ports; i++) {
+            portsToUse.push(openPorts[i][0]);
+            this.ports[openPorts[i][0]] = false;
+          }
+          console.log("nodeSideCar portsToUse", portsToUse);
+          argz.ports = portsToUse;
+          const builtfile = destFolder + ".mjs";
+          let haltReturns = false;
+          let buffer = new Buffer("");
+          const server = net.createServer((socket) => {
+            socket.on("data", (data) => {
+              buffer = Buffer.concat([buffer, data]);
+              const messages = [];
+              for (let b = 0; b < buffer.length + 1; b++) {
+                const c = buffer.slice(0, b);
+                let d2;
+                try {
+                  d2 = JSON.parse(c.toString());
+                  messages.push(d2);
+                  buffer = buffer.slice(b, buffer.length + 1);
+                  b = 0;
+                } catch (e) {
+                }
+              }
+              messages.forEach(async (payload) => {
+                this.mapping().forEach(async ([command, func]) => {
+                  if (payload[0] === command) {
+                    const x = payload.slice(1, -1);
+                    const r2 = await this[command](...x);
+                    if (!haltReturns) {
+                      child.send(
+                        JSON.stringify({
+                          payload: r2,
+                          key: payload[payload.length - 1]
+                        })
+                      );
+                    }
+                  }
+                });
+              });
+            });
+          });
+          const oStream = fs3.createWriteStream(`${reportDest}/console_log.txt`);
+          const child = spawn("node", [builtfile, JSON.stringify(argz)], {
+            stdio: ["pipe", "pipe", "pipe", "ipc"]
+            // silent: true
+          });
+          const p = "/tmp/tpipe" + Math.random();
+          const errFile = `${reportDest}/error.txt`;
+          server.listen(p, () => {
+            child.stderr?.on("data", (data) => {
+              oStream.write(`stderr > ${data}`);
+            });
+            child.stdout?.on("data", (data) => {
+              oStream.write(`stdout > ${data}`);
+            });
+            child.on("close", (code) => {
+              oStream.close();
+              server.close();
+              haltReturns = true;
+            });
+            child.on("exit", (code) => {
+              haltReturns = true;
+              for (let i = 0; i <= portsToUse.length; i++) {
+                if (portsToUse[i]) {
+                  this.ports[portsToUse[i]] = true;
+                }
+              }
+            });
+            child.on("error", (e) => {
+              if (fs3.existsSync(p)) {
+                fs3.rmSync(p);
+              }
+              haltReturns = true;
+              console.log(
+                ansiC2.red(
+                  ansiC2.inverse(
+                    `launchNodeSideCar - ${src} errored with: ${e.name}. Check ${errFile}for more info`
+                  )
+                )
+              );
+              this.writeFileSync(`${reportDest}/error.txt`, e.toString(), src);
+            });
+          });
+          child.send({ path: p });
+          const r = Math.random();
+          this.nodeSidecars[r] = child;
+          return [r, argz];
+        } else {
+          console.log("Not enough open ports!", openPorts, testReq.ports);
+          this.queue.push(sidecar[0]);
+          return [Math.random(), argz];
+        }
+      } else {
+        console.error("negative port makes no sense", sidecar[0]);
+        process.exit(-1);
+      }
+    };
+    this.stopPureSideCar = async (uid) => {
+      console.log(ansiC2.green(ansiC2.inverse(`stopPureSideCar ${uid}`)));
+      await this.sidecars[uid].shutdown();
+      return;
+    };
+    this.launchPureSideCar = async (sidecar) => {
+      console.log(ansiC2.green(ansiC2.inverse(`launchPureSideCar ${sidecar[0]}`)));
+      const r = Math.random();
+      const dest = process.cwd() + `/testeranto/bundles/pure/${this.name}/${sidecar[0]}`;
+      const builtfile = dest.split(".").slice(0, -1).concat("mjs").join(".");
       const destFolder = dest.replace(".mjs", "");
-      let argz = "";
-      const testConfigResource = testConfig[2];
-      let portsToUse = [];
+      let argz;
+      const z = sidecar[2];
+      const testConfigResource = sidecar[2];
+      const src = sidecar[0];
+      const portsToUse = [];
       if (testConfigResource.ports === 0) {
-        argz = JSON.stringify({
-          scheduled: true,
+        argz = {
+          // scheduled: true,
           name: src,
           ports: portsToUse,
           fs: destFolder,
           browserWSEndpoint: this.browser.wsEndpoint()
-        });
+        };
       } else if (testConfigResource.ports > 0) {
         const openPorts = Object.entries(this.ports).filter(
           ([portnumber, portopen]) => portopen
@@ -941,14 +1189,14 @@ ${addableFiles.map((x) => {
             portsToUse.push(openPorts[i][0]);
             this.ports[openPorts[i][0]] = false;
           }
-          argz = JSON.stringify({
-            scheduled: true,
+          argz = {
+            // scheduled: true,
             name: src,
             // ports: [3333],
             ports: portsToUse,
             fs: ".",
             browserWSEndpoint: this.browser.wsEndpoint()
-          });
+          };
         } else {
           this.queue.push(src);
           return;
@@ -957,29 +1205,22 @@ ${addableFiles.map((x) => {
         console.error("negative port makes no sense", src);
         process.exit(-1);
       }
-      const builtfile = dest + ".mjs";
       await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
-        return module.default.then((defaultModule) => {
-          const s = new defaultModule();
-          s.receiveTestResourceConfig(argz);
-        });
+        this.pureSidecars[r] = module.default;
+        this.pureSidecars[r].start(argz);
       });
-      for (let i = 0; i <= portsToUse.length; i++) {
-        if (portsToUse[i]) {
-          this.ports[portsToUse[i]] = "true";
-        }
-      }
+      return [r, argz];
     };
     this.launchWeb = async (src, dest) => {
-      console.log(ansiC.green(ansiC.inverse(`! web ${src}`)));
+      console.log(ansiC2.green(ansiC2.inverse(`! web ${src}`)));
       this.bddTestIsRunning(src);
       const reportDest = `testeranto/reports/${this.name}/${src.split(".").slice(0, -1).join(".")}/web`;
-      if (!fs2.existsSync(reportDest)) {
-        fs2.mkdirSync(reportDest, { recursive: true });
+      if (!fs3.existsSync(reportDest)) {
+        fs3.mkdirSync(reportDest, { recursive: true });
       }
       const destFolder = dest.replace(".mjs", "");
       const webArgz = JSON.stringify({
-        name: dest,
+        name: src,
         ports: [].toString(),
         fs: reportDest,
         browserWSEndpoint: this.browser.wsEndpoint()
@@ -995,10 +1236,20 @@ ${addableFiles.map((x) => {
         console.log("fail", e)
       }
     })`;
-      const oStream = fs2.createWriteStream(`${reportDest}/console_log.txt`);
+      const oStream = fs3.createWriteStream(`${reportDest}/console_log.txt`);
       this.browser.newPage().then((page) => {
         this.mapping().forEach(async ([command, func]) => {
-          page.exposeFunction(command, func);
+          if (command === "page") {
+            page.exposeFunction(command, (x) => {
+              if (x) {
+                return func(x);
+              } else {
+                return func(page.mainFrame()._id);
+              }
+            });
+          } else {
+            return page.exposeFunction(command, func);
+          }
         });
         return page;
       }).then(async (page) => {
@@ -1006,10 +1257,6 @@ ${addableFiles.map((x) => {
           if (!files2[src]) {
             files2[src] = /* @__PURE__ */ new Set();
           }
-          fs2.writeFileSync(
-            destFolder + "/manifest.json",
-            JSON.stringify(Array.from(files2[src]))
-          );
           delete files2[src];
           Promise.all(screenshots2[src] || []).then(() => {
             delete screenshots2[src];
@@ -1039,17 +1286,21 @@ ${addableFiles.map((x) => {
         });
         page.on("console", (log) => {
           oStream.write(log.text());
+          oStream.write("\n");
           oStream.write(JSON.stringify(log.location()));
+          oStream.write("\n");
           oStream.write(JSON.stringify(log.stackTrace()));
           oStream.write("\n");
         });
         await page.goto(`file://${`${destFolder}.html`}`, {});
+        this.webSidecars[Math.random()] = page.mainFrame()._id;
         await page.evaluate(evaluation).then(async ({ fails, failed, features }) => {
-          this.receiveFeatures(features, destFolder, src, "web");
           statusMessagePretty(fails, src);
           this.bddTestIsNowDone(src, fails);
         }).catch((e) => {
-          console.log(ansiC.red(ansiC.inverse(`${src} errored with: ${e}`)));
+          console.log(
+            ansiC2.red(ansiC2.inverse(`launchweb - ${src} errored with: ${e}`))
+          );
         }).finally(() => {
           this.bddTestIsNowDone(src, -1);
           close();
@@ -1057,74 +1308,106 @@ ${addableFiles.map((x) => {
         return page;
       });
     };
-    this.receiveFeatures = (features, destFolder, srcTest, platform) => {
-      const featureDestination = path3.resolve(
+    this.receiveFeaturesV2 = (reportDest, srcTest, platform) => {
+      const featureDestination = path4.resolve(
         process.cwd(),
         "reports",
         "features",
         "strings",
         srcTest.split(".").slice(0, -1).join(".") + ".features.txt"
       );
-      features.reduce(async (mm, featureStringKey) => {
+      const testReport = JSON.parse(
+        fs3.readFileSync(`${reportDest}/tests.json`).toString()
+      );
+      testReport.features.reduce(async (mm, featureStringKey) => {
         const accum = await mm;
         const isUrl = isValidUrl(featureStringKey);
         if (isUrl) {
           const u = new URL(featureStringKey);
           if (u.protocol === "file:") {
-            const newPath = `${process.cwd()}/testeranto/features/internal/${path3.relative(
+            const newPath = `${process.cwd()}/testeranto/features/internal/${path4.relative(
               process.cwd(),
               u.pathname
             )}`;
-            await fs2.promises.mkdir(path3.dirname(newPath), { recursive: true });
-            try {
-              await fs2.unlinkSync(newPath);
-            } catch (error) {
-              if (error.code !== "ENOENT") {
-              }
-            }
-            accum.files.push(newPath);
+            accum.files.push(u.pathname);
           } else if (u.protocol === "http:" || u.protocol === "https:") {
-            const newPath = `${process.cwd()}/testeranto/features/external${u.hostname}${u.pathname}`;
+            const newPath = `${process.cwd()}/testeranto/features/external/${u.hostname}${u.pathname}`;
             const body = await this.configs.featureIngestor(featureStringKey);
             writeFileAndCreateDir(newPath, body);
             accum.files.push(newPath);
           }
         } else {
-          await fs2.promises.mkdir(path3.dirname(featureDestination), {
+          await fs3.promises.mkdir(path4.dirname(featureDestination), {
             recursive: true
           });
           accum.strings.push(featureStringKey);
         }
         return accum;
       }, Promise.resolve({ files: [], strings: [] })).then(({ files: files3, strings }) => {
-        fs2.writeFileSync(
+        fs3.writeFileSync(
           `testeranto/reports/${this.name}/${srcTest.split(".").slice(0, -1).join(".")}/${platform}/featurePrompt.txt`,
           files3.map((f) => {
             return `/read ${f}`;
           }).join("\n")
         );
       });
+      testReport.givens.forEach((g) => {
+        if (g.failed === true) {
+          this.summary[srcTest].failingFeatures[g.key] = g.features;
+        }
+      });
+      this.writeBigBoard();
     };
-    this.writeBigBoard = () => {
-      fs2.writeFileSync(
-        `./testeranto/reports/${this.name}/summary.json`,
-        JSON.stringify(this.bigBoard, null, 2)
-      );
-    };
-    this.name = name;
-    this.mode = mode2;
     this.ports = {};
-    this.configs.tests.forEach(([t]) => {
-      this.bigBoard[t] = {
-        runTimeError: "?",
-        typeErrors: "?",
-        staticErrors: "?",
-        prompt: "?"
-      };
-    });
+    this.queue = [];
+    this.nodeSidecars = {};
+    this.webSidecars = {};
+    this.pureSidecars = {};
     this.configs.ports.forEach((element) => {
-      this.ports[element] = "true";
+      this.ports[element] = true;
+    });
+  }
+  async stopSideCar(uid) {
+    console.log(ansiC2.green(ansiC2.inverse(`stopSideCar ${uid}`)));
+    Object.entries(this.pureSidecars).forEach(async ([k, v]) => {
+      if (Number(k) === uid) {
+        await this.pureSidecars[Number(k)].stop();
+        delete this.pureSidecars[Number(k)];
+      }
+    });
+    Object.entries(this.nodeSidecars).forEach(async ([k, v]) => {
+      if (Number(k) === uid) {
+        await this.nodeSidecars[Number(k)].send("stop");
+        delete this.nodeSidecars[Number(k)];
+      }
+    });
+    Object.entries(this.webSidecars).forEach(async ([k, v]) => {
+      if (Number(k) === uid) {
+        (await this.browser.pages()).forEach(async (p) => {
+          if (p.mainFrame()._id === k) {
+            await this.webSidecars[Number(k)].close();
+            delete this.webSidecars[Number(k)];
+          }
+        });
+      }
     });
+    return;
+  }
+  async launchSideCar(n, name) {
+    const c = this.configs.tests.find(([v, r2]) => {
+      return v === name;
+    });
+    const s = c[3][n];
+    const r = s[1];
+    if (r === "node") {
+      return this.launchNodeSideCar(s);
+    } else if (r === "web") {
+      return this.launchWebSideCar(s);
+    } else if (r === "pure") {
+      return this.launchPureSideCar(s);
+    } else {
+      throw `unknown runtime ${r}`;
+    }
   }
   mapping() {
     return [
@@ -1133,20 +1416,23 @@ ${addableFiles.map((x) => {
       ["closePage", this.closePage],
       ["createWriteStream", this.createWriteStream],
       ["customclose", this.customclose],
-      ["customScreenShot", this.customScreenShot],
+      ["customScreenShot", this.customScreenShot.bind(this)],
       ["end", this.end],
       ["existsSync", this.existsSync],
       ["focusOn", this.focusOn],
       ["getAttribute", this.getAttribute],
-      ["getValue", this.getValue],
-      ["goto", this.goto],
+      ["getInnerHtml", this.getInnerHtml],
+      // ["setValue", this.setValue],
+      ["goto", this.goto.bind(this)],
       ["isDisabled", this.isDisabled],
+      ["launchSideCar", this.launchSideCar.bind(this)],
       ["mkdirSync", this.mkdirSync],
       ["newPage", this.newPage],
       ["page", this.page],
       ["pages", this.pages],
       ["screencast", this.screencast],
       ["screencastStop", this.screencastStop],
+      ["stopSideCar", this.stopSideCar.bind(this)],
       ["typeInto", this.typeInto],
       ["waitForSelector", this.waitForSelector],
       ["write", this.write],
@@ -1157,51 +1443,57 @@ ${addableFiles.map((x) => {
     this.mapping().forEach(async ([command, func]) => {
       globalThis[command] = func;
     });
-    if (!fs2.existsSync(`testeranto/reports/${this.name}`)) {
-      fs2.mkdirSync(`testeranto/reports/${this.name}`);
+    if (!fs3.existsSync(`testeranto/reports/${this.name}`)) {
+      fs3.mkdirSync(`testeranto/reports/${this.name}`);
     }
-    this.browser = await puppeteer.launch({
-      slowMo: 1,
-      waitForInitialPage: false,
-      executablePath: (
-        // process.env.CHROMIUM_PATH || "/opt/homebrew/bin/chromium",
-        "/opt/homebrew/bin/chromium"
-      ),
-      headless: true,
-      dumpio: false,
-      devtools: false,
-      args: [
-        "--allow-file-access-from-files",
-        "--allow-insecure-localhost",
-        "--allow-running-insecure-content",
-        "--auto-open-devtools-for-tabs",
-        "--disable-dev-shm-usage",
-        "--disable-extensions",
-        "--disable-gpu",
-        "--disable-setuid-sandbox",
-        "--disable-site-isolation-trials",
-        "--disable-site-isolation-trials",
-        "--disable-web-security",
-        "--no-first-run",
-        "--no-sandbox",
-        "--no-startup-window",
-        "--reduce-security-for-testing",
-        "--remote-allow-origins=*",
-        `--remote-debugging-port=3234`,
-        "--unsafely-treat-insecure-origin-as-secure=*"
-        // "--disable-features=IsolateOrigins,site-per-process",
-        // "--disable-features=IsolateOrigins",
-        // "--disk-cache-dir=/dev/null",
-        // "--disk-cache-size=1",
-        // "--no-zygote",
-        // "--remote-allow-origins=ws://localhost:3234",
-        // "--single-process",
-        // "--start-maximized",
-        // "--unsafely-treat-insecure-origin-as-secure",
-        // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
-      ]
-    });
-    const { nodeEntryPoints, webEntryPoints, importEntryPoints } = this.getRunnables(this.configs.tests, this.name);
+    const executablePath = "/opt/homebrew/bin/chromium";
+    try {
+      this.browser = await puppeteer.launch({
+        slowMo: 1,
+        waitForInitialPage: false,
+        executablePath,
+        headless: true,
+        dumpio: false,
+        devtools: false,
+        args: [
+          "--disable-features=site-per-process",
+          "--allow-file-access-from-files",
+          "--allow-insecure-localhost",
+          "--allow-running-insecure-content",
+          "--auto-open-devtools-for-tabs",
+          "--disable-dev-shm-usage",
+          "--disable-extensions",
+          "--disable-gpu",
+          "--disable-setuid-sandbox",
+          "--disable-site-isolation-trials",
+          "--disable-web-security",
+          "--no-first-run",
+          "--no-sandbox",
+          "--no-startup-window",
+          "--reduce-security-for-testing",
+          "--remote-allow-origins=*",
+          "--unsafely-treat-insecure-origin-as-secure=*",
+          `--remote-debugging-port=3234`
+          // "--disable-features=IsolateOrigins,site-per-process",
+          // "--disable-features=IsolateOrigins",
+          // "--disk-cache-dir=/dev/null",
+          // "--disk-cache-size=1",
+          // "--no-zygote",
+          // "--remote-allow-origins=ws://localhost:3234",
+          // "--single-process",
+          // "--start-maximized",
+          // "--unsafely-treat-insecure-origin-as-secure",
+          // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
+        ]
+      });
+    } catch (e) {
+      console.error(e);
+      console.error(
+        "could not start chrome via puppeter. Check this path: ",
+        executablePath
+      );
+    }
+    const { nodeEntryPoints, webEntryPoints, pureEntryPoints } = this.getRunnables(this.configs.tests, this.name);
     [
       [
         nodeEntryPoints,
@@ -1220,7 +1512,7 @@ ${addableFiles.map((x) => {
         }
       ],
       [
-        importEntryPoints,
+        pureEntryPoints,
         this.launchPure,
         "pure",
         (w) => {
@@ -1240,7 +1532,7 @@ ${addableFiles.map((x) => {
                 if (fileHashes[k] !== hash) {
                   fileHashes[k] = hash;
                   console.log(
-                    ansiC.yellow(ansiC.inverse(`< ${e} ${filename}`))
+                    ansiC2.yellow(ansiC2.inverse(`< ${e} ${filename}`))
                   );
                   launcher(k, outputFile);
                 }
@@ -1254,7 +1546,7 @@ ${addableFiles.map((x) => {
         watcher(
           watch(metafile, async (e, filename) => {
             console.log(
-              ansiC.yellow(ansiC.inverse(`< ${e} ${filename} (${runtime})`))
+              ansiC2.yellow(ansiC2.inverse(`< ${e} ${filename} (${runtime})`))
             );
             this.metafileOutputs(runtime);
           })
@@ -1262,8 +1554,10 @@ ${addableFiles.map((x) => {
       }
     );
   }
+  async launchExternalTest(externalTestName, externalTest) {
+  }
   async stop() {
-    console.log(ansiC.inverse("Testeranto-Run is shutting down gracefully..."));
+    console.log(ansiC2.inverse("Testeranto-Run is shutting down gracefully..."));
     this.mode = "once";
     this.nodeMetafileWatcher.close();
     this.webMetafileWatcher.close();
@@ -1272,7 +1566,7 @@ ${addableFiles.map((x) => {
   }
   async metafileOutputs(platform) {
     const metafile = JSON.parse(
-      fs2.readFileSync(
+      fs3.readFileSync(
         `./testeranto/bundles/${platform}/${this.name}/metafile.json`
       ).toString()
     ).metafile;
@@ -1280,16 +1574,22 @@ ${addableFiles.map((x) => {
       return;
     const outputs = metafile.outputs;
     Object.keys(outputs).forEach(async (k) => {
+      const pattern = `testeranto/bundles/${platform}/${this.name}/${this.configs.src}`;
+      if (!k.startsWith(pattern)) {
+        return false;
+      }
       const addableFiles = Object.keys(outputs[k].inputs).filter((i) => {
-        if (!fs2.existsSync(i))
+        if (!fs3.existsSync(i))
           return false;
         if (i.startsWith("node_modules"))
           return false;
+        if (i.startsWith("./node_modules"))
+          return false;
         return true;
       });
       const f = `${k.split(".").slice(0, -1).join(".")}/`;
-      if (!fs2.existsSync(f)) {
-        fs2.mkdirSync(f);
+      if (!fs3.existsSync(f)) {
+        fs3.mkdirSync(f);
       }
       const entrypoint = outputs[k].entryPoint;
       if (entrypoint) {
@@ -1314,10 +1614,10 @@ ${addableFiles.map((x) => {
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
   process.stdin.setRawMode(true);
-console.log(ansiC2.inverse("Press 'x' to shutdown forcefully."));
+console.log(ansiC3.inverse("Press 'x' to shutdown forcefully."));
 process.stdin.on("keypress", (str, key) => {
   if (key.name === "x") {
-    console.log(ansiC2.inverse("Shutting down forcefully..."));
+    console.log(ansiC3.inverse("Shutting down forcefully..."));
     process.exit(-1);
   }
 });