testeranto 0.94.0 → 0.100.0

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

@@ -1,13 +1,11 @@
 import { createRequire } from 'module';const require = createRequire(import.meta.url);
 
-// src/Puppeteer.ts
-import readline from "readline";
-import fs2 from "fs";
-import watch from "recursive-watch";
+// src/cli2.ts
+import { watch } from "fs";
 
 // src/PM/main.ts
 import fs from "fs";
-import path2 from "path";
+import path from "path";
 import puppeteer from "puppeteer-core";
 import crypto from "crypto";
 
@@ -15,17 +13,22 @@ import crypto from "crypto";
 var PM = class {
 };
 
-// src/utils.ts
-import path from "path";
-var destinationOfRuntime = (f, r, configs) => {
-  return path.normalize(`${configs.buildDir}/${r}/${f}`).split(".").slice(0, -1).join(".");
-};
-
 // 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();
@@ -50,7 +53,7 @@ var PM_Main = class extends PM {
       }
     };
     this.launchNode = async (src, dest) => {
-      console.log("launchNode", src);
+      console.log("! node", src);
       this.register(src);
       const destFolder = dest.replace(".mjs", "");
       let argz = "";
@@ -96,33 +99,13 @@ 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);
           }).catch((e) => {
             console.log(`${src} errored with`, e);
           }).finally(() => {
@@ -149,7 +132,7 @@ var PM_Main = class extends PM {
             "custom-screenshot",
             async (ssOpts, testName) => {
               const p = ssOpts.path;
-              const dir = path2.dirname(p);
+              const dir = path.dirname(p);
               fs.mkdirSync(dir, {
                 recursive: true
               });
@@ -169,7 +152,7 @@ var PM_Main = class extends PM {
           page.exposeFunction(
             "writeFileSync",
             (fp, contents, testName) => {
-              const dir = path2.dirname(fp);
+              const dir = path.dirname(fp);
               fs.mkdirSync(dir, {
                 recursive: true
               });
@@ -284,18 +267,9 @@ var PM_Main = class extends PM {
         }
       }
     };
-    this.launchWeb = (t, dest, sidecars) => {
-      console.log("launchWeb", t, dest);
+    this.launchWeb = (t, dest) => {
+      console.log("! web", t);
       this.register(t);
-      sidecars.map((sidecar) => {
-        if (sidecar[1] === "node") {
-          return this.launchNodeSideCar(
-            sidecar[0],
-            destinationOfRuntime(sidecar[0], "node", this.configs),
-            sidecar
-          );
-        }
-      });
       const destFolder = dest.replace(".mjs", "");
       const webArgz = JSON.stringify({
         name: dest,
@@ -303,9 +277,10 @@ 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("importing ${d}");
+    import('${d}').then(async (x) => {
       console.log("imported", (await x.default));
       try {
         return await (await x.default).receiveTestResourceConfig(${webArgz})
@@ -315,14 +290,14 @@ 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",
           async (ssOpts, testName) => {
             const p = ssOpts.path;
-            const dir = path2.dirname(p);
+            const dir = path.dirname(p);
             fs.mkdirSync(dir, {
               recursive: true
             });
@@ -346,7 +321,7 @@ var PM_Main = class extends PM {
           "customScreenShot",
           async (ssOpts, testName) => {
             const p = ssOpts.path;
-            const dir = path2.dirname(p);
+            const dir = path.dirname(p);
             fs.mkdirSync(dir, {
               recursive: true
             });
@@ -458,7 +433,7 @@ 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];
@@ -489,10 +464,10 @@ var PM_Main = class extends PM {
           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);
         }).catch((e) => {
           console.log(`${t} errored with`, e);
         }).finally(() => {
@@ -501,18 +476,25 @@ var PM_Main = class extends PM {
         return page;
       });
     };
-    this.receiveFeatures = (features, destFolder) => {
+    this.receiveFeatures = (features, destFolder, srcTest) => {
+      const featureDestination = path.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(
+            const newPath = `${process.cwd()}/docs/features/internal/${path.relative(
               process.cwd(),
               u.pathname
             )}`;
-            await fs.promises.mkdir(path2.dirname(newPath), { recursive: true });
+            await fs.promises.mkdir(path.dirname(newPath), { recursive: true });
             try {
               await fs.unlinkSync(newPath);
             } catch (error) {
@@ -524,25 +506,24 @@ var PM_Main = class extends PM {
               } 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(path.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")
         );
@@ -555,6 +536,35 @@ var PM_Main = class extends PM {
     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 (path3) => {
+      return recorders[path3].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 (!fs.existsSync(fp)) {
         return fs.mkdirSync(fp, {
@@ -564,7 +574,7 @@ var PM_Main = class extends PM {
       return false;
     };
     globalThis["writeFileSync"] = (filepath, contents, testName) => {
-      const dir = path2.dirname(filepath);
+      const dir = path.dirname(filepath);
       fs.mkdirSync(dir, {
         recursive: true
       });
@@ -592,9 +602,12 @@ 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(
+        (p2) => p2.mainFrame()._id === pageKey
+      );
       const p = opts.path;
-      const dir = path2.dirname(p);
+      const dir = path.dirname(p);
       fs.mkdirSync(dir, {
         recursive: true
       });
@@ -613,6 +626,37 @@ var PM_Main = class extends PM {
       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 = path.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 +664,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) {
@@ -648,7 +692,7 @@ var PM_Main = class extends PM {
       callback(
         new Promise((res, rej) => {
           tLog("testArtiFactory =>", fPath);
-          const cleanPath = path2.resolve(fPath);
+          const cleanPath = path.resolve(fPath);
           fPaths.push(cleanPath.replace(process.cwd(), ``));
           const targetDir = cleanPath.split("/").slice(0, -1).join("/");
           fs.mkdir(targetDir, { recursive: true }, async (error) => {
@@ -656,7 +700,7 @@ var PM_Main = class extends PM {
               console.error(`\u2757\uFE0FtestArtiFactory failed`, targetDir, error);
             }
             fs.writeFileSync(
-              path2.resolve(
+              path.resolve(
                 targetDir.split("/").slice(0, -1).join("/"),
                 "manifest"
               ),
@@ -712,6 +756,9 @@ 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);
@@ -724,21 +771,14 @@ var PM_Main = class extends PM {
   }
 };
 async function writeFileAndCreateDir(filePath, data) {
-  const dirPath = path2.dirname(filePath);
+  const dirPath = path.dirname(filePath);
   try {
     await fs.promises.mkdir(dirPath, { recursive: true });
-    await fs.promises.writeFile(filePath, data);
+    await fs.appendFileSync(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);
@@ -748,29 +788,57 @@ function isValidUrl(string) {
   }
 }
 
-// src/Puppeteer.ts
-readline.emitKeypressEvents(process.stdin);
-if (process.stdin.isTTY)
-  process.stdin.setRawMode(true);
-var Puppeteer_default = async (partialConfig) => {
+// src/cli2.ts
+import path2 from "path";
+import crypto2 from "node:crypto";
+import fs2 from "fs";
+var fileHashes = {};
+async function fileHash(filePath, algorithm = "md5") {
+  return new Promise((resolve, reject) => {
+    const hash = crypto2.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}`);
+    });
+  });
+}
+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);
+};
+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
-    )
-  );
-  const pm = new PM_Main(config);
+  let pm = new PM_Main(config);
   await pm.startPuppeteer(
     {
+      slowMo: 1,
       // timeout: 1,
       waitForInitialPage: false,
       executablePath: (
@@ -814,58 +882,37 @@ 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]) => {
+      console.log("watching and running", 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(`< ${e} ${filename} ${hash}`);
+            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]) => {
+      console.log("watching and running", outputFile);
+      pm.launchWeb(k, outputFile);
+      watch(outputFile, async (e, filename) => {
+        const hash = await fileHash(outputFile);
+        console.log(`< ${e} ${filename} ${hash}`);
+        if (fileHashes[k] !== hash) {
+          fileHashes[k] = hash;
+          pm.launchWeb(k, outputFile);
+        }
+      });
+    }
+  );
+});

package/dist/types/src/Node.d.ts

@@ -1,7 +1,7 @@
 import Testeranto from "./lib/core.js";
 import { ITTestResourceRequest } from "./lib/index.js";
 import type { IBaseTest, ITestImplementation, ITestSpecification } from "./Types.js";
-import { ITestInterface, INodeTestInterface } from "./lib/types.js";
+import { ITestInterface } from "./lib/types.js";
 export declare class NodeTesteranto<TestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> extends Testeranto<TestShape> {
     constructor(input: TestShape["iinput"], testSpecification: ITestSpecification<TestShape>, testImplementation: ITestImplementation<TestShape>, testResourceRequirement: ITTestResourceRequest, testInterface: Partial<ITestInterface<TestShape>>);
     receiveTestResourceConfig(partialTestResource: string): Promise<{
@@ -9,5 +9,5 @@ export declare class NodeTesteranto<TestShape extends IBaseTest<unknown, unknown
         failed: number;
     }>;
 }
-declare const _default: <ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: ITestImplementation<ITestShape, object>, testInterface: Partial<INodeTestInterface<ITestShape>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<ITestShape>>;
+declare const _default: <ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: any, testInterface: INodeTestInterface<ITestShape>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<ITestShape>>;
 export default _default;

package/dist/types/src/PM/index.d.ts

@@ -1,3 +1,5 @@
+import { CdpPage } from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser";
+import { ScreenRecorderOptions } from "puppeteer-core/lib/esm/puppeteer";
 import { ITLog, ITTestResourceConfiguration } from "../lib";
 export declare abstract class PM {
     server: any;
@@ -13,8 +15,9 @@ export declare abstract class PM {
     abstract end(accessObject: {
         uid: number;
     }): boolean;
-    abstract customScreenShot(opts: object): any;
-    abstract screencast(opts: object): any;
+    abstract customScreenShot(opts: object, page?: string): any;
+    abstract screencast(opts: ScreenRecorderOptions, p?: any): any;
+    abstract screencastStop(s: string): any;
     abstract page(): string | undefined;
     abstract click(selector: string): any;
     abstract focusOn(selector: string): any;
@@ -23,4 +26,9 @@ export declare abstract class PM {
     abstract getAttribute(selector: string, attribute: string): any;
     abstract isDisabled(selector: string): boolean;
     abstract $(selector: string): any;
+    abstract newPage(): CdpPage;
+    abstract goto(p: any, url: string): any;
+    abstract closePage(p: any): any;
+    abstract waitForSelector(p: any, sel: string): any;
+    abstract customclose(): any;
 }

package/dist/types/src/PM/main.d.ts

@@ -1,13 +1,13 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
+import { CdpPage, Page } from "puppeteer-core/lib/esm/puppeteer";
 import fs from "fs";
-import { Browser } from "puppeteer-core";
+import { Browser, LaunchOptions } from "puppeteer-core";
 import { PassThrough } from "stream";
 import { IBuiltConfig, ITestTypes } from "../lib/types";
-import { PM } from "./index.js";
 import { ITLog } from "../lib/index.js";
-import { Page } from "puppeteer-core/lib/esm/puppeteer";
+import { PM } from "./index.js";
 export declare class PM_Main extends PM {
     browser: Browser;
     shutdownMode: boolean;
@@ -16,9 +16,14 @@ export declare class PM_Main extends PM {
     queue: any[];
     registry: Record<string, boolean>;
     constructor(configs: IBuiltConfig);
+    customclose(): void;
+    waitForSelector(p: string, s: string): any;
+    closePage(p: any): any;
+    newPage(): CdpPage;
+    goto(p: any, url: string): any;
     $(selector: string): boolean;
     screencast(opts: object): void;
-    customScreenShot(opts: object): void;
+    customScreenShot(opts: object, cdpPage?: CdpPage): void;
     end(accessObject: {
         uid: number;
     }): boolean;
@@ -37,7 +42,8 @@ export declare class PM_Main extends PM {
     getValue(value: string): void;
     getAttribute(selector: string, attribute: string): void;
     isDisabled(selector: string): boolean;
-    startPuppeteer(options: any, destfolder: string): Promise<any>;
+    screencastStop(s: string): void;
+    startPuppeteer(options: LaunchOptions, destfolder: string): Promise<any>;
     shutDown(): void;
     checkForShutdown: () => void;
     register: (src: string) => void;
@@ -45,6 +51,6 @@ export declare class PM_Main extends PM {
     launchNode: (src: string, dest: string) => Promise<void>;
     launchWebSideCar: (src: string, dest: string, testConfig: ITestTypes) => Promise<Page>;
     launchNodeSideCar: (src: string, dest: string, testConfig: ITestTypes) => Promise<void>;
-    launchWeb: (t: string, dest: string, sidecars: ITestTypes[]) => void;
-    receiveFeatures: (features: string[], destFolder: string) => void;
+    launchWeb: (t: string, dest: string) => void;
+    receiveFeatures: (features: string[], destFolder: string, srcTest: string) => void;
 }