testeranto 0.94.0 → 0.110.0

package/dist/prebuild/{run-tests.mjs → run.mjs}

@@ -1,64 +1,149 @@
 import { createRequire } from 'module';const require = createRequire(import.meta.url);
 
-// src/Puppeteer.ts
-import readline from "readline";
+// src/run.ts
+import ansiC2 from "ansi-colors";
+import { watch } from "fs";
+import path3 from "path";
+import crypto from "node:crypto";
 import fs2 from "fs";
-import watch from "recursive-watch";
+import tsc from "tsc-prog";
+import { ESLint } from "eslint";
+import ts from "typescript";
+import readline from "readline";
 
 // src/PM/main.ts
 import fs from "fs";
 import path2 from "path";
 import puppeteer from "puppeteer-core";
-import crypto from "crypto";
-
-// src/PM/index.ts
-var PM = class {
-};
+import ansiC from "ansi-colors";
 
 // src/utils.ts
 import path from "path";
-var destinationOfRuntime = (f, r, configs) => {
-  return path.normalize(`${configs.buildDir}/${r}/${f}`).split(".").slice(0, -1).join(".");
+var tscPather = (entryPoint, platform) => {
+  return path.join(
+    "./docs/",
+    platform,
+    entryPoint.split(".").slice(0, -1).join("."),
+    `type_errors.txt`
+  );
+};
+var tscExitCodePather = (entryPoint, platform) => {
+  return path.join(
+    "./docs/",
+    platform,
+    entryPoint.split(".").slice(0, -1).join("."),
+    `type_errors.txt`
+  );
+};
+var lintPather = (entryPoint, platform) => {
+  return path.join(
+    "./docs/",
+    platform,
+    entryPoint.split(".").slice(0, -1).join("."),
+    `lint_errors.json`
+  );
+};
+var lintExitCodePather = (entryPoint, platform) => {
+  return path.join(
+    "./docs/",
+    platform,
+    entryPoint.split(".").slice(0, -1).join("."),
+    `lint_errors.txt`
+  );
+};
+var bddExitCodePather = (entryPoint, platform) => {
+  return path.join(
+    "./docs/",
+    platform,
+    entryPoint.split(".").slice(0, -1).join("."),
+    `bdd_errors.txt`
+  );
+};
+
+// src/PM/index.ts
+var PM = class {
 };
 
 // src/PM/main.ts
 var fileStreams3 = [];
 var fPaths = [];
 var files = {};
+var recorders = {};
 var screenshots = {};
+var statusMessagePretty = (failures, test) => {
+  if (failures === 0) {
+    console.log(ansiC.green(ansiC.inverse(`> ${test} completed successfully`)));
+  } else {
+    console.log(ansiC.red(ansiC.inverse(`> ${test} failed ${failures} times`)));
+  }
+};
+async function writeFileAndCreateDir(filePath, data) {
+  const dirPath = path2.dirname(filePath);
+  try {
+    await fs.promises.mkdir(dirPath, { recursive: true });
+    await fs.appendFileSync(filePath, data);
+  } catch (error) {
+    console.error(`Error writing file: ${error}`);
+  }
+}
+function isValidUrl(string) {
+  try {
+    new URL(string);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
 var PM_Main = class extends PM {
   constructor(configs) {
     super();
     this.shutdownMode = false;
+    this.bigBoard = {};
     this.checkForShutdown = () => {
-      const anyRunning = Object.values(this.registry).filter((x) => x === false).length > 0;
+      const anyRunning = Object.values(this.bigBoard).filter((x) => x.status === "running").length > 0;
       if (anyRunning) {
       } else {
         this.browser.disconnect().then(() => {
-          console.log("Goodbye");
+          const final = {
+            timestamp: Date.now(),
+            tests: this.configs.tests.reduce((mm, t) => {
+              const bddErrors = fs.readFileSync(bddExitCodePather(t[0], t[1])).toString();
+              const lintErrors = fs.readFileSync(lintExitCodePather(t[0], t[1])).toString();
+              const typeErrors = fs.readFileSync(tscExitCodePather(t[0], t[1])).toString();
+              mm[t[0]] = {
+                bddErrors,
+                lintErrors,
+                typeErrors
+              };
+              return mm;
+            }, {})
+          };
+          const s = JSON.stringify(final, null, 2);
+          fs.writeFileSync("docs/summary.json", s);
+          console.log(ansiC.inverse("Goodbye"));
           process.exit();
         });
       }
     };
-    this.register = (src) => {
-      this.registry[src] = false;
+    this.testIsNowRunning = (src) => {
+      this.bigBoard[src].status = "running";
     };
-    this.deregister = (src) => {
-      this.registry[src] = true;
+    this.testIsNowDone = (src) => {
+      this.bigBoard[src].status = "waiting";
       if (this.shutdownMode) {
         this.checkForShutdown();
       }
     };
     this.launchNode = async (src, dest) => {
-      console.log("launchNode", src);
-      this.register(src);
+      console.log(ansiC.green(ansiC.inverse(`! node, ${src}`)));
+      this.testIsNowRunning(src);
       const destFolder = dest.replace(".mjs", "");
       let argz = "";
       const testConfig = this.configs.tests.find((t) => {
         return t[0] === src;
       });
       if (!testConfig) {
-        console.error("missing test config");
+        console.log(ansiC.inverse("missing test config! Exiting ungracefully!"));
         process.exit(-1);
       }
       const testConfigResource = testConfig[2];
@@ -96,38 +181,19 @@ var PM_Main = class extends PM {
         console.error("negative port makes no sense", src);
         process.exit(-1);
       }
-      const builtfile = dest + ".mjs";
+      const builtfile = dest;
       const webSideCares = [];
-      await Promise.all(
-        testConfig[3].map(async (sidecar) => {
-          if (sidecar[1] === "web") {
-            const s = await this.launchWebSideCar(
-              sidecar[0],
-              destinationOfRuntime(sidecar[0], "web", this.configs),
-              sidecar
-            );
-            webSideCares.push(s);
-            return s;
-          }
-          if (sidecar[1] === "node") {
-            return this.launchNodeSideCar(
-              sidecar[0],
-              destinationOfRuntime(sidecar[0], "node", this.configs),
-              sidecar
-            );
-          }
-        })
-      );
       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);
-            console.log(`${src} completed with ${failed} errors`);
+            this.receiveFeatures(features, destFolder, src);
+            statusMessagePretty(failed, src);
+            this.receiveExitCode(src, failed);
           }).catch((e) => {
-            console.log(`${src} errored with`, e);
+            console.log(ansiC.red(ansiC.inverse(`${src} errored with: ${e}`)));
           }).finally(() => {
             webSideCares.forEach((webSideCar) => webSideCar.close());
-            this.deregister(src);
+            this.testIsNowDone(src);
           });
         });
       });
@@ -139,7 +205,7 @@ var PM_Main = class extends PM {
     };
     this.launchWebSideCar = async (src, dest, testConfig) => {
       const d = dest + ".mjs";
-      console.log("launchWebSideCar", src, dest, d);
+      console.log(ansiC.green(ansiC.inverse(`launchWebSideCar ${src}`)));
       const destFolder = dest.replace(".mjs", "");
       const fileStreams2 = [];
       const doneFileStream2 = [];
@@ -233,7 +299,7 @@ var PM_Main = class extends PM {
     };
     this.launchNodeSideCar = async (src, dest, testConfig) => {
       const d = dest + ".mjs";
-      console.log("launchNodeSideCar", src, dest, d);
+      console.log(ansiC.green(ansiC.inverse(`launchNodeSideCar ${src}`)));
       const destFolder = dest.replace(".mjs", "");
       let argz = "";
       const testConfigResource = testConfig[2];
@@ -284,18 +350,9 @@ var PM_Main = class extends PM {
         }
       }
     };
-    this.launchWeb = (t, dest, sidecars) => {
-      console.log("launchWeb", t, dest);
-      this.register(t);
-      sidecars.map((sidecar) => {
-        if (sidecar[1] === "node") {
-          return this.launchNodeSideCar(
-            sidecar[0],
-            destinationOfRuntime(sidecar[0], "node", this.configs),
-            sidecar
-          );
-        }
-      });
+    this.launchWeb = (t, dest) => {
+      console.log(ansiC.green(ansiC.inverse(`! web ${t}`)));
+      this.testIsNowRunning(t);
       const destFolder = dest.replace(".mjs", "");
       const webArgz = JSON.stringify({
         name: dest,
@@ -303,10 +360,11 @@ var PM_Main = class extends PM {
         fs: destFolder,
         browserWSEndpoint: this.browser.wsEndpoint()
       });
+      const d = `${dest}?cacheBust=${Date.now()}`;
       const evaluation = `
-    console.log("importing ${dest}.mjs");
-    import('${dest}.mjs').then(async (x) => {
-      console.log("imported", (await x.default));
+
+    import('${d}').then(async (x) => {
+
       try {
         return await (await x.default).receiveTestResourceConfig(${webArgz})
       } catch (e) {
@@ -315,8 +373,8 @@ var PM_Main = class extends PM {
     })`;
       const fileStreams2 = [];
       const doneFileStream2 = [];
-      const stdoutStream = fs.createWriteStream(`${dest}/stdout.log`);
-      const stderrStream = fs.createWriteStream(`${dest}/stderr.log`);
+      const stdoutStream = fs.createWriteStream(`${destFolder}/stdout.log`);
+      const stderrStream = fs.createWriteStream(`${destFolder}/stderr.log`);
       this.browser.newPage().then((page) => {
         page.exposeFunction(
           "screencast",
@@ -458,14 +516,14 @@ var PM_Main = class extends PM {
             files[t] = /* @__PURE__ */ new Set();
           }
           fs.writeFileSync(
-            dest + "/manifest.json",
+            destFolder + "/manifest.json",
             JSON.stringify(Array.from(files[t]))
           );
           delete files[t];
           Promise.all(screenshots[t] || []).then(() => {
             delete screenshots[t];
             page.close();
-            this.deregister(t);
+            this.testIsNowDone(t);
             stderrStream.close();
             stdoutStream.close();
           });
@@ -483,25 +541,34 @@ var PM_Main = class extends PM {
           }
           console.debug(`Error from message ${t}: [${err.message}] `);
           stderrStream.write(err.message);
+          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://${`${dest}.html`}`, {});
+        await page.goto(`file://${`${destFolder}.html`}`, {});
         await page.evaluate(evaluation).then(async ({ failed, features }) => {
-          this.receiveFeatures(features, destFolder);
-          console.log(`${t} completed with ${failed} errors`);
+          this.receiveFeatures(features, destFolder, t);
+          statusMessagePretty(failed, t);
+          this.receiveExitCode(t, failed);
         }).catch((e) => {
-          console.log(`${t} errored with`, e);
+          console.log(ansiC.red(ansiC.inverse(`${t} errored with: ${e}`)));
         }).finally(() => {
           close();
         });
         return page;
       });
     };
-    this.receiveFeatures = (features, destFolder) => {
+    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);
@@ -519,42 +586,82 @@ var PM_Main = class extends PM {
               if (error.code !== "ENOENT") {
               }
             }
-            fs.symlink(u.pathname, newPath, (err) => {
-              if (err) {
-              } else {
-              }
-            });
-            accum.push(newPath);
+            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.push(newPath);
+            accum.files.push(newPath);
           }
         } else {
-          const newPath = `${process.cwd()}/docs/features/plain/${await sha256(
-            featureStringKey
-          )}`;
-          writeFileAndCreateDir(newPath, featureStringKey);
-          accum.push(newPath);
+          await fs.promises.mkdir(path2.dirname(featureDestination), {
+            recursive: true
+          });
+          accum.strings.push(featureStringKey);
         }
         return accum;
-      }, Promise.resolve([])).then((features2) => {
+      }, Promise.resolve({ files: [], strings: [] })).then(({ files: files2, strings }) => {
         fs.writeFileSync(
           `${destFolder}/featurePrompt.txt`,
-          features2.map((f) => {
+          files2.map((f) => {
             return `/read ${f}`;
           }).join("\n")
         );
       });
+      this.writeBigBoard();
+    };
+    this.receiveExitCode = (srcTest, failures) => {
+      this.bigBoard[srcTest].runTimeError = failures;
+      this.writeBigBoard();
+    };
+    this.writeBigBoard = () => {
+      fs.writeFileSync(
+        "./docs/bigBoard.json",
+        JSON.stringify(this.bigBoard, null, 2)
+      );
     };
     this.server = {};
     this.configs = configs;
     this.ports = {};
-    this.registry = {};
+    this.configs.tests.forEach(([t]) => {
+      this.bigBoard[t] = {
+        status: "?"
+      };
+    });
     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 (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, {
@@ -564,8 +671,7 @@ var PM_Main = class extends PM {
       return false;
     };
     globalThis["writeFileSync"] = (filepath, contents, testName) => {
-      const dir = path2.dirname(filepath);
-      fs.mkdirSync(dir, {
+      fs.mkdirSync(path2.dirname(filepath), {
         recursive: true
       });
       if (!files[testName]) {
@@ -592,7 +698,11 @@ var PM_Main = class extends PM {
     globalThis["end"] = (uid) => {
       fileStreams3[uid].end();
     };
-    globalThis["customScreenShot"] = async (opts, page) => {
+    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, {
@@ -613,6 +723,38 @@ var PM_Main = class extends PM {
       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
+      });
+      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.");
@@ -620,7 +762,7 @@ var PM_Main = class extends PM {
   screencast(opts) {
     throw new Error("Method not implemented.");
   }
-  customScreenShot(opts) {
+  customScreenShot(opts, cdpPage) {
     throw new Error("Method not implemented.");
   }
   end(accessObject) {
@@ -712,65 +854,265 @@ var PM_Main = class extends PM {
   isDisabled(selector) {
     throw new Error("Method not implemented.");
   }
+  screencastStop(s) {
+    throw new Error("Method not implemented.");
+  }
   ////////////////////////////////////////////////////////////////////////////////
   async startPuppeteer(options, destfolder) {
     this.browser = await puppeteer.launch(options);
   }
-  ////////////////////////////////////////////////////////////////////////////////
+  // goodbye = () => {
+  //   this.browser.disconnect().then(() => {
+  //     console.log("Goodbye");
+  //     process.exit();
+  //   });
+  // };
   shutDown() {
-    console.log("shutting down...");
     this.shutdownMode = true;
     this.checkForShutdown();
   }
 };
-async function writeFileAndCreateDir(filePath, data) {
-  const dirPath = path2.dirname(filePath);
-  try {
-    await fs.promises.mkdir(dirPath, { recursive: true });
-    await fs.promises.writeFile(filePath, data);
-  } catch (error) {
-    console.error(`Error writing file: ${error}`);
-  }
-}
-async function sha256(rawData) {
-  const data = typeof rawData === "object" ? JSON.stringify(rawData) : String(rawData);
-  const msgBuffer = new TextEncoder().encode(data);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", msgBuffer);
-  const hashArray = Array.from(new Uint8Array(hashBuffer));
-  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-function isValidUrl(string) {
-  try {
-    new URL(string);
-    return true;
-  } catch (err) {
-    return false;
-  }
-}
 
-// src/Puppeteer.ts
+// src/run.ts
+console.log(ansiC2.inverse("Press 'x' to shutdown forcefully."));
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
   process.stdin.setRawMode(true);
-var Puppeteer_default = async (partialConfig) => {
+process.stdin.on("keypress", (str, key) => {
+  if (key.name === "x") {
+    console.log(ansiC2.inverse("Shutting down forcefully..."));
+    process.exit(-1);
+  }
+});
+async function fileHash(filePath, algorithm = "md5") {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash(algorithm);
+    const fileStream = fs2.createReadStream(filePath);
+    fileStream.on("data", (data) => {
+      hash.update(data);
+    });
+    fileStream.on("end", () => {
+      const fileHash2 = hash.digest("hex");
+      resolve(fileHash2);
+    });
+    fileStream.on("error", (error) => {
+      reject(`Error reading file: ${error.message}`);
+    });
+  });
+}
+async function filesHash(files2, algorithm = "md5") {
+  return new Promise((resolve, reject) => {
+    resolve(
+      files2.reduce(async (mm, f) => {
+        return await mm + await fileHash(f);
+      }, Promise.resolve(""))
+    );
+  });
+}
+var getRunnables = (tests, payload = {
+  nodeEntryPoints: {},
+  webEntryPoints: {}
+}) => {
+  return tests.reduce((pt, cv, cndx, cry) => {
+    if (cv[1] === "node") {
+      pt.nodeEntryPoints[cv[0]] = path3.resolve(
+        `./docs/node/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
+      );
+    } else if (cv[1] === "web") {
+      pt.webEntryPoints[cv[0]] = path3.resolve(
+        `./docs/web/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
+      );
+    }
+    if (cv[3].length) {
+      getRunnables(cv[3], payload);
+    }
+    return pt;
+  }, payload);
+};
+var changes = {};
+var tscCheck = async ({
+  entrypoint,
+  addableFiles,
+  platform
+}) => {
+  console.log(ansiC2.green(ansiC2.inverse(`tsc < ${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),
+      // declaration: true,
+      // skipLibCheck: true,
+      noEmit: true
+    },
+    include: addableFiles
+    //["src/**/*"],
+    // exclude: ["**/*.test.ts", "**/*.spec.ts"],
+  });
+  const tscPath = tscPather(entrypoint, platform);
+  let allDiagnostics = program.getSemanticDiagnostics();
+  const d = [];
+  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}`
+      );
+    } else {
+      d.push(ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+    }
+  });
+  fs2.writeFileSync(tscPath, d.join("\n"));
+  fs2.writeFileSync(
+    tscExitCodePather(entrypoint, platform),
+    d.length.toString()
+  );
+};
+var eslint = new ESLint();
+var formatter = await eslint.loadFormatter(
+  "./node_modules/testeranto/dist/prebuild/esbuildConfigs/eslint-formatter-testeranto.mjs"
+);
+var eslintCheck = async (entrypoint, platform, addableFiles) => {
+  console.log(ansiC2.green(ansiC2.inverse(`eslint < ${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;
+  });
+  fs2.writeFileSync(
+    lintPather(entrypoint, platform),
+    await formatter.format(results)
+  );
+  fs2.writeFileSync(
+    lintExitCodePather(entrypoint, platform),
+    results.length.toString()
+  );
+};
+var makePrompt = async (entryPoint, addableFiles, platform) => {
+  const promptPath = path3.join(
+    "./docs/",
+    platform,
+    entryPoint.split(".").slice(0, -1).join("."),
+    `prompt.txt`
+  );
+  const testPaths = path3.join(
+    "./docs/",
+    platform,
+    entryPoint.split(".").slice(0, -1).join("."),
+    `tests.json`
+  );
+  const featuresPath = path3.join(
+    "./docs/",
+    platform,
+    entryPoint.split(".").slice(0, -1).join("."),
+    `featurePrompt.txt`
+  );
+  fs2.writeFileSync(
+    promptPath,
+    `
+${addableFiles.map((x) => {
+      return `/add ${x}`;
+    }).join("\n")}
+
+/read ${lintPather(entryPoint, platform)}
+/read ${tscPather(entryPoint, platform)}
+/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
+    )}"
+          `
+  );
+};
+var metafileOutputs = async (platform) => {
+  const metafile = JSON.parse(
+    fs2.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 (!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;
+        tscCheck({ platform, addableFiles, entrypoint });
+        eslintCheck(entrypoint, platform, addableFiles);
+        makePrompt(entrypoint, addableFiles, platform);
+      }
+    }
+  });
+};
+import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
+  const rawConfig = module.default;
   const config = {
-    ...partialConfig,
-    buildDir: process.cwd() + "/" + partialConfig.outdir
+    ...rawConfig,
+    buildDir: process.cwd() + "/" + rawConfig.outdir
   };
-  fs2.writeFileSync(
-    `${config.outdir}/testeranto.json`,
-    JSON.stringify(
-      {
-        ...config,
-        buildDir: process.cwd() + "/" + config.outdir
-      },
-      null,
-      2
-    )
+  let mode = config.devMode ? "DEV" : "PROD";
+  const fileHashes = {};
+  let pm = new PM_Main(config);
+  console.log(ansiC2.inverse(`Press 'q' to shutdown gracefully`));
+  process.stdin.on("keypress", (str, key) => {
+    if (key.name === "q") {
+      console.log(
+        ansiC2.inverse("Testeranto-Run is shutting down gracefully...")
+      );
+      mode = "PROD";
+      nodeMetafileWatcher.close();
+      webMetafileWatcher.close();
+      pm.shutDown();
+    }
+  });
+  metafileOutputs("node");
+  const nodeMetafileWatcher = watch(
+    "docs/node/metafile.json",
+    async (e, filename) => {
+      console.log(ansiC2.green(ansiC2.inverse(`< ${e} ${filename} (node)`)));
+      metafileOutputs("node");
+    }
+  );
+  metafileOutputs("web");
+  const webMetafileWatcher = watch(
+    "docs/web/metafile.json",
+    async (e, filename) => {
+      console.log(ansiC2.green(ansiC2.inverse(`< ${e} ${filename} (web)`)));
+      metafileOutputs("web");
+    }
   );
-  const pm = new PM_Main(config);
   await pm.startPuppeteer(
     {
+      slowMo: 1,
       // timeout: 1,
       waitForInitialPage: false,
       executablePath: (
@@ -814,58 +1156,35 @@ var Puppeteer_default = async (partialConfig) => {
     },
     "."
   );
-  console.log(
-    "\n Puppeteer is running. Press 'q' to shutdown softly. Press 'x' to shutdown forcefully.\n"
-  );
-  process.stdin.on("keypress", (str, key) => {
-    if (key.name === "q") {
-      pm.shutDown();
-    }
-    if (key.name === "x") {
-      process.exit(-1);
-    }
-  });
-  config.tests.forEach(([test, runtime, tr, sidecars]) => {
-    if (runtime === "node") {
-      pm.launchNode(test, destinationOfRuntime(test, "node", config));
-    } else if (runtime === "web") {
-      pm.launchWeb(test, destinationOfRuntime(test, "web", config), sidecars);
-    } else {
-      console.error("runtime makes no sense", runtime);
-    }
-  });
-  if (config.devMode) {
-    console.log("ready and watching for changes...", config.buildDir);
-    watch(config.buildDir, (eventType, changedFile) => {
-      if (changedFile) {
-        config.tests.forEach(([test, runtime, tr, sidecars]) => {
-          if (eventType === "change" || eventType === "rename") {
-            if (changedFile === test.replace("./", "node/").split(".").slice(0, -1).concat("mjs").join(".")) {
-              pm.launchNode(test, destinationOfRuntime(test, "node", config));
-            }
-            if (changedFile === test.replace("./", "web/").split(".").slice(0, -1).concat("mjs").join(".")) {
-              pm.launchWeb(
-                test,
-                destinationOfRuntime(test, "web", config),
-                sidecars
-              );
-            }
+  const { nodeEntryPoints, webEntryPoints } = getRunnables(config.tests);
+  Object.entries(nodeEntryPoints).forEach(
+    ([k, outputFile]) => {
+      pm.launchNode(k, outputFile);
+      try {
+        watch(outputFile, async (e, filename) => {
+          const hash = await fileHash(outputFile);
+          if (fileHashes[k] !== hash) {
+            fileHashes[k] = hash;
+            console.log(ansiC2.green(ansiC2.inverse(`< ${e} ${filename}`)));
+            pm.launchNode(k, outputFile);
           }
         });
+      } catch (e) {
+        console.error(e);
       }
-    });
-  } else {
-    pm.shutDown();
-  }
-};
-
-// src/run-tests.ts
-import process2 from "process";
-if (!process2.argv[2]) {
-  console.log("You didn't pass a config file");
-  process2.exit(-1);
-} else {
-  import(process2.cwd() + "/" + process2.argv[2]).then((module) => {
-    Puppeteer_default(module.default);
-  });
-}
+    }
+  );
+  Object.entries(webEntryPoints).forEach(
+    ([k, outputFile]) => {
+      pm.launchWeb(k, outputFile);
+      watch(outputFile, async (e, filename) => {
+        const hash = await fileHash(outputFile);
+        if (fileHashes[k] !== hash) {
+          fileHashes[k] = hash;
+          console.log(ansiC2.green(ansiC2.inverse(`< ${e} ${filename}`)));
+          pm.launchWeb(k, outputFile);
+        }
+      });
+    }
+  );
+});