testeranto 0.114.1 → 0.121.1

package/dist/prebuild/run.mjs

@@ -6,8 +6,8 @@ import readline from "readline";
 
 // src/PM/main.ts
 import ts from "typescript";
-import fs, { watch } from "fs";
-import path2 from "path";
+import fs2, { watch } from "fs";
+import path3 from "path";
 import puppeteer from "puppeteer-core";
 import ansiC from "ansi-colors";
 import crypto from "node:crypto";
@@ -16,27 +16,286 @@ import tsc from "tsc-prog";
 
 // src/utils.ts
 import path from "path";
-var tscPather = (entryPoint, platform) => {
+var tscPather = (entryPoint, platform, projectName) => {
   return path.join(
-    "./docs/",
-    platform,
+    "testeranto",
+    "reports",
+    projectName,
     entryPoint.split(".").slice(0, -1).join("."),
+    platform,
     `type_errors.txt`
   );
 };
-var lintPather = (entryPoint, platform) => {
+var lintPather = (entryPoint, platform, projectName) => {
   return path.join(
-    "./docs/",
-    platform,
+    "testeranto",
+    "reports",
+    projectName,
     entryPoint.split(".").slice(0, -1).join("."),
+    platform,
     `lint_errors.json`
   );
 };
+var promptPather = (entryPoint, platform, projectName) => {
+  return path.join(
+    "testeranto",
+    "reports",
+    projectName,
+    entryPoint.split(".").slice(0, -1).join("."),
+    platform,
+    `prompt.txt`
+  );
+};
+
+// src/PM/base.ts
+import fs from "fs";
+import path2 from "path";
 
 // src/PM/index.ts
 var PM = class {
 };
 
+// src/PM/base.ts
+var fileStreams3 = [];
+var fPaths = [];
+var files = {};
+var recorders = {};
+var screenshots = {};
+var PM_Base = class extends PM {
+  constructor(configs) {
+    super();
+    this.server = {};
+    this.configs = configs;
+    globalThis["waitForSelector"] = async (pageKey, sel) => {
+      const page = (await this.browser.pages()).find(
+        /* @ts-ignore:next-line */
+        (p) => p.mainFrame()._id === pageKey
+      );
+      await page?.waitForSelector(sel);
+    };
+    globalThis["screencastStop"] = async (path4) => {
+      return recorders[path4].stop();
+    };
+    globalThis["closePage"] = async (pageKey) => {
+      const page = (await this.browser.pages()).find(
+        /* @ts-ignore:next-line */
+        (p) => p.mainFrame()._id === pageKey
+      );
+      return page.close();
+    };
+    globalThis["goto"] = async (pageKey, url) => {
+      const page = (await this.browser.pages()).find(
+        /* @ts-ignore:next-line */
+        (p) => p.mainFrame()._id === pageKey
+      );
+      await page?.goto(url);
+      return;
+    };
+    globalThis["newPage"] = () => {
+      return this.browser.newPage();
+    };
+    globalThis["pages"] = () => {
+      return this.browser.pages();
+    };
+    globalThis["mkdirSync"] = (fp) => {
+      if (!fs.existsSync(fp)) {
+        return fs.mkdirSync(fp, {
+          recursive: true
+        });
+      }
+      return false;
+    };
+    globalThis["writeFileSync"] = (filepath, contents, testName2) => {
+      fs.mkdirSync(path2.dirname(filepath), {
+        recursive: true
+      });
+      if (!files[testName2]) {
+        files[testName2] = /* @__PURE__ */ new Set();
+      }
+      files[testName2].add(filepath);
+      return fs.writeFileSync(filepath, contents);
+    };
+    globalThis["createWriteStream"] = (filepath, testName2) => {
+      const f = fs.createWriteStream(filepath);
+      fileStreams3.push(f);
+      if (!files[testName2]) {
+        files[testName2] = /* @__PURE__ */ new Set();
+      }
+      files[testName2].add(filepath);
+      return {
+        ...JSON.parse(JSON.stringify(f)),
+        uid: fileStreams3.length - 1
+      };
+    };
+    globalThis["write"] = (uid, contents) => {
+      fileStreams3[uid].write(contents);
+    };
+    globalThis["end"] = (uid) => {
+      fileStreams3[uid].end();
+    };
+    globalThis["customScreenShot"] = async (opts, pageKey, testName2) => {
+      const page = (await this.browser.pages()).find(
+        /* @ts-ignore:next-line */
+        (p2) => p2.mainFrame()._id === pageKey
+      );
+      const p = opts.path;
+      const dir = path2.dirname(p);
+      fs.mkdirSync(dir, {
+        recursive: true
+      });
+      if (!files[opts.path]) {
+        files[opts.path] = /* @__PURE__ */ new Set();
+      }
+      files[opts.path].add(opts.path);
+      const sPromise = page.screenshot({
+        ...opts,
+        path: p
+      });
+      if (!screenshots[opts.path]) {
+        screenshots[opts.path] = [];
+      }
+      screenshots[opts.path].push(sPromise);
+      await sPromise;
+      return sPromise;
+    };
+    globalThis["screencast"] = async (opts, pageKey) => {
+      const page = (await this.browser.pages()).find(
+        /* @ts-ignore:next-line */
+        (p2) => p2.mainFrame()._id === pageKey
+      );
+      const p = opts.path;
+      const dir = path2.dirname(p);
+      fs.mkdirSync(dir, {
+        recursive: true
+      });
+      const recorder = await page?.screencast({
+        ...opts,
+        /* @ts-ignore:next-line */
+        path: p
+      });
+      recorders[opts.path] = recorder;
+      return opts.path;
+    };
+  }
+  customclose() {
+    throw new Error("Method not implemented.");
+  }
+  waitForSelector(p, s) {
+    throw new Error("Method not implemented.");
+  }
+  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.");
+  }
+  /* @ts-ignore:next-line */
+  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 = path2.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(`\u2757\uFE0FtestArtiFactory failed`, targetDir, error);
+            }
+            fs.writeFileSync(
+              path2.resolve(
+                targetDir.split("/").slice(0, -1).join("/"),
+                "manifest"
+              ),
+              fPaths.join(`
+`),
+              {
+                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 {
+              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.");
+  }
+};
+
 // src/PM/main.ts
 var eslint = new ESLint();
 var formatter = await eslint.loadFormatter(
@@ -44,15 +303,12 @@ var formatter = await eslint.loadFormatter(
 );
 var changes = {};
 var fileHashes = {};
-var fileStreams3 = [];
-var fPaths = [];
-var files = {};
-var recorders = {};
-var screenshots = {};
+var files2 = {};
+var screenshots2 = {};
 async function fileHash(filePath, algorithm = "md5") {
   return new Promise((resolve, reject) => {
     const hash = crypto.createHash(algorithm);
-    const fileStream = fs.createReadStream(filePath);
+    const fileStream = fs2.createReadStream(filePath);
     fileStream.on("data", (data) => {
       hash.update(data);
     });
@@ -65,26 +321,6 @@ async function fileHash(filePath, algorithm = "md5") {
     });
   });
 }
-var getRunnables = (tests, payload = {
-  nodeEntryPoints: {},
-  webEntryPoints: {}
-}) => {
-  return tests.reduce((pt, cv, cndx, cry) => {
-    if (cv[1] === "node") {
-      pt.nodeEntryPoints[cv[0]] = path2.resolve(
-        `./docs/node/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
-      );
-    } else if (cv[1] === "web") {
-      pt.webEntryPoints[cv[0]] = path2.resolve(
-        `./docs/web/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
-      );
-    }
-    if (cv[3].length) {
-      getRunnables(cv[3], payload);
-    }
-    return pt;
-  }, payload);
-};
 var statusMessagePretty = (failures, test) => {
   if (failures === 0) {
     console.log(ansiC.green(ansiC.inverse(`> ${test} completed successfully`)));
@@ -93,18 +329,18 @@ var statusMessagePretty = (failures, test) => {
   }
 };
 async function writeFileAndCreateDir(filePath, data) {
-  const dirPath = path2.dirname(filePath);
+  const dirPath = path3.dirname(filePath);
   try {
-    await fs.promises.mkdir(dirPath, { recursive: true });
-    await fs.appendFileSync(filePath, data);
+    await fs2.promises.mkdir(dirPath, { recursive: true });
+    await fs2.appendFileSync(filePath, data);
   } catch (error) {
     console.error(`Error writing file: ${error}`);
   }
 }
-var filesHash = async (files2, algorithm = "md5") => {
+var filesHash = async (files3, algorithm = "md5") => {
   return new Promise((resolve, reject) => {
     resolve(
-      files2.reduce(async (mm, f) => {
+      files3.reduce(async (mm, f) => {
         return await mm + await fileHash(f);
       }, Promise.resolve(""))
     );
@@ -118,25 +354,44 @@ function isValidUrl(string) {
     return false;
   }
 }
-var PM_Main = class extends PM {
-  constructor(configs) {
-    super();
-    this.shutdownMode = false;
+var PM_Main = class extends PM_Base {
+  constructor(configs, name, mode2) {
+    super(configs);
     this.bigBoard = {};
     this.stop = () => {
       console.log(ansiC.inverse("Testeranto-Run is shutting down gracefully..."));
-      this.mode = "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]] = path3.resolve(
+            `./testeranto/bundles/node/${this.name}/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
+          );
+        } else if (cv[1] === "web") {
+          pt.webEntryPoints[cv[0]] = path3.resolve(
+            `./testeranto/bundles/web/${this.name}/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
+          );
+        }
+        if (cv[3].length) {
+          this.getRunnables(cv[3], payload);
+        }
+        return pt;
+      }, payload);
+    };
     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
@@ -144,7 +399,7 @@ var PM_Main = class extends PM {
         // config to inherit from (optional)
         compilerOptions: {
           rootDir: "src",
-          outDir: tscPather(entrypoint, platform),
+          outDir: tscPather(entrypoint, platform, this.name),
           // declaration: true,
           // skipLibCheck: true,
           noEmit: true
@@ -153,9 +408,9 @@ var PM_Main = class extends PM {
         //["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(
@@ -166,111 +421,149 @@ var PM_Main = class extends PM {
             diagnostic.messageText,
             "\n"
           );
-          d.push(
+          results.push(
             `${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`
           );
         } else {
-          d.push(ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+          results.push(
+            ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")
+          );
         }
       });
-      fs.writeFileSync(tscPath, d.join("\n"));
-      this.bigBoard[entrypoint].typeErrors = d.length;
-      if (this.shutdownMode) {
-        this.checkForShutdown();
-      }
+      fs2.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) => {
         return r.messages[0].ruleId !== null;
       }).map((r) => {
         delete r.source;
         return r;
       });
-      fs.writeFileSync(
-        lintPather(entrypoint, platform),
+      fs2.writeFileSync(
+        lintPather(entrypoint, platform, this.name),
         await formatter.format(results)
       );
-      this.bigBoard[entrypoint].staticErrors = results.length;
-      if (this.shutdownMode) {
-        this.checkForShutdown();
-      }
+      this.lintIsNowDone(entrypoint, results.length);
     };
     this.makePrompt = async (entryPoint, addableFiles, platform) => {
       this.bigBoard[entryPoint].prompt = "?";
-      const promptPath = path2.join(
-        "./docs/",
-        platform,
-        entryPoint.split(".").slice(0, -1).join("."),
-        `prompt.txt`
-      );
-      const testPaths = path2.join(
-        "./docs/",
+      const promptPath = promptPather(entryPoint, platform, this.name);
+      const testPaths = path3.join(
+        "testeranto",
+        "reports",
+        this.name,
         platform,
         entryPoint.split(".").slice(0, -1).join("."),
         `tests.json`
       );
-      const featuresPath = path2.join(
-        "./docs/",
+      const featuresPath = path3.join(
+        "testeranto",
+        "reports",
+        this.name,
         platform,
         entryPoint.split(".").slice(0, -1).join("."),
         `featurePrompt.txt`
       );
-      fs.writeFileSync(
+      fs2.writeFileSync(
         promptPath,
         `
 ${addableFiles.map((x) => {
           return `/add ${x}`;
         }).join("\n")}
 
-/read ${lintPather(entryPoint, platform)}
-/read ${tscPather(entryPoint, platform)}
+/read ${lintPather(entryPoint, platform, this.name)}
+/read ${tscPather(entryPoint, platform, this.name)}
 /read ${testPaths}
 
 /load ${featuresPath}
 
 /code Fix the failing tests described in ${testPaths}. Correct any type signature errors described in the files ${tscPather(
           entryPoint,
-          platform
+          platform,
+          this.name
         )}. Implement any method which throws "Function not implemented. Resolve the lint errors described in ${lintPather(
           entryPoint,
-          platform
+          platform,
+          this.name
         )}"
           `
       );
-      this.bigBoard[entryPoint].prompt = `aider --model deepseek/deepseek-chat --load docs/${platform}/${entryPoint.split(".").slice(0, -1).join(".")}/prompt.txt`;
-      if (this.shutdownMode) {
-        this.checkForShutdown();
-      }
+      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();
     };
     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(`\u{1F555} prompt ${k}`)));
+          inflight = true;
+        }
+      });
+      Object.keys(this.bigBoard).forEach((k) => {
+        if (this.bigBoard[k].runTimeError === "?") {
+          console.log(ansiC.blue(ansiC.inverse(`\u{1F555} runTimeError ${k}`)));
+          inflight = true;
+        }
+      });
+      Object.keys(this.bigBoard).forEach((k) => {
+        if (this.bigBoard[k].staticErrors === "?") {
+          console.log(ansiC.blue(ansiC.inverse(`\u{1F555} staticErrors ${k}`)));
+          inflight = true;
+        }
+      });
+      Object.keys(this.bigBoard).forEach((k) => {
+        if (this.bigBoard[k].typeErrors === "?") {
+          console.log(ansiC.blue(ansiC.inverse(`\u{1F555} 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.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 (!fs2.existsSync(reportDest)) {
+        fs2.mkdirSync(reportDest, { recursive: true });
+      }
       const destFolder = dest.replace(".mjs", "");
       let argz = "";
       const testConfig = this.configs.tests.find((t) => {
@@ -287,7 +580,7 @@ ${addableFiles.map((x) => {
           scheduled: true,
           name: src,
           ports: portsToUse,
-          fs: destFolder,
+          fs: reportDest,
           browserWSEndpoint: this.browser.wsEndpoint()
         });
       } else if (testConfigResource.ports > 0) {
@@ -320,14 +613,14 @@ ${addableFiles.map((x) => {
       this.server[builtfile] = await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
         return module.default.then((defaultModule) => {
           defaultModule.receiveTestResourceConfig(argz).then(async ({ features, failed }) => {
-            this.receiveFeatures(features, destFolder, src);
+            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}`)));
+            this.bddTestIsNowDone(src, -1);
           }).finally(() => {
             webSideCares.forEach((webSideCar) => webSideCar.close());
-            this.testIsNowDone(src);
           });
         });
       });
@@ -346,50 +639,50 @@ ${addableFiles.map((x) => {
         this.browser.newPage().then((page) => {
           page.exposeFunction(
             "custom-screenshot",
-            async (ssOpts, testName) => {
+            async (ssOpts, testName2) => {
               const p = ssOpts.path;
-              const dir = path2.dirname(p);
-              fs.mkdirSync(dir, {
+              const dir = path3.dirname(p);
+              fs2.mkdirSync(dir, {
                 recursive: true
               });
-              files[testName].add(ssOpts.path);
+              files2[testName2].add(ssOpts.path);
               const sPromise = page.screenshot({
                 ...ssOpts,
                 path: p
               });
-              if (!screenshots[testName]) {
-                screenshots[testName] = [];
+              if (!screenshots2[testName2]) {
+                screenshots2[testName2] = [];
               }
-              screenshots[testName].push(sPromise);
+              screenshots2[testName2].push(sPromise);
               await sPromise;
               return sPromise;
             }
           );
           page.exposeFunction(
             "writeFileSync",
-            (fp, contents, testName) => {
-              const dir = path2.dirname(fp);
-              fs.mkdirSync(dir, {
+            (fp, contents, testName2) => {
+              const dir = path3.dirname(fp);
+              fs2.mkdirSync(dir, {
                 recursive: true
               });
               const p = new Promise(async (res2, rej2) => {
-                fs.writeFileSync(fp, contents);
+                fs2.writeFileSync(fp, contents);
                 res2(fp);
               });
               doneFileStream2.push(p);
-              if (!files[testName]) {
-                files[testName] = /* @__PURE__ */ new Set();
+              if (!files2[testName2]) {
+                files2[testName2] = /* @__PURE__ */ new Set();
               }
-              files[testName].add(fp);
+              files2[testName2].add(fp);
               return p;
             }
           );
           page.exposeFunction("existsSync", (fp, contents) => {
-            return fs.existsSync(fp);
+            return fs2.existsSync(fp);
           });
           page.exposeFunction("mkdirSync", (fp) => {
-            if (!fs.existsSync(fp)) {
-              return fs.mkdirSync(fp, {
+            if (!fs2.existsSync(fp)) {
+              return fs2.mkdirSync(fp, {
                 recursive: true
               });
             }
@@ -397,9 +690,9 @@ ${addableFiles.map((x) => {
           });
           page.exposeFunction(
             "createWriteStream",
-            (fp, testName) => {
-              const f = fs.createWriteStream(fp);
-              files[testName].add(fp);
+            (fp, testName2) => {
+              const f = fs2.createWriteStream(fp);
+              files2[testName2].add(fp);
               const p = new Promise((res2, rej2) => {
                 res2(fp);
               });
@@ -483,14 +776,18 @@ ${addableFiles.map((x) => {
         }
       }
     };
-    this.launchWeb = (t, dest) => {
-      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 (!fs2.existsSync(reportDest)) {
+        fs2.mkdirSync(reportDest, { recursive: true });
+      }
       const destFolder = dest.replace(".mjs", "");
       const webArgz = JSON.stringify({
         name: dest,
         ports: [].toString(),
-        fs: destFolder,
+        fs: reportDest,
         browserWSEndpoint: this.browser.wsEndpoint()
       });
       const d = `${dest}?cacheBust=${Date.now()}`;
@@ -506,69 +803,72 @@ ${addableFiles.map((x) => {
     })`;
       const fileStreams2 = [];
       const doneFileStream2 = [];
-      const stdoutStream = fs.createWriteStream(`${destFolder}/stdout.log`);
-      const stderrStream = fs.createWriteStream(`${destFolder}/stderr.log`);
+      const stdoutStream = fs2.createWriteStream(`${destFolder}/stdout.log`);
+      const stderrStream = fs2.createWriteStream(`${destFolder}/stderr.log`);
       this.browser.newPage().then((page) => {
+        page.on("console", (msg) => {
+          console.log("web > ", msg.args(), msg.text());
+        });
         page.exposeFunction(
           "screencast",
-          async (ssOpts, testName) => {
+          async (ssOpts, testName2) => {
             const p = ssOpts.path;
-            const dir = path2.dirname(p);
-            fs.mkdirSync(dir, {
+            const dir = path3.dirname(p);
+            fs2.mkdirSync(dir, {
               recursive: true
             });
-            if (!files[testName]) {
-              files[testName] = /* @__PURE__ */ new Set();
+            if (!files2[testName2]) {
+              files2[testName2] = /* @__PURE__ */ new Set();
             }
-            files[testName].add(ssOpts.path);
+            files2[testName2].add(ssOpts.path);
             const sPromise = page.screenshot({
               ...ssOpts,
               path: p
             });
-            if (!screenshots[testName]) {
-              screenshots[testName] = [];
+            if (!screenshots2[testName2]) {
+              screenshots2[testName2] = [];
             }
-            screenshots[testName].push(sPromise);
+            screenshots2[testName2].push(sPromise);
             await sPromise;
             return sPromise;
           }
         );
         page.exposeFunction(
           "customScreenShot",
-          async (ssOpts, testName) => {
+          async (ssOpts, testName2) => {
             const p = ssOpts.path;
-            const dir = path2.dirname(p);
-            fs.mkdirSync(dir, {
+            const dir = path3.dirname(p);
+            fs2.mkdirSync(dir, {
               recursive: true
             });
-            if (!files[testName]) {
-              files[testName] = /* @__PURE__ */ new Set();
+            if (!files2[testName2]) {
+              files2[testName2] = /* @__PURE__ */ new Set();
             }
-            files[testName].add(ssOpts.path);
+            files2[testName2].add(ssOpts.path);
             const sPromise = page.screenshot({
               ...ssOpts,
               path: p
             });
-            if (!screenshots[testName]) {
-              screenshots[testName] = [];
+            if (!screenshots2[testName2]) {
+              screenshots2[testName2] = [];
             }
-            screenshots[testName].push(sPromise);
+            screenshots2[testName2].push(sPromise);
             await sPromise;
             return sPromise;
           }
         );
         page.exposeFunction(
           "writeFileSync",
-          (fp, contents, testName) => {
-            return globalThis["writeFileSync"](fp, contents, testName);
+          (fp, contents, testName2) => {
+            return globalThis["writeFileSync"](fp, contents, testName2);
           }
         );
         page.exposeFunction("existsSync", (fp, contents) => {
-          return fs.existsSync(fp);
+          return fs2.existsSync(fp);
         });
         page.exposeFunction("mkdirSync", (fp) => {
-          if (!fs.existsSync(fp)) {
-            return fs.mkdirSync(fp, {
+          if (!fs2.existsSync(fp)) {
+            return fs2.mkdirSync(fp, {
               recursive: true
             });
           }
@@ -576,12 +876,12 @@ ${addableFiles.map((x) => {
         });
         page.exposeFunction(
           "createWriteStream",
-          (fp, testName) => {
-            const f = fs.createWriteStream(fp);
-            if (!files[testName]) {
-              files[testName] = /* @__PURE__ */ new Set();
+          (fp, testName2) => {
+            const f = fs2.createWriteStream(fp);
+            if (!files2[testName2]) {
+              files2[testName2] = /* @__PURE__ */ new Set();
             }
-            files[testName].add(fp);
+            files2[testName2].add(fp);
             const p = new Promise((res, rej) => {
               res(fp);
             });
@@ -645,436 +945,172 @@ ${addableFiles.map((x) => {
         return page;
       }).then(async (page) => {
         const close = () => {
-          if (!files[t]) {
-            files[t] = /* @__PURE__ */ new Set();
+          if (!files2[src]) {
+            files2[src] = /* @__PURE__ */ new Set();
           }
-          fs.writeFileSync(
+          fs2.writeFileSync(
             destFolder + "/manifest.json",
-            JSON.stringify(Array.from(files[t]))
+            JSON.stringify(Array.from(files2[src]))
           );
-          delete files[t];
-          Promise.all(screenshots[t] || []).then(() => {
-            delete screenshots[t];
+          delete files2[src];
+          Promise.all(screenshots2[src] || []).then(() => {
+            delete screenshots2[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) => {
           stdoutStream.write(log.text());
-          stdoutStream.write(JSON.stringify(log.location()));
-          stdoutStream.write(JSON.stringify(log.stackTrace()));
-        });
-        await page.goto(`file://${`${destFolder}.html`}`, {});
-        await page.evaluate(evaluation).then(async ({ failed, features }) => {
-          this.receiveFeatures(features, destFolder, t);
-          statusMessagePretty(failed, t);
-          this.receiveExitCode(t, failed);
-        }).catch((e) => {
-          console.log(ansiC.red(ansiC.inverse(`${t} errored with: ${e}`)));
-        }).finally(() => {
-          close();
-        });
-        return page;
-      });
-    };
-    this.receiveFeatures = (features, destFolder, srcTest) => {
-      const featureDestination = path2.resolve(
-        process.cwd(),
-        "docs",
-        "features",
-        "strings",
-        srcTest.split(".").slice(0, -1).join(".") + ".features.txt"
-      );
-      features.reduce(async (mm, featureStringKey) => {
-        const accum = await mm;
-        const isUrl = isValidUrl(featureStringKey);
-        if (isUrl) {
-          const u = new URL(featureStringKey);
-          if (u.protocol === "file:") {
-            const newPath = `${process.cwd()}/docs/features/internal/${path2.relative(
-              process.cwd(),
-              u.pathname
-            )}`;
-            await fs.promises.mkdir(path2.dirname(newPath), { recursive: true });
-            try {
-              await fs.unlinkSync(newPath);
-            } catch (error) {
-              if (error.code !== "ENOENT") {
-              }
-            }
-            accum.files.push(newPath);
-          } else if (u.protocol === "http:" || u.protocol === "https:") {
-            const newPath = `${process.cwd()}/docs/features/external${u.hostname}${u.pathname}`;
-            const body = await this.configs.featureIngestor(featureStringKey);
-            writeFileAndCreateDir(newPath, body);
-            accum.files.push(newPath);
-          }
-        } else {
-          await fs.promises.mkdir(path2.dirname(featureDestination), {
-            recursive: true
-          });
-          accum.strings.push(featureStringKey);
-        }
-        return accum;
-      }, Promise.resolve({ files: [], strings: [] })).then(({ files: files2, strings }) => {
-        fs.writeFileSync(
-          `${destFolder}/featurePrompt.txt`,
-          files2.map((f) => {
-            return `/read ${f}`;
-          }).join("\n")
-        );
-      });
-    };
-    this.receiveExitCode = (srcTest, failures) => {
-      this.bigBoard[srcTest].runTimeError = failures;
-      this.writeBigBoard();
-    };
-    this.writeBigBoard = () => {
-      fs.writeFileSync(
-        "./docs/summary.json",
-        JSON.stringify(this.bigBoard, null, 2)
-      );
-    };
-    this.mode = configs.devMode ? "DEV" : "PROD";
-    this.server = {};
-    this.configs = configs;
-    this.ports = {};
-    this.configs.tests.forEach(([t]) => {
-      this.bigBoard[t] = {
-        runTimeError: "?",
-        typeErrors: "?",
-        staticErrors: "?",
-        prompt: "?"
-      };
-    });
-    this.configs.ports.forEach((element) => {
-      this.ports[element] = "true";
-    });
-    globalThis["waitForSelector"] = async (pageKey, sel) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p) => p.mainFrame()._id === pageKey
-      );
-      await page?.waitForSelector(sel);
-    };
-    globalThis["screencastStop"] = async (path3) => {
-      return recorders[path3].stop();
-    };
-    globalThis["closePage"] = async (pageKey) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p) => p.mainFrame()._id === pageKey
-      );
-      return page.close();
-    };
-    globalThis["goto"] = async (pageKey, url) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p) => p.mainFrame()._id === pageKey
-      );
-      await page?.goto(url);
-      return;
-    };
-    globalThis["newPage"] = () => {
-      return this.browser.newPage();
-    };
-    globalThis["pages"] = () => {
-      return this.browser.pages();
-    };
-    globalThis["mkdirSync"] = (fp) => {
-      if (!fs.existsSync(fp)) {
-        return fs.mkdirSync(fp, {
-          recursive: true
-        });
-      }
-      return false;
-    };
-    globalThis["writeFileSync"] = (filepath, contents, testName) => {
-      fs.mkdirSync(path2.dirname(filepath), {
-        recursive: true
-      });
-      if (!files[testName]) {
-        files[testName] = /* @__PURE__ */ new Set();
-      }
-      files[testName].add(filepath);
-      return fs.writeFileSync(filepath, contents);
-    };
-    globalThis["createWriteStream"] = (filepath, testName) => {
-      const f = fs.createWriteStream(filepath);
-      fileStreams3.push(f);
-      if (!files[testName]) {
-        files[testName] = /* @__PURE__ */ new Set();
-      }
-      files[testName].add(filepath);
-      return {
-        ...JSON.parse(JSON.stringify(f)),
-        uid: fileStreams3.length - 1
-      };
-    };
-    globalThis["write"] = (uid, contents) => {
-      fileStreams3[uid].write(contents);
-    };
-    globalThis["end"] = (uid) => {
-      fileStreams3[uid].end();
-    };
-    globalThis["customScreenShot"] = async (opts, pageKey, testName) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p2) => p2.mainFrame()._id === pageKey
-      );
-      const p = opts.path;
-      const dir = path2.dirname(p);
-      fs.mkdirSync(dir, {
-        recursive: true
-      });
-      if (!files[opts.path]) {
-        files[opts.path] = /* @__PURE__ */ new Set();
-      }
-      files[opts.path].add(opts.path);
-      const sPromise = page.screenshot({
-        ...opts,
-        path: p
-      });
-      if (!screenshots[opts.path]) {
-        screenshots[opts.path] = [];
-      }
-      screenshots[opts.path].push(sPromise);
-      await sPromise;
-      return sPromise;
-    };
-    globalThis["screencast"] = async (opts, pageKey) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p2) => p2.mainFrame()._id === pageKey
-      );
-      const p = opts.path;
-      const dir = path2.dirname(p);
-      fs.mkdirSync(dir, {
-        recursive: true
-      });
-      const recorder = await page?.screencast({
-        ...opts,
-        path: p
+          stdoutStream.write(JSON.stringify(log.location()));
+          stdoutStream.write(JSON.stringify(log.stackTrace()));
+        });
+        await page.goto(`file://${`${destFolder}.html`}`, {});
+        await page.evaluate(evaluation).then(async ({ failed, features }) => {
+          this.receiveFeatures(features, destFolder, src, "web");
+          statusMessagePretty(failed, src);
+          this.bddTestIsNowDone(src, failed);
+        }).catch((e) => {
+          console.log(ansiC.red(ansiC.inverse(`${src} errored with: ${e}`)));
+        }).finally(() => {
+          this.bddTestIsNowDone(src, -1);
+          close();
+        });
+        return page;
       });
-      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 = path2.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(`\u2757\uFE0FtestArtiFactory failed`, targetDir, error);
-            }
-            fs.writeFileSync(
-              path2.resolve(
-                targetDir.split("/").slice(0, -1).join("/"),
-                "manifest"
-              ),
-              fPaths.join(`
-`),
-              {
-                encoding: "utf-8"
+    this.receiveFeatures = (features, destFolder, srcTest, platform) => {
+      const featureDestination = path3.resolve(
+        process.cwd(),
+        "reports",
+        "features",
+        "strings",
+        srcTest.split(".").slice(0, -1).join(".") + ".features.txt"
+      );
+      features.reduce(async (mm, featureStringKey) => {
+        const accum = await mm;
+        const isUrl = isValidUrl(featureStringKey);
+        if (isUrl) {
+          const u = new URL(featureStringKey);
+          if (u.protocol === "file:") {
+            const newPath = `${process.cwd()}/testeranto/features/internal/${path3.relative(
+              process.cwd(),
+              u.pathname
+            )}`;
+            await fs2.promises.mkdir(path3.dirname(newPath), { recursive: true });
+            try {
+              await fs2.unlinkSync(newPath);
+            } catch (error) {
+              if (error.code !== "ENOENT") {
               }
-            );
-            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 {
-              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]) {
+            accum.files.push(newPath);
+          } else if (u.protocol === "http:" || u.protocol === "https:") {
+            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);
+          }
         } else {
-          changes[entrypoint] = changeDigest;
-          this.tscCheck({
-            platform,
-            addableFiles,
-            entrypoint: "./" + entrypoint
+          await fs2.promises.mkdir(path3.dirname(featureDestination), {
+            recursive: true
           });
-          this.eslintCheck("./" + entrypoint, platform, addableFiles);
-          this.makePrompt("./" + entrypoint, addableFiles, platform);
+          accum.strings.push(featureStringKey);
         }
-      }
+        return accum;
+      }, Promise.resolve({ files: [], strings: [] })).then(({ files: files3, strings }) => {
+        fs2.writeFileSync(
+          // `${destFolder}/featurePrompt.txt`,
+          `testeranto/reports/${this.name}/${srcTest.split(".").slice(0, -1).join(".")}/${platform}/featurePrompt.txt`,
+          files3.map((f) => {
+            return `/read ${f}`;
+          }).join("\n")
+        );
+      });
+    };
+    this.writeBigBoard = () => {
+      fs2.writeFileSync(
+        `./testeranto/reports/${this.name}/summary.json`,
+        JSON.stringify(this.bigBoard, null, 2)
+      );
+    };
+    this.name = name;
+    this.mode = mode2;
+    this.ports = {};
+    this.configs.tests.forEach(([t]) => {
+      this.bigBoard[t] = {
+        runTimeError: "?",
+        typeErrors: "?",
+        staticErrors: "?",
+        prompt: "?"
+      };
+    });
+    this.configs.ports.forEach((element) => {
+      this.ports[element] = "true";
     });
   }
   async start() {
+    if (!fs2.existsSync(`testeranto/reports/${this.name}`)) {
+      fs2.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(
+    const { nodeEntryPoints, webEntryPoints } = this.getRunnables(
       this.configs.tests
     );
     Object.entries(nodeEntryPoints).forEach(
@@ -1108,22 +1144,59 @@ ${addableFiles.map((x) => {
       }
     );
     this.metafileOutputs("node");
-    this.nodeMetafileWatcher = watch(
-      "docs/node/metafile.json",
-      async (e, filename) => {
-        console.log(ansiC.green(ansiC.inverse(`< ${e} ${filename} (node)`)));
-        this.metafileOutputs("node");
-      }
-    );
+    const w = `./testeranto/bundles/node/${this.name}/metafile.json`;
+    console.log("w", w);
+    this.nodeMetafileWatcher = watch(w, async (e, filename) => {
+      console.log(ansiC.green(ansiC.inverse(`< ${e} ${filename} (node)`)));
+      this.metafileOutputs("node");
+    });
     this.metafileOutputs("web");
     this.webMetafileWatcher = watch(
-      "docs/web/metafile.json",
+      `./testeranto/bundles/web/${this.name}/metafile.json`,
       async (e, filename) => {
         console.log(ansiC.green(ansiC.inverse(`< ${e} ${filename} (web)`)));
         this.metafileOutputs("web");
       }
     );
   }
+  async metafileOutputs(platform) {
+    const metafile = JSON.parse(
+      fs2.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 (!fs2.existsSync(i))
+          return false;
+        if (i.startsWith("node_modules"))
+          return false;
+        return true;
+      });
+      const f = `${k.split(".").slice(0, -1).join(".")}/`;
+      if (!fs2.existsSync(f)) {
+        fs2.mkdirSync(f);
+      }
+      const entrypoint = outputs[k].entryPoint;
+      if (entrypoint) {
+        const changeDigest = await filesHash(addableFiles);
+        if (changeDigest === changes[entrypoint]) {
+        } else {
+          changes[entrypoint] = changeDigest;
+          this.tscCheck({
+            platform,
+            addableFiles,
+            entrypoint: "./" + entrypoint
+          });
+          this.eslintCheck("./" + entrypoint, platform, addableFiles);
+          this.makePrompt("./" + entrypoint, addableFiles, platform);
+        }
+      }
+    });
+  }
 };
 
 // src/run.ts
@@ -1137,13 +1210,21 @@ process.stdin.on("keypress", (str, key) => {
     process.exit(-1);
   }
 });
-import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
-  const rawConfig = module.default;
+var testName = process.argv[2];
+var mode = process.argv[3];
+if (mode !== "once" && mode !== "dev") {
+  console.error("the 2nd argument should be 'dev' or 'once' ");
+  process.exit(-1);
+}
+console.log("testeranto is running", testName, mode);
+import(process.cwd() + "/testeranto.config.ts").then(async (module) => {
+  const bigConfig = module.default;
+  const rawConfig = bigConfig.projects[testName];
   const config = {
     ...rawConfig,
-    buildDir: process.cwd() + "/" + rawConfig.outdir
+    buildDir: process.cwd() + `/testeranto/${testName}.json`
   };
-  const pm = new PM_Main(config);
+  const pm = new PM_Main(config, testName, mode);
   pm.start();
   process.stdin.on("keypress", (str, key) => {
     if (key.name === "q") {