testeranto 0.121.1 → 0.125.0

package/dist/prebuild/run.mjs

@@ -5,7 +5,9 @@ import ansiC2 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 puppeteer from "puppeteer-core";
@@ -46,164 +48,131 @@ var promptPather = (entryPoint, platform, projectName) => {
     `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/base.ts
 import fs from "fs";
 import path2 from "path";
-
-// src/PM/index.ts
-var PM = class {
-};
-
-// src/PM/base.ts
 var fileStreams3 = [];
 var fPaths = [];
 var files = {};
 var recorders = {};
 var screenshots = {};
-var PM_Base = class extends PM {
+var PM_Base = class {
   constructor(configs) {
-    super();
-    this.server = {};
     this.configs = configs;
-    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 (path4) => {
-      return recorders[path4].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, testName2) => {
-      fs.mkdirSync(path2.dirname(filepath), {
-        recursive: true
-      });
-      if (!files[testName2]) {
-        files[testName2] = /* @__PURE__ */ new Set();
-      }
-      files[testName2].add(filepath);
-      return fs.writeFileSync(filepath, contents);
-    };
-    globalThis["createWriteStream"] = (filepath, testName2) => {
-      const f = fs.createWriteStream(filepath);
-      fileStreams3.push(f);
-      if (!files[testName2]) {
-        files[testName2] = /* @__PURE__ */ new Set();
-      }
-      files[testName2].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, testName2) => {
-      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,
-        /* @ts-ignore:next-line */
-        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.");
+    return new Promise((res) => {
+      this.doInPage(p, async (page) => {
+        const x = page.$(s);
+        const y = await x;
+        res(y !== null);
+      });
+    });
   }
   closePage(p) {
-    throw new Error("Method not implemented.");
+    return new Promise((res) => {
+      this.doInPage(p, async (page) => {
+        page.close();
+        res({});
+      });
+    });
   }
   newPage() {
-    throw new Error("Method not implemented.");
+    return this.browser.newPage();
   }
   goto(p, url) {
-    throw new Error("Method not implemented.");
+    return new Promise((res) => {
+      this.doInPage(p, async (page) => {
+        await page?.goto(url);
+        res({});
+      });
+    });
   }
-  $(selector) {
-    throw new Error("Method not implemented.");
+  $(selector, p) {
+    return new Promise((res) => {
+      this.doInPage(p, async (page) => {
+        const x = page.$(selector);
+        const y = await x;
+        res(y !== null);
+      });
+    });
   }
-  screencast(opts) {
-    throw new Error("Method not implemented.");
+  async pages() {
+    return (await this.browser.pages()).map((p) => {
+      return p.mainFrame()._id;
+    });
   }
-  /* @ts-ignore:next-line */
-  customScreenShot(opts, cdpPage) {
-    throw new Error("Method not implemented.");
+  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;
   }
-  end(accessObject) {
-    throw new Error("Method not implemented.");
+  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);
@@ -216,11 +185,29 @@ var PM_Base = class extends PM {
     }
     return false;
   }
-  writeFileSync(fp, contents) {
-    fs.writeFileSync(fp, contents);
+  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);
+    });
   }
-  createWriteStream(filepath) {
-    return fs.createWriteStream(filepath);
+  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) => {
@@ -267,32 +254,54 @@ var PM_Base = class extends PM {
       );
     };
   }
-  write(accessObject, contents) {
-    throw new Error("Method not implemented.");
+  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) {
-    throw new Error("Method not implemented.");
+  click(selector, page) {
+    return page.click(selector);
   }
-  focusOn(selector) {
-    throw new Error("Method not implemented.");
+  async focusOn(selector, p) {
+    this.doInPage(p, (page) => {
+      return page.focus(selector);
+    });
   }
-  typeInto(value) {
-    throw new Error("Method not implemented.");
+  async typeInto(value, p) {
+    this.doInPage(p, (page) => {
+      return page.keyboard.type(value);
+    });
   }
-  getValue(value) {
-    throw new Error("Method not implemented.");
+  getValue(value, p) {
+    this.doInPage(p, (page) => {
+      return page.keyboard.type(value);
+    });
   }
-  getAttribute(selector, attribute) {
-    throw new Error("Method not implemented.");
+  getAttribute(selector, attribute, p) {
+    this.doInPage(p, (page) => {
+      return page.$eval(selector, (input) => input.getAttribute("value"));
+    });
   }
-  isDisabled(selector) {
-    throw new Error("Method not implemented.");
+  isDisabled(selector, p) {
+    this.doInPage(p, async (page) => {
+      return await page.$eval(selector, (input) => {
+        return input.disabled;
+      });
+    });
   }
   screencastStop(s) {
-    throw new Error("Method not implemented.");
+    return recorders[s].stop();
+  }
+  async doInPage(p, cb) {
+    (await this.browser.pages()).forEach((page) => {
+      if (page.mainFrame()._id === p) {
+        return cb(page);
+      }
+    });
   }
 };
 
@@ -354,36 +363,25 @@ function isValidUrl(string) {
     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 {
   constructor(configs, name, mode2) {
     super(configs);
     this.bigBoard = {};
-    this.stop = () => {
-      console.log(ansiC.inverse("Testeranto-Run is shutting down gracefully..."));
-      this.mode = "once";
-      this.nodeMetafileWatcher.close();
-      this.webMetafileWatcher.close();
-      this.checkForShutdown();
-    };
-    this.getRunnables = (tests, payload = {
+    this.getRunnables = (tests, testName2, payload = {
       nodeEntryPoints: {},
-      webEntryPoints: {}
+      webEntryPoints: {},
+      importEntryPoints: {}
     }) => {
-      return tests.reduce((pt, cv, cndx, cry) => {
-        if (cv[1] === "node") {
-          pt.nodeEntryPoints[cv[0]] = path3.resolve(
-            `./testeranto/bundles/node/${this.name}/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
-          );
-        } else if (cv[1] === "web") {
-          pt.webEntryPoints[cv[0]] = path3.resolve(
-            `./testeranto/bundles/web/${this.name}/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
-          );
-        }
-        if (cv[3].length) {
-          this.getRunnables(cv[3], payload);
-        }
-        return pt;
-      }, payload);
+      return getRunnables(tests, testName2, payload);
     };
     this.tscCheck = async ({
       entrypoint,
@@ -406,6 +404,7 @@ var PM_Main = class extends PM_Base {
         },
         include: addableFiles
         //["src/**/*"],
+        // exclude: ["node_modules", "../testeranto"],
         // exclude: ["**/*.test.ts", "**/*.spec.ts"],
       });
       const tscPath = tscPather(entrypoint, platform, this.name);
@@ -557,10 +556,10 @@ ${addableFiles.map((x) => {
       this.writeBigBoard();
       this.checkForShutdown();
     };
-    this.launchNode = async (src, dest) => {
-      console.log(ansiC.green(ansiC.inverse(`! node, ${src}`)));
+    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(".")}/node`;
+      const reportDest = `testeranto/reports/${this.name}/${src.split(".").slice(0, -1).join(".")}/pure`;
       if (!fs2.existsSync(reportDest)) {
         fs2.mkdirSync(reportDest, { recursive: true });
       }
@@ -595,7 +594,6 @@ ${addableFiles.map((x) => {
           argz = JSON.stringify({
             scheduled: true,
             name: src,
-            // ports: [3333],
             ports: portsToUse,
             fs: destFolder,
             browserWSEndpoint: this.browser.wsEndpoint()
@@ -610,12 +608,12 @@ ${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, "node");
-            statusMessagePretty(failed, src);
-            this.bddTestIsNowDone(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);
@@ -630,6 +628,129 @@ ${addableFiles.map((x) => {
         }
       }
     };
+    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}`)));
@@ -764,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);
@@ -776,7 +897,7 @@ ${addableFiles.map((x) => {
         }
       }
     };
-    this.launchWeb = (src, dest) => {
+    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`;
@@ -801,146 +922,10 @@ ${addableFiles.map((x) => {
         console.log("fail", e)
       }
     })`;
-      const fileStreams2 = [];
-      const doneFileStream2 = [];
-      const stdoutStream = fs2.createWriteStream(`${destFolder}/stdout.log`);
-      const stderrStream = fs2.createWriteStream(`${destFolder}/stderr.log`);
+      const oStream = fs2.createWriteStream(`${reportDest}/console_log.txt`);
       this.browser.newPage().then((page) => {
-        page.on("console", (msg) => {
-          console.log("web > ", msg.args(), msg.text());
-        });
-        page.exposeFunction(
-          "screencast",
-          async (ssOpts, testName2) => {
-            const p = ssOpts.path;
-            const dir = path3.dirname(p);
-            fs2.mkdirSync(dir, {
-              recursive: true
-            });
-            if (!files2[testName2]) {
-              files2[testName2] = /* @__PURE__ */ new Set();
-            }
-            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(
-          "customScreenShot",
-          async (ssOpts, testName2) => {
-            const p = ssOpts.path;
-            const dir = path3.dirname(p);
-            fs2.mkdirSync(dir, {
-              recursive: true
-            });
-            if (!files2[testName2]) {
-              files2[testName2] = /* @__PURE__ */ new Set();
-            }
-            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) => {
-            return globalThis["writeFileSync"](fp, contents, testName2);
-          }
-        );
-        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, testName2) => {
-            const f = fs2.createWriteStream(fp);
-            if (!files2[testName2]) {
-              files2[testName2] = /* @__PURE__ */ new Set();
-            }
-            files2[testName2].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) => {
@@ -956,36 +941,40 @@ ${addableFiles.map((x) => {
           Promise.all(screenshots2[src] || []).then(() => {
             delete screenshots2[src];
             page.close();
-            stderrStream.close();
-            stdoutStream.close();
+            oStream.close();
           });
         };
         page.on("pageerror", (err) => {
           console.debug(`Error from ${src}: [${err.name}] `);
-          stderrStream.write(err.name);
+          oStream.write(err.name);
+          oStream.write("\n");
           if (err.cause) {
             console.debug(`Error from ${src} cause: [${err.cause}] `);
-            stderrStream.write(err.cause);
+            oStream.write(err.cause);
+            oStream.write("\n");
           }
           if (err.stack) {
             console.debug(`Error from stack ${src}: [${err.stack}] `);
-            stderrStream.write(err.stack);
+            oStream.write(err.stack);
+            oStream.write("\n");
           }
           console.debug(`Error from message ${src}: [${err.message}] `);
-          stderrStream.write(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 }) => {
+        await page.evaluate(evaluation).then(async ({ fails, failed, features }) => {
           this.receiveFeatures(features, destFolder, src, "web");
-          statusMessagePretty(failed, src);
-          this.bddTestIsNowDone(src, failed);
+          statusMessagePretty(fails, src);
+          this.bddTestIsNowDone(src, fails);
         }).catch((e) => {
           console.log(ansiC.red(ansiC.inverse(`${src} errored with: ${e}`)));
         }).finally(() => {
@@ -1036,7 +1025,6 @@ ${addableFiles.map((x) => {
         return accum;
       }, Promise.resolve({ files: [], strings: [] })).then(({ files: files3, strings }) => {
         fs2.writeFileSync(
-          // `${destFolder}/featurePrompt.txt`,
           `testeranto/reports/${this.name}/${srcTest.split(".").slice(0, -1).join(".")}/${platform}/featurePrompt.txt`,
           files3.map((f) => {
             return `/read ${f}`;
@@ -1065,7 +1053,37 @@ ${addableFiles.map((x) => {
       this.ports[element] = "true";
     });
   }
+  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}`);
     }
@@ -1110,55 +1128,73 @@ ${addableFiles.map((x) => {
         // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
       ]
     });
-    const { nodeEntryPoints, webEntryPoints } = this.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("node");
-    const w = `./testeranto/bundles/node/${this.name}/metafile.json`;
-    console.log("w", w);
-    this.nodeMetafileWatcher = watch(w, async (e, filename) => {
-      console.log(ansiC.green(ansiC.inverse(`< ${e} ${filename} (node)`)));
-      this.metafileOutputs("node");
-    });
-    this.metafileOutputs("web");
-    this.webMetafileWatcher = watch(
-      `./testeranto/bundles/web/${this.name}/metafile.json`,
-      async (e, filename) => {
-        console.log(ansiC.green(ansiC.inverse(`< ${e} ${filename} (web)`)));
-        this.metafileOutputs("web");
+        );
+        this.metafileOutputs(runtime);
+        watcher(
+          watch(metafile, async (e, filename) => {
+            console.log(
+              ansiC.green(ansiC.inverse(`< ${e} ${filename} (${runtime})`))
+            );
+            this.metafileOutputs(runtime);
+          })
+        );
       }
     );
   }
+  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(