testeranto 0.128.0 → 0.134.0

package/src/PM/main.ts

@@ -1,27 +1,27 @@
-import { spawn } from "node:child_process";
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable no-async-promise-executor */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { ChildProcess, spawn } from "node:child_process";
 
-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, { ConsoleMessage, ScreenshotOptions } from "puppeteer-core";
+import puppeteer, { ConsoleMessage } 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 {
-  getRunnables,
-  ISummary,
-  lintPather,
-  promptPather,
-  tscPather,
-} from "../utils";
+  IFinalResults,
+  IRunnables,
+  ITTestResourceConfiguration,
+} from "../lib/index.js";
+import { getRunnables } from "../utils";
 import { IBuiltConfig, IRunTime, ITestTypes } from "../Types.js";
-
-import { PM_Base } from "./base.js";
+import { Sidecar } from "../lib/Sidecar.js";
+import { Queue } from "../utils/queue.js";
+import { PM_WithEslintAndTsc } from "./PM_WithEslintAndTsc.js";
 
 type IOutputs = Record<
   string,
@@ -30,10 +30,7 @@ type IOutputs = Record<
     inputs: Record<string, string>;
   }
 >;
-const eslint = new ESLint();
-const formatter = await eslint.loadFormatter(
-  "./node_modules/testeranto/dist/prebuild/esbuildConfigs/eslint-formatter-testeranto.mjs"
-);
+
 const changes: Record<string, string> = {};
 const fileHashes = {};
 const files: Record<string, Set<string>> = {};
@@ -61,7 +58,9 @@ async function fileHash(filePath, algorithm = "md5") {
 
 const statusMessagePretty = (failures: number, test: string) => {
   if (failures === 0) {
-    console.log(ansiC.green(ansiC.inverse(`> ${test} completed successfully`)));
+    console.log(
+      ansiC.green(ansiC.inverse(`> ${test} completed successfully?!?`))
+    );
   } else {
     console.log(ansiC.red(ansiC.inverse(`> ${test} failed ${failures} times`)));
   }
@@ -72,7 +71,7 @@ async function writeFileAndCreateDir(filePath, data) {
 
   try {
     await fs.promises.mkdir(dirPath, { recursive: true });
-    await fs.appendFileSync(filePath, data);
+    await fs.writeFileSync(filePath, data);
   } catch (error) {
     console.error(`Error writing file: ${error}`);
   }
@@ -98,7 +97,7 @@ function isValidUrl(string) {
 }
 
 // Wait for file to exist, checks every 2 seconds by default
-function pollForFile(path, timeout = 2000) {
+async function pollForFile(path, timeout = 2000) {
   const intervalObj = setInterval(function () {
     const file = path;
     const fileExists = fs.existsSync(file);
@@ -112,35 +111,82 @@ function pollForFile(path, timeout = 2000) {
   }, timeout);
 }
 
-export class PM_Main extends PM_Base {
-  name: string;
+export class PM_Main extends PM_WithEslintAndTsc {
   ports: Record<number, boolean>;
   queue: any[];
-  mode: "once" | "dev";
-  bigBoard: ISummary = {};
   webMetafileWatcher: fs.FSWatcher;
   nodeMetafileWatcher: fs.FSWatcher;
   importMetafileWatcher: fs.FSWatcher;
+  pureSidecars: Record<number, Sidecar>;
+  nodeSidecars: Record<number, ChildProcess>;
+  webSidecars: Record<number, Page>;
 
   constructor(configs: IBuiltConfig, name: string, mode: "once" | "dev") {
-    super(configs);
+    super(configs, name, mode);
 
-    this.name = name;
-    this.mode = mode;
     this.ports = {};
+    this.queue = [];
 
-    this.configs.tests.forEach(([t]) => {
-      this.bigBoard[t] = {
-        runTimeError: "?",
-        typeErrors: "?",
-        staticErrors: "?",
-        prompt: "?",
-      };
-    });
+    this.nodeSidecars = {};
+    this.webSidecars = {};
+    this.pureSidecars = {};
 
     this.configs.ports.forEach((element) => {
-      this.ports[element] = "true"; // set ports as open
+      this.ports[element] = true; // set ports as open
+    });
+  }
+
+  async stopSideCar(uid: number): Promise<any> {
+    console.log(ansiC.green(ansiC.inverse(`stopSideCar ${uid}`)));
+
+    Object.entries(this.pureSidecars).forEach(async ([k, v]) => {
+      if (Number(k) === uid) {
+        await this.pureSidecars[Number(k)].stop();
+        delete this.pureSidecars[Number(k)];
+      }
     });
+
+    Object.entries(this.nodeSidecars).forEach(async ([k, v]) => {
+      if (Number(k) === uid) {
+        await this.nodeSidecars[Number(k)].send("stop");
+        delete this.nodeSidecars[Number(k)];
+      }
+    });
+
+    Object.entries(this.webSidecars).forEach(async ([k, v]) => {
+      if (Number(k) === uid) {
+        (await this.browser.pages()).forEach(async (p) => {
+          if (p.mainFrame()._id === k) {
+            await this.webSidecars[Number(k)].close();
+            delete this.webSidecars[Number(k)];
+          }
+        });
+      }
+    });
+
+    return;
+  }
+
+  async launchSideCar(
+    n: number,
+    name: string
+  ): Promise<[number, ITTestResourceConfiguration]> {
+    const c = this.configs.tests.find(([v, r]) => {
+      return v === name;
+    }) as ITestTypes;
+
+    const s = c[3][n];
+
+    const r = s[1];
+    if (r === "node") {
+      return this.launchNodeSideCar(s);
+    } else if (r === "web") {
+      return this.launchWebSideCar(s);
+    } else if (r === "pure") {
+      return this.launchPureSideCar(s);
+    } else {
+      throw `unknown runtime ${r}`;
+    }
   }
 
   mapping(): [string, (...a) => any][] {
@@ -150,20 +196,23 @@ export class PM_Main extends PM_Base {
       ["closePage", this.closePage],
       ["createWriteStream", this.createWriteStream],
       ["customclose", this.customclose],
-      ["customScreenShot", this.customScreenShot],
+      ["customScreenShot", this.customScreenShot.bind(this)],
       ["end", this.end],
       ["existsSync", this.existsSync],
       ["focusOn", this.focusOn],
       ["getAttribute", this.getAttribute],
-      ["getValue", this.getValue],
-      ["goto", this.goto],
+      ["getInnerHtml", this.getInnerHtml],
+      // ["setValue", this.setValue],
+      ["goto", this.goto.bind(this)],
       ["isDisabled", this.isDisabled],
+      ["launchSideCar", this.launchSideCar.bind(this)],
       ["mkdirSync", this.mkdirSync],
       ["newPage", this.newPage],
       ["page", this.page],
       ["pages", this.pages],
       ["screencast", this.screencast],
       ["screencastStop", this.screencastStop],
+      ["stopSideCar", this.stopSideCar.bind(this)],
       ["typeInto", this.typeInto],
       ["waitForSelector", this.waitForSelector],
       ["write", this.write],
@@ -174,7 +223,6 @@ export class PM_Main extends PM_Base {
   async start() {
     // set up the "pure" listeners
     this.mapping().forEach(async ([command, func]) => {
-      // page.exposeFunction(command, func);
       globalThis[command] = func;
     });
 
@@ -182,51 +230,59 @@ export class PM_Main extends PM_Base {
       fs.mkdirSync(`testeranto/reports/${this.name}`);
     }
 
-    // await pollForFile();
-
-    this.browser = (await puppeteer.launch({
-      slowMo: 1,
-      waitForInitialPage: false,
-      executablePath:
-        // process.env.CHROMIUM_PATH || "/opt/homebrew/bin/chromium",
-        "/opt/homebrew/bin/chromium",
-      headless: true,
-      dumpio: false,
-      devtools: false,
-
-      args: [
-        "--allow-file-access-from-files",
-        "--allow-insecure-localhost",
-        "--allow-running-insecure-content",
-        "--auto-open-devtools-for-tabs",
-        "--disable-dev-shm-usage",
-        "--disable-extensions",
-        "--disable-gpu",
-        "--disable-setuid-sandbox",
-        "--disable-site-isolation-trials",
-        "--disable-site-isolation-trials",
-        "--disable-web-security",
-        "--no-first-run",
-        "--no-sandbox",
-        "--no-startup-window",
-        "--reduce-security-for-testing",
-        "--remote-allow-origins=*",
-        `--remote-debugging-port=3234`,
-        "--unsafely-treat-insecure-origin-as-secure=*",
-        // "--disable-features=IsolateOrigins,site-per-process",
-        // "--disable-features=IsolateOrigins",
-        // "--disk-cache-dir=/dev/null",
-        // "--disk-cache-size=1",
-        // "--no-zygote",
-        // "--remote-allow-origins=ws://localhost:3234",
-        // "--single-process",
-        // "--start-maximized",
-        // "--unsafely-treat-insecure-origin-as-secure",
-        // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
-      ],
-    })) as any;
+    const executablePath = "/opt/homebrew/bin/chromium";
 
-    const { nodeEntryPoints, webEntryPoints, importEntryPoints } =
+    try {
+      this.browser = await puppeteer.launch({
+        slowMo: 1,
+        waitForInitialPage: false,
+        executablePath,
+
+        headless: false,
+
+        dumpio: false,
+        devtools: false,
+
+        args: [
+          "--disable-features=site-per-process",
+          "--allow-file-access-from-files",
+          "--allow-insecure-localhost",
+          "--allow-running-insecure-content",
+          "--auto-open-devtools-for-tabs",
+          "--disable-dev-shm-usage",
+          "--disable-extensions",
+          "--disable-gpu",
+          "--disable-setuid-sandbox",
+          "--disable-site-isolation-trials",
+          "--disable-web-security",
+          "--no-first-run",
+          "--no-sandbox",
+          "--no-startup-window",
+          "--reduce-security-for-testing",
+          "--remote-allow-origins=*",
+          "--unsafely-treat-insecure-origin-as-secure=*",
+          `--remote-debugging-port=3234`,
+          // "--disable-features=IsolateOrigins,site-per-process",
+          // "--disable-features=IsolateOrigins",
+          // "--disk-cache-dir=/dev/null",
+          // "--disk-cache-size=1",
+          // "--no-zygote",
+          // "--remote-allow-origins=ws://localhost:3234",
+          // "--single-process",
+          // "--start-maximized",
+          // "--unsafely-treat-insecure-origin-as-secure",
+          // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
+        ],
+      });
+    } catch (e) {
+      console.error(e);
+      console.error(
+        "could not start chrome via puppeter. Check this path: ",
+        executablePath
+      );
+    }
+
+    const { nodeEntryPoints, webEntryPoints, pureEntryPoints } =
       this.getRunnables(this.configs.tests, this.name);
 
     [
@@ -247,7 +303,7 @@ export class PM_Main extends PM_Base {
         },
       ],
       [
-        importEntryPoints,
+        pureEntryPoints,
         this.launchPure,
         "pure",
         (w) => {
@@ -299,6 +355,43 @@ export class PM_Main extends PM_Base {
         );
       }
     );
+
+    // Object.keys(this.configs.externalTests).forEach((et) => {
+    //   this.launchExternalTest(et, this.configs.externalTests[et]);
+    // });
+  }
+
+  async launchExternalTest(
+    externalTestName: string,
+    externalTest: {
+      watch: string[];
+      exec: string;
+    }
+  ) {
+    // fs.mkdirSync(`testeranto/externalTests/${externalTestName}`);
+    // exec(externalTest.exec, (error, stdout, stderr) => {
+    //   if (error) {
+    //     fs.writeFileSync(
+    //       `testeranto/externalTests/${externalTestName}/exitcode.txt`,
+    //       `${error.name}\n${error.message}\n${error.code}\n`
+    //     );
+    //   } else {
+    //     fs.writeFileSync(
+    //       `testeranto/externalTests/${externalTestName}/exitcode.txt`,
+    //       `0`
+    //     );
+    //   }
+    //   fs.writeFileSync(
+    //     `testeranto/externalTests/${externalTestName}/stdout.txt`,
+    //     stdout
+    //   );
+    //   fs.writeFileSync(
+    //     `testeranto/externalTests/${externalTestName}/stderr.txt`,
+    //     stderr
+    //   );
+    //   // console.log(`externalTest stdout: ${stdout}`);
+    //   // console.error(`externalTest stderr: ${stderr}`);
+    // });
   }
 
   async stop() {
@@ -315,8 +408,11 @@ export class PM_Main extends PM_Base {
     testName: string,
     payload = {
       nodeEntryPoints: {},
+      nodeEntryPointSidecars: {},
       webEntryPoints: {},
-      importEntryPoints: {},
+      webEntryPointSidecars: {},
+      pureEntryPoints: {},
+      pureEntryPointSidecars: {},
     }
   ): IRunnables => {
     return getRunnables(tests, testName, payload);
@@ -336,13 +432,21 @@ export class PM_Main extends PM_Base {
     const outputs: IOutputs = metafile.outputs;
 
     Object.keys(outputs).forEach(async (k) => {
+      const pattern = `testeranto/bundles/${platform}/${this.name}/${this.configs.src}`;
+      if (!k.startsWith(pattern)) {
+        return false;
+      }
+
       const addableFiles = Object.keys(outputs[k].inputs).filter((i) => {
         if (!fs.existsSync(i)) return false;
         if (i.startsWith("node_modules")) return false;
+        if (i.startsWith("./node_modules")) return false;
+
         return true;
       });
 
       const f = `${k.split(".").slice(0, -1).join(".")}/`;
+
       if (!fs.existsSync(f)) {
         fs.mkdirSync(f);
       }
@@ -368,228 +472,6 @@ export class PM_Main extends PM_Base {
     });
   }
 
-  tscCheck = async ({
-    entrypoint,
-    addableFiles,
-    platform,
-  }: {
-    platform: IRunTime;
-    entrypoint: string;
-    addableFiles: string[];
-  }) => {
-    console.log(ansiC.green(ansiC.inverse(`tsc < ${entrypoint}`)));
-    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: {
-        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, this.name);
-
-    let allDiagnostics = program.getSemanticDiagnostics();
-
-    const results: string[] = [];
-    allDiagnostics.forEach((diagnostic) => {
-      if (diagnostic.file) {
-        let { line, character } = ts.getLineAndCharacterOfPosition(
-          diagnostic.file,
-          diagnostic.start!
-        );
-        let message = ts.flattenDiagnosticMessageText(
-          diagnostic.messageText,
-          "\n"
-        );
-        results.push(
-          `${diagnostic.file.fileName} (${line + 1},${
-            character + 1
-          }): ${message}`
-        );
-      } else {
-        results.push(
-          ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")
-        );
-      }
-    });
-
-    fs.writeFileSync(tscPath, results.join("\n"));
-
-    this.typeCheckIsNowDone(entrypoint, results.length);
-  };
-
-  eslintCheck = async (
-    entrypoint: string,
-    platform: IRunTime,
-    addableFiles: string[]
-  ) => {
-    console.log(ansiC.green(ansiC.inverse(`eslint < ${entrypoint}`)));
-    this.lintIsRunning(entrypoint);
-
-    const results = (await eslint.lintFiles(addableFiles))
-      .filter((r) => r.messages.length)
-      .filter((r) => {
-        return r.messages[0].ruleId !== null;
-      })
-      .map((r) => {
-        delete r.source;
-        return r;
-      });
-
-    fs.writeFileSync(
-      lintPather(entrypoint, platform, this.name),
-      await formatter.format(results)
-    );
-    this.lintIsNowDone(entrypoint, results.length);
-  };
-
-  makePrompt = async (
-    entryPoint: string,
-    addableFiles: string[],
-    platform: IRunTime
-  ) => {
-    this.bigBoard[entryPoint].prompt = "?";
-    const promptPath = promptPather(entryPoint, platform, this.name);
-
-    const testPaths = path.join(
-      "testeranto",
-      "reports",
-      this.name,
-      platform,
-      entryPoint.split(".").slice(0, -1).join("."),
-      `tests.json`
-    );
-
-    const featuresPath = path.join(
-      "testeranto",
-      "reports",
-      this.name,
-      platform,
-      entryPoint.split(".").slice(0, -1).join("."),
-      `featurePrompt.txt`
-    );
-
-    fs.writeFileSync(
-      promptPath,
-      `
-${addableFiles
-  .map((x) => {
-    return `/add ${x}`;
-  })
-  .join("\n")}
-
-/read ${lintPather(entryPoint, platform, this.name)}
-/read ${tscPather(entryPoint, platform, this.name)}
-/read ${testPaths}
-
-/load ${featuresPath}
-
-/code Fix the failing tests described in ${testPaths}. Correct any type signature errors described in the files ${tscPather(
-        entryPoint,
-        platform,
-        this.name
-      )}. Implement any method which throws "Function not implemented. Resolve the lint errors described in ${lintPather(
-        entryPoint,
-        platform,
-        this.name
-      )}"
-          `
-    );
-    this.bigBoard[
-      entryPoint
-    ].prompt = `aider --model deepseek/deepseek-chat --load testeranto/${
-      this.name
-    }/reports/${platform}/${entryPoint
-      .split(".")
-      .slice(0, -1)
-      .join(".")}/prompt.txt`;
-    this.checkForShutdown();
-  };
-
-  checkForShutdown = () => {
-    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(() => {
-        console.log(ansiC.inverse(`${this.name} has been tested. Goodbye.`));
-        process.exit();
-      });
-    }
-  };
-
-  typeCheckIsRunning = (src: string) => {
-    this.bigBoard[src].typeErrors = "?";
-  };
-
-  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();
-  };
-
   launchPure = async (src: string, dest: string) => {
     console.log(ansiC.green(ansiC.inverse(`! pure, ${src}`)));
     this.bddTestIsRunning(src);
@@ -598,6 +480,7 @@ ${addableFiles
       .split(".")
       .slice(0, -1)
       .join(".")}/pure`;
+
     if (!fs.existsSync(reportDest)) {
       fs.mkdirSync(reportDest, { recursive: true });
     }
@@ -616,7 +499,7 @@ ${addableFiles
     }
     const testConfigResource = testConfig[2];
 
-    let portsToUse: string[] = [];
+    const portsToUse: string[] = [];
     if (testConfigResource.ports === 0) {
       argz = JSON.stringify({
         scheduled: true,
@@ -691,19 +574,23 @@ ${addableFiles
             defaultModule
               .receiveTestResourceConfig(argz)
               .then(async (results: IFinalResults) => {
-                this.receiveFeatures(results.features, destFolder, src, "pure");
+                // this.receiveFeatures(results.features, destFolder, src, "pure");
+                // this.receiveFeaturesV2(reportDest, src, "pure");
+
                 statusMessagePretty(results.fails, src);
                 this.bddTestIsNowDone(src, results.fails);
               })
               .catch((e) => {
                 console.log(
-                  ansiC.red(ansiC.inverse(`${src} errored with: ${e}`))
+                  ansiC.red(
+                    ansiC.inverse(`launchPure - ${src} errored with: ${e}`)
+                  )
                 );
                 this.bddTestIsNowDone(src, -1);
-              })
-              .finally(() => {
-                webSideCares.forEach((webSideCar) => webSideCar.close());
               });
+            // .finally(() => {
+            //   // webSideCares.forEach((webSideCar) => webSideCar.close());
+            // });
           })
           .catch((e) => {
             console.log(
@@ -732,10 +619,9 @@ ${addableFiles
       statusMessagePretty(-1, src);
     }
 
-    // console.log("portsToUse", portsToUse);
     for (let i = 0; i <= portsToUse.length; i++) {
       if (portsToUse[i]) {
-        this.ports[portsToUse[i]] = "true"; //port is open again
+        this.ports[portsToUse[i]] = true; //port is open again
       }
     }
   };
@@ -748,11 +634,12 @@ ${addableFiles
       .split(".")
       .slice(0, -1)
       .join(".")}/node`;
+
     if (!fs.existsSync(reportDest)) {
       fs.mkdirSync(reportDest, { recursive: true });
     }
 
-    const destFolder = dest.replace(".mjs", "");
+    // const destFolder = dest.replace(".mjs", "");
 
     let testResources = "";
 
@@ -768,17 +655,20 @@ ${addableFiles
     }
     const testConfigResource = testConfig[2];
 
-    let portsToUse: string[] = [];
+    const portsToUse: string[] = [];
     if (testConfigResource.ports === 0) {
-      testResources = JSON.stringify({
-        scheduled: true,
+      console.error("portsToUse?!", []);
+      const t: ITTestResourceConfiguration = {
         name: src,
-        ports: portsToUse,
+        // ports: portsToUse.map((v) => Number(v)),
+        ports: [],
         fs: reportDest,
         browserWSEndpoint: this.browser.wsEndpoint(),
-      });
+      };
+
+      testResources = JSON.stringify(t);
     } else if (testConfigResource.ports > 0) {
-      const openPorts = Object.entries(this.ports).filter(
+      const openPorts: [string, boolean][] = Object.entries(this.ports).filter(
         ([portnumber, portopen]) => portopen
       );
 
@@ -789,14 +679,17 @@ ${addableFiles
           this.ports[openPorts[i][0]] = false; // port is now closed
         }
 
+        console.error("portsToUse", portsToUse);
+
         testResources = JSON.stringify({
           scheduled: true,
           name: src,
           ports: portsToUse,
-          fs: destFolder,
+          fs: reportDest,
           browserWSEndpoint: this.browser.wsEndpoint(),
         });
       } else {
+        console.log("Not enough ports! Enqueuing test job...");
         this.queue.push(src);
         return;
       }
@@ -807,51 +700,28 @@ ${addableFiles
 
     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;
 
+    const ipcfile = "/tmp/tpipe_" + Math.random();
+    const child = spawn("node", [builtfile, testResources, ipcfile], {
+      stdio: ["pipe", "pipe", "pipe", "ipc"],
+    });
+
     let buffer: Buffer<ArrayBufferLike> = new Buffer("");
+
     const server = net.createServer((socket) => {
+      const queue = new Queue<string[]>();
+
       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);
+          const c = buffer.slice(0, b);
           let d;
           try {
             d = JSON.parse(c.toString());
 
-            messages.push(d);
+            queue.enqueue(d);
             buffer = buffer.slice(b, buffer.length + 1);
             b = 0;
           } catch (e) {
@@ -859,77 +729,53 @@ ${addableFiles
           }
         }
 
-        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],
-                  })
-                );
+        while (queue.size() > 0) {
+          const message = queue.dequeue();
+
+          if (message) {
+            // set up the "node" listeners
+            this.mapping().forEach(async ([command, func]) => {
+              if (message[0] === command) {
+                const x = message.slice(1, -1);
+                const r = await this[command](...x);
+
+                if (!haltReturns) {
+                  child.send(
+                    JSON.stringify({
+                      payload: r,
+                      key: message[message.length - 1],
+                    })
+                  );
+                }
               }
-            }
-          });
-        });
+            });
+          }
+        }
       });
     });
 
     const oStream = fs.createWriteStream(`${reportDest}/console_log.txt`);
 
-    const child = spawn(
-      "node",
-      [builtfile, testResources, "--trace-warnings"],
-      {
-        stdio: ["pipe", "pipe", "pipe", "ipc"],
-        // silent: true
-      }
-    );
-
-    // const child = spawn(
-    //   "node",
-    //   ["inspect", builtfile, testResources, "--trace-warnings"],
-    //   {
-    //     stdio: ["pipe", "pipe", "pipe", "ipc"],
-    //     env: {
-    //       // NODE_INSPECT_RESUME_ON_START: "1",
-    //     },
-    //     // silent: true
-    //   }
-    // );
-
-    // console.log(
-    //   "spawning",
-    //   "node",
-    //   ["inspect", builtfile, testResources, "--trace-warnings"],
-    //   {
-    //     NODE_INSPECT_RESUME_ON_START: "1",
-    //   }
-    // );
-
-    const p = destFolder + "/pipe";
     const errFile = `${reportDest}/error.txt`;
 
     if (fs.existsSync(errFile)) {
       fs.rmSync(errFile);
     }
 
-    server.listen(p, () => {
+    server.listen(ipcfile, () => {
       child.stderr?.on("data", (data) => {
-        oStream.write(`stderr data ${data}`);
+        oStream.write(`stderr > ${data}`);
       });
       child.stdout?.on("data", (data) => {
-        oStream.write(`stdout data ${data}`);
+        oStream.write(`stdout > ${data}`);
       });
       child.on("close", (code) => {
+        console.log("close");
         oStream.close();
         server.close();
 
+        // this.receiveFeaturesV2(reportDest, src, "node");
+
         if (code === null) {
           this.bddTestIsNowDone(src, -1);
           statusMessagePretty(-1, src);
@@ -941,21 +787,25 @@ ${addableFiles
           statusMessagePretty(code, src);
         }
 
-        if (fs.existsSync(p)) {
-          fs.rmSync(p);
-        }
-
         haltReturns = true;
       });
       child.on("exit", (code) => {
+        console.log("exit");
         haltReturns = true;
+
+        for (let i = 0; i <= portsToUse.length; i++) {
+          if (portsToUse[i]) {
+            this.ports[portsToUse[i]] = true; //port is open again
+          }
+        }
+
+        console.log("exitthis.ports", this.ports);
       });
       child.on("error", (e) => {
+        console.log("error");
+
         haltReturns = true;
 
-        if (fs.existsSync(p)) {
-          fs.rmSync(p);
-        }
         console.log(
           ansiC.red(
             ansiC.inverse(
@@ -966,170 +816,338 @@ ${addableFiles
         this.writeFileSync(`${reportDest}/error.txt`, e.toString(), src);
         this.bddTestIsNowDone(src, -1);
         statusMessagePretty(-1, src);
-
-        // this.bddTestIsNowDone(src, -1);
-        // statusMessagePretty(-1, src);
       });
     });
-
-    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,
+    // src: string,
+    // dest: string,
     testConfig: ITestTypes
-  ): Promise<Page> => {
-    const d = dest + ".mjs";
+  ): Promise<[number, ITTestResourceConfiguration]> => {
+    const src = testConfig[0];
+    const dest = src.split(".").slice(0, -1).join(".");
+    // const d = dest + ".mjs";
+
+    const destFolder = dest.replace(".mjs", "");
 
     console.log(ansiC.green(ansiC.inverse(`launchWebSideCar ${src}`)));
 
     const fileStreams2: fs.WriteStream[] = [];
     const doneFileStream2: Promise<any>[] = [];
 
+    const oStream = fs.createWriteStream(`${destFolder}/console_log.txt`);
+
     return new Promise((res, rej) => {
       this.browser
         .newPage()
-        .then((page) => {
-          // page.on("console", (msg) => {
-          //   console.log("web > ", msg.args(), msg.text());
-          //   // for (let i = 0; i < msg._args.length; ++i)
-          //   //   console.log(`${i}: ${msg._args[i]}`);
-          // });
-
-          page.exposeFunction(
-            "custom-screenshot",
-            async (ssOpts: ScreenshotOptions, testName: string) => {
-              const p = ssOpts.path as string;
-              const dir = path.dirname(p);
-              fs.mkdirSync(dir, {
-                recursive: true,
-              });
-              files[testName].add(ssOpts.path as string);
-
-              const sPromise = page.screenshot({
-                ...ssOpts,
-                path: p,
-              });
+        .then(async (page) => {
+          this.mapping().forEach(async ([command, func]) => {
+            page.exposeFunction(command, func);
+          });
 
-              if (!screenshots[testName]) {
-                screenshots[testName] = [];
-              }
-              screenshots[testName].push(sPromise);
-              await sPromise;
-              return sPromise;
+          const close = () => {
+            if (!files[src]) {
+              files[src] = new Set();
             }
-          );
+            // files[t].add(filepath);
 
-          page.exposeFunction(
-            "writeFileSync",
-            (fp: string, contents: string, testName: string) => {
-              const dir = path.dirname(fp);
-
-              fs.mkdirSync(dir, {
-                recursive: true,
-              });
+            fs.writeFileSync(
+              destFolder + "/manifest.json",
+              JSON.stringify(Array.from(files[src]))
+            );
+            delete files[src];
+
+            Promise.all(screenshots[src] || []).then(() => {
+              delete screenshots[src];
+              page.close();
+              oStream.close();
+            });
+          };
+
+          page.on("pageerror", (err: Error) => {
+            console.debug(`Error from ${src}: [${err.name}] `);
+            oStream.write(err.name);
+            oStream.write("\n");
 
-              const p = new Promise<string>(async (res, rej) => {
-                fs.writeFileSync(fp, contents);
-                res(fp);
-              });
-              doneFileStream2.push(p);
+            if (err.cause) {
+              console.debug(`Error from ${src} cause: [${err.cause}] `);
+              oStream.write(err.cause);
+              oStream.write("\n");
+            }
 
-              if (!files[testName]) {
-                files[testName] = new Set();
-              }
-              files[testName].add(fp);
-              return p;
+            if (err.stack) {
+              console.debug(`Error from stack ${src}: [${err.stack}] `);
+              oStream.write(err.stack);
+              oStream.write("\n");
             }
-          );
 
-          page.exposeFunction("existsSync", (fp: string, contents: string) => {
-            return fs.existsSync(fp);
+            console.debug(`Error from message ${src}: [${err.message}] `);
+            oStream.write(err.message);
+            oStream.write("\n");
+
+            this.bddTestIsNowDone(src, -1);
+            close();
           });
 
-          page.exposeFunction("mkdirSync", (fp: string) => {
-            if (!fs.existsSync(fp)) {
-              return fs.mkdirSync(fp, {
-                recursive: true,
-              });
-            }
-            return false;
+          page.on("console", (log: ConsoleMessage) => {
+            oStream.write(log.text());
+            oStream.write(JSON.stringify(log.location()));
+            oStream.write(JSON.stringify(log.stackTrace()));
+            oStream.write("\n");
+          });
+
+          await page.goto(`file://${`${destFolder}.html`}`, {});
+
+          const webArgz = JSON.stringify({
+            name: dest,
+            ports: [].toString(),
+            fs: dest,
+            browserWSEndpoint: this.browser.wsEndpoint(),
           });
 
-          page.exposeFunction(
-            "createWriteStream",
-            (fp: string, testName: string) => {
-              const f = fs.createWriteStream(fp);
+          const d = `${dest}?cacheBust=${Date.now()}`;
 
-              files[testName].add(fp);
+          const evaluation = `
+    import('${d}').then(async (x) => {
 
-              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,
-              };
-            }
-          );
+      try {
+        return await (await x.default).receiveTestResourceConfig(${webArgz})
+      } catch (e) {
+        console.log("fail", e.toString())
+      }
+    })`;
 
-          page.exposeFunction(
-            "write",
-            async (uid: number, contents: string) => {
-              return fileStreams2[uid].write(contents);
-            }
-          );
+          await page
+            .evaluate(evaluation)
+            .then(async ({ fails, failed, features }: IFinalResults) => {
+              // this.receiveFeatures(features, destFolder, src, "web");
+              // this.receiveFeaturesV2(reportDest, src, "web");
 
-          page.exposeFunction("end", async (uid: number) => {
-            return fileStreams2[uid].end();
-          });
+              statusMessagePretty(fails, src);
+              this.bddTestIsNowDone(src, fails);
+            })
+            .catch((e) => {
+              console.log(
+                ansiC.red(
+                  ansiC.inverse(`launchWebSidecar - ${src} errored with: ${e}`)
+                )
+              );
+            })
+            .finally(() => {
+              this.bddTestIsNowDone(src, -1);
+              close();
+            });
 
           return page;
+
+          // return page;
         })
         .then(async (page) => {
           await page.goto(`file://${`${dest}.html`}`, {});
 
           /* @ts-ignore:next-line */
-          res(page);
+          res([Math.random(), page]);
         });
     });
   };
 
   launchNodeSideCar = async (
-    src: string,
-    dest: string,
-    testConfig: ITestTypes
-  ) => {
+    sidecar: ITestTypes
+  ): Promise<[number, ITTestResourceConfiguration]> => {
+    const src = sidecar[0];
+    const dest =
+      process.cwd() + `/testeranto/bundles/node/${this.name}/${sidecar[0]}`;
     const d = dest + ".mjs";
-    console.log(ansiC.green(ansiC.inverse(`launchNodeSideCar ${src}`)));
+    console.log(ansiC.green(ansiC.inverse(`launchNodeSideCar ${sidecar[0]}`)));
+
+    const destFolder = dest.replace(".ts", "");
+
+    const reportDest = `testeranto/reports/${this.name}/${src
+      .split(".")
+      .slice(0, -1)
+      .join(".")}/node`;
+
+    const argz: ITTestResourceConfiguration = {
+      name: sidecar[0],
+      ports: [],
+      fs: destFolder,
+      browserWSEndpoint: this.browser.wsEndpoint(),
+    };
+
+    const testReq: { ports: number } = sidecar[2];
+
+    const portsToUse: number[] = [];
+    if (testReq.ports === 0) {
+      // argz = {
+      //   name: sidecar[0],
+      //   ports: portsToUse,
+      //   fs: destFolder,
+      //   browserWSEndpoint: this.browser.wsEndpoint(),
+      // };
+    } else if (testReq.ports > 0) {
+      const openPorts = Object.entries(this.ports).filter(
+        ([portnumber, portopen]) => portopen
+      );
+
+      if (openPorts.length >= testReq.ports) {
+        for (let i = 0; i < testReq.ports; i++) {
+          portsToUse.push(openPorts[i][0]);
+
+          this.ports[openPorts[i][0]] = false; // port is now closed
+        }
+
+        console.log("nodeSideCar portsToUse", portsToUse);
+        argz.ports = portsToUse;
+
+        const builtfile = destFolder + ".mjs";
+
+        let haltReturns = false;
+
+        let buffer: Buffer<ArrayBufferLike> = new Buffer("");
+
+        const server = net.createServer((socket) => {
+          socket.on("data", (data) => {
+            buffer = Buffer.concat([buffer, data]);
+
+            const messages: string[][] = [];
+            for (let b = 0; b < buffer.length + 1; b++) {
+              const 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) => {
+              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, JSON.stringify(argz)], {
+          stdio: ["pipe", "pipe", "pipe", "ipc"],
+          // silent: true
+        });
+
+        const p = "/tmp/tpipe" + Math.random();
+
+        const errFile = `${reportDest}/error.txt`;
+
+        server.listen(p, () => {
+          child.stderr?.on("data", (data) => {
+            oStream.write(`stderr > ${data}`);
+          });
+          child.stdout?.on("data", (data) => {
+            oStream.write(`stdout > ${data}`);
+          });
+          child.on("close", (code) => {
+            oStream.close();
+            server.close();
+
+            haltReturns = true;
+          });
+          child.on("exit", (code) => {
+            haltReturns = true;
+
+            for (let i = 0; i <= portsToUse.length; i++) {
+              if (portsToUse[i]) {
+                this.ports[portsToUse[i]] = true; //port is open again
+              }
+            }
+          });
+          child.on("error", (e) => {
+            if (fs.existsSync(p)) {
+              fs.rmSync(p);
+            }
+
+            haltReturns = true;
+
+            console.log(
+              ansiC.red(
+                ansiC.inverse(
+                  `launchNodeSideCar - ${src} errored with: ${e.name}. Check ${errFile}for more info`
+                )
+              )
+            );
+            this.writeFileSync(`${reportDest}/error.txt`, e.toString(), src);
+            // this.bddTestIsNowDone(src, -1);
+            // statusMessagePretty(-1, src);
+          });
+        });
+
+        child.send({ path: p });
+
+        const r = Math.random();
+        this.nodeSidecars[r] = child;
+        return [r, argz];
+      } else {
+        console.log("Not enough open ports!", openPorts, testReq.ports);
+        this.queue.push(sidecar[0]);
+        return [Math.random(), argz];
+      }
+    } else {
+      console.error("negative port makes no sense", sidecar[0]);
+      process.exit(-1);
+    }
+  };
+
+  stopPureSideCar = async (uid: number) => {
+    console.log(ansiC.green(ansiC.inverse(`stopPureSideCar ${uid}`)));
+    await this.sidecars[uid].shutdown();
+    return;
+  };
+
+  launchPureSideCar = async (
+    sidecar: ITestTypes
+  ): Promise<[number, ITTestResourceConfiguration]> => {
+    console.log(ansiC.green(ansiC.inverse(`launchPureSideCar ${sidecar[0]}`)));
+
+    const r = Math.random();
+
+    const dest =
+      process.cwd() + `/testeranto/bundles/pure/${this.name}/${sidecar[0]}`;
+    const builtfile = dest.split(".").slice(0, -1).concat("mjs").join(".");
 
     const destFolder = dest.replace(".mjs", "");
 
-    let argz = "";
+    let argz: ITTestResourceConfiguration;
 
-    const testConfigResource = testConfig[2];
+    const z = sidecar[2];
+    const testConfigResource: { ports: number } = sidecar[2];
+    const src = sidecar[0];
 
-    let portsToUse: string[] = [];
+    const portsToUse: number[] = [];
     if (testConfigResource.ports === 0) {
-      argz = JSON.stringify({
-        scheduled: true,
+      argz = {
+        // scheduled: true,
         name: src,
         ports: portsToUse,
         fs: destFolder,
         browserWSEndpoint: this.browser.wsEndpoint(),
-      });
+      };
     } else if (testConfigResource.ports > 0) {
       const openPorts = Object.entries(this.ports).filter(
         ([portnumber, portopen]) => portopen
@@ -1142,14 +1160,14 @@ ${addableFiles
           this.ports[openPorts[i][0]] = false; // port is now closed
         }
 
-        argz = JSON.stringify({
-          scheduled: true,
+        argz = {
+          // scheduled: true,
           name: src,
           // ports: [3333],
           ports: portsToUse,
           fs: ".",
           browserWSEndpoint: this.browser.wsEndpoint(),
-        });
+        };
       } else {
         this.queue.push(src);
         return;
@@ -1159,32 +1177,19 @@ ${addableFiles
       process.exit(-1);
     }
 
-    const builtfile = dest + ".mjs";
+    // const builtfile = dest + ".mjs";
 
     await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
-      return module.default.then((defaultModule) => {
-        // console.log("defaultModule", defaultModule);
-        const s = new defaultModule();
-        s.receiveTestResourceConfig(argz);
-        // Object.create(defaultModule);
-
-        // defaultModule
-        //   .receiveTestResourceConfig(argz)
-        //   .then((x) => {
-        //     console.log("then", x);
-        //     return x;
-        //   })
-        //   .catch((e) => {
-        //     console.log("catch", e);
-        //   });
-      });
+      this.pureSidecars[r] = module.default;
+      this.pureSidecars[r].start(argz);
     });
 
-    for (let i = 0; i <= portsToUse.length; i++) {
-      if (portsToUse[i]) {
-        this.ports[portsToUse[i]] = "true"; //port is open again
-      }
-    }
+    return [r, argz];
+    // for (let i = 0; i <= portsToUse.length; i++) {
+    //   if (portsToUse[i]) {
+    //     this.ports[portsToUse[i]] = "true"; //port is open again
+    //   }
+    // }
   };
 
   launchWeb = async (src: string, dest: string) => {
@@ -1202,7 +1207,7 @@ ${addableFiles
     const destFolder = dest.replace(".mjs", "");
 
     const webArgz = JSON.stringify({
-      name: dest,
+      name: src,
       ports: [].toString(),
       fs: reportDest,
       browserWSEndpoint: this.browser.wsEndpoint(),
@@ -1226,9 +1231,18 @@ ${addableFiles
     this.browser
       .newPage()
       .then((page) => {
-        // set up the "node" listeners
         this.mapping().forEach(async ([command, func]) => {
-          page.exposeFunction(command, func);
+          if (command === "page") {
+            page.exposeFunction(command, (x?) => {
+              if (x) {
+                return func(x);
+              } else {
+                return func(page.mainFrame()._id);
+              }
+            });
+          } else {
+            return page.exposeFunction(command, func);
+          }
         });
 
         return page;
@@ -1279,24 +1293,34 @@ ${addableFiles
         });
         page.on("console", (log: ConsoleMessage) => {
           oStream.write(log.text());
+          oStream.write("\n");
           oStream.write(JSON.stringify(log.location()));
+          oStream.write("\n");
           oStream.write(JSON.stringify(log.stackTrace()));
           oStream.write("\n");
         });
+
         await page.goto(`file://${`${destFolder}.html`}`, {});
 
+        this.webSidecars[Math.random()] = page.mainFrame()._id;
+
         await page
           .evaluate(evaluation)
           .then(async ({ fails, failed, features }: IFinalResults) => {
-            this.receiveFeatures(features, destFolder, src, "web");
+            // this.receiveFeatures(features, destFolder, src, "web");
+            // this.receiveFeaturesV2(reportDest, src, "web");
+
             statusMessagePretty(fails, src);
             this.bddTestIsNowDone(src, fails);
           })
           .catch((e) => {
-            console.log(ansiC.red(ansiC.inverse(`${src} errored with: ${e}`)));
+            console.log(
+              ansiC.red(ansiC.inverse(`launchweb - ${src} errored with: ${e}`))
+            );
           })
           .finally(() => {
             this.bddTestIsNowDone(src, -1);
+            // process.exit(-1);
             close();
           });
 
@@ -1304,9 +1328,8 @@ ${addableFiles
       });
   };
 
-  receiveFeatures = (
-    features: string[],
-    destFolder: string,
+  receiveFeaturesV2 = (
+    reportDest: string,
     srcTest: string,
     platform: IRunTime
   ) => {
@@ -1318,8 +1341,16 @@ ${addableFiles
       srcTest.split(".").slice(0, -1).join(".") + ".features.txt"
     );
 
-    features
+    const testReport = JSON.parse(
+      fs.readFileSync(`${reportDest}/tests.json`).toString()
+    );
+
+    // console.log("mark2", testReport);
+
+    testReport.features
       .reduce(async (mm, featureStringKey) => {
+        // console.log("mark4", featureStringKey);
+
         const accum = await mm;
 
         const isUrl = isValidUrl(featureStringKey);
@@ -1333,16 +1364,16 @@ ${addableFiles
               u.pathname
             )}`;
 
-            await fs.promises.mkdir(path.dirname(newPath), { recursive: true });
+            // await fs.promises.mkdir(path.dirname(newPath), { recursive: true });
 
-            try {
-              await fs.unlinkSync(newPath);
-              // console.log(`Removed existing link at ${newPath}`);
-            } catch (error) {
-              if (error.code !== "ENOENT") {
-                // throw error;
-              }
-            }
+            // try {
+            //   await fs.unlinkSync(newPath);
+            //   // console.log(`Removed existing link at ${newPath}`);
+            // } catch (error) {
+            //   if (error.code !== "ENOENT") {
+            //     // throw error;
+            //   }
+            // }
 
             // fs.symlink(u.pathname, newPath, (err) => {
             //   if (err) {
@@ -1351,12 +1382,14 @@ ${addableFiles
             //     // console.log("Symlink created successfully");
             //   }
             // });
-            accum.files.push(newPath);
+            accum.files.push(u.pathname);
           } else if (u.protocol === "http:" || u.protocol === "https:") {
-            const newPath = `${process.cwd()}/testeranto/features/external${
+            const newPath = `${process.cwd()}/testeranto/features/external/${
               u.hostname
             }${u.pathname}`;
+
             const body = await this.configs.featureIngestor(featureStringKey);
+
             writeFileAndCreateDir(newPath, body);
             accum.files.push(newPath);
           }
@@ -1372,6 +1405,8 @@ ${addableFiles
       }, Promise.resolve({ files: [] as string[], strings: [] as string[] }))
 
       .then(({ files, strings }: { files: string[]; strings: string[] }) => {
+        // Markdown files must be referenced in the prompt but string style features are already present in the test.json file
+
         fs.writeFileSync(
           `testeranto/reports/${this.name}/${srcTest
             .split(".")
@@ -1384,12 +1419,16 @@ ${addableFiles
             .join("\n")
         );
       });
-  };
 
-  writeBigBoard = () => {
-    fs.writeFileSync(
-      `./testeranto/reports/${this.name}/summary.json`,
-      JSON.stringify(this.bigBoard, null, 2)
-    );
+    // const f: Record<string, string> = {};
+
+    testReport.givens.forEach((g) => {
+      if (g.failed === true) {
+        this.summary[srcTest].failingFeatures[g.key] = g.features;
+      }
+    });
+
+    // this.summary[srcTest].failingFeatures = f;
+    this.writeBigBoard();
   };
 }