testeranto 0.113.1 → 0.121.1

package/src/PM/main.ts

@@ -1,15 +1,9 @@
 import ts from "typescript";
 
-import { CdpPage, Page } from "puppeteer-core/lib/esm/puppeteer";
+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";
@@ -19,11 +13,10 @@ import {
   IFinalResults,
   IRunnables,
   ITestTypes,
-  ITLog,
 } from "../lib/index.js";
-import { ISummary, lintPather, tscPather } from "../utils";
+import { ISummary, lintPather, promptPather, tscPather } from "../utils";
 
-import { PM } from "./index.js";
+import { PM_Base } from "./base.js";
 
 type IOutputs = Record<
   string,
@@ -38,11 +31,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 +54,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 +92,20 @@ function isValidUrl(string) {
   }
 }
 
-export class PM_Main extends PM {
-  browser: Browser;
-
-  shutdownMode = false;
-  configs: IBuiltConfig;
+export class PM_Main extends PM_Base {
+  name: string;
   ports: Record<number, boolean>;
   queue: any[];
-
-  mode: "DEV" | "PROD";
-
+  mode: "once" | "dev";
   bigBoard: ISummary = {};
   webMetafileWatcher: fs.FSWatcher;
   nodeMetafileWatcher: 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,378 +120,56 @@ 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();
-    };
-
-    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
-      );
-
-      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);
-
-      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: ScreenshotOptions,
-      pageKey: string
-    ) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p) => p.mainFrame()._id === pageKey
-      );
-
-      const p = opts.path as string;
-      const dir = path.dirname(p);
-      fs.mkdirSync(dir, {
-        recursive: true,
-      });
-
-      const recorder = await page?.screencast({
-        ...opts,
-        path: p,
-      });
-
-      recorders[opts.path] = recorder;
-
-      return opts.path;
-    };
-  }
-
-  stop = () => {
-    console.log(ansiC.inverse("Testeranto-Run is shutting down gracefully..."));
-    this.mode = "PROD";
-    this.nodeMetafileWatcher.close();
-    this.webMetafileWatcher.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,
-      });
+  async start(): Promise<any> {
+    if (!fs.existsSync(`testeranto/reports/${this.name}`)) {
+      fs.mkdirSync(`testeranto/reports/${this.name}`);
     }
-    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.");
-  }
-  ////////////////////////////////////////////////////////////////////////////////
-
-  async metafileOutputs(platform: "web" | "node") {
-    const metafile = JSON.parse(
-      fs.readFileSync(`docs/${platform}/metafile.json`).toString()
-    ).metafile;
-
-    if (!metafile) return;
-
-    const outputs: IOutputs = 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]) {
-          // skip
-        } else {
-          changes[entrypoint] = changeDigest;
-          this.tscCheck({
-            platform,
-            addableFiles,
-            entrypoint: "./" + entrypoint,
-          });
-          this.eslintCheck("./" + entrypoint, platform, addableFiles);
-          this.makePrompt("./" + entrypoint, addableFiles, platform);
-        }
-      }
-    });
-  }
-
-  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,
+      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",
       ],
     })) as any;
 
-    const { nodeEntryPoints, webEntryPoints } = getRunnables(
+    const { nodeEntryPoints, webEntryPoints } = this.getRunnables(
       this.configs.tests
     );
 
@@ -572,17 +206,16 @@ export class PM_Main extends PM {
     );
 
     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");
-      }
-    );
+    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(
-      "docs/web/metafile.json",
+      `./testeranto/bundles/web/${this.name}/metafile.json`,
       async (e, filename) => {
         console.log(ansiC.green(ansiC.inverse(`< ${e} ${filename} (web)`)));
         this.metafileOutputs("web");
@@ -590,6 +223,94 @@ export class PM_Main extends PM {
     );
   }
 
+  stop = () => {
+    console.log(ansiC.inverse("Testeranto-Run is shutting down gracefully..."));
+    this.mode = "once";
+    this.nodeMetafileWatcher.close();
+    this.webMetafileWatcher.close();
+    this.checkForShutdown();
+  };
+
+  getRunnables = (
+    tests: ITestTypes[],
+    payload = {
+      nodeEntryPoints: {},
+      webEntryPoints: {},
+    }
+  ): IRunnables => {
+    return tests.reduce((pt, cv, cndx, cry) => {
+      if (cv[1] === "node") {
+        pt.nodeEntryPoints[cv[0]] = path.resolve(
+          `./testeranto/bundles/node/${this.name}/${cv[0]
+            .split(".")
+            .slice(0, -1)
+            .concat("mjs")
+            .join(".")}`
+        );
+      } else if (cv[1] === "web") {
+        pt.webEntryPoints[cv[0]] = path.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 as IRunnables);
+  };
+
+  async metafileOutputs(platform: "web" | "node") {
+    const metafile = JSON.parse(
+      fs
+        .readFileSync(
+          `./testeranto/bundles/${platform}/${this.name}/metafile.json`
+        )
+        .toString()
+    ).metafile;
+
+    if (!metafile) return;
+
+    const outputs: IOutputs = 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]) {
+          // skip
+        } else {
+          changes[entrypoint] = changeDigest;
+          this.tscCheck({
+            platform,
+            addableFiles,
+            entrypoint: "./" + entrypoint,
+          });
+          this.eslintCheck("./" + entrypoint, platform, addableFiles);
+          this.makePrompt("./" + entrypoint, addableFiles, platform);
+        }
+      }
+    });
+  }
+
   tscCheck = async ({
     entrypoint,
     addableFiles,
@@ -600,14 +321,14 @@ export class PM_Main extends PM {
     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,
@@ -615,11 +336,11 @@ export class PM_Main extends PM {
       include: addableFiles, //["src/**/*"],
       // 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,25 +351,21 @@ 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 (
@@ -656,8 +373,9 @@ export class PM_Main extends PM {
     platform: "web" | "node",
     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,17 +387,10 @@ 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 (
@@ -688,22 +399,21 @@ export class PM_Main extends PM {
     platform: "web" | "node"
   ) => {
     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 +428,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();
+  };
+
+  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();
   };
 
   launchNode = async (src: string, dest: string) => {
-    // console.log(ansiC.yellow(`! node, ${src}`));
     console.log(ansiC.green(ansiC.inverse(`! node, ${src}`)));
-    this.testIsNowRunning(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", "");
 
@@ -804,7 +565,7 @@ ${addableFiles
         scheduled: true,
         name: src,
         ports: portsToUse,
-        fs: destFolder,
+        fs: reportDest,
         browserWSEndpoint: this.browser.wsEndpoint(),
       });
     } else if (testConfigResource.ports > 0) {
@@ -869,18 +630,16 @@ ${addableFiles
         defaultModule
           .receiveTestResourceConfig(argz)
           .then(async ({ features, failed }: IFinalResults) => {
-            this.receiveFeatures(features, destFolder, src);
-            // console.log(`${src} completed with ${failed} errors`);
+            this.receiveFeatures(features, destFolder, src, "node");
             statusMessagePretty(failed, src);
-            this.receiveExitCode(src, failed);
+            this.bddTestIsNowDone(src, failed);
           })
           .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);
           });
       });
     });
@@ -918,7 +677,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 +693,8 @@ ${addableFiles
                 screenshots[testName] = [];
               }
               screenshots[testName].push(sPromise);
-              // sPromise.then(())
               await sPromise;
               return sPromise;
-              // page.evaluate(`window["screenshot done"]`);
             }
           );
 
@@ -983,9 +739,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 +767,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);
         });
     });
@@ -1119,10 +860,17 @@ ${addableFiles
     }
   };
 
-  launchWeb = (t: string, dest: string) => {
-    // console.log(green, "! web", t);
-    console.log(ansiC.green(ansiC.inverse(`! web ${t}`)));
-    this.testIsNowRunning(t);
+  launchWeb = (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 });
+    }
 
     // sidecars.map((sidecar) => {
     //   if (sidecar[1] === "node") {
@@ -1139,7 +887,7 @@ ${addableFiles
     const webArgz = JSON.stringify({
       name: dest,
       ports: [].toString(),
-      fs: destFolder,
+      fs: reportDest,
       browserWSEndpoint: this.browser.wsEndpoint(),
     });
 
@@ -1165,9 +913,9 @@ ${addableFiles
     this.browser
       .newPage()
       .then((page) => {
-        // page.on("console", (msg) => {
-        //   // console.log("web > ", msg.args(), msg.text());
-        // });
+        page.on("console", (msg) => {
+          console.log("web > ", msg.args(), msg.text());
+        });
 
         page.exposeFunction(
           "screencast",
@@ -1297,45 +1045,6 @@ ${addableFiles
           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;
         });
@@ -1388,43 +1097,43 @@ ${addableFiles
       })
       .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();
           });
         };
 
         page.on("pageerror", (err: Error) => {
-          console.debug(`Error from ${t}: [${err.name}] `);
+          console.debug(`Error from ${src}: [${err.name}] `);
           stderrStream.write(err.name);
 
           if (err.cause) {
-            console.debug(`Error from ${t} cause: [${err.cause}] `);
+            console.debug(`Error from ${src} cause: [${err.cause}] `);
             stderrStream.write(err.cause);
           }
 
           if (err.stack) {
-            console.debug(`Error from stack ${t}: [${err.stack}] `);
+            console.debug(`Error from stack ${src}: [${err.stack}] `);
             stderrStream.write(err.stack);
           }
 
-          console.debug(`Error from message ${t}: [${err.message}] `);
+          console.debug(`Error from message ${src}: [${err.message}] `);
           stderrStream.write(err.message);
+
+          this.bddTestIsNowDone(src, -1);
           close();
         });
         page.on("console", (log: ConsoleMessage) => {
@@ -1442,17 +1151,17 @@ ${addableFiles
         await page
           .evaluate(evaluation)
           .then(async ({ failed, features }: IFinalResults) => {
-            this.receiveFeatures(features, destFolder, t);
+            this.receiveFeatures(features, destFolder, src, "web");
             // console.log(`${t} completed with ${failed} errors`);
-            statusMessagePretty(failed, t);
-            this.receiveExitCode(t, failed);
+            statusMessagePretty(failed, src);
+            this.bddTestIsNowDone(src, failed);
           })
           .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 +1172,12 @@ ${addableFiles
   receiveFeatures = (
     features: string[],
     destFolder: string,
-    srcTest: string
+    srcTest: string,
+    platform: "node" | "web"
   ) => {
     const featureDestination = path.resolve(
       process.cwd(),
-      "docs",
+      "reports",
       "features",
       "strings",
       srcTest.split(".").slice(0, -1).join(".") + ".features.txt"
@@ -1483,7 +1193,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 +1218,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);
@@ -1530,7 +1240,11 @@ ${addableFiles
         // writeFileAndCreateDir(`${featureDestination}`, JSON.stringify(strings));
 
         fs.writeFileSync(
-          `${destFolder}/featurePrompt.txt`,
+          // `${destFolder}/featurePrompt.txt`,
+          `testeranto/reports/${this.name}/${srcTest
+            .split(".")
+            .slice(0, -1)
+            .join(".")}/${platform}/featurePrompt.txt`,
           files
             .map((f) => {
               return `/read ${f}`;
@@ -1542,14 +1256,9 @@ ${addableFiles
     // 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)
     );
   };