testeranto 0.114.1 → 0.121.1

package/dist/module/PM/main.js

@@ -6,16 +6,13 @@ import ansiC from "ansi-colors";
 import crypto from "node:crypto";
 import { ESLint } from "eslint";
 import tsc from "tsc-prog";
-import { lintPather, tscPather } from "../utils";
-import { PM } from "./index.js";
+import { lintPather, promptPather, tscPather } from "../utils";
+import { PM_Base } from "./base.js";
 const eslint = new ESLint();
 const formatter = await eslint.loadFormatter("./node_modules/testeranto/dist/prebuild/esbuildConfigs/eslint-formatter-testeranto.mjs");
 const changes = {};
 const fileHashes = {};
-const fileStreams3 = [];
-const fPaths = [];
 const files = {};
-const recorders = {};
 const screenshots = {};
 async function fileHash(filePath, algorithm = "md5") {
     return new Promise((resolve, reject) => {
@@ -33,23 +30,6 @@ async function fileHash(filePath, algorithm = "md5") {
         });
     });
 }
-const getRunnables = (tests, payload = {
-    nodeEntryPoints: {},
-    webEntryPoints: {},
-}) => {
-    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);
-};
 const statusMessagePretty = (failures, test) => {
     if (failures === 0) {
         console.log(ansiC.green(ansiC.inverse(`> ${test} completed successfully`)));
@@ -84,27 +64,51 @@ function isValidUrl(string) {
         return false;
     }
 }
-export class PM_Main extends PM {
-    constructor(configs) {
-        super();
-        this.shutdownMode = false;
+export class PM_Main extends PM_Base {
+    constructor(configs, name, mode) {
+        super(configs);
         this.bigBoard = {};
         this.stop = () => {
             console.log(ansiC.inverse("Testeranto-Run is shutting down gracefully..."));
-            this.mode = "PROD";
+            this.mode = "once";
             this.nodeMetafileWatcher.close();
             this.webMetafileWatcher.close();
             this.checkForShutdown();
         };
+        this.getRunnables = (tests, payload = {
+            nodeEntryPoints: {},
+            webEntryPoints: {},
+        }) => {
+            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);
+        };
         this.tscCheck = async ({ entrypoint, addableFiles, platform, }) => {
             console.log(ansiC.green(ansiC.inverse(`tsc < ${entrypoint}`)));
-            this.bigBoard[entrypoint].typeErrors = "?";
+            this.typeCheckIsRunning(entrypoint);
             const program = tsc.createProgramFromConfig({
                 basePath: process.cwd(), // always required, used for relative paths
                 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,
@@ -112,32 +116,25 @@ 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 = [];
+            const results = [];
             allDiagnostics.forEach((diagnostic) => {
                 if (diagnostic.file) {
                     let { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
                     let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-                    d.push(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+                    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);
         };
         this.eslintCheck = async (entrypoint, platform, addableFiles) => {
-            this.bigBoard[entrypoint].staticErrors = "?";
             console.log(ansiC.green(ansiC.inverse(`eslint < ${entrypoint}`)));
+            this.lintIsRunning(entrypoint);
             const results = (await eslint.lintFiles(addableFiles))
                 .filter((r) => r.messages.length)
                 .filter((r) => {
@@ -147,21 +144,14 @@ export class PM_Main extends PM {
                 delete r.source;
                 return r;
             });
-            fs.writeFileSync(lintPather(entrypoint, platform), await formatter.format(results));
-            this.bigBoard[entrypoint].staticErrors = results.length;
-            if (this.shutdownMode) {
-                this.checkForShutdown();
-            }
-            // fs.writeFileSync(
-            //   lintExitCodePather(entrypoint, platform),
-            //   results.length.toString()
-            // );
+            fs.writeFileSync(lintPather(entrypoint, platform, this.name), await formatter.format(results));
+            this.lintIsNowDone(entrypoint, results.length);
         };
         this.makePrompt = async (entryPoint, addableFiles, platform) => {
             this.bigBoard[entryPoint].prompt = "?";
-            const promptPath = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `prompt.txt`);
-            const testPaths = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `tests.json`);
-            const featuresPath = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `featurePrompt.txt`);
+            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) => {
@@ -169,55 +159,93 @@ ${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)}. Implement any method which throws "Function not implemented. Resolve the lint errors described in ${lintPather(entryPoint, platform)}"
+/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 docs/${platform}/${entryPoint
+            this.bigBoard[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();
         };
         this.checkForShutdown = () => {
-            const anyRunning = Object.values(this.bigBoard).filter((x) => x.prompt === "?").length +
-                Object.values(this.bigBoard).filter((x) => x.runTimeError === "?")
-                    .length +
-                Object.values(this.bigBoard).filter((x) => x.staticErrors === "?")
-                    .length +
-                Object.values(this.bigBoard).filter((x) => x.typeErrors === "?")
-                    .length >
-                0;
-            if (anyRunning) {
-                console.log(ansiC.inverse("Shutting down. Please wait"));
-            }
-            else {
+            this.writeBigBoard();
+            if (this.mode === "dev")
+                return;
+            let inflight = false;
+            Object.keys(this.bigBoard).forEach((k) => {
+                if (this.bigBoard[k].prompt === "?") {
+                    console.log(ansiC.blue(ansiC.inverse(`🕕 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();
                 });
             }
         };
-        this.testIsNowRunning = (src) => {
-            this.bigBoard[src].status = "running";
+        this.typeCheckIsRunning = (src) => {
+            this.bigBoard[src].typeErrors = "?";
         };
-        this.testIsNowDone = (src) => {
-            this.bigBoard[src].status = "waiting";
-            if (this.shutdownMode) {
-                this.checkForShutdown();
-            }
+        this.typeCheckIsNowDone = (src, failures) => {
+            this.bigBoard[src].typeErrors = failures;
+            this.writeBigBoard();
+            this.checkForShutdown();
+        };
+        this.lintIsRunning = (src) => {
+            this.bigBoard[src].staticErrors = "?";
+            this.writeBigBoard();
+        };
+        this.lintIsNowDone = (src, failures) => {
+            this.bigBoard[src].staticErrors = failures;
+            this.writeBigBoard();
+            this.checkForShutdown();
+        };
+        this.bddTestIsRunning = (src) => {
+            this.bigBoard[src].runTimeError = "?";
+            this.writeBigBoard();
+        };
+        this.bddTestIsNowDone = (src, failures) => {
+            this.bigBoard[src].runTimeError = failures;
+            this.writeBigBoard();
+            this.checkForShutdown();
         };
         this.launchNode = async (src, dest) => {
-            // 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", "");
             let argz = "";
             const testConfig = this.configs.tests.find((t) => {
@@ -234,7 +262,7 @@ ${addableFiles
                     scheduled: true,
                     name: src,
                     ports: portsToUse,
-                    fs: destFolder,
+                    fs: reportDest,
                     browserWSEndpoint: this.browser.wsEndpoint(),
                 });
             }
@@ -290,18 +318,16 @@ ${addableFiles
                     defaultModule
                         .receiveTestResourceConfig(argz)
                         .then(async ({ features, failed }) => {
-                        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);
                     });
                 });
             });
@@ -327,7 +353,6 @@ ${addableFiles
                     //   //   console.log(`${i}: ${msg._args[i]}`);
                     // });
                     page.exposeFunction("custom-screenshot", async (ssOpts, testName) => {
-                        // console.log("main.ts browser custom-screenshot", testName);
                         const p = ssOpts.path;
                         const dir = path.dirname(p);
                         fs.mkdirSync(dir, {
@@ -339,10 +364,8 @@ ${addableFiles
                             screenshots[testName] = [];
                         }
                         screenshots[testName].push(sPromise);
-                        // sPromise.then(())
                         await sPromise;
                         return sPromise;
-                        // page.evaluate(`window["screenshot done"]`);
                     });
                     page.exposeFunction("writeFileSync", (fp, contents, testName) => {
                         const dir = path.dirname(fp);
@@ -373,9 +396,6 @@ ${addableFiles
                     });
                     page.exposeFunction("createWriteStream", (fp, testName) => {
                         const f = fs.createWriteStream(fp);
-                        // if (!files[testName]) {
-                        //   files[testName] = new Set();
-                        // }
                         files[testName].add(fp);
                         const p = new Promise((res, rej) => {
                             res(fp);
@@ -393,21 +413,11 @@ ${addableFiles
                     page.exposeFunction("end", async (uid) => {
                         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);
                 });
             });
@@ -478,10 +488,16 @@ ${addableFiles
                 }
             }
         };
-        this.launchWeb = (t, dest) => {
-            // console.log(green, "! web", t);
-            console.log(ansiC.green(ansiC.inverse(`! web ${t}`)));
-            this.testIsNowRunning(t);
+        this.launchWeb = (src, dest) => {
+            console.log(ansiC.green(ansiC.inverse(`! web ${src}`)));
+            this.bddTestIsRunning(src);
+            const reportDest = `testeranto/reports/${this.name}/${src
+                .split(".")
+                .slice(0, -1)
+                .join(".")}/web`;
+            if (!fs.existsSync(reportDest)) {
+                fs.mkdirSync(reportDest, { recursive: true });
+            }
             // sidecars.map((sidecar) => {
             //   if (sidecar[1] === "node") {
             //     return this.launchNodeSideCar(
@@ -495,7 +511,7 @@ ${addableFiles
             const webArgz = JSON.stringify({
                 name: dest,
                 ports: [].toString(),
-                fs: destFolder,
+                fs: reportDest,
                 browserWSEndpoint: this.browser.wsEndpoint(),
             });
             const d = `${dest}?cacheBust=${Date.now()}`;
@@ -516,9 +532,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", async (ssOpts, testName) => {
                     const p = ssOpts.path;
                     const dir = path.dirname(p);
@@ -609,37 +625,6 @@ ${addableFiles
                 page.exposeFunction("end", async (uid) => {
                     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()._id;
                 });
@@ -672,33 +657,33 @@ ${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])));
-                    delete files[t];
-                    Promise.all(screenshots[t] || []).then(() => {
-                        delete screenshots[t];
+                    fs.writeFileSync(destFolder + "/manifest.json", JSON.stringify(Array.from(files[src])));
+                    delete files[src];
+                    Promise.all(screenshots[src] || []).then(() => {
+                        delete screenshots[src];
                         page.close();
-                        this.testIsNowDone(t);
                         stderrStream.close();
                         stdoutStream.close();
                     });
                 };
                 page.on("pageerror", (err) => {
-                    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) => {
@@ -715,24 +700,24 @@ ${addableFiles
                 await page
                     .evaluate(evaluation)
                     .then(async ({ failed, features }) => {
-                    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();
                 });
                 return page;
             });
         };
-        this.receiveFeatures = (features, destFolder, srcTest) => {
-            const featureDestination = path.resolve(process.cwd(), "docs", "features", "strings", srcTest.split(".").slice(0, -1).join(".") + ".features.txt");
+        this.receiveFeatures = (features, destFolder, srcTest, platform) => {
+            const featureDestination = path.resolve(process.cwd(), "reports", "features", "strings", srcTest.split(".").slice(0, -1).join(".") + ".features.txt");
             features
                 .reduce(async (mm, featureStringKey) => {
                 const accum = await mm;
@@ -740,7 +725,7 @@ ${addableFiles
                 if (isUrl) {
                     const u = new URL(featureStringKey);
                     if (u.protocol === "file:") {
-                        const newPath = `${process.cwd()}/docs/features/internal/${path.relative(process.cwd(), u.pathname)}`;
+                        const newPath = `${process.cwd()}/testeranto/features/internal/${path.relative(process.cwd(), u.pathname)}`;
                         await fs.promises.mkdir(path.dirname(newPath), { recursive: true });
                         try {
                             await fs.unlinkSync(newPath);
@@ -761,7 +746,7 @@ ${addableFiles
                         accum.files.push(newPath);
                     }
                     else if (u.protocol === "http:" || u.protocol === "https:") {
-                        const newPath = `${process.cwd()}/docs/features/external${u.hostname}${u.pathname}`;
+                        const newPath = `${process.cwd()}/testeranto/features/external${u.hostname}${u.pathname}`;
                         const body = await this.configs.featureIngestor(featureStringKey);
                         writeFileAndCreateDir(newPath, body);
                         accum.files.push(newPath);
@@ -777,7 +762,12 @@ ${addableFiles
             }, Promise.resolve({ files: [], strings: [] }))
                 .then(({ files, strings }) => {
                 // writeFileAndCreateDir(`${featureDestination}`, JSON.stringify(strings));
-                fs.writeFileSync(`${destFolder}/featurePrompt.txt`, files
+                fs.writeFileSync(
+                // `${destFolder}/featurePrompt.txt`,
+                `testeranto/reports/${this.name}/${srcTest
+                    .split(".")
+                    .slice(0, -1)
+                    .join(".")}/${platform}/featurePrompt.txt`, files
                     .map((f) => {
                     return `/read ${f}`;
                 })
@@ -785,16 +775,11 @@ ${addableFiles
             });
             // this.writeBigBoard();
         };
-        this.receiveExitCode = (srcTest, failures) => {
-            this.bigBoard[srcTest].runTimeError = failures;
-            this.writeBigBoard();
-        };
         this.writeBigBoard = () => {
-            fs.writeFileSync("./docs/summary.json", JSON.stringify(this.bigBoard, null, 2));
+            fs.writeFileSync(`./testeranto/reports/${this.name}/summary.json`, JSON.stringify(this.bigBoard, null, 2));
         };
-        this.mode = configs.devMode ? "DEV" : "PROD";
-        this.server = {};
-        this.configs = configs;
+        this.name = name;
+        this.mode = mode;
         this.ports = {};
         this.configs.tests.forEach(([t]) => {
             this.bigBoard[t] = {
@@ -807,294 +792,52 @@ ${addableFiles
         this.configs.ports.forEach((element) => {
             this.ports[element] = "true"; // set ports as open
         });
-        globalThis["waitForSelector"] = async (pageKey, sel) => {
-            const page = (await this.browser.pages()).find(
-            /* @ts-ignore:next-line */
-            (p) => p.mainFrame()._id === pageKey);
-            await (page === null || page === void 0 ? void 0 : page.waitForSelector(sel));
-        };
-        globalThis["screencastStop"] = async (path) => {
-            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, url) => {
-            const page = (await this.browser.pages()).find(
-            /* @ts-ignore:next-line */
-            (p) => p.mainFrame()._id === pageKey);
-            await (page === null || page === void 0 ? void 0 : page.goto(url));
-            return;
-        };
-        globalThis["newPage"] = () => {
-            return this.browser.newPage();
-        };
-        globalThis["pages"] = () => {
-            return this.browser.pages();
-        };
-        globalThis["mkdirSync"] = (fp) => {
-            if (!fs.existsSync(fp)) {
-                return fs.mkdirSync(fp, {
-                    recursive: true,
-                });
-            }
-            return false;
-        };
-        globalThis["writeFileSync"] = (filepath, contents, testName) => {
-            fs.mkdirSync(path.dirname(filepath), {
-                recursive: true,
-            });
-            if (!files[testName]) {
-                files[testName] = new Set();
-            }
-            files[testName].add(filepath);
-            return fs.writeFileSync(filepath, contents);
-        };
-        globalThis["createWriteStream"] = (filepath, testName) => {
-            const f = fs.createWriteStream(filepath);
-            fileStreams3.push(f);
-            // files.add(filepath);
-            if (!files[testName]) {
-                files[testName] = new Set();
-            }
-            files[testName].add(filepath);
-            return Object.assign(Object.assign({}, JSON.parse(JSON.stringify(f))), { uid: fileStreams3.length - 1 });
-        };
-        globalThis["write"] = (uid, contents) => {
-            fileStreams3[uid].write(contents);
-        };
-        globalThis["end"] = (uid) => {
-            fileStreams3[uid].end();
-        };
-        globalThis["customScreenShot"] = async (opts, pageKey, testName) => {
-            const page = (await this.browser.pages()).find(
-            /* @ts-ignore:next-line */
-            (p) => p.mainFrame()._id === pageKey);
-            const p = opts.path;
-            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);
-            const sPromise = page.screenshot(Object.assign(Object.assign({}, opts), { path: p }));
-            if (!screenshots[opts.path]) {
-                screenshots[opts.path] = [];
-            }
-            screenshots[opts.path].push(sPromise);
-            await sPromise;
-            return sPromise;
-        };
-        globalThis["screencast"] = async (opts, pageKey) => {
-            const page = (await this.browser.pages()).find(
-            /* @ts-ignore:next-line */
-            (p) => p.mainFrame()._id === pageKey);
-            const p = opts.path;
-            const dir = path.dirname(p);
-            fs.mkdirSync(dir, {
-                recursive: true,
-            });
-            const recorder = await (page === null || page === void 0 ? void 0 : page.screencast(Object.assign(Object.assign({}, opts), { path: p })));
-            recorders[opts.path] = recorder;
-            return opts.path;
-        };
-    }
-    customclose() {
-        throw new Error("Method not implemented.");
-    }
-    waitForSelector(p, s) {
-        throw new Error("Method not implemented.");
-    }
-    closePage(p) {
-        throw new Error("Method not implemented.");
-    }
-    newPage() {
-        throw new Error("Method not implemented.");
-    }
-    goto(p, url) {
-        throw new Error("Method not implemented.");
-    }
-    $(selector) {
-        throw new Error("Method not implemented.");
-    }
-    screencast(opts) {
-        throw new Error("Method not implemented.");
-    }
-    customScreenShot(opts, cdpPage) {
-        throw new Error("Method not implemented.");
-    }
-    end(accessObject) {
-        throw new Error("Method not implemented.");
-    }
-    existsSync(destFolder) {
-        return fs.existsSync(destFolder);
-    }
-    async mkdirSync(fp) {
-        if (!fs.existsSync(fp)) {
-            return fs.mkdirSync(fp, {
-                recursive: true,
-            });
-        }
-        return false;
-    }
-    writeFileSync(fp, contents) {
-        fs.writeFileSync(fp, contents);
-    }
-    createWriteStream(filepath) {
-        return fs.createWriteStream(filepath);
-    }
-    testArtiFactoryfileWriter(tLog, callback) {
-        return (fPath, value) => {
-            callback(new Promise((res, rej) => {
-                tLog("testArtiFactory =>", fPath);
-                const cleanPath = 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 = value;
-                        const myFile = fs.createWriteStream(fPath);
-                        pipeStream.pipe(myFile);
-                        pipeStream.on("close", () => {
-                            myFile.close();
-                            res();
-                        });
-                    }
-                });
-            }));
-        };
-    }
-    write(accessObject, contents) {
-        throw new Error("Method not implemented.");
-    }
-    page() {
-        throw new Error("Method not implemented.");
-    }
-    click(selector) {
-        throw new Error("Method not implemented.");
-    }
-    focusOn(selector) {
-        throw new Error("Method not implemented.");
-    }
-    typeInto(value) {
-        throw new Error("Method not implemented.");
-    }
-    getValue(value) {
-        throw new Error("Method not implemented.");
-    }
-    getAttribute(selector, attribute) {
-        throw new Error("Method not implemented.");
-    }
-    isDisabled(selector) {
-        throw new Error("Method not implemented.");
-    }
-    screencastStop(s) {
-        throw new Error("Method not implemented.");
-    }
-    ////////////////////////////////////////////////////////////////////////////////
-    async metafileOutputs(platform) {
-        const metafile = JSON.parse(fs.readFileSync(`docs/${platform}/metafile.json`).toString()).metafile;
-        if (!metafile)
-            return;
-        const outputs = metafile.outputs;
-        Object.keys(outputs).forEach(async (k) => {
-            const addableFiles = Object.keys(outputs[k].inputs).filter((i) => {
-                if (!fs.existsSync(i))
-                    return false;
-                if (i.startsWith("node_modules"))
-                    return false;
-                return true;
-            });
-            const f = `${k.split(".").slice(0, -1).join(".")}/`;
-            if (!fs.existsSync(f)) {
-                fs.mkdirSync(f);
-            }
-            const entrypoint = outputs[k].entryPoint;
-            if (entrypoint) {
-                const changeDigest = await filesHash(addableFiles);
-                if (changeDigest === changes[entrypoint]) {
-                    // skip
-                }
-                else {
-                    changes[entrypoint] = changeDigest;
-                    this.tscCheck({
-                        platform,
-                        addableFiles,
-                        entrypoint: "./" + entrypoint,
-                    });
-                    this.eslintCheck("./" + entrypoint, platform, addableFiles);
-                    this.makePrompt("./" + entrypoint, addableFiles, platform);
-                }
-            }
-        });
     }
     async start() {
+        if (!fs.existsSync(`testeranto/reports/${this.name}`)) {
+            fs.mkdirSync(`testeranto/reports/${this.name}`);
+        }
         this.browser = (await puppeteer.launch({
             slowMo: 1,
-            // timeout: 1,
             waitForInitialPage: false,
             executablePath: 
             // process.env.CHROMIUM_PATH || "/opt/homebrew/bin/chromium",
             "/opt/homebrew/bin/chromium",
             headless: true,
-            dumpio: true,
-            // timeout: 0,
-            devtools: true,
+            dumpio: false,
+            devtools: false,
             args: [
-                "--auto-open-devtools-for-tabs",
-                `--remote-debugging-port=3234`,
-                // "--disable-features=IsolateOrigins,site-per-process",
-                "--disable-site-isolation-trials",
-                "--allow-insecure-localhost",
                 "--allow-file-access-from-files",
+                "--allow-insecure-localhost",
                 "--allow-running-insecure-content",
+                "--auto-open-devtools-for-tabs",
                 "--disable-dev-shm-usage",
                 "--disable-extensions",
                 "--disable-gpu",
                 "--disable-setuid-sandbox",
                 "--disable-site-isolation-trials",
+                "--disable-site-isolation-trials",
                 "--disable-web-security",
                 "--no-first-run",
                 "--no-sandbox",
                 "--no-startup-window",
-                // "--no-zygote",
                 "--reduce-security-for-testing",
                 "--remote-allow-origins=*",
+                `--remote-debugging-port=3234`,
                 "--unsafely-treat-insecure-origin-as-secure=*",
+                // "--disable-features=IsolateOrigins,site-per-process",
                 // "--disable-features=IsolateOrigins",
+                // "--disk-cache-dir=/dev/null",
+                // "--disk-cache-size=1",
+                // "--no-zygote",
                 // "--remote-allow-origins=ws://localhost:3234",
                 // "--single-process",
+                // "--start-maximized",
                 // "--unsafely-treat-insecure-origin-as-secure",
                 // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
-                // "--disk-cache-dir=/dev/null",
-                // "--disk-cache-size=1",
-                // "--start-maximized",
             ],
         }));
-        const { nodeEntryPoints, webEntryPoints } = getRunnables(this.configs.tests);
+        const { nodeEntryPoints, webEntryPoints } = this.getRunnables(this.configs.tests);
         Object.entries(nodeEntryPoints).forEach(([k, outputFile]) => {
             this.launchNode(k, outputFile);
             try {
@@ -1123,14 +866,54 @@ ${addableFiles
             });
         });
         this.metafileOutputs("node");
-        this.nodeMetafileWatcher = watch("docs/node/metafile.json", async (e, filename) => {
+        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", async (e, filename) => {
+        this.webMetafileWatcher = watch(`./testeranto/bundles/web/${this.name}/metafile.json`, async (e, filename) => {
             console.log(ansiC.green(ansiC.inverse(`< ${e} ${filename} (web)`)));
             this.metafileOutputs("web");
         });
     }
+    async metafileOutputs(platform) {
+        const metafile = JSON.parse(fs
+            .readFileSync(`./testeranto/bundles/${platform}/${this.name}/metafile.json`)
+            .toString()).metafile;
+        if (!metafile)
+            return;
+        const outputs = metafile.outputs;
+        Object.keys(outputs).forEach(async (k) => {
+            const addableFiles = Object.keys(outputs[k].inputs).filter((i) => {
+                if (!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);
+                }
+            }
+        });
+    }
 }