testeranto 0.100.0 → 0.110.0

package/dist/prebuild/cli.mjs

@@ -1,1491 +0,0 @@
-import { createRequire } from 'module';const require = createRequire(import.meta.url);
-
-// src/cli.ts
-import { spawn as spawn2 } from "child_process";
-import fs3 from "fs";
-import path5 from "path";
-import readline from "readline";
-import { glob } from "glob";
-import { debounceWatch } from "@bscotch/debounce-watch";
-import esbuild from "esbuild";
-
-// src/esbuildConfigs/index.ts
-var esbuildConfigs_default = (config) => {
-  return {
-    // packages: "external",
-    target: "esnext",
-    format: "esm",
-    splitting: true,
-    outExtension: { ".js": ".mjs" },
-    outbase: config.outbase,
-    jsx: "transform",
-    bundle: true,
-    minify: config.minify === true,
-    write: true,
-    loader: {
-      ".js": "jsx",
-      ".png": "binary",
-      ".jpg": "binary"
-    }
-  };
-};
-
-// src/esbuildConfigs/inputFilesPlugin.ts
-import fs from "fs";
-import path from "path";
-import { spawn } from "child_process";
-var otherInputs = {};
-var register = (entrypoint, sources) => {
-  if (!otherInputs[entrypoint]) {
-    otherInputs[entrypoint] = /* @__PURE__ */ new Set();
-  }
-  sources.forEach((s) => otherInputs[entrypoint].add(s));
-};
-function tree(meta, key) {
-  const outputKey = Object.keys(meta.outputs).find((k) => {
-    return meta.outputs[k].entryPoint === key;
-  });
-  if (!outputKey) {
-    console.error("No outputkey found");
-    process.exit(-1);
-  }
-  return Object.keys(meta.outputs[outputKey].inputs).filter(
-    (k) => k.startsWith("src")
-  );
-}
-var inputFilesPlugin_default = (platform, entryPoints) => {
-  return {
-    register,
-    inputFilesPluginFactory: {
-      name: "metafileWriter",
-      setup(build) {
-        build.onEnd((result) => {
-          fs.writeFileSync(
-            `docs/${platform}/metafile.json`,
-            JSON.stringify(result, null, 2)
-          );
-          if (result.errors.length === 0) {
-            entryPoints.forEach((entryPoint) => {
-              const filePath = path.join(
-                "./docs/",
-                platform,
-                entryPoint.split(".").slice(0, -1).join("."),
-                `inputFiles.json`
-              );
-              const dirName = path.dirname(filePath);
-              if (!fs.existsSync(dirName)) {
-                fs.mkdirSync(dirName, { recursive: true });
-              }
-              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 stderrPath = path.join(
-                "./docs/",
-                platform,
-                entryPoint.split(".").slice(0, -1).join("."),
-                `stderr.log`
-              );
-              const stdoutPath = path.join(
-                "./docs/",
-                platform,
-                entryPoint.split(".").slice(0, -1).join("."),
-                `stdout.log`
-              );
-              if (result.metafile) {
-                const addableFiles = tree(
-                  result.metafile,
-                  entryPoint.split("/").slice(1).join("/")
-                ).map((y) => {
-                  if (otherInputs[y]) {
-                    return Array.from(otherInputs[y]);
-                  }
-                  return y;
-                }).flat();
-                const typeErrorFiles = addableFiles.map(
-                  (t) => `docs/types/${t}.type_errors.txt`
-                );
-                const lintPath = path.join(
-                  "./docs/",
-                  platform,
-                  entryPoint.split(".").slice(0, -1).join("."),
-                  `lint_errors.txt`
-                );
-                fs.writeFileSync(
-                  promptPath,
-                  `
-${addableFiles.map((x) => {
-                    return `/add ${x}`;
-                  }).join("\n")}
-  
-${typeErrorFiles.map((x) => {
-                    return `/read ${x}`;
-                  }).join("\n")}
-
-/read ${lintPath}
-/read ${testPaths}
-/read ${stdoutPath}
-/read ${stderrPath}
-
-/load ${featuresPath}
-
-/code Fix the failing tests described in ${testPaths}. Correct any type signature errors described in the files [${typeErrorFiles.join(
-                    ", "
-                  )}]. Implement any method which throws "Function not implemented. Resolve the lint errors described in ${lintPath}"
-`
-                );
-                const logContent = [];
-                const tsc = spawn("eslint", addableFiles);
-                tsc.stdout.on("data", (data) => {
-                  const lines = data.toString().split("\n");
-                  logContent.push(...lines);
-                });
-                tsc.stderr.on("data", (data) => {
-                  console.error(`stderr: ${data}`);
-                  process.exit(-1);
-                });
-                tsc.on("close", (code) => {
-                  fs.writeFileSync(lintPath, logContent.join("\n"));
-                });
-              }
-            });
-          }
-        });
-      }
-    }
-  };
-};
-
-// src/esbuildConfigs/featuresPlugin.ts
-import path2 from "path";
-var featuresPlugin_default = {
-  name: "feature-markdown",
-  setup(build) {
-    build.onResolve({ filter: /\.md$/ }, (args) => {
-      if (args.resolveDir === "")
-        return;
-      return {
-        path: path2.isAbsolute(args.path) ? args.path : path2.join(args.resolveDir, args.path),
-        namespace: "feature-markdown"
-      };
-    });
-    build.onLoad(
-      { filter: /.*/, namespace: "feature-markdown" },
-      async (args) => {
-        return {
-          contents: `file://${args.path}`,
-          loader: "text"
-          // contents: JSON.stringify({ path: args.path }),
-          // loader: "json",
-          // contents: JSON.stringify({
-          //   // html: markdownHTML,
-          //   raw: markdownContent,
-          //   filename: args.path, //path.basename(args.path),
-          // }),
-          // loader: "json",
-        };
-      }
-    );
-  }
-};
-
-// src/esbuildConfigs/node.ts
-var node_default = (config, entryPoints) => {
-  const { inputFilesPluginFactory, register: register2 } = inputFilesPlugin_default(
-    "node",
-    entryPoints
-  );
-  return {
-    ...esbuildConfigs_default(config),
-    splitting: true,
-    outdir: config.outdir + "/node",
-    // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
-    metafile: true,
-    supported: {
-      "dynamic-import": true
-    },
-    define: {
-      "process.env.FLUENTFFMPEG_COV": "0"
-    },
-    absWorkingDir: process.cwd(),
-    banner: {
-      js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
-    },
-    platform: "node",
-    external: [
-      // "testeranto.json",
-      // "features.test.js",
-      "react",
-      // "events",
-      // "ganache"
-      ...config.externals
-    ],
-    entryPoints: [...entryPoints],
-    plugins: [
-      featuresPlugin_default,
-      ...config.nodePlugins.map((p) => p(register2, entryPoints)) || [],
-      inputFilesPluginFactory,
-      // inputFilesPlugin("node", entryPoints),
-      {
-        name: "rebuild-notify",
-        setup(build) {
-          build.onEnd((result) => {
-            console.log(
-              `> node build ended with ${result.errors.length} errors`
-            );
-            if (result.errors.length > 0) {
-              console.log(result);
-            }
-          });
-        }
-      }
-    ]
-  };
-};
-
-// src/esbuildConfigs/web.ts
-import path3 from "path";
-var web_default = (config, entryPoints) => {
-  const { inputFilesPluginFactory, register: register2 } = inputFilesPlugin_default(
-    "web",
-    entryPoints
-  );
-  return {
-    ...esbuildConfigs_default(config),
-    // inject: ["./node_modules/testeranto/dist/cjs-shim.js"],
-    // banner: {
-    //   js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
-    // },
-    // splitting: true,
-    outdir: config.outdir + "/web",
-    alias: {
-      react: path3.resolve("./node_modules/react")
-    },
-    metafile: true,
-    external: [
-      // "testeranto.json",
-      // "features.test.ts",
-      // "url",
-      // "react",
-      "path",
-      "fs",
-      "stream",
-      "http",
-      "constants",
-      "net",
-      "assert",
-      "tls",
-      "os",
-      "child_process",
-      "readline",
-      "zlib",
-      "crypto",
-      "https",
-      "util",
-      "process",
-      "dns"
-    ],
-    platform: "browser",
-    entryPoints: [...entryPoints],
-    plugins: [
-      featuresPlugin_default,
-      // markdownPlugin({}),
-      ...config.nodePlugins.map((p) => p(register2, entryPoints)) || [],
-      inputFilesPluginFactory,
-      {
-        name: "rebuild-notify",
-        setup(build) {
-          build.onEnd((result) => {
-            console.log(
-              `> web build ended with ${result.errors.length} errors`
-            );
-            if (result.errors.length > 0) {
-              console.log(result);
-            }
-          });
-        }
-      }
-    ]
-  };
-};
-
-// src/web.html.ts
-var web_html_default = (jsfilePath, htmlFilePath) => `
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-  <script type="module" src="${jsfilePath}"></script>
-
-</head>
-
-<body>
-  <h1>${htmlFilePath}</h1>
-  <div id="root">
-
-  </div>
-</body>
-
-<footer></footer>
-
-</html>
-`;
-
-// src/PM/main.ts
-import fs2 from "fs";
-import path4 from "path";
-import puppeteer from "puppeteer-core";
-import crypto from "crypto";
-
-// src/PM/index.ts
-var PM = class {
-};
-
-// src/PM/main.ts
-var fileStreams3 = [];
-var fPaths = [];
-var files = {};
-var recorders = {};
-var screenshots = {};
-var red = "\x1B[31m";
-var green = "\x1B[32m";
-var reset = "\x1B[0m";
-var statusMessagePretty = (failures, test) => {
-  if (failures === 0) {
-    console.log(green + `${test} completed successfully` + reset);
-  } else {
-    console.log(red + `${test} failed ${failures} times` + reset);
-  }
-};
-var PM_Main = class extends PM {
-  constructor(configs) {
-    super();
-    this.shutdownMode = false;
-    this.checkForShutdown = () => {
-      const anyRunning = Object.values(this.registry).filter((x) => x === false).length > 0;
-      if (anyRunning) {
-      } else {
-        this.browser.disconnect().then(() => {
-          console.log("Goodbye");
-          process.exit();
-        });
-      }
-    };
-    this.register = (src) => {
-      this.registry[src] = false;
-    };
-    this.deregister = (src) => {
-      this.registry[src] = true;
-      if (this.shutdownMode) {
-        this.checkForShutdown();
-      }
-    };
-    this.launchNode = async (src, dest) => {
-      console.log("! node", src);
-      this.register(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");
-        process.exit(-1);
-      }
-      const testConfigResource = testConfig[2];
-      let portsToUse = [];
-      if (testConfigResource.ports === 0) {
-        argz = JSON.stringify({
-          scheduled: true,
-          name: src,
-          ports: portsToUse,
-          fs: destFolder,
-          browserWSEndpoint: this.browser.wsEndpoint()
-        });
-      } else if (testConfigResource.ports > 0) {
-        const openPorts = Object.entries(this.ports).filter(
-          ([portnumber, portopen]) => portopen
-        );
-        if (openPorts.length >= testConfigResource.ports) {
-          for (let i = 0; i < testConfigResource.ports; i++) {
-            portsToUse.push(openPorts[i][0]);
-            this.ports[openPorts[i][0]] = false;
-          }
-          argz = JSON.stringify({
-            scheduled: true,
-            name: src,
-            // ports: [3333],
-            ports: portsToUse,
-            fs: destFolder,
-            browserWSEndpoint: this.browser.wsEndpoint()
-          });
-        } else {
-          this.queue.push(src);
-          return;
-        }
-      } else {
-        console.error("negative port makes no sense", src);
-        process.exit(-1);
-      }
-      const builtfile = dest;
-      const webSideCares = [];
-      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);
-            statusMessagePretty(failed, src);
-          }).catch((e) => {
-            console.log(`${src} errored with`, e);
-          }).finally(() => {
-            webSideCares.forEach((webSideCar) => webSideCar.close());
-            this.deregister(src);
-          });
-        });
-      });
-      for (let i = 0; i <= portsToUse.length; i++) {
-        if (portsToUse[i]) {
-          this.ports[portsToUse[i]] = "true";
-        }
-      }
-    };
-    this.launchWebSideCar = async (src, dest, testConfig) => {
-      const d = dest + ".mjs";
-      console.log("launchWebSideCar", src, dest, d);
-      const destFolder = dest.replace(".mjs", "");
-      const fileStreams2 = [];
-      const doneFileStream2 = [];
-      return new Promise((res, rej) => {
-        this.browser.newPage().then((page) => {
-          page.exposeFunction(
-            "custom-screenshot",
-            async (ssOpts, testName) => {
-              const p = ssOpts.path;
-              const dir = path4.dirname(p);
-              fs2.mkdirSync(dir, {
-                recursive: true
-              });
-              files[testName].add(ssOpts.path);
-              const sPromise = page.screenshot({
-                ...ssOpts,
-                path: p
-              });
-              if (!screenshots[testName]) {
-                screenshots[testName] = [];
-              }
-              screenshots[testName].push(sPromise);
-              await sPromise;
-              return sPromise;
-            }
-          );
-          page.exposeFunction(
-            "writeFileSync",
-            (fp, contents, testName) => {
-              const dir = path4.dirname(fp);
-              fs2.mkdirSync(dir, {
-                recursive: true
-              });
-              const p = new Promise(async (res2, rej2) => {
-                fs2.writeFileSync(fp, contents);
-                res2(fp);
-              });
-              doneFileStream2.push(p);
-              if (!files[testName]) {
-                files[testName] = /* @__PURE__ */ new Set();
-              }
-              files[testName].add(fp);
-              return p;
-            }
-          );
-          page.exposeFunction("existsSync", (fp, contents) => {
-            return fs2.existsSync(fp);
-          });
-          page.exposeFunction("mkdirSync", (fp) => {
-            if (!fs2.existsSync(fp)) {
-              return fs2.mkdirSync(fp, {
-                recursive: true
-              });
-            }
-            return false;
-          });
-          page.exposeFunction(
-            "createWriteStream",
-            (fp, testName) => {
-              const f = fs2.createWriteStream(fp);
-              files[testName].add(fp);
-              const p = new Promise((res2, rej2) => {
-                res2(fp);
-              });
-              doneFileStream2.push(p);
-              f.on("close", async () => {
-                await p;
-              });
-              fileStreams2.push(f);
-              return {
-                ...JSON.parse(JSON.stringify(f)),
-                uid: fileStreams2.length - 1
-              };
-            }
-          );
-          page.exposeFunction(
-            "write",
-            async (uid, contents) => {
-              return fileStreams2[uid].write(contents);
-            }
-          );
-          page.exposeFunction("end", async (uid) => {
-            return fileStreams2[uid].end();
-          });
-          return page;
-        }).then(async (page) => {
-          await page.goto(`file://${`${dest}.html`}`, {});
-          res(page);
-        });
-      });
-    };
-    this.launchNodeSideCar = async (src, dest, testConfig) => {
-      const d = dest + ".mjs";
-      console.log("launchNodeSideCar", src, dest, d);
-      const destFolder = dest.replace(".mjs", "");
-      let argz = "";
-      const testConfigResource = testConfig[2];
-      let portsToUse = [];
-      if (testConfigResource.ports === 0) {
-        argz = JSON.stringify({
-          scheduled: true,
-          name: src,
-          ports: portsToUse,
-          fs: destFolder,
-          browserWSEndpoint: this.browser.wsEndpoint()
-        });
-      } else if (testConfigResource.ports > 0) {
-        const openPorts = Object.entries(this.ports).filter(
-          ([portnumber, portopen]) => portopen
-        );
-        if (openPorts.length >= testConfigResource.ports) {
-          for (let i = 0; i < testConfigResource.ports; i++) {
-            portsToUse.push(openPorts[i][0]);
-            this.ports[openPorts[i][0]] = false;
-          }
-          argz = JSON.stringify({
-            scheduled: true,
-            name: src,
-            // ports: [3333],
-            ports: portsToUse,
-            fs: ".",
-            browserWSEndpoint: this.browser.wsEndpoint()
-          });
-        } else {
-          this.queue.push(src);
-          return;
-        }
-      } else {
-        console.error("negative port makes no sense", src);
-        process.exit(-1);
-      }
-      const builtfile = dest + ".mjs";
-      this.server[builtfile] = await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
-        return module.default.then((defaultModule) => {
-          const s = new defaultModule();
-          s.receiveTestResourceConfig(argz);
-        });
-      });
-      for (let i = 0; i <= portsToUse.length; i++) {
-        if (portsToUse[i]) {
-          this.ports[portsToUse[i]] = "true";
-        }
-      }
-    };
-    this.launchWeb = (t, dest) => {
-      console.log("! web", t);
-      this.register(t);
-      const destFolder = dest.replace(".mjs", "");
-      const webArgz = JSON.stringify({
-        name: dest,
-        ports: [].toString(),
-        fs: destFolder,
-        browserWSEndpoint: this.browser.wsEndpoint()
-      });
-      const d = `${dest}?cacheBust=${Date.now()}`;
-      const evaluation = `
-    console.log("importing ${d}");
-    import('${d}').then(async (x) => {
-      console.log("imported", (await x.default));
-      try {
-        return await (await x.default).receiveTestResourceConfig(${webArgz})
-      } catch (e) {
-        console.log("fail", e)
-      }
-    })`;
-      const fileStreams2 = [];
-      const doneFileStream2 = [];
-      const stdoutStream = fs2.createWriteStream(`${destFolder}/stdout.log`);
-      const stderrStream = fs2.createWriteStream(`${destFolder}/stderr.log`);
-      this.browser.newPage().then((page) => {
-        page.exposeFunction(
-          "screencast",
-          async (ssOpts, testName) => {
-            const p = ssOpts.path;
-            const dir = path4.dirname(p);
-            fs2.mkdirSync(dir, {
-              recursive: true
-            });
-            if (!files[testName]) {
-              files[testName] = /* @__PURE__ */ new Set();
-            }
-            files[testName].add(ssOpts.path);
-            const sPromise = page.screenshot({
-              ...ssOpts,
-              path: p
-            });
-            if (!screenshots[testName]) {
-              screenshots[testName] = [];
-            }
-            screenshots[testName].push(sPromise);
-            await sPromise;
-            return sPromise;
-          }
-        );
-        page.exposeFunction(
-          "customScreenShot",
-          async (ssOpts, testName) => {
-            const p = ssOpts.path;
-            const dir = path4.dirname(p);
-            fs2.mkdirSync(dir, {
-              recursive: true
-            });
-            if (!files[testName]) {
-              files[testName] = /* @__PURE__ */ new Set();
-            }
-            files[testName].add(ssOpts.path);
-            const sPromise = page.screenshot({
-              ...ssOpts,
-              path: p
-            });
-            if (!screenshots[testName]) {
-              screenshots[testName] = [];
-            }
-            screenshots[testName].push(sPromise);
-            await sPromise;
-            return sPromise;
-          }
-        );
-        page.exposeFunction(
-          "writeFileSync",
-          (fp, contents, testName) => {
-            return globalThis["writeFileSync"](fp, contents, testName);
-          }
-        );
-        page.exposeFunction("existsSync", (fp, contents) => {
-          return fs2.existsSync(fp);
-        });
-        page.exposeFunction("mkdirSync", (fp) => {
-          if (!fs2.existsSync(fp)) {
-            return fs2.mkdirSync(fp, {
-              recursive: true
-            });
-          }
-          return false;
-        });
-        page.exposeFunction(
-          "createWriteStream",
-          (fp, testName) => {
-            const f = fs2.createWriteStream(fp);
-            if (!files[testName]) {
-              files[testName] = /* @__PURE__ */ new Set();
-            }
-            files[testName].add(fp);
-            const p = new Promise((res, rej) => {
-              res(fp);
-            });
-            doneFileStream2.push(p);
-            f.on("close", async () => {
-              await p;
-            });
-            fileStreams2.push(f);
-            return {
-              ...JSON.parse(JSON.stringify(f)),
-              uid: fileStreams2.length - 1
-            };
-          }
-        );
-        page.exposeFunction("write", async (uid, contents) => {
-          return fileStreams2[uid].write(contents);
-        });
-        page.exposeFunction("end", async (uid) => {
-          return fileStreams2[uid].end();
-        });
-        page.exposeFunction("page", () => {
-          return page.mainFrame()._id;
-        });
-        page.exposeFunction("click", (sel) => {
-          return page.click(sel);
-        });
-        page.exposeFunction("focusOn", (sel) => {
-          return page.focus(sel);
-        });
-        page.exposeFunction(
-          "typeInto",
-          async (value) => await page.keyboard.type(value)
-        );
-        page.exposeFunction(
-          "getValue",
-          (selector) => page.$eval(selector, (input) => input.getAttribute("value"))
-        );
-        page.exposeFunction(
-          "getAttribute",
-          async (selector, attribute) => {
-            const attributeValue = await page.$eval(selector, (input) => {
-              return input.getAttribute(attribute);
-            });
-            return attributeValue;
-          }
-        );
-        page.exposeFunction("isDisabled", async (selector) => {
-          const attributeValue = await page.$eval(
-            selector,
-            (input) => {
-              return input.disabled;
-            }
-          );
-          return attributeValue;
-        });
-        page.exposeFunction("$", async (selector) => {
-          const x = page.$(selector);
-          const y = await x;
-          return y;
-        });
-        return page;
-      }).then(async (page) => {
-        const close = () => {
-          if (!files[t]) {
-            files[t] = /* @__PURE__ */ new Set();
-          }
-          fs2.writeFileSync(
-            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);
-            stderrStream.close();
-            stdoutStream.close();
-          });
-        };
-        page.on("pageerror", (err) => {
-          console.debug(`Error from ${t}: [${err.name}] `);
-          stderrStream.write(err.name);
-          if (err.cause) {
-            console.debug(`Error from ${t} cause: [${err.cause}] `);
-            stderrStream.write(err.cause);
-          }
-          if (err.stack) {
-            console.debug(`Error from stack ${t}: [${err.stack}] `);
-            stderrStream.write(err.stack);
-          }
-          console.debug(`Error from message ${t}: [${err.message}] `);
-          stderrStream.write(err.message);
-        });
-        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);
-        }).catch((e) => {
-          console.log(`${t} errored with`, e);
-        }).finally(() => {
-          close();
-        });
-        return page;
-      });
-    };
-    this.receiveFeatures = (features, destFolder, srcTest) => {
-      const featureDestination = path4.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/${path4.relative(
-              process.cwd(),
-              u.pathname
-            )}`;
-            await fs2.promises.mkdir(path4.dirname(newPath), { recursive: true });
-            try {
-              await fs2.unlinkSync(newPath);
-            } catch (error) {
-              if (error.code !== "ENOENT") {
-              }
-            }
-            fs2.symlink(u.pathname, newPath, (err) => {
-              if (err) {
-              } else {
-              }
-            });
-            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 fs2.promises.mkdir(path4.dirname(featureDestination), {
-            recursive: true
-          });
-          accum.strings.push(featureStringKey);
-        }
-        return accum;
-      }, Promise.resolve({ files: [], strings: [] })).then(({ files: files2, strings }) => {
-        fs2.writeFileSync(
-          `${destFolder}/featurePrompt.txt`,
-          files2.map((f) => {
-            return `/read ${f}`;
-          }).join("\n")
-        );
-      });
-    };
-    this.server = {};
-    this.configs = configs;
-    this.ports = {};
-    this.registry = {};
-    this.configs.ports.forEach((element) => {
-      this.ports[element] = "true";
-    });
-    globalThis["waitForSelector"] = async (pageKey, sel) => {
-      console.log("waitForSelector", pageKey, sel);
-      const page = (await this.browser.pages()).find(
-        (p) => p.mainFrame()._id === pageKey
-      );
-      await page?.waitForSelector(sel);
-    };
-    globalThis["screencastStop"] = async (path6) => {
-      return recorders[path6].stop();
-    };
-    globalThis["closePage"] = async (pageKey) => {
-      const page = (await this.browser.pages()).find(
-        (p) => p.mainFrame()._id === pageKey
-      );
-      return page.close();
-    };
-    globalThis["goto"] = async (pageKey, url) => {
-      const page = (await this.browser.pages()).find(
-        (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 (!fs2.existsSync(fp)) {
-        return fs2.mkdirSync(fp, {
-          recursive: true
-        });
-      }
-      return false;
-    };
-    globalThis["writeFileSync"] = (filepath, contents, testName) => {
-      const dir = path4.dirname(filepath);
-      fs2.mkdirSync(dir, {
-        recursive: true
-      });
-      if (!files[testName]) {
-        files[testName] = /* @__PURE__ */ new Set();
-      }
-      files[testName].add(filepath);
-      return fs2.writeFileSync(filepath, contents);
-    };
-    globalThis["createWriteStream"] = (filepath, testName) => {
-      const f = fs2.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(
-        (p2) => p2.mainFrame()._id === pageKey
-      );
-      const p = opts.path;
-      const dir = path4.dirname(p);
-      fs2.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(
-        (p2) => p2.mainFrame()._id === pageKey
-      );
-      const p = opts.path;
-      const dir = path4.dirname(p);
-      fs2.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.");
-  }
-  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 fs2.existsSync(destFolder);
-  }
-  async mkdirSync(fp) {
-    if (!fs2.existsSync(fp)) {
-      return fs2.mkdirSync(fp, {
-        recursive: true
-      });
-    }
-    return false;
-  }
-  writeFileSync(fp, contents) {
-    fs2.writeFileSync(fp, contents);
-  }
-  createWriteStream(filepath) {
-    return fs2.createWriteStream(filepath);
-  }
-  testArtiFactoryfileWriter(tLog, callback) {
-    return (fPath, value) => {
-      callback(
-        new Promise((res, rej) => {
-          tLog("testArtiFactory =>", fPath);
-          const cleanPath = path4.resolve(fPath);
-          fPaths.push(cleanPath.replace(process.cwd(), ``));
-          const targetDir = cleanPath.split("/").slice(0, -1).join("/");
-          fs2.mkdir(targetDir, { recursive: true }, async (error) => {
-            if (error) {
-              console.error(`\u2757\uFE0FtestArtiFactory failed`, targetDir, error);
-            }
-            fs2.writeFileSync(
-              path4.resolve(
-                targetDir.split("/").slice(0, -1).join("/"),
-                "manifest"
-              ),
-              fPaths.join(`
-`),
-              {
-                encoding: "utf-8"
-              }
-            );
-            if (Buffer.isBuffer(value)) {
-              fs2.writeFileSync(fPath, value, "binary");
-              res();
-            } else if (`string` === typeof value) {
-              fs2.writeFileSync(fPath, value.toString(), {
-                encoding: "utf-8"
-              });
-              res();
-            } else {
-              const pipeStream = value;
-              const myFile = fs2.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 startPuppeteer(options, destfolder) {
-    this.browser = await puppeteer.launch(options);
-  }
-  ////////////////////////////////////////////////////////////////////////////////
-  shutDown() {
-    console.log("shutting down...");
-    this.shutdownMode = true;
-    this.checkForShutdown();
-  }
-};
-async function writeFileAndCreateDir(filePath, data) {
-  const dirPath = path4.dirname(filePath);
-  try {
-    await fs2.promises.mkdir(dirPath, { recursive: true });
-    await fs2.appendFileSync(filePath, data);
-  } catch (error) {
-    console.error(`Error writing file: ${error}`);
-  }
-}
-function isValidUrl(string) {
-  try {
-    new URL(string);
-    return true;
-  } catch (err) {
-    return false;
-  }
-}
-
-// src/cli.ts
-readline.emitKeypressEvents(process.stdin);
-if (process.stdin.isTTY)
-  process.stdin.setRawMode(true);
-function parseTsErrors(logContent) {
-  fs3.writeFileSync("docs/types/log.txt", logContent.join("\n"));
-  try {
-    const regex = /(^src(.*?))\(\d*,\d*\): error/gm;
-    const brokenFilesToLines = {};
-    for (let i = 0; i < logContent.length - 1; i++) {
-      let m;
-      while ((m = regex.exec(logContent[i])) !== null) {
-        if (m.index === regex.lastIndex) {
-          regex.lastIndex++;
-        }
-        if (!brokenFilesToLines[m[1]]) {
-          brokenFilesToLines[m[1]] = /* @__PURE__ */ new Set();
-        }
-        brokenFilesToLines[m[1]].add(i);
-      }
-    }
-    const final = Object.keys(brokenFilesToLines).reduce((mm, lm, ndx) => {
-      mm[lm] = Array.from(brokenFilesToLines[lm]).map((l, ndx3) => {
-        const a = Array.from(brokenFilesToLines[lm]);
-        return Object.keys(a).reduce((mm2, lm2, ndx2) => {
-          const acc = [];
-          let j = a[lm2] + 1;
-          let working = true;
-          while (j < logContent.length - 1 && working) {
-            if (!logContent[j].match(regex) && working && !logContent[j].match(/^..\/(.*?)\(\d*,\d*\)/)) {
-              acc.push(logContent[j]);
-            } else {
-              working = false;
-            }
-            j++;
-          }
-          mm2[lm] = [logContent[l], ...acc];
-          return mm2;
-        }, {})[lm];
-      });
-      return mm;
-    }, {});
-    Object.keys(final).forEach((k) => {
-      fs3.mkdirSync(`./docs/types/${k.split("/").slice(0, -1).join("/")}`, {
-        recursive: true
-      });
-      fs3.writeFileSync(
-        `./docs/types/${k}.type_errors.txt`,
-        final[k].flat().flat().join("\r\n")
-      );
-    });
-  } catch (error) {
-    console.error("Error reading or parsing the log file:", error);
-    process.exit(1);
-  }
-}
-function parseLintErrors(logContent) {
-  fs3.writeFileSync("docs/eslint/log.txt", logContent.join("\n"));
-  try {
-    const regex = new RegExp(`^${process.cwd()}/(.*?)`, "gm");
-    const brokenFilesToLines = {};
-    for (let i = 0; i < logContent.length - 1; i++) {
-      let m;
-      while ((m = regex.exec(logContent[i])) !== null) {
-        if (m.index === regex.lastIndex) {
-          regex.lastIndex++;
-        }
-        if (!brokenFilesToLines[m[1]]) {
-          brokenFilesToLines[m[1]] = /* @__PURE__ */ new Set();
-        }
-        brokenFilesToLines[m[1]].add(i);
-      }
-    }
-    const final = Object.keys(brokenFilesToLines).reduce((mm, lm, ndx) => {
-      mm[lm] = Array.from(brokenFilesToLines[lm]).map((l, ndx3) => {
-        const a = Array.from(brokenFilesToLines[lm]);
-        return Object.keys(a).reduce((mm2, lm2, ndx2) => {
-          const acc = [];
-          let j = a[lm2] + 1;
-          let working = true;
-          while (j < logContent.length - 1 && working) {
-            if (!logContent[j].match(regex) && working) {
-              acc.push(logContent[j]);
-            } else {
-              working = false;
-            }
-            j++;
-          }
-          mm2[lm] = [logContent[l], ...acc];
-          return mm2;
-        }, {})[lm];
-      });
-      return mm;
-    }, {});
-    Object.keys(final).forEach((k) => {
-      fs3.mkdirSync(`./docs/eslint/${k.split("/").slice(0, -1).join("/")}`, {
-        recursive: true
-      });
-      fs3.writeFileSync(
-        `./docs/eslint/${k}.lint_errors.txt`,
-        final[k].flat().flat().join("\r\n")
-      );
-    });
-  } catch (error) {
-    console.error("Error reading or parsing the log file:", error);
-    process.exit(1);
-  }
-}
-var typecheck = () => {
-  const logContent = [];
-  fs3.rmSync("docs/types", { force: true, recursive: true });
-  fs3.mkdirSync("docs/types");
-  const tsc = spawn2("tsc", ["-noEmit"]);
-  tsc.stdout.on("data", (data) => {
-    const lines = data.toString().split("\n");
-    logContent.push(...lines);
-  });
-  tsc.stderr.on("data", (data) => {
-    console.error(`stderr: ${data}`);
-    process.exit(-1);
-  });
-  tsc.on("close", (code) => {
-    parseTsErrors(logContent);
-  });
-};
-var eslint = () => {
-  const logContent = [];
-  fs3.rmSync("docs/eslint", { force: true, recursive: true });
-  fs3.mkdirSync("docs/eslint");
-  const tsc = spawn2("eslint", ["./src"]);
-  tsc.stdout.on("data", (data) => {
-    const lines = data.toString().split("\n");
-    logContent.push(...lines);
-  });
-  tsc.stderr.on("data", (data) => {
-    console.error(`stderr: ${data}`);
-    process.exit(-1);
-  });
-  tsc.on("close", (code) => {
-    parseLintErrors(logContent);
-  });
-};
-var getRunnables = (tests, payload = {
-  nodeEntryPoints: {},
-  webEntryPoints: {}
-}) => {
-  return tests.reduce((pt, cv, cndx, cry) => {
-    if (cv[1] === "node") {
-      pt.nodeEntryPoints[cv[0]] = path5.resolve(
-        `./docs/node/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
-      );
-    } else if (cv[1] === "web") {
-      pt.webEntryPoints[cv[0]] = path5.resolve(
-        `./docs/web/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
-      );
-    }
-    if (cv[3].length) {
-      getRunnables(cv[3], payload);
-    }
-    return pt;
-  }, payload);
-};
-import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
-  const rawConfig = module.default;
-  const getSecondaryEndpointsPoints = (runtime) => {
-    const meta = (ts, st) => {
-      ts.forEach((t) => {
-        if (t[1] === runtime) {
-          st.add(t[0]);
-        }
-        if (Array.isArray(t[3])) {
-          meta(t[3], st);
-        }
-      });
-      return st;
-    };
-    return Array.from(meta(config.tests, /* @__PURE__ */ new Set()));
-  };
-  const config = {
-    ...rawConfig,
-    buildDir: process.cwd() + "/" + rawConfig.outdir
-  };
-  let nodeDone = false;
-  let webDone = false;
-  let mode = config.devMode ? "DEV" : "PROD";
-  let status = "build";
-  let pm = new PM_Main(config);
-  const fileHashes = {};
-  const { nodeEntryPoints, webEntryPoints } = getRunnables(config.tests);
-  const onNodeDone = () => {
-    nodeDone = true;
-    onDone();
-  };
-  const onWebDone = () => {
-    webDone = true;
-    onDone();
-  };
-  const onDone = async () => {
-    if (nodeDone && webDone) {
-      status = "built";
-    }
-    if (nodeDone && webDone && status === "built") {
-    }
-    if (nodeDone && webDone && mode === "PROD") {
-      console.log("Testeranto-EsBuild is all done. Goodbye!");
-      process.exit();
-    } else {
-      if (mode === "PROD") {
-        console.log("waiting for tests to finish");
-        console.log(
-          JSON.stringify(
-            {
-              nodeDone,
-              webDone,
-              mode
-            },
-            null,
-            2
-          )
-        );
-      } else {
-        console.log("waiting for tests to change");
-      }
-      console.log("press 'q' to quit");
-      if (config.devMode) {
-        console.log("ready and watching for changes...");
-      } else {
-        pm.shutDown();
-      }
-    }
-  };
-  console.log(
-    `Press 'q' to shutdown gracefully. Press 'x' to shutdown forcefully.`
-  );
-  process.stdin.on("keypress", (str, key) => {
-    if (key.name === "q") {
-      console.log("Testeranto-EsBuild is shutting down...");
-      mode = "PROD";
-      onDone();
-    }
-  });
-  fs3.writeFileSync(
-    `${config.outdir}/testeranto.json`,
-    JSON.stringify(config, null, 2)
-  );
-  Promise.resolve(
-    Promise.all(
-      [...getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
-        const sourceFileSplit = sourceFilePath.split("/");
-        const sourceDir = sourceFileSplit.slice(0, -1);
-        const sourceFileName = sourceFileSplit[sourceFileSplit.length - 1];
-        const sourceFileNameMinusJs = sourceFileName.split(".").slice(0, -1).join(".");
-        const htmlFilePath = path5.normalize(
-          `${process.cwd()}/${config.outdir}/web/${sourceDir.join(
-            "/"
-          )}/${sourceFileNameMinusJs}.html`
-        );
-        const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
-        return fs3.promises.mkdir(path5.dirname(htmlFilePath), { recursive: true }).then(
-          (x) => fs3.writeFileSync(
-            htmlFilePath,
-            web_html_default(jsfilePath, htmlFilePath)
-          )
-        );
-      })
-    )
-  );
-  glob(`./${config.outdir}/chunk-*.mjs`, {
-    ignore: "node_modules/**"
-  }).then((chunks) => {
-    chunks.forEach((chunk) => {
-      fs3.unlinkSync(chunk);
-    });
-  });
-  debounceWatch(
-    (events) => {
-      typecheck();
-      eslint();
-    },
-    "./src",
-    {
-      onlyFileExtensions: ["ts", "tsx", "mts"],
-      debounceWaitSeconds: 0.2,
-      allowOverlappingRuns: false
-    }
-  );
-  await pm.startPuppeteer(
-    {
-      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,
-      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-running-insecure-content",
-        "--disable-dev-shm-usage",
-        "--disable-extensions",
-        "--disable-gpu",
-        "--disable-setuid-sandbox",
-        "--disable-site-isolation-trials",
-        "--disable-web-security",
-        "--no-first-run",
-        "--no-sandbox",
-        "--no-startup-window",
-        // "--no-zygote",
-        "--reduce-security-for-testing",
-        "--remote-allow-origins=*",
-        "--unsafely-treat-insecure-origin-as-secure=*"
-        // "--disable-features=IsolateOrigins",
-        // "--remote-allow-origins=ws://localhost:3234",
-        // "--single-process",
-        // "--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",
-      ]
-    },
-    "."
-  );
-  await Promise.all([
-    esbuild.context(node_default(config, Object.keys(nodeEntryPoints))).then(async (nodeContext) => {
-      if (config.devMode) {
-        await nodeContext.watch().then((v) => {
-          onNodeDone();
-        });
-      } else {
-        nodeContext.rebuild().then((v) => {
-          onNodeDone();
-        });
-      }
-      return nodeContext;
-    }),
-    esbuild.context(web_default(config, Object.keys(webEntryPoints))).then(async (webContext) => {
-      if (config.devMode) {
-        await webContext.watch().then((v) => {
-          onWebDone();
-        });
-      } else {
-        webContext.rebuild().then((v) => {
-          onWebDone();
-        });
-      }
-      return webContext;
-    })
-  ]);
-});