testeranto 0.114.1 → 0.125.0

package/dist/prebuild/run.mjs

@@ -5,9 +5,11 @@ import ansiC2 from "ansi-colors";
 import readline from "readline";
 
 // src/PM/main.ts
+import { spawn } from "node:child_process";
 import ts from "typescript";
-import fs, { watch } from "fs";
-import path2 from "path";
+import net from "net";
+import fs2, { watch } from "fs";
+import path3 from "path";
 import puppeteer from "puppeteer-core";
 import ansiC from "ansi-colors";
 import crypto from "node:crypto";
@@ -16,25 +18,291 @@ import tsc from "tsc-prog";
 
 // src/utils.ts
 import path from "path";
-var tscPather = (entryPoint, platform) => {
+var tscPather = (entryPoint, platform, projectName) => {
   return path.join(
-    "./docs/",
-    platform,
+    "testeranto",
+    "reports",
+    projectName,
     entryPoint.split(".").slice(0, -1).join("."),
+    platform,
     `type_errors.txt`
   );
 };
-var lintPather = (entryPoint, platform) => {
+var lintPather = (entryPoint, platform, projectName) => {
   return path.join(
-    "./docs/",
-    platform,
+    "testeranto",
+    "reports",
+    projectName,
     entryPoint.split(".").slice(0, -1).join("."),
+    platform,
     `lint_errors.json`
   );
 };
+var promptPather = (entryPoint, platform, projectName) => {
+  return path.join(
+    "testeranto",
+    "reports",
+    projectName,
+    entryPoint.split(".").slice(0, -1).join("."),
+    platform,
+    `prompt.txt`
+  );
+};
+var getRunnables = (tests, projectName, payload = {
+  nodeEntryPoints: {},
+  webEntryPoints: {},
+  importEntryPoints: {}
+}) => {
+  return tests.reduce((pt, cv, cndx, cry) => {
+    if (cv[1] === "node") {
+      pt.nodeEntryPoints[cv[0]] = path.resolve(
+        `./testeranto/bundles/node/${projectName}/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
+      );
+    } else if (cv[1] === "web") {
+      pt.webEntryPoints[cv[0]] = path.resolve(
+        `./testeranto/bundles/web/${projectName}/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
+      );
+    } else if (cv[1] === "pure") {
+      pt.importEntryPoints[cv[0]] = path.resolve(
+        `./testeranto/bundles/pure/${projectName}/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
+      );
+    }
+    return pt;
+  }, payload);
+};
 
-// src/PM/index.ts
-var PM = class {
+// src/PM/base.ts
+import fs from "fs";
+import path2 from "path";
+var fileStreams3 = [];
+var fPaths = [];
+var files = {};
+var recorders = {};
+var screenshots = {};
+var PM_Base = class {
+  constructor(configs) {
+    this.configs = configs;
+  }
+  customclose() {
+    throw new Error("Method not implemented.");
+  }
+  waitForSelector(p, s) {
+    return new Promise((res) => {
+      this.doInPage(p, async (page) => {
+        const x = page.$(s);
+        const y = await x;
+        res(y !== null);
+      });
+    });
+  }
+  closePage(p) {
+    return new Promise((res) => {
+      this.doInPage(p, async (page) => {
+        page.close();
+        res({});
+      });
+    });
+  }
+  newPage() {
+    return this.browser.newPage();
+  }
+  goto(p, url) {
+    return new Promise((res) => {
+      this.doInPage(p, async (page) => {
+        await page?.goto(url);
+        res({});
+      });
+    });
+  }
+  $(selector, p) {
+    return new Promise((res) => {
+      this.doInPage(p, async (page) => {
+        const x = page.$(selector);
+        const y = await x;
+        res(y !== null);
+      });
+    });
+  }
+  async pages() {
+    return (await this.browser.pages()).map((p) => {
+      return p.mainFrame()._id;
+    });
+  }
+  async screencast(ssOpts, testName2, page) {
+    const p = ssOpts.path;
+    const dir = path2.dirname(p);
+    fs.mkdirSync(dir, {
+      recursive: true
+    });
+    if (!files[testName2]) {
+      files[testName2] = /* @__PURE__ */ new Set();
+    }
+    files[testName2].add(ssOpts.path);
+    const sPromise = page.screenshot({
+      ...ssOpts,
+      path: p
+    });
+    if (!screenshots[testName2]) {
+      screenshots[testName2] = [];
+    }
+    screenshots[testName2].push(sPromise);
+    await sPromise;
+    return sPromise;
+  }
+  async customScreenShot(ssOpts, testName2, page) {
+    const p = ssOpts.path;
+    const dir = path2.dirname(p);
+    fs.mkdirSync(dir, {
+      recursive: true
+    });
+    if (!files[testName2]) {
+      files[testName2] = /* @__PURE__ */ new Set();
+    }
+    files[testName2].add(ssOpts.path);
+    const sPromise = page.screenshot({
+      ...ssOpts,
+      path: p
+    });
+    if (!screenshots[testName2]) {
+      screenshots[testName2] = [];
+    }
+    screenshots[testName2].push(sPromise);
+    await sPromise;
+    return sPromise;
+  }
+  async end(uid) {
+    await fileStreams3[uid].end();
+    return true;
+  }
+  existsSync(destFolder) {
+    return fs.existsSync(destFolder);
+  }
+  async mkdirSync(fp) {
+    if (!fs.existsSync(fp)) {
+      return fs.mkdirSync(fp, {
+        recursive: true
+      });
+    }
+    return false;
+  }
+  async writeFileSync(filepath, contents, testName2) {
+    return new Promise(async (res) => {
+      fs.mkdirSync(path2.dirname(filepath), {
+        recursive: true
+      });
+      if (!files[testName2]) {
+        files[testName2] = /* @__PURE__ */ new Set();
+      }
+      files[testName2].add(filepath);
+      await fs.writeFileSync(filepath, contents);
+      res(true);
+    });
+  }
+  async createWriteStream(filepath, testName2) {
+    return new Promise((res) => {
+      const f = fs.createWriteStream(filepath);
+      fileStreams3.push(f);
+      if (!files[testName2]) {
+        files[testName2] = /* @__PURE__ */ new Set();
+      }
+      files[testName2].add(filepath);
+      res(fileStreams3.length - 1);
+    });
+  }
+  testArtiFactoryfileWriter(tLog, callback) {
+    return (fPath, value) => {
+      callback(
+        new Promise((res, rej) => {
+          tLog("testArtiFactory =>", fPath);
+          const cleanPath = path2.resolve(fPath);
+          fPaths.push(cleanPath.replace(process.cwd(), ``));
+          const targetDir = cleanPath.split("/").slice(0, -1).join("/");
+          fs.mkdir(targetDir, { recursive: true }, async (error) => {
+            if (error) {
+              console.error(`\u2757\uFE0FtestArtiFactory failed`, targetDir, error);
+            }
+            fs.writeFileSync(
+              path2.resolve(
+                targetDir.split("/").slice(0, -1).join("/"),
+                "manifest"
+              ),
+              fPaths.join(`
+`),
+              {
+                encoding: "utf-8"
+              }
+            );
+            if (Buffer.isBuffer(value)) {
+              fs.writeFileSync(fPath, value, "binary");
+              res();
+            } else if (`string` === typeof value) {
+              fs.writeFileSync(fPath, value.toString(), {
+                encoding: "utf-8"
+              });
+              res();
+            } else {
+              const pipeStream = value;
+              const myFile = fs.createWriteStream(fPath);
+              pipeStream.pipe(myFile);
+              pipeStream.on("close", () => {
+                myFile.close();
+                res();
+              });
+            }
+          });
+        })
+      );
+    };
+  }
+  async write(uid, contents) {
+    return new Promise((res) => {
+      const x = fileStreams3[uid].write(contents);
+      res(x);
+    });
+  }
+  page() {
+    throw new Error("Method not implemented.");
+  }
+  click(selector, page) {
+    return page.click(selector);
+  }
+  async focusOn(selector, p) {
+    this.doInPage(p, (page) => {
+      return page.focus(selector);
+    });
+  }
+  async typeInto(value, p) {
+    this.doInPage(p, (page) => {
+      return page.keyboard.type(value);
+    });
+  }
+  getValue(value, p) {
+    this.doInPage(p, (page) => {
+      return page.keyboard.type(value);
+    });
+  }
+  getAttribute(selector, attribute, p) {
+    this.doInPage(p, (page) => {
+      return page.$eval(selector, (input) => input.getAttribute("value"));
+    });
+  }
+  isDisabled(selector, p) {
+    this.doInPage(p, async (page) => {
+      return await page.$eval(selector, (input) => {
+        return input.disabled;
+      });
+    });
+  }
+  screencastStop(s) {
+    return recorders[s].stop();
+  }
+  async doInPage(p, cb) {
+    (await this.browser.pages()).forEach((page) => {
+      if (page.mainFrame()._id === p) {
+        return cb(page);
+      }
+    });
+  }
 };
 
 // src/PM/main.ts
@@ -44,15 +312,12 @@ var formatter = await eslint.loadFormatter(
 );
 var changes = {};
 var fileHashes = {};
-var fileStreams3 = [];
-var fPaths = [];
-var files = {};
-var recorders = {};
-var screenshots = {};
+var files2 = {};
+var screenshots2 = {};
 async function fileHash(filePath, algorithm = "md5") {
   return new Promise((resolve, reject) => {
     const hash = crypto.createHash(algorithm);
-    const fileStream = fs.createReadStream(filePath);
+    const fileStream = fs2.createReadStream(filePath);
     fileStream.on("data", (data) => {
       hash.update(data);
     });
@@ -65,26 +330,6 @@ async function fileHash(filePath, algorithm = "md5") {
     });
   });
 }
-var getRunnables = (tests, payload = {
-  nodeEntryPoints: {},
-  webEntryPoints: {}
-}) => {
-  return tests.reduce((pt, cv, cndx, cry) => {
-    if (cv[1] === "node") {
-      pt.nodeEntryPoints[cv[0]] = path2.resolve(
-        `./docs/node/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
-      );
-    } else if (cv[1] === "web") {
-      pt.webEntryPoints[cv[0]] = path2.resolve(
-        `./docs/web/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
-      );
-    }
-    if (cv[3].length) {
-      getRunnables(cv[3], payload);
-    }
-    return pt;
-  }, payload);
-};
 var statusMessagePretty = (failures, test) => {
   if (failures === 0) {
     console.log(ansiC.green(ansiC.inverse(`> ${test} completed successfully`)));
@@ -93,18 +338,18 @@ var statusMessagePretty = (failures, test) => {
   }
 };
 async function writeFileAndCreateDir(filePath, data) {
-  const dirPath = path2.dirname(filePath);
+  const dirPath = path3.dirname(filePath);
   try {
-    await fs.promises.mkdir(dirPath, { recursive: true });
-    await fs.appendFileSync(filePath, data);
+    await fs2.promises.mkdir(dirPath, { recursive: true });
+    await fs2.appendFileSync(filePath, data);
   } catch (error) {
     console.error(`Error writing file: ${error}`);
   }
 }
-var filesHash = async (files2, algorithm = "md5") => {
+var filesHash = async (files3, algorithm = "md5") => {
   return new Promise((resolve, reject) => {
     resolve(
-      files2.reduce(async (mm, f) => {
+      files3.reduce(async (mm, f) => {
         return await mm + await fileHash(f);
       }, Promise.resolve(""))
     );
@@ -118,17 +363,25 @@ function isValidUrl(string) {
     return false;
   }
 }
-var PM_Main = class extends PM {
-  constructor(configs) {
-    super();
-    this.shutdownMode = 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 {
+  constructor(configs, name, mode2) {
+    super(configs);
     this.bigBoard = {};
-    this.stop = () => {
-      console.log(ansiC.inverse("Testeranto-Run is shutting down gracefully..."));
-      this.mode = "PROD";
-      this.nodeMetafileWatcher.close();
-      this.webMetafileWatcher.close();
-      this.checkForShutdown();
+    this.getRunnables = (tests, testName2, payload = {
+      nodeEntryPoints: {},
+      webEntryPoints: {},
+      importEntryPoints: {}
+    }) => {
+      return getRunnables(tests, testName2, payload);
     };
     this.tscCheck = async ({
       entrypoint,
@@ -136,7 +389,7 @@ var PM_Main = class extends PM {
       platform
     }) => {
       console.log(ansiC.green(ansiC.inverse(`tsc < ${entrypoint}`)));
-      this.bigBoard[entrypoint].typeErrors = "?";
+      this.typeCheckIsRunning(entrypoint);
       const program = tsc.createProgramFromConfig({
         basePath: process.cwd(),
         // always required, used for relative paths
@@ -144,18 +397,19 @@ var PM_Main = class extends PM {
         // config to inherit from (optional)
         compilerOptions: {
           rootDir: "src",
-          outDir: tscPather(entrypoint, platform),
+          outDir: tscPather(entrypoint, platform, this.name),
           // declaration: true,
           // skipLibCheck: true,
           noEmit: true
         },
         include: addableFiles
         //["src/**/*"],
+        // exclude: ["node_modules", "../testeranto"],
         // exclude: ["**/*.test.ts", "**/*.spec.ts"],
       });
-      const tscPath = tscPather(entrypoint, platform);
+      const tscPath = tscPather(entrypoint, platform, this.name);
       let allDiagnostics = program.getSemanticDiagnostics();
-      const d = [];
+      const results = [];
       allDiagnostics.forEach((diagnostic) => {
         if (diagnostic.file) {
           let { line, character } = ts.getLineAndCharacterOfPosition(
@@ -166,111 +420,149 @@ var PM_Main = class extends PM {
             diagnostic.messageText,
             "\n"
           );
-          d.push(
+          results.push(
             `${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`
           );
         } else {
-          d.push(ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+          results.push(
+            ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")
+          );
         }
       });
-      fs.writeFileSync(tscPath, d.join("\n"));
-      this.bigBoard[entrypoint].typeErrors = d.length;
-      if (this.shutdownMode) {
-        this.checkForShutdown();
-      }
+      fs2.writeFileSync(tscPath, results.join("\n"));
+      this.typeCheckIsNowDone(entrypoint, results.length);
     };
     this.eslintCheck = async (entrypoint, platform, addableFiles) => {
-      this.bigBoard[entrypoint].staticErrors = "?";
       console.log(ansiC.green(ansiC.inverse(`eslint < ${entrypoint}`)));
+      this.lintIsRunning(entrypoint);
       const results = (await eslint.lintFiles(addableFiles)).filter((r) => r.messages.length).filter((r) => {
         return r.messages[0].ruleId !== null;
       }).map((r) => {
         delete r.source;
         return r;
       });
-      fs.writeFileSync(
-        lintPather(entrypoint, platform),
+      fs2.writeFileSync(
+        lintPather(entrypoint, platform, this.name),
         await formatter.format(results)
       );
-      this.bigBoard[entrypoint].staticErrors = results.length;
-      if (this.shutdownMode) {
-        this.checkForShutdown();
-      }
+      this.lintIsNowDone(entrypoint, results.length);
     };
     this.makePrompt = async (entryPoint, addableFiles, platform) => {
       this.bigBoard[entryPoint].prompt = "?";
-      const promptPath = path2.join(
-        "./docs/",
-        platform,
-        entryPoint.split(".").slice(0, -1).join("."),
-        `prompt.txt`
-      );
-      const testPaths = path2.join(
-        "./docs/",
+      const promptPath = promptPather(entryPoint, platform, this.name);
+      const testPaths = path3.join(
+        "testeranto",
+        "reports",
+        this.name,
         platform,
         entryPoint.split(".").slice(0, -1).join("."),
         `tests.json`
       );
-      const featuresPath = path2.join(
-        "./docs/",
+      const featuresPath = path3.join(
+        "testeranto",
+        "reports",
+        this.name,
         platform,
         entryPoint.split(".").slice(0, -1).join("."),
         `featurePrompt.txt`
       );
-      fs.writeFileSync(
+      fs2.writeFileSync(
         promptPath,
         `
 ${addableFiles.map((x) => {
           return `/add ${x}`;
         }).join("\n")}
 
-/read ${lintPather(entryPoint, platform)}
-/read ${tscPather(entryPoint, platform)}
+/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
+          platform,
+          this.name
         )}. Implement any method which throws "Function not implemented. Resolve the lint errors described in ${lintPather(
           entryPoint,
-          platform
+          platform,
+          this.name
         )}"
           `
       );
-      this.bigBoard[entryPoint].prompt = `aider --model deepseek/deepseek-chat --load docs/${platform}/${entryPoint.split(".").slice(0, -1).join(".")}/prompt.txt`;
-      if (this.shutdownMode) {
-        this.checkForShutdown();
-      }
+      this.bigBoard[entryPoint].prompt = `aider --model deepseek/deepseek-chat --load testeranto/${this.name}/reports/${platform}/${entryPoint.split(".").slice(0, -1).join(".")}/prompt.txt`;
+      this.checkForShutdown();
     };
     this.checkForShutdown = () => {
-      const anyRunning = Object.values(this.bigBoard).filter((x) => x.prompt === "?").length + Object.values(this.bigBoard).filter((x) => x.runTimeError === "?").length + Object.values(this.bigBoard).filter((x) => x.staticErrors === "?").length + Object.values(this.bigBoard).filter((x) => x.typeErrors === "?").length > 0;
-      if (anyRunning) {
-        console.log(ansiC.inverse("Shutting down. Please wait"));
-      } else {
+      this.writeBigBoard();
+      if (this.mode === "dev")
+        return;
+      let inflight = false;
+      Object.keys(this.bigBoard).forEach((k) => {
+        if (this.bigBoard[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 === "?") {
+          console.log(ansiC.blue(ansiC.inverse(`\u{1F555} runTimeError ${k}`)));
+          inflight = true;
+        }
+      });
+      Object.keys(this.bigBoard).forEach((k) => {
+        if (this.bigBoard[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 === "?") {
+          console.log(ansiC.blue(ansiC.inverse(`\u{1F555} typeErrors ${k}`)));
+          inflight = true;
+        }
+      });
+      this.writeBigBoard();
+      if (!inflight) {
         this.browser.disconnect().then(() => {
-          fs.writeFileSync(
-            "docs/summary.json",
-            JSON.stringify(this.bigBoard, null, 2)
-          );
-          console.log(ansiC.inverse("Goodbye"));
+          console.log(ansiC.inverse(`${this.name} has been tested. Goodbye.`));
           process.exit();
         });
       }
     };
-    this.testIsNowRunning = (src) => {
-      this.bigBoard[src].status = "running";
+    this.typeCheckIsRunning = (src) => {
+      this.bigBoard[src].typeErrors = "?";
     };
-    this.testIsNowDone = (src) => {
-      this.bigBoard[src].status = "waiting";
-      if (this.shutdownMode) {
-        this.checkForShutdown();
-      }
+    this.typeCheckIsNowDone = (src, failures) => {
+      this.bigBoard[src].typeErrors = failures;
+      this.writeBigBoard();
+      this.checkForShutdown();
     };
-    this.launchNode = async (src, dest) => {
-      console.log(ansiC.green(ansiC.inverse(`! node, ${src}`)));
-      this.testIsNowRunning(src);
+    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.launchPure = async (src, dest) => {
+      console.log(ansiC.green(ansiC.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 });
+      }
       const destFolder = dest.replace(".mjs", "");
       let argz = "";
       const testConfig = this.configs.tests.find((t) => {
@@ -287,7 +579,7 @@ ${addableFiles.map((x) => {
           scheduled: true,
           name: src,
           ports: portsToUse,
-          fs: destFolder,
+          fs: reportDest,
           browserWSEndpoint: this.browser.wsEndpoint()
         });
       } else if (testConfigResource.ports > 0) {
@@ -302,7 +594,6 @@ ${addableFiles.map((x) => {
           argz = JSON.stringify({
             scheduled: true,
             name: src,
-            // ports: [3333],
             ports: portsToUse,
             fs: destFolder,
             browserWSEndpoint: this.browser.wsEndpoint()
@@ -317,17 +608,17 @@ ${addableFiles.map((x) => {
       }
       const builtfile = dest;
       const webSideCares = [];
-      this.server[builtfile] = await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
+      await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
         return module.default.then((defaultModule) => {
-          defaultModule.receiveTestResourceConfig(argz).then(async ({ features, failed }) => {
-            this.receiveFeatures(features, destFolder, src);
-            statusMessagePretty(failed, src);
-            this.receiveExitCode(src, failed);
+          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}`)));
+            this.bddTestIsNowDone(src, -1);
           }).finally(() => {
             webSideCares.forEach((webSideCar) => webSideCar.close());
-            this.testIsNowDone(src);
           });
         });
       });
@@ -337,69 +628,192 @@ ${addableFiles.map((x) => {
         }
       }
     };
-    this.launchWebSideCar = async (src, dest, testConfig) => {
-      const d = dest + ".mjs";
-      console.log(ansiC.green(ansiC.inverse(`launchWebSideCar ${src}`)));
-      const fileStreams2 = [];
-      const doneFileStream2 = [];
-      return new Promise((res, rej) => {
-        this.browser.newPage().then((page) => {
-          page.exposeFunction(
-            "custom-screenshot",
-            async (ssOpts, testName) => {
-              const p = ssOpts.path;
-              const dir = path2.dirname(p);
-              fs.mkdirSync(dir, {
-                recursive: true
-              });
-              files[testName].add(ssOpts.path);
-              const sPromise = page.screenshot({
-                ...ssOpts,
-                path: p
-              });
-              if (!screenshots[testName]) {
-                screenshots[testName] = [];
-              }
-              screenshots[testName].push(sPromise);
-              await sPromise;
-              return sPromise;
-            }
-          );
-          page.exposeFunction(
-            "writeFileSync",
-            (fp, contents, testName) => {
-              const dir = path2.dirname(fp);
-              fs.mkdirSync(dir, {
-                recursive: true
-              });
-              const p = new Promise(async (res2, rej2) => {
-                fs.writeFileSync(fp, contents);
-                res2(fp);
-              });
-              doneFileStream2.push(p);
-              if (!files[testName]) {
-                files[testName] = /* @__PURE__ */ new Set();
-              }
-              files[testName].add(fp);
-              return p;
-            }
-          );
-          page.exposeFunction("existsSync", (fp, contents) => {
-            return fs.existsSync(fp);
-          });
-          page.exposeFunction("mkdirSync", (fp) => {
-            if (!fs.existsSync(fp)) {
-              return fs.mkdirSync(fp, {
-                recursive: true
-              });
-            }
-            return false;
-          });
-          page.exposeFunction(
+    this.launchNode = async (src, dest) => {
+      console.log(ansiC.green(ansiC.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 });
+      }
+      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!"));
+        process.exit(-1);
+      }
+      const testConfigResource = testConfig[2];
+      let portsToUse = [];
+      if (testConfigResource.ports === 0) {
+        testResources = JSON.stringify({
+          scheduled: true,
+          name: src,
+          ports: portsToUse,
+          fs: reportDest,
+          browserWSEndpoint: this.browser.wsEndpoint()
+        });
+      } else if (testConfigResource.ports > 0) {
+        const openPorts = Object.entries(this.ports).filter(
+          ([portnumber, portopen]) => portopen
+        );
+        if (openPorts.length >= testConfigResource.ports) {
+          for (let i = 0; i < testConfigResource.ports; i++) {
+            portsToUse.push(openPorts[i][0]);
+            this.ports[openPorts[i][0]] = false;
+          }
+          testResources = JSON.stringify({
+            scheduled: true,
+            name: src,
+            ports: portsToUse,
+            fs: destFolder,
+            browserWSEndpoint: this.browser.wsEndpoint()
+          });
+        } else {
+          this.queue.push(src);
+          return;
+        }
+      } else {
+        console.error("negative port makes no sense", src);
+        process.exit(-1);
+      }
+      const builtfile = dest;
+      let haltReturns = false;
+      let buffer = new Buffer("");
+      const server = net.createServer((socket) => {
+        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);
+            let d;
+            try {
+              d = JSON.parse(c.toString());
+              messages.push(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]
+                    })
+                  );
+                }
+              }
+            });
+          });
+        });
+      });
+      const oStream = fs2.createWriteStream(`${reportDest}/console_log.txt`);
+      const child = spawn("node", [builtfile, testResources], {
+        stdio: ["pipe", "pipe", "pipe", "ipc"]
+        // silent: true
+      });
+      const p = destFolder + "/pipe";
+      server.listen(p, () => {
+        child.stderr?.on("data", (data) => {
+          oStream.write(`stderr data ${data}`);
+        });
+        child.stdout?.on("data", (data) => {
+          oStream.write(`stdout data ${data}`);
+        });
+        child.on("close", (code) => {
+          oStream.close();
+          server.close();
+          if (code === null) {
+            this.bddTestIsNowDone(src, -1);
+            statusMessagePretty(-1, src);
+          } else if (code === 0) {
+            this.bddTestIsNowDone(src, 0);
+            statusMessagePretty(0, src);
+          } else {
+            this.bddTestIsNowDone(src, code);
+            statusMessagePretty(code, src);
+          }
+        });
+        child.on("exit", (code) => {
+        });
+      });
+      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}`)));
+      const fileStreams2 = [];
+      const doneFileStream2 = [];
+      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);
+          });
+          page.exposeFunction("mkdirSync", (fp) => {
+            if (!fs2.existsSync(fp)) {
+              return fs2.mkdirSync(fp, {
+                recursive: true
+              });
+            }
+            return false;
+          });
+          page.exposeFunction(
             "createWriteStream",
-            (fp, testName) => {
-              const f = fs.createWriteStream(fp);
-              files[testName].add(fp);
+            (fp, testName2) => {
+              const f = fs2.createWriteStream(fp);
+              files2[testName2].add(fp);
               const p = new Promise((res2, rej2) => {
                 res2(fp);
               });
@@ -471,7 +885,7 @@ ${addableFiles.map((x) => {
         process.exit(-1);
       }
       const builtfile = dest + ".mjs";
-      this.server[builtfile] = await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
+      await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
         return module.default.then((defaultModule) => {
           const s = new defaultModule();
           s.receiveTestResourceConfig(argz);
@@ -483,14 +897,18 @@ ${addableFiles.map((x) => {
         }
       }
     };
-    this.launchWeb = (t, dest) => {
-      console.log(ansiC.green(ansiC.inverse(`! web ${t}`)));
-      this.testIsNowRunning(t);
+    this.launchWeb = async (src, dest) => {
+      console.log(ansiC.green(ansiC.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 });
+      }
       const destFolder = dest.replace(".mjs", "");
       const webArgz = JSON.stringify({
         name: dest,
         ports: [].toString(),
-        fs: destFolder,
+        fs: reportDest,
         browserWSEndpoint: this.browser.wsEndpoint()
       });
       const d = `${dest}?cacheBust=${Date.now()}`;
@@ -504,200 +922,72 @@ ${addableFiles.map((x) => {
         console.log("fail", e)
       }
     })`;
-      const fileStreams2 = [];
-      const doneFileStream2 = [];
-      const stdoutStream = fs.createWriteStream(`${destFolder}/stdout.log`);
-      const stderrStream = fs.createWriteStream(`${destFolder}/stderr.log`);
+      const oStream = fs2.createWriteStream(`${reportDest}/console_log.txt`);
       this.browser.newPage().then((page) => {
-        page.exposeFunction(
-          "screencast",
-          async (ssOpts, testName) => {
-            const p = ssOpts.path;
-            const dir = path2.dirname(p);
-            fs.mkdirSync(dir, {
-              recursive: true
-            });
-            if (!files[testName]) {
-              files[testName] = /* @__PURE__ */ new Set();
-            }
-            files[testName].add(ssOpts.path);
-            const sPromise = page.screenshot({
-              ...ssOpts,
-              path: p
-            });
-            if (!screenshots[testName]) {
-              screenshots[testName] = [];
-            }
-            screenshots[testName].push(sPromise);
-            await sPromise;
-            return sPromise;
-          }
-        );
-        page.exposeFunction(
-          "customScreenShot",
-          async (ssOpts, testName) => {
-            const p = ssOpts.path;
-            const dir = path2.dirname(p);
-            fs.mkdirSync(dir, {
-              recursive: true
-            });
-            if (!files[testName]) {
-              files[testName] = /* @__PURE__ */ new Set();
-            }
-            files[testName].add(ssOpts.path);
-            const sPromise = page.screenshot({
-              ...ssOpts,
-              path: p
-            });
-            if (!screenshots[testName]) {
-              screenshots[testName] = [];
-            }
-            screenshots[testName].push(sPromise);
-            await sPromise;
-            return sPromise;
-          }
-        );
-        page.exposeFunction(
-          "writeFileSync",
-          (fp, contents, testName) => {
-            return globalThis["writeFileSync"](fp, contents, testName);
-          }
-        );
-        page.exposeFunction("existsSync", (fp, contents) => {
-          return fs.existsSync(fp);
-        });
-        page.exposeFunction("mkdirSync", (fp) => {
-          if (!fs.existsSync(fp)) {
-            return fs.mkdirSync(fp, {
-              recursive: true
-            });
-          }
-          return false;
-        });
-        page.exposeFunction(
-          "createWriteStream",
-          (fp, testName) => {
-            const f = fs.createWriteStream(fp);
-            if (!files[testName]) {
-              files[testName] = /* @__PURE__ */ new Set();
-            }
-            files[testName].add(fp);
-            const p = new Promise((res, rej) => {
-              res(fp);
-            });
-            doneFileStream2.push(p);
-            f.on("close", async () => {
-              await p;
-            });
-            fileStreams2.push(f);
-            return {
-              ...JSON.parse(JSON.stringify(f)),
-              uid: fileStreams2.length - 1
-            };
-          }
-        );
-        page.exposeFunction("write", async (uid, contents) => {
-          return fileStreams2[uid].write(contents);
-        });
-        page.exposeFunction("end", async (uid) => {
-          return fileStreams2[uid].end();
-        });
-        page.exposeFunction("page", () => {
-          return page.mainFrame()._id;
-        });
-        page.exposeFunction("click", (sel) => {
-          return page.click(sel);
-        });
-        page.exposeFunction("focusOn", (sel) => {
-          return page.focus(sel);
-        });
-        page.exposeFunction(
-          "typeInto",
-          async (value) => await page.keyboard.type(value)
-        );
-        page.exposeFunction(
-          "getValue",
-          (selector) => page.$eval(selector, (input) => input.getAttribute("value"))
-        );
-        page.exposeFunction(
-          "getAttribute",
-          async (selector, attribute) => {
-            const attributeValue = await page.$eval(selector, (input) => {
-              return input.getAttribute(attribute);
-            });
-            return attributeValue;
-          }
-        );
-        page.exposeFunction("isDisabled", async (selector) => {
-          const attributeValue = await page.$eval(
-            selector,
-            (input) => {
-              return input.disabled;
-            }
-          );
-          return attributeValue;
-        });
-        page.exposeFunction("$", async (selector) => {
-          const x = page.$(selector);
-          const y = await x;
-          return y;
+        this.mapping().forEach(async ([command, func]) => {
+          page.exposeFunction(command, func);
         });
         return page;
       }).then(async (page) => {
         const close = () => {
-          if (!files[t]) {
-            files[t] = /* @__PURE__ */ new Set();
+          if (!files2[src]) {
+            files2[src] = /* @__PURE__ */ new Set();
           }
-          fs.writeFileSync(
+          fs2.writeFileSync(
             destFolder + "/manifest.json",
-            JSON.stringify(Array.from(files[t]))
+            JSON.stringify(Array.from(files2[src]))
           );
-          delete files[t];
-          Promise.all(screenshots[t] || []).then(() => {
-            delete screenshots[t];
+          delete files2[src];
+          Promise.all(screenshots2[src] || []).then(() => {
+            delete screenshots2[src];
             page.close();
-            this.testIsNowDone(t);
-            stderrStream.close();
-            stdoutStream.close();
+            oStream.close();
           });
         };
         page.on("pageerror", (err) => {
-          console.debug(`Error from ${t}: [${err.name}] `);
-          stderrStream.write(err.name);
+          console.debug(`Error from ${src}: [${err.name}] `);
+          oStream.write(err.name);
+          oStream.write("\n");
           if (err.cause) {
-            console.debug(`Error from ${t} cause: [${err.cause}] `);
-            stderrStream.write(err.cause);
+            console.debug(`Error from ${src} cause: [${err.cause}] `);
+            oStream.write(err.cause);
+            oStream.write("\n");
           }
           if (err.stack) {
-            console.debug(`Error from stack ${t}: [${err.stack}] `);
-            stderrStream.write(err.stack);
+            console.debug(`Error from stack ${src}: [${err.stack}] `);
+            oStream.write(err.stack);
+            oStream.write("\n");
           }
-          console.debug(`Error from message ${t}: [${err.message}] `);
-          stderrStream.write(err.message);
+          console.debug(`Error from message ${src}: [${err.message}] `);
+          oStream.write(err.message);
+          oStream.write("\n");
+          this.bddTestIsNowDone(src, -1);
           close();
         });
         page.on("console", (log) => {
-          stdoutStream.write(log.text());
-          stdoutStream.write(JSON.stringify(log.location()));
-          stdoutStream.write(JSON.stringify(log.stackTrace()));
+          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`}`, {});
-        await page.evaluate(evaluation).then(async ({ failed, features }) => {
-          this.receiveFeatures(features, destFolder, t);
-          statusMessagePretty(failed, t);
-          this.receiveExitCode(t, failed);
+        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(`${t} errored with: ${e}`)));
+          console.log(ansiC.red(ansiC.inverse(`${src} errored with: ${e}`)));
         }).finally(() => {
+          this.bddTestIsNowDone(src, -1);
           close();
         });
         return page;
       });
     };
-    this.receiveFeatures = (features, destFolder, srcTest) => {
-      const featureDestination = path2.resolve(
+    this.receiveFeatures = (features, destFolder, srcTest, platform) => {
+      const featureDestination = path3.resolve(
         process.cwd(),
-        "docs",
+        "reports",
         "features",
         "strings",
         srcTest.split(".").slice(0, -1).join(".") + ".features.txt"
@@ -708,53 +998,48 @@ ${addableFiles.map((x) => {
         if (isUrl) {
           const u = new URL(featureStringKey);
           if (u.protocol === "file:") {
-            const newPath = `${process.cwd()}/docs/features/internal/${path2.relative(
+            const newPath = `${process.cwd()}/testeranto/features/internal/${path3.relative(
               process.cwd(),
               u.pathname
             )}`;
-            await fs.promises.mkdir(path2.dirname(newPath), { recursive: true });
+            await fs2.promises.mkdir(path3.dirname(newPath), { recursive: true });
             try {
-              await fs.unlinkSync(newPath);
+              await fs2.unlinkSync(newPath);
             } catch (error) {
               if (error.code !== "ENOENT") {
               }
             }
             accum.files.push(newPath);
           } else if (u.protocol === "http:" || u.protocol === "https:") {
-            const newPath = `${process.cwd()}/docs/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 fs.promises.mkdir(path2.dirname(featureDestination), {
+          await fs2.promises.mkdir(path3.dirname(featureDestination), {
             recursive: true
           });
           accum.strings.push(featureStringKey);
         }
         return accum;
-      }, Promise.resolve({ files: [], strings: [] })).then(({ files: files2, strings }) => {
-        fs.writeFileSync(
-          `${destFolder}/featurePrompt.txt`,
-          files2.map((f) => {
+      }, Promise.resolve({ files: [], strings: [] })).then(({ files: files3, strings }) => {
+        fs2.writeFileSync(
+          `testeranto/reports/${this.name}/${srcTest.split(".").slice(0, -1).join(".")}/${platform}/featurePrompt.txt`,
+          files3.map((f) => {
             return `/read ${f}`;
           }).join("\n")
         );
       });
     };
-    this.receiveExitCode = (srcTest, failures) => {
-      this.bigBoard[srcTest].runTimeError = failures;
-      this.writeBigBoard();
-    };
     this.writeBigBoard = () => {
-      fs.writeFileSync(
-        "./docs/summary.json",
+      fs2.writeFileSync(
+        `./testeranto/reports/${this.name}/summary.json`,
         JSON.stringify(this.bigBoard, null, 2)
       );
     };
-    this.mode = configs.devMode ? "DEV" : "PROD";
-    this.server = {};
-    this.configs = configs;
+    this.name = name;
+    this.mode = mode2;
     this.ports = {};
     this.configs.tests.forEach(([t]) => {
       this.bigBoard[t] = {
@@ -767,362 +1052,186 @@ ${addableFiles.map((x) => {
     this.configs.ports.forEach((element) => {
       this.ports[element] = "true";
     });
-    globalThis["waitForSelector"] = async (pageKey, sel) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p) => p.mainFrame()._id === pageKey
-      );
-      await page?.waitForSelector(sel);
-    };
-    globalThis["screencastStop"] = async (path3) => {
-      return recorders[path3].stop();
-    };
-    globalThis["closePage"] = async (pageKey) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p) => p.mainFrame()._id === pageKey
-      );
-      return page.close();
-    };
-    globalThis["goto"] = async (pageKey, url) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p) => p.mainFrame()._id === pageKey
-      );
-      await page?.goto(url);
-      return;
-    };
-    globalThis["newPage"] = () => {
-      return this.browser.newPage();
-    };
-    globalThis["pages"] = () => {
-      return this.browser.pages();
-    };
-    globalThis["mkdirSync"] = (fp) => {
-      if (!fs.existsSync(fp)) {
-        return fs.mkdirSync(fp, {
-          recursive: true
-        });
-      }
-      return false;
-    };
-    globalThis["writeFileSync"] = (filepath, contents, testName) => {
-      fs.mkdirSync(path2.dirname(filepath), {
-        recursive: true
-      });
-      if (!files[testName]) {
-        files[testName] = /* @__PURE__ */ new Set();
-      }
-      files[testName].add(filepath);
-      return fs.writeFileSync(filepath, contents);
-    };
-    globalThis["createWriteStream"] = (filepath, testName) => {
-      const f = fs.createWriteStream(filepath);
-      fileStreams3.push(f);
-      if (!files[testName]) {
-        files[testName] = /* @__PURE__ */ new Set();
-      }
-      files[testName].add(filepath);
-      return {
-        ...JSON.parse(JSON.stringify(f)),
-        uid: fileStreams3.length - 1
-      };
-    };
-    globalThis["write"] = (uid, contents) => {
-      fileStreams3[uid].write(contents);
-    };
-    globalThis["end"] = (uid) => {
-      fileStreams3[uid].end();
-    };
-    globalThis["customScreenShot"] = async (opts, pageKey, testName) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p2) => p2.mainFrame()._id === pageKey
-      );
-      const p = opts.path;
-      const dir = path2.dirname(p);
-      fs.mkdirSync(dir, {
-        recursive: true
-      });
-      if (!files[opts.path]) {
-        files[opts.path] = /* @__PURE__ */ new Set();
-      }
-      files[opts.path].add(opts.path);
-      const sPromise = page.screenshot({
-        ...opts,
-        path: p
-      });
-      if (!screenshots[opts.path]) {
-        screenshots[opts.path] = [];
-      }
-      screenshots[opts.path].push(sPromise);
-      await sPromise;
-      return sPromise;
-    };
-    globalThis["screencast"] = async (opts, pageKey) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p2) => p2.mainFrame()._id === pageKey
-      );
-      const p = opts.path;
-      const dir = path2.dirname(p);
-      fs.mkdirSync(dir, {
-        recursive: true
-      });
-      const recorder = await page?.screencast({
-        ...opts,
-        path: p
-      });
-      recorders[opts.path] = recorder;
-      return opts.path;
-    };
-  }
-  customclose() {
-    throw new Error("Method not implemented.");
-  }
-  waitForSelector(p, s) {
-    throw new Error("Method not implemented.");
   }
-  closePage(p) {
-    throw new Error("Method not implemented.");
-  }
-  newPage() {
-    throw new Error("Method not implemented.");
-  }
-  goto(p, url) {
-    throw new Error("Method not implemented.");
-  }
-  $(selector) {
-    throw new Error("Method not implemented.");
-  }
-  screencast(opts) {
-    throw new Error("Method not implemented.");
-  }
-  customScreenShot(opts, cdpPage) {
-    throw new Error("Method not implemented.");
-  }
-  end(accessObject) {
-    throw new Error("Method not implemented.");
-  }
-  existsSync(destFolder) {
-    return fs.existsSync(destFolder);
-  }
-  async mkdirSync(fp) {
-    if (!fs.existsSync(fp)) {
-      return fs.mkdirSync(fp, {
-        recursive: true
-      });
-    }
-    return false;
-  }
-  writeFileSync(fp, contents) {
-    fs.writeFileSync(fp, contents);
-  }
-  createWriteStream(filepath) {
-    return fs.createWriteStream(filepath);
-  }
-  testArtiFactoryfileWriter(tLog, callback) {
-    return (fPath, value) => {
-      callback(
-        new Promise((res, rej) => {
-          tLog("testArtiFactory =>", fPath);
-          const cleanPath = path2.resolve(fPath);
-          fPaths.push(cleanPath.replace(process.cwd(), ``));
-          const targetDir = cleanPath.split("/").slice(0, -1).join("/");
-          fs.mkdir(targetDir, { recursive: true }, async (error) => {
-            if (error) {
-              console.error(`\u2757\uFE0FtestArtiFactory failed`, targetDir, error);
-            }
-            fs.writeFileSync(
-              path2.resolve(
-                targetDir.split("/").slice(0, -1).join("/"),
-                "manifest"
-              ),
-              fPaths.join(`
-`),
-              {
-                encoding: "utf-8"
-              }
-            );
-            if (Buffer.isBuffer(value)) {
-              fs.writeFileSync(fPath, value, "binary");
-              res();
-            } else if (`string` === typeof value) {
-              fs.writeFileSync(fPath, value.toString(), {
-                encoding: "utf-8"
-              });
-              res();
-            } else {
-              const pipeStream = value;
-              const myFile = fs.createWriteStream(fPath);
-              pipeStream.pipe(myFile);
-              pipeStream.on("close", () => {
-                myFile.close();
-                res();
-              });
-            }
-          });
-        })
-      );
-    };
-  }
-  write(accessObject, contents) {
-    throw new Error("Method not implemented.");
-  }
-  page() {
-    throw new Error("Method not implemented.");
-  }
-  click(selector) {
-    throw new Error("Method not implemented.");
-  }
-  focusOn(selector) {
-    throw new Error("Method not implemented.");
-  }
-  typeInto(value) {
-    throw new Error("Method not implemented.");
-  }
-  getValue(value) {
-    throw new Error("Method not implemented.");
-  }
-  getAttribute(selector, attribute) {
-    throw new Error("Method not implemented.");
-  }
-  isDisabled(selector) {
-    throw new Error("Method not implemented.");
-  }
-  screencastStop(s) {
-    throw new Error("Method not implemented.");
-  }
-  ////////////////////////////////////////////////////////////////////////////////
-  async metafileOutputs(platform) {
-    const metafile = JSON.parse(
-      fs.readFileSync(`docs/${platform}/metafile.json`).toString()
-    ).metafile;
-    if (!metafile)
-      return;
-    const outputs = metafile.outputs;
-    Object.keys(outputs).forEach(async (k) => {
-      const addableFiles = Object.keys(outputs[k].inputs).filter((i) => {
-        if (!fs.existsSync(i))
-          return false;
-        if (i.startsWith("node_modules"))
-          return false;
-        return true;
-      });
-      const f = `${k.split(".").slice(0, -1).join(".")}/`;
-      if (!fs.existsSync(f)) {
-        fs.mkdirSync(f);
-      }
-      const entrypoint = outputs[k].entryPoint;
-      if (entrypoint) {
-        const changeDigest = await filesHash(addableFiles);
-        if (changeDigest === changes[entrypoint]) {
-        } else {
-          changes[entrypoint] = changeDigest;
-          this.tscCheck({
-            platform,
-            addableFiles,
-            entrypoint: "./" + entrypoint
-          });
-          this.eslintCheck("./" + entrypoint, platform, addableFiles);
-          this.makePrompt("./" + entrypoint, addableFiles, platform);
-        }
-      }
-    });
+  mapping() {
+    return [
+      ["$", this.$],
+      ["click", this.click],
+      ["closePage", this.closePage],
+      ["createWriteStream", this.createWriteStream],
+      ["customclose", this.customclose],
+      ["customScreenShot", this.customScreenShot],
+      ["end", this.end],
+      ["existsSync", this.existsSync],
+      ["focusOn", this.focusOn],
+      ["getAttribute", this.getAttribute],
+      ["getValue", this.getValue],
+      ["goto", this.goto],
+      ["isDisabled", this.isDisabled],
+      ["mkdirSync", this.mkdirSync],
+      ["newPage", this.newPage],
+      ["page", this.page],
+      ["pages", this.pages],
+      ["screencast", this.screencast],
+      ["screencastStop", this.screencastStop],
+      ["typeInto", this.typeInto],
+      ["waitForSelector", this.waitForSelector],
+      ["write", this.write],
+      ["writeFileSync", this.writeFileSync]
+    ];
   }
   async start() {
+    this.mapping().forEach(async ([command, func]) => {
+      globalThis[command] = func;
+    });
+    if (!fs2.existsSync(`testeranto/reports/${this.name}`)) {
+      fs2.mkdirSync(`testeranto/reports/${this.name}`);
+    }
     this.browser = await puppeteer.launch({
       slowMo: 1,
-      // timeout: 1,
       waitForInitialPage: false,
       executablePath: (
         // process.env.CHROMIUM_PATH || "/opt/homebrew/bin/chromium",
         "/opt/homebrew/bin/chromium"
       ),
       headless: true,
-      dumpio: true,
-      // timeout: 0,
-      devtools: true,
+      dumpio: false,
+      devtools: false,
       args: [
-        "--auto-open-devtools-for-tabs",
-        `--remote-debugging-port=3234`,
-        // "--disable-features=IsolateOrigins,site-per-process",
-        "--disable-site-isolation-trials",
-        "--allow-insecure-localhost",
         "--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",
-        // "--no-zygote",
         "--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",
-        // "--disk-cache-dir=/dev/null",
-        // "--disk-cache-size=1",
-        // "--start-maximized",
       ]
     });
-    const { nodeEntryPoints, webEntryPoints } = getRunnables(
-      this.configs.tests
-    );
-    Object.entries(nodeEntryPoints).forEach(
-      ([k, outputFile]) => {
-        this.launchNode(k, outputFile);
-        try {
-          watch(outputFile, async (e, filename) => {
-            const hash = await fileHash(outputFile);
-            if (fileHashes[k] !== hash) {
-              fileHashes[k] = hash;
-              console.log(ansiC.green(ansiC.inverse(`< ${e} ${filename}`)));
-              this.launchNode(k, outputFile);
-            }
-          });
-        } catch (e) {
-          console.error(e);
+    const { nodeEntryPoints, webEntryPoints, importEntryPoints } = this.getRunnables(this.configs.tests, this.name);
+    [
+      [
+        nodeEntryPoints,
+        this.launchNode,
+        "node",
+        (w) => {
+          this.nodeMetafileWatcher = w;
         }
-      }
-    );
-    Object.entries(webEntryPoints).forEach(
-      ([k, outputFile]) => {
-        this.launchWeb(k, outputFile);
-        watch(outputFile, async (e, filename) => {
-          const hash = await fileHash(outputFile);
-          if (fileHashes[k] !== hash) {
-            fileHashes[k] = hash;
-            console.log(ansiC.green(ansiC.inverse(`< ${e} ${filename}`)));
-            this.launchWeb(k, outputFile);
+      ],
+      [
+        webEntryPoints,
+        this.launchWeb,
+        "web",
+        (w) => {
+          this.webMetafileWatcher = w;
+        }
+      ],
+      [
+        importEntryPoints,
+        this.launchPure,
+        "pure",
+        (w) => {
+          this.importMetafileWatcher = w;
+        }
+      ]
+    ].forEach(
+      async ([eps, launcher, runtime, watcher]) => {
+        const metafile = `./testeranto/bundles/${runtime}/${this.name}/metafile.json`;
+        await pollForFile(metafile);
+        Object.entries(eps).forEach(
+          async ([k, outputFile]) => {
+            launcher(k, outputFile);
+            try {
+              watch(outputFile, async (e, filename) => {
+                const hash = await fileHash(outputFile);
+                if (fileHashes[k] !== hash) {
+                  fileHashes[k] = hash;
+                  console.log(ansiC.green(ansiC.inverse(`< ${e} ${filename}`)));
+                  launcher(k, outputFile);
+                }
+              });
+            } catch (e) {
+              console.error(e);
+            }
           }
-        });
+        );
+        this.metafileOutputs(runtime);
+        watcher(
+          watch(metafile, async (e, filename) => {
+            console.log(
+              ansiC.green(ansiC.inverse(`< ${e} ${filename} (${runtime})`))
+            );
+            this.metafileOutputs(runtime);
+          })
+        );
       }
     );
-    this.metafileOutputs("node");
-    this.nodeMetafileWatcher = watch(
-      "docs/node/metafile.json",
-      async (e, filename) => {
-        console.log(ansiC.green(ansiC.inverse(`< ${e} ${filename} (node)`)));
-        this.metafileOutputs("node");
+  }
+  async stop() {
+    console.log(ansiC.inverse("Testeranto-Run is shutting down gracefully..."));
+    this.mode = "once";
+    this.nodeMetafileWatcher.close();
+    this.webMetafileWatcher.close();
+    this.importMetafileWatcher.close();
+    this.checkForShutdown();
+  }
+  async metafileOutputs(platform) {
+    const metafile = JSON.parse(
+      fs2.readFileSync(
+        `./testeranto/bundles/${platform}/${this.name}/metafile.json`
+      ).toString()
+    ).metafile;
+    if (!metafile)
+      return;
+    const outputs = metafile.outputs;
+    Object.keys(outputs).forEach(async (k) => {
+      const addableFiles = Object.keys(outputs[k].inputs).filter((i) => {
+        if (!fs2.existsSync(i))
+          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);
       }
-    );
-    this.metafileOutputs("web");
-    this.webMetafileWatcher = watch(
-      "docs/web/metafile.json",
-      async (e, filename) => {
-        console.log(ansiC.green(ansiC.inverse(`< ${e} ${filename} (web)`)));
-        this.metafileOutputs("web");
+      const entrypoint = outputs[k].entryPoint;
+      if (entrypoint) {
+        const changeDigest = await filesHash(addableFiles);
+        if (changeDigest === changes[entrypoint]) {
+        } else {
+          changes[entrypoint] = changeDigest;
+          this.tscCheck({
+            platform,
+            addableFiles,
+            entrypoint: "./" + entrypoint
+          });
+          this.eslintCheck("./" + entrypoint, platform, addableFiles);
+          this.makePrompt("./" + entrypoint, addableFiles, platform);
+        }
       }
-    );
+    });
   }
 };
 
@@ -1137,13 +1246,21 @@ process.stdin.on("keypress", (str, key) => {
     process.exit(-1);
   }
 });
-import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
-  const rawConfig = module.default;
+var testName = process.argv[2];
+var mode = process.argv[3];
+if (mode !== "once" && mode !== "dev") {
+  console.error("the 2nd argument should be 'dev' or 'once' ");
+  process.exit(-1);
+}
+console.log("testeranto is running", testName, mode);
+import(process.cwd() + "/testeranto.config.ts").then(async (module) => {
+  const bigConfig = module.default;
+  const rawConfig = bigConfig.projects[testName];
   const config = {
     ...rawConfig,
-    buildDir: process.cwd() + "/" + rawConfig.outdir
+    buildDir: process.cwd() + `/testeranto/${testName}.json`
   };
-  const pm = new PM_Main(config);
+  const pm = new PM_Main(config, testName, mode);
   pm.start();
   process.stdin.on("keypress", (str, key) => {
     if (key.name === "q") {