testeranto 0.114.1 → 0.125.0

package/src/PM/main.ts

@@ -1,29 +1,27 @@
-import ts from "typescript";
+import { spawn } from "node:child_process";
 
-import { CdpPage, Page } from "puppeteer-core/lib/esm/puppeteer";
+import ts from "typescript";
+import net from "net";
+import { Page } from "puppeteer-core/lib/esm/puppeteer";
 import fs, { watch } from "fs";
 import path from "path";
-import puppeteer, {
-  Browser,
-  ConsoleMessage,
-  ScreenRecorder,
-  ScreenshotOptions,
-} from "puppeteer-core";
-import { PassThrough } from "stream";
+import puppeteer, { ConsoleMessage, ScreenshotOptions } from "puppeteer-core";
 import ansiC from "ansi-colors";
 import crypto from "node:crypto";
 import { ESLint } from "eslint";
 import tsc from "tsc-prog";
+
+import { IFinalResults, IRunnables } from "../lib/index.js";
 import {
-  IBuiltConfig,
-  IFinalResults,
-  IRunnables,
-  ITestTypes,
-  ITLog,
-} from "../lib/index.js";
-import { ISummary, lintPather, tscPather } from "../utils";
+  getRunnables,
+  ISummary,
+  lintPather,
+  promptPather,
+  tscPather,
+} from "../utils";
+import { IBuiltConfig, IRunTime, ITestTypes } from "../Types.js";
 
-import { PM } from "./index.js";
+import { PM_Base } from "./base.js";
 
 type IOutputs = Record<
   string,
@@ -38,11 +36,7 @@ const formatter = await eslint.loadFormatter(
 );
 const changes: Record<string, string> = {};
 const fileHashes = {};
-const fileStreams3: fs.WriteStream[] = [];
-type IFPaths = string[];
-const fPaths: IFPaths = [];
 const files: Record<string, Set<string>> = {};
-const recorders: Record<string, ScreenRecorder> = {};
 const screenshots: Record<string, Promise<Uint8Array>[]> = {};
 
 async function fileHash(filePath, algorithm = "md5") {
@@ -65,32 +59,6 @@ async function fileHash(filePath, algorithm = "md5") {
   });
 }
 
-const getRunnables = (
-  tests: ITestTypes[],
-  payload = {
-    nodeEntryPoints: {},
-    webEntryPoints: {},
-  }
-): IRunnables => {
-  return tests.reduce((pt, cv, cndx, cry) => {
-    if (cv[1] === "node") {
-      pt.nodeEntryPoints[cv[0]] = path.resolve(
-        `./docs/node/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
-      );
-    } else if (cv[1] === "web") {
-      pt.webEntryPoints[cv[0]] = path.resolve(
-        `./docs/web/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
-      );
-    }
-
-    if (cv[3].length) {
-      getRunnables(cv[3], payload);
-    }
-
-    return pt;
-  }, payload as IRunnables);
-};
-
 const statusMessagePretty = (failures: number, test: string) => {
   if (failures === 0) {
     console.log(ansiC.green(ansiC.inverse(`> ${test} completed successfully`)));
@@ -129,27 +97,36 @@ function isValidUrl(string) {
   }
 }
 
-export class PM_Main extends PM {
-  browser: Browser;
+// Wait for file to exist, checks every 2 seconds by default
+function pollForFile(path, timeout = 2000) {
+  const intervalObj = setInterval(function () {
+    const file = path;
+    const fileExists = fs.existsSync(file);
 
-  shutdownMode = false;
-  configs: IBuiltConfig;
-  ports: Record<number, boolean>;
-  queue: any[];
+    // console.log("Checking for: ", file);
+    // console.log("Exists: ", fileExists);
 
-  mode: "DEV" | "PROD";
+    if (fileExists) {
+      clearInterval(intervalObj);
+    }
+  }, timeout);
+}
 
+export class PM_Main extends PM_Base {
+  name: string;
+  ports: Record<number, boolean>;
+  queue: any[];
+  mode: "once" | "dev";
   bigBoard: ISummary = {};
   webMetafileWatcher: fs.FSWatcher;
   nodeMetafileWatcher: fs.FSWatcher;
+  importMetafileWatcher: fs.FSWatcher;
 
-  constructor(configs: IBuiltConfig) {
-    super();
-
-    this.mode = configs.devMode ? "DEV" : "PROD";
+  constructor(configs: IBuiltConfig, name: string, mode: "once" | "dev") {
+    super(configs);
 
-    this.server = {};
-    this.configs = configs;
+    this.name = name;
+    this.mode = mode;
     this.ports = {};
 
     this.configs.tests.forEach(([t]) => {
@@ -164,290 +141,192 @@ export class PM_Main extends PM {
     this.configs.ports.forEach((element) => {
       this.ports[element] = "true"; // set ports as open
     });
+  }
 
-    globalThis["waitForSelector"] = async (pageKey: string, sel: string) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p) => p.mainFrame()._id === pageKey
-      );
-      await page?.waitForSelector(sel);
-    };
-
-    globalThis["screencastStop"] = async (path: string) => {
-      return recorders[path].stop();
-    };
+  mapping(): [string, (...a) => any][] {
+    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],
+    ];
+  }
 
-    globalThis["closePage"] = async (pageKey) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p) => p.mainFrame()._id === pageKey
-      );
-      /* @ts-ignore:next-line */
-      return page.close();
-    };
-
-    globalThis["goto"] = async (pageKey: string, url: string) => {
-      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: string) => {
-      if (!fs.existsSync(fp)) {
-        return fs.mkdirSync(fp, {
-          recursive: true,
-        });
-      }
-      return false;
-    };
-
-    globalThis["writeFileSync"] = (
-      filepath: string,
-      contents: string,
-      testName: string
-    ) => {
-      fs.mkdirSync(path.dirname(filepath), {
-        recursive: true,
-      });
-      if (!files[testName]) {
-        files[testName] = new Set();
-      }
-      files[testName].add(filepath);
-      return fs.writeFileSync(filepath, contents);
-    };
-
-    globalThis["createWriteStream"] = (filepath: string, testName: string) => {
-      const f = fs.createWriteStream(filepath);
-      fileStreams3.push(f);
-      // files.add(filepath);
-      if (!files[testName]) {
-        files[testName] = new Set();
-      }
-      files[testName].add(filepath);
-      return {
-        ...JSON.parse(JSON.stringify(f)),
-        uid: fileStreams3.length - 1,
-      };
-    };
-
-    globalThis["write"] = (uid: number, contents: string) => {
-      fileStreams3[uid].write(contents);
-    };
-
-    globalThis["end"] = (uid: number) => {
-      fileStreams3[uid].end();
-    };
-
-    globalThis["customScreenShot"] = async (
-      opts: { path: string },
-      pageKey: string,
-      testName: string
-    ) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p) => p.mainFrame()._id === pageKey
-      );
+  async start() {
+    // set up the "pure" listeners
+    this.mapping().forEach(async ([command, func]) => {
+      // page.exposeFunction(command, func);
+      globalThis[command] = func;
+    });
 
-      const p = opts.path as string;
-      const dir = path.dirname(p);
-      fs.mkdirSync(dir, {
-        recursive: true,
-      });
-      if (!files[opts.path]) {
-        files[opts.path] = new Set();
-      }
-      files[opts.path].add(opts.path as string);
+    if (!fs.existsSync(`testeranto/reports/${this.name}`)) {
+      fs.mkdirSync(`testeranto/reports/${this.name}`);
+    }
 
-      const sPromise = page.screenshot({
-        ...opts,
-        path: p,
-      });
+    // await pollForFile();
 
-      if (!screenshots[opts.path]) {
-        screenshots[opts.path] = [];
-      }
-      screenshots[opts.path].push(sPromise);
-
-      await sPromise;
-      return sPromise;
-    };
-
-    globalThis["screencast"] = async (
-      opts: ScreenshotOptions,
-      pageKey: string
-    ) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p) => p.mainFrame()._id === pageKey
-      );
+    this.browser = (await puppeteer.launch({
+      slowMo: 1,
+      waitForInitialPage: false,
+      executablePath:
+        // process.env.CHROMIUM_PATH || "/opt/homebrew/bin/chromium",
+        "/opt/homebrew/bin/chromium",
+      headless: true,
+      dumpio: false,
+      devtools: false,
 
-      const p = opts.path as string;
-      const dir = path.dirname(p);
-      fs.mkdirSync(dir, {
-        recursive: true,
-      });
+      args: [
+        "--allow-file-access-from-files",
+        "--allow-insecure-localhost",
+        "--allow-running-insecure-content",
+        "--auto-open-devtools-for-tabs",
+        "--disable-dev-shm-usage",
+        "--disable-extensions",
+        "--disable-gpu",
+        "--disable-setuid-sandbox",
+        "--disable-site-isolation-trials",
+        "--disable-site-isolation-trials",
+        "--disable-web-security",
+        "--no-first-run",
+        "--no-sandbox",
+        "--no-startup-window",
+        "--reduce-security-for-testing",
+        "--remote-allow-origins=*",
+        `--remote-debugging-port=3234`,
+        "--unsafely-treat-insecure-origin-as-secure=*",
+        // "--disable-features=IsolateOrigins,site-per-process",
+        // "--disable-features=IsolateOrigins",
+        // "--disk-cache-dir=/dev/null",
+        // "--disk-cache-size=1",
+        // "--no-zygote",
+        // "--remote-allow-origins=ws://localhost:3234",
+        // "--single-process",
+        // "--start-maximized",
+        // "--unsafely-treat-insecure-origin-as-secure",
+        // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
+      ],
+    })) as any;
 
-      const recorder = await page?.screencast({
-        ...opts,
-        path: p,
-      });
+    const { nodeEntryPoints, webEntryPoints, importEntryPoints } =
+      this.getRunnables(this.configs.tests, this.name);
+
+    [
+      [
+        nodeEntryPoints,
+        this.launchNode,
+        "node",
+        (w) => {
+          this.nodeMetafileWatcher = w;
+        },
+      ],
+      [
+        webEntryPoints,
+        this.launchWeb,
+        "web",
+        (w) => {
+          this.webMetafileWatcher = w;
+        },
+      ],
+      [
+        importEntryPoints,
+        this.launchPure,
+        "pure",
+        (w) => {
+          this.importMetafileWatcher = w;
+        },
+      ],
+    ].forEach(
+      async ([eps, launcher, runtime, watcher]: [
+        Record<string, string>,
+        (src: string, dest: string) => Promise<void>,
+        IRunTime,
+        (f: fs.FSWatcher) => void
+      ]) => {
+        const metafile = `./testeranto/bundles/${runtime}/${this.name}/metafile.json`;
+
+        await pollForFile(metafile);
+
+        Object.entries(eps).forEach(
+          async ([k, outputFile]: [string, string]) => {
+            // await pollForFile(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);
+            }
+          }
+        );
 
-      recorders[opts.path] = recorder;
+        this.metafileOutputs(runtime);
 
-      return opts.path;
-    };
+        watcher(
+          watch(metafile, async (e, filename) => {
+            console.log(
+              ansiC.green(ansiC.inverse(`< ${e} ${filename} (${runtime})`))
+            );
+            this.metafileOutputs(runtime);
+          })
+        );
+      }
+    );
   }
 
-  stop = () => {
+  async stop() {
     console.log(ansiC.inverse("Testeranto-Run is shutting down gracefully..."));
-    this.mode = "PROD";
+    this.mode = "once";
     this.nodeMetafileWatcher.close();
     this.webMetafileWatcher.close();
+    this.importMetafileWatcher.close();
     this.checkForShutdown();
-  };
-
-  customclose() {
-    throw new Error("Method not implemented.");
-  }
-  waitForSelector(p: string, s: string): any {
-    throw new Error("Method not implemented.");
-  }
-  closePage(p): any {
-    throw new Error("Method not implemented.");
-  }
-  newPage(): CdpPage {
-    throw new Error("Method not implemented.");
-  }
-  goto(p, url: string): any {
-    throw new Error("Method not implemented.");
-  }
-  $(selector: string): boolean {
-    throw new Error("Method not implemented.");
-  }
-  screencast(opts: object) {
-    throw new Error("Method not implemented.");
-  }
-  customScreenShot(opts: object, cdpPage?: CdpPage) {
-    throw new Error("Method not implemented.");
-  }
-  end(accessObject: { uid: number }): boolean {
-    throw new Error("Method not implemented.");
-  }
-  existsSync(destFolder: string): boolean {
-    return fs.existsSync(destFolder);
   }
 
-  async mkdirSync(fp: string) {
-    if (!fs.existsSync(fp)) {
-      return fs.mkdirSync(fp, {
-        recursive: true,
-      });
+  getRunnables = (
+    tests: ITestTypes[],
+    testName: string,
+    payload = {
+      nodeEntryPoints: {},
+      webEntryPoints: {},
+      importEntryPoints: {},
     }
-    return false;
-  }
-
-  writeFileSync(fp: string, contents: string) {
-    fs.writeFileSync(fp, contents);
-  }
-
-  createWriteStream(filepath: string): fs.WriteStream {
-    return fs.createWriteStream(filepath);
-  }
-
-  testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise) => void) {
-    return (fPath, value: string | Buffer | PassThrough) => {
-      callback(
-        new Promise<void>((res, rej) => {
-          tLog("testArtiFactory =>", fPath);
-
-          const cleanPath = path.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(`❗️testArtiFactory failed`, targetDir, error);
-            }
-
-            fs.writeFileSync(
-              path.resolve(
-                targetDir.split("/").slice(0, -1).join("/"),
-                "manifest"
-              ),
-              fPaths.join(`\n`),
-              {
-                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 {
-              /* @ts-ignore:next-line */
-              const pipeStream: PassThrough = value;
-              const myFile = fs.createWriteStream(fPath);
-              pipeStream.pipe(myFile);
-              pipeStream.on("close", () => {
-                myFile.close();
-                res();
-              });
-            }
-          });
-        })
-      );
-    };
-  }
-
-  write(accessObject: { uid: number }, contents: string): boolean {
-    throw new Error("Method not implemented.");
-  }
-  page(): string | undefined {
-    throw new Error("Method not implemented.");
-  }
-  click(selector: string): string | undefined {
-    throw new Error("Method not implemented.");
-  }
-  focusOn(selector: string) {
-    throw new Error("Method not implemented.");
-  }
-  typeInto(value: string) {
-    throw new Error("Method not implemented.");
-  }
-  getValue(value: string) {
-    throw new Error("Method not implemented.");
-  }
-  getAttribute(selector: string, attribute: string) {
-    throw new Error("Method not implemented.");
-  }
-  isDisabled(selector: string): Promise<boolean> {
-    throw new Error("Method not implemented.");
-  }
-  screencastStop(s: string) {
-    throw new Error("Method not implemented.");
-  }
-  ////////////////////////////////////////////////////////////////////////////////
+  ): IRunnables => {
+    return getRunnables(tests, testName, payload);
+  };
 
-  async metafileOutputs(platform: "web" | "node") {
+  async metafileOutputs(platform: IRunTime) {
     const metafile = JSON.parse(
-      fs.readFileSync(`docs/${platform}/metafile.json`).toString()
+      fs
+        .readFileSync(
+          `./testeranto/bundles/${platform}/${this.name}/metafile.json`
+        )
+        .toString()
     ).metafile;
 
     if (!metafile) return;
@@ -487,139 +366,37 @@ export class PM_Main extends PM {
     });
   }
 
-  async start(): Promise<any> {
-    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,
-
-      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-running-insecure-content",
-
-        "--disable-dev-shm-usage",
-        "--disable-extensions",
-        "--disable-gpu",
-        "--disable-setuid-sandbox",
-        "--disable-site-isolation-trials",
-        "--disable-web-security",
-        "--no-first-run",
-        "--no-sandbox",
-        "--no-startup-window",
-        // "--no-zygote",
-        "--reduce-security-for-testing",
-        "--remote-allow-origins=*",
-        "--unsafely-treat-insecure-origin-as-secure=*",
-        // "--disable-features=IsolateOrigins",
-        // "--remote-allow-origins=ws://localhost:3234",
-        // "--single-process",
-        // "--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",
-      ],
-    })) as any;
-
-    const { nodeEntryPoints, webEntryPoints } = getRunnables(
-      this.configs.tests
-    );
-
-    Object.entries(nodeEntryPoints).forEach(
-      ([k, outputFile]: [string, string]) => {
-        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);
-        }
-      }
-    );
-
-    Object.entries(webEntryPoints).forEach(
-      ([k, outputFile]: [string, string]) => {
-        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);
-          }
-        });
-      }
-    );
-
-    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");
-      }
-    );
-
-    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");
-      }
-    );
-  }
-
   tscCheck = async ({
     entrypoint,
     addableFiles,
     platform,
   }: {
-    platform: "web" | "node";
+    platform: IRunTime;
     entrypoint: string;
     addableFiles: string[];
   }) => {
     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
       configFilePath: "tsconfig.json", // 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: string[] = [];
+    const results: string[] = [];
     allDiagnostics.forEach((diagnostic) => {
       if (diagnostic.file) {
         let { line, character } = ts.getLineAndCharacterOfPosition(
@@ -630,34 +407,31 @@ export class PM_Main 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();
-    }
-    // fs.writeFileSync(
-    //   tscExitCodePather(entrypoint, platform),
-    //   d.length.toString()
-    // );
+    fs.writeFileSync(tscPath, results.join("\n"));
+
+    this.typeCheckIsNowDone(entrypoint, results.length);
   };
 
   eslintCheck = async (
     entrypoint: string,
-    platform: "web" | "node",
+    platform: IRunTime,
     addableFiles: string[]
   ) => {
-    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) => {
@@ -669,41 +443,33 @@ export class PM_Main extends PM {
       });
 
     fs.writeFileSync(
-      lintPather(entrypoint, platform),
+      lintPather(entrypoint, platform, this.name),
       await formatter.format(results)
     );
-    this.bigBoard[entrypoint].staticErrors = results.length;
-    if (this.shutdownMode) {
-      this.checkForShutdown();
-    }
-    // fs.writeFileSync(
-    //   lintExitCodePather(entrypoint, platform),
-    //   results.length.toString()
-    // );
+    this.lintIsNowDone(entrypoint, results.length);
   };
 
   makePrompt = async (
     entryPoint: string,
     addableFiles: string[],
-    platform: "web" | "node"
+    platform: IRunTime
   ) => {
     this.bigBoard[entryPoint].prompt = "?";
-    const promptPath = path.join(
-      "./docs/",
-      platform,
-      entryPoint.split(".").slice(0, -1).join("."),
-      `prompt.txt`
-    );
+    const promptPath = promptPather(entryPoint, platform, this.name);
 
     const testPaths = path.join(
-      "./docs/",
+      "testeranto",
+      "reports",
+      this.name,
       platform,
       entryPoint.split(".").slice(0, -1).join("."),
       `tests.json`
     );
 
     const featuresPath = path.join(
-      "./docs/",
+      "testeranto",
+      "reports",
+      this.name,
       platform,
       entryPoint.split(".").slice(0, -1).join("."),
       `featurePrompt.txt`
@@ -718,71 +484,122 @@ ${addableFiles
   })
   .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
+    ].prompt = `aider --model deepseek/deepseek-chat --load testeranto/${
+      this.name
+    }/reports/${platform}/${entryPoint
       .split(".")
       .slice(0, -1)
       .join(".")}/prompt.txt`;
-    if (this.shutdownMode) {
-      this.checkForShutdown();
-    }
+    this.checkForShutdown();
   };
 
   checkForShutdown = () => {
-    const anyRunning: boolean =
-      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(`🕕 prompt ${k}`)));
+        inflight = true;
+      }
+    });
+
+    Object.keys(this.bigBoard).forEach((k) => {
+      if (this.bigBoard[k].runTimeError === "?") {
+        console.log(ansiC.blue(ansiC.inverse(`🕕 runTimeError ${k}`)));
+        inflight = true;
+      }
+    });
+
+    Object.keys(this.bigBoard).forEach((k) => {
+      if (this.bigBoard[k].staticErrors === "?") {
+        console.log(ansiC.blue(ansiC.inverse(`🕕 staticErrors ${k}`)));
+        inflight = true;
+      }
+    });
+
+    Object.keys(this.bigBoard).forEach((k) => {
+      if (this.bigBoard[k].typeErrors === "?") {
+        console.log(ansiC.blue(ansiC.inverse(`🕕 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();
       });
     }
   };
 
-  testIsNowRunning = (src: string) => {
-    this.bigBoard[src].status = "running";
+  typeCheckIsRunning = (src: string) => {
+    this.bigBoard[src].typeErrors = "?";
   };
 
-  testIsNowDone = (src: string) => {
-    this.bigBoard[src].status = "waiting";
-    if (this.shutdownMode) {
-      this.checkForShutdown();
-    }
+  typeCheckIsNowDone = (src: string, failures: number) => {
+    this.bigBoard[src].typeErrors = failures;
+    this.writeBigBoard();
+    this.checkForShutdown();
   };
 
-  launchNode = async (src: string, dest: string) => {
-    // console.log(ansiC.yellow(`! node, ${src}`));
-    console.log(ansiC.green(ansiC.inverse(`! node, ${src}`)));
-    this.testIsNowRunning(src);
+  lintIsRunning = (src: string) => {
+    this.bigBoard[src].staticErrors = "?";
+    this.writeBigBoard();
+  };
+
+  lintIsNowDone = (src: string, failures: number) => {
+    this.bigBoard[src].staticErrors = failures;
+    this.writeBigBoard();
+    this.checkForShutdown();
+  };
+
+  bddTestIsRunning = (src: string) => {
+    this.bigBoard[src].runTimeError = "?";
+    this.writeBigBoard();
+  };
+
+  bddTestIsNowDone = (src: string, failures: number) => {
+    this.bigBoard[src].runTimeError = failures;
+    this.writeBigBoard();
+    this.checkForShutdown();
+  };
+
+  launchPure = async (src: string, dest: string) => {
+    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 (!fs.existsSync(reportDest)) {
+      fs.mkdirSync(reportDest, { recursive: true });
+    }
 
     const destFolder = dest.replace(".mjs", "");
 
@@ -804,7 +621,7 @@ ${addableFiles
         scheduled: true,
         name: src,
         ports: portsToUse,
-        fs: destFolder,
+        fs: reportDest,
         browserWSEndpoint: this.browser.wsEndpoint(),
       });
     } else if (testConfigResource.ports > 0) {
@@ -822,7 +639,6 @@ ${addableFiles
         argz = JSON.stringify({
           scheduled: true,
           name: src,
-          // ports: [3333],
           ports: portsToUse,
           fs: destFolder,
           browserWSEndpoint: this.browser.wsEndpoint(),
@@ -840,6 +656,11 @@ ${addableFiles
 
     const webSideCares: Page[] = [];
 
+    // fs.writeFileSync(
+    //   `${reportDest}/stdlog.txt`,
+    //   "THIS FILE IS AUTO GENERATED. IT IS PURPOSEFULLY LEFT BLANK."
+    // );
+
     // await Promise.all(
     //   testConfig[3].map(async (sidecar) => {
     //     if (sidecar[1] === "web") {
@@ -862,25 +683,21 @@ ${addableFiles
     //   })
     // );
 
-    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 }: IFinalResults) => {
-            this.receiveFeatures(features, destFolder, src);
-            // console.log(`${src} completed with ${failed} errors`);
-            statusMessagePretty(failed, src);
-            this.receiveExitCode(src, failed);
+          .then(async (results: IFinalResults) => {
+            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}`)));
-            // console.log(reset, `${src} errored with`, e);
+            this.bddTestIsNowDone(src, -1);
           })
           .finally(() => {
             webSideCares.forEach((webSideCar) => webSideCar.close());
-            this.testIsNowDone(src);
           });
       });
     });
@@ -893,6 +710,188 @@ ${addableFiles
     }
   };
 
+  launchNode = async (src: string, dest: string) => {
+    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 (!fs.existsSync(reportDest)) {
+      fs.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: string[] = [];
+    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; // port is now closed
+        }
+
+        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;
+
+    // const webSideCares: Page[] = [];
+
+    // await Promise.all(
+    //   testConfig[3].map(async (sidecar) => {
+    //     if (sidecar[1] === "web") {
+    //       const s = await this.launchWebSideCar(
+    //         sidecar[0],
+    //         destinationOfRuntime(sidecar[0], "web", this.configs),
+    //         sidecar
+    //       );
+    //       webSideCares.push(s);
+    //       return s;
+    //     }
+
+    //     if (sidecar[1] === "node") {
+    //       return this.launchNodeSideCar(
+    //         sidecar[0],
+    //         destinationOfRuntime(sidecar[0], "node", this.configs),
+    //         sidecar
+    //       );
+    //     }
+    //   })
+    // );
+
+    // const f = fork(builtfile, [testResources], {
+    //   silent: true,
+    //   // detached: true,
+    //   // stdio: "ignore",
+    // });
+
+    let haltReturns = false;
+
+    let buffer: Buffer<ArrayBufferLike> = new Buffer("");
+    const server = net.createServer((socket) => {
+      socket.on("data", (data) => {
+        buffer = Buffer.concat([buffer, data]);
+
+        let messages: string[][] = [];
+        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) {
+            // b++;
+          }
+        }
+
+        messages.forEach(async (payload) => {
+          // set up the "node" listeners
+          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 = fs.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);
+        }
+
+        // haltReturns = true;
+      });
+      child.on("exit", (code) => {});
+    });
+
+    child.send({ path: p });
+
+    for (let i = 0; i <= portsToUse.length; i++) {
+      if (portsToUse[i]) {
+        this.ports[portsToUse[i]] = "true"; //port is open again
+      }
+    }
+  };
+
   launchWebSideCar = async (
     src: string,
     dest: string,
@@ -918,7 +917,6 @@ ${addableFiles
           page.exposeFunction(
             "custom-screenshot",
             async (ssOpts: ScreenshotOptions, testName: string) => {
-              // console.log("main.ts browser custom-screenshot", testName);
               const p = ssOpts.path as string;
               const dir = path.dirname(p);
               fs.mkdirSync(dir, {
@@ -935,10 +933,8 @@ ${addableFiles
                 screenshots[testName] = [];
               }
               screenshots[testName].push(sPromise);
-              // sPromise.then(())
               await sPromise;
               return sPromise;
-              // page.evaluate(`window["screenshot done"]`);
             }
           );
 
@@ -983,9 +979,6 @@ ${addableFiles
             (fp: string, testName: string) => {
               const f = fs.createWriteStream(fp);
 
-              // if (!files[testName]) {
-              //   files[testName] = new Set();
-              // }
               files[testName].add(fp);
 
               const p = new Promise<string>((res, rej) => {
@@ -1014,24 +1007,12 @@ ${addableFiles
             return fileStreams2[uid].end();
           });
 
-          // page.exposeFunction("customclose", (p: string, testName: string) => {
-          //   fs.writeFileSync(
-          //     p + "/manifest.json",
-          //     JSON.stringify(Array.from(files[testName]))
-          //   );
-          //   delete files[testName];
-
-          //   Promise.all(screenshots[testName] || []).then(() => {
-          //     delete screenshots[testName];
-          //     // page.close();
-          //   });
-          // });
-
           return page;
         })
         .then(async (page) => {
           await page.goto(`file://${`${dest}.html`}`, {});
 
+          /* @ts-ignore:next-line */
           res(page);
         });
     });
@@ -1091,9 +1072,7 @@ ${addableFiles
 
     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) => {
         // console.log("defaultModule", defaultModule);
         const s = new defaultModule();
@@ -1119,27 +1098,24 @@ ${addableFiles
     }
   };
 
-  launchWeb = (t: string, dest: string) => {
-    // console.log(green, "! web", t);
-    console.log(ansiC.green(ansiC.inverse(`! web ${t}`)));
-    this.testIsNowRunning(t);
-
-    // sidecars.map((sidecar) => {
-    //   if (sidecar[1] === "node") {
-    //     return this.launchNodeSideCar(
-    //       sidecar[0],
-    //       destinationOfRuntime(sidecar[0], "node", this.configs),
-    //       sidecar
-    //     );
-    //   }
-    // });
+  launchWeb = async (src: string, dest: string) => {
+    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 (!fs.existsSync(reportDest)) {
+      fs.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(),
     });
 
@@ -1156,303 +1132,82 @@ ${addableFiles
       }
     })`;
 
-    const fileStreams2: fs.WriteStream[] = [];
-    const doneFileStream2: Promise<any>[] = [];
-
-    const stdoutStream = fs.createWriteStream(`${destFolder}/stdout.log`);
-    const stderrStream = fs.createWriteStream(`${destFolder}/stderr.log`);
+    const oStream = fs.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: ScreenshotOptions, testName: string) => {
-            const p = ssOpts.path as string;
-            const dir = path.dirname(p);
-            fs.mkdirSync(dir, {
-              recursive: true,
-            });
-            if (!files[testName]) {
-              files[testName] = new Set();
-            }
-            files[testName].add(ssOpts.path as string);
-
-            const sPromise = page.screenshot({
-              ...ssOpts,
-              path: p,
-            });
-
-            if (!screenshots[testName]) {
-              screenshots[testName] = [];
-            }
-            screenshots[testName].push(sPromise);
-            // sPromise.then(())
-            await sPromise;
-            return sPromise;
-            // page.evaluate(`window["screenshot done"]`);
-          }
-        );
-
-        page.exposeFunction(
-          "customScreenShot",
-          async (ssOpts: ScreenshotOptions, testName: string) => {
-            const p = ssOpts.path as string;
-            const dir = path.dirname(p);
-            fs.mkdirSync(dir, {
-              recursive: true,
-            });
-            if (!files[testName]) {
-              files[testName] = new Set();
-            }
-            files[testName].add(ssOpts.path as string);
-
-            const sPromise = page.screenshot({
-              ...ssOpts,
-              path: p,
-            });
-
-            if (!screenshots[testName]) {
-              screenshots[testName] = [];
-            }
-            screenshots[testName].push(sPromise);
-            // sPromise.then(())
-            await sPromise;
-            return sPromise;
-            // page.evaluate(`window["screenshot done"]`);
-          }
-        );
-
-        page.exposeFunction(
-          "writeFileSync",
-          (fp: string, contents: string, testName: string) => {
-            return globalThis["writeFileSync"](fp, contents, testName);
-            // const dir = path.dirname(fp);
-
-            // fs.mkdirSync(dir, {
-            //   recursive: true,
-            // });
-
-            // const p = new Promise<string>(async (res, rej) => {
-            //   fs.writeFileSync(fp, contents);
-            //   res(fp);
-            // });
-            // doneFileStream2.push(p);
-
-            // if (!files[testName]) {
-            //   files[testName] = new Set();
-            // }
-            // files[testName].add(fp);
-            // return p;
-          }
-        );
-
-        page.exposeFunction("existsSync", (fp: string, contents: string) => {
-          return fs.existsSync(fp);
-        });
-
-        page.exposeFunction("mkdirSync", (fp: string) => {
-          if (!fs.existsSync(fp)) {
-            return fs.mkdirSync(fp, {
-              recursive: true,
-            });
-          }
-          return false;
-        });
-
-        page.exposeFunction(
-          "createWriteStream",
-          (fp: string, testName: string) => {
-            const f = fs.createWriteStream(fp);
-
-            if (!files[testName]) {
-              files[testName] = new Set();
-            }
-            files[testName].add(fp);
-
-            const p = new Promise<string>((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: number, contents: string) => {
-          return fileStreams2[uid].write(contents);
-        });
-
-        page.exposeFunction("end", async (uid: number) => {
-          return fileStreams2[uid].end();
-        });
-
-        // page.exposeFunction("customclose", (p: string, testName: string) => {
-        //   // console.log("closing", p);
-
-        //   console.log("\t GOODBYE customclose");
-
-        //   fs.writeFileSync(
-        //     p + "/manifest.json",
-        //     JSON.stringify(Array.from(files[testName]))
-        //   );
-        //   delete files[testName];
-
-        //   // console.log("screenshots[testName]", screenshots[testName]);
-        //   Promise.all(screenshots[testName] || []).then(() => {
-        //     delete screenshots[testName];
-        //   });
-
-        //   // globalThis["writeFileSync"](
-        //   //   p + "/manifest.json",
-        //   //   // files.entries()
-        //   //   JSON.stringify(Array.from(files[testName]))
-        //   // );
-
-        //   // console.log("closing doneFileStream2", doneFileStream2);
-        //   // console.log("closing doneFileStream2", doneFileStream2);
-        //   // Promise.all([...doneFileStream2, ...screenshots2]).then(() => {
-        //   //   page.close();
-        //   // });
-
-        //   // Promise.all(screenshots).then(() => {
-        //   //   page.close();
-        //   // });
-        //   // setTimeout(() => {
-        //   //   console.log("Delayed for 1 second.");
-        //   //   page.close();
-        //   // }, 5000);
-
-        //   // return page.close();
-        // });
-
-        page.exposeFunction("page", () => {
-          return (page.mainFrame() as unknown as { _id: string })._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: string, attribute: string) => {
-            const attributeValue = await page.$eval(selector, (input) => {
-              return input.getAttribute(attribute);
-            });
-            return attributeValue;
-          }
-        );
-
-        page.exposeFunction("isDisabled", async (selector: string) => {
-          const attributeValue = await page.$eval(
-            selector,
-            (input: HTMLButtonElement) => {
-              return input.disabled;
-            }
-          );
-          return attributeValue;
-        });
-
-        page.exposeFunction("$", async (selector: string) => {
-          const x = page.$(selector);
-          const y = await x;
-
-          return y;
+        // set up the "node" listeners
+        this.mapping().forEach(async ([command, func]) => {
+          page.exposeFunction(command, func);
         });
 
         return page;
       })
       .then(async (page) => {
         const close = () => {
-          if (!files[t]) {
-            files[t] = new Set();
+          if (!files[src]) {
+            files[src] = new Set();
           }
           // files[t].add(filepath);
 
           fs.writeFileSync(
             destFolder + "/manifest.json",
-            JSON.stringify(Array.from(files[t]))
+            JSON.stringify(Array.from(files[src]))
           );
-          delete files[t];
+          delete files[src];
 
-          Promise.all(screenshots[t] || []).then(() => {
-            delete screenshots[t];
+          Promise.all(screenshots[src] || []).then(() => {
+            delete screenshots[src];
             page.close();
-
-            this.testIsNowDone(t);
-            stderrStream.close();
-            stdoutStream.close();
+            oStream.close();
           });
         };
 
         page.on("pageerror", (err: Error) => {
-          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: ConsoleMessage) => {
-          // console.debug(`Log from ${t}: [${log.text()}] `);
-          // console.debug(`Log from ${t}: [${JSON.stringify(log.location())}] `);
-          // console.debug(
-          //   `Log from ${t}: [${JSON.stringify(log.stackTrace())}] `
-          // );
-          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 }: IFinalResults) => {
-            this.receiveFeatures(features, destFolder, t);
-            // console.log(`${t} completed with ${failed} errors`);
-            statusMessagePretty(failed, t);
-            this.receiveExitCode(t, failed);
+          .then(async ({ fails, failed, features }: IFinalResults) => {
+            this.receiveFeatures(features, destFolder, src, "web");
+            statusMessagePretty(fails, src);
+            this.bddTestIsNowDone(src, fails);
           })
           .catch((e) => {
-            // console.log(red, `${t} errored with`, e);
-            console.log(ansiC.red(ansiC.inverse(`${t} errored with: ${e}`)));
+            console.log(ansiC.red(ansiC.inverse(`${src} errored with: ${e}`)));
           })
           .finally(() => {
-            // this.testIsNowDone(t);
+            this.bddTestIsNowDone(src, -1);
             close();
           });
 
@@ -1463,11 +1218,12 @@ ${addableFiles
   receiveFeatures = (
     features: string[],
     destFolder: string,
-    srcTest: string
+    srcTest: string,
+    platform: IRunTime
   ) => {
     const featureDestination = path.resolve(
       process.cwd(),
-      "docs",
+      "reports",
       "features",
       "strings",
       srcTest.split(".").slice(0, -1).join(".") + ".features.txt"
@@ -1483,7 +1239,7 @@ ${addableFiles
           const u = new URL(featureStringKey);
 
           if (u.protocol === "file:") {
-            const newPath = `${process.cwd()}/docs/features/internal/${path.relative(
+            const newPath = `${process.cwd()}/testeranto/features/internal/${path.relative(
               process.cwd(),
               u.pathname
             )}`;
@@ -1508,7 +1264,7 @@ ${addableFiles
             // });
             accum.files.push(newPath);
           } else if (u.protocol === "http:" || u.protocol === "https:") {
-            const newPath = `${process.cwd()}/docs/features/external${
+            const newPath = `${process.cwd()}/testeranto/features/external${
               u.hostname
             }${u.pathname}`;
             const body = await this.configs.featureIngestor(featureStringKey);
@@ -1527,10 +1283,11 @@ ${addableFiles
       }, Promise.resolve({ files: [] as string[], strings: [] as string[] }))
 
       .then(({ files, strings }: { files: string[]; strings: string[] }) => {
-        // writeFileAndCreateDir(`${featureDestination}`, JSON.stringify(strings));
-
         fs.writeFileSync(
-          `${destFolder}/featurePrompt.txt`,
+          `testeranto/reports/${this.name}/${srcTest
+            .split(".")
+            .slice(0, -1)
+            .join(".")}/${platform}/featurePrompt.txt`,
           files
             .map((f) => {
               return `/read ${f}`;
@@ -1538,18 +1295,11 @@ ${addableFiles
             .join("\n")
         );
       });
-
-    // this.writeBigBoard();
-  };
-
-  receiveExitCode = (srcTest: string, failures: number) => {
-    this.bigBoard[srcTest].runTimeError = failures;
-    this.writeBigBoard();
   };
 
   writeBigBoard = () => {
     fs.writeFileSync(
-      "./docs/summary.json",
+      `./testeranto/reports/${this.name}/summary.json`,
       JSON.stringify(this.bigBoard, null, 2)
     );
   };