testeranto 0.129.0 → 0.135.0

package/dist/module/src/Init.js

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import fs from "fs";
 export default async () => {
     [
@@ -9,6 +10,7 @@ export default async () => {
         `testeranto/reports`,
         `testeranto/reports/`,
         `testeranto/features/`,
+        `testeranto/externalTests/`,
     ].forEach((f) => {
         try {
             fs.mkdirSync(`${process.cwd()}/${f}`);
@@ -20,7 +22,10 @@ export default async () => {
     fs.copyFileSync(`node_modules/testeranto/dist/prebuild/Project.js`, `testeranto/Project.js`);
     fs.copyFileSync(`node_modules/testeranto/dist/prebuild/ReportClient.js`, `testeranto/ReportClient.js`);
     fs.copyFileSync(`node_modules/testeranto/dist/prebuild/Project.css`, `testeranto/Project.css`);
-    fs.copyFileSync(`node_modules/testeranto/dist/prebuild/ReportClient.css`, `testeranto/ReportClient.css`);
+    // fs.copyFileSync(
+    //   `node_modules/testeranto/dist/prebuild/ReportClient.css`,
+    //   `testeranto/ReportClient.css`
+    // );
     fs.copyFileSync(`node_modules/testeranto/dist/prebuild/TestReport.js`, `testeranto/TestReport.js`);
     fs.copyFileSync(`node_modules/testeranto/dist/prebuild/TestReport.css`, `testeranto/TestReport.css`);
 };

package/dist/module/src/Node.js

@@ -1,6 +1,7 @@
 import Testeranto from "./lib/core.js";
 import { defaultTestResourceRequirement, } from "./lib/index.js";
 import { PM_Node } from "./PM/node.js";
+let ipcfile;
 export class NodeTesteranto extends Testeranto {
     constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
         super(input, testSpecification, testImplementation, testResourceRequirement, testInterface, () => {
@@ -9,7 +10,7 @@ export class NodeTesteranto extends Testeranto {
     }
     async receiveTestResourceConfig(partialTestResource) {
         const t = JSON.parse(partialTestResource);
-        const pm = new PM_Node(t);
+        const pm = new PM_Node(t, ipcfile);
         return await this.testJobs[0].receiveTestResourceConfig(pm);
         // const { failed, artifacts, logPromise, features } =
         //   await this.testJobs[0].receiveTestResourceConfig(pm);
@@ -22,15 +23,16 @@ const testeranto = async (input, testSpecification, testImplementation, testInte
     process.on("unhandledRejection", (reason, promise) => {
         console.error("Unhandled Rejection at:", promise, "reason:", reason);
         // Optionally, terminate the process or perform cleanup
+        // t.registerUncaughtPromise(reason, promise);
     });
     try {
-        console.log(process.argv);
+        ipcfile = process.argv[3];
         const f = await t.receiveTestResourceConfig(process.argv[2]);
-        console.error("goodbye node error", f.fails);
+        console.error("goodbye node with failures", f.fails);
         process.exit(f.fails);
     }
     catch (e) {
-        console.error("goodbye node error", e);
+        console.error("goodbye node with caught error", e);
         process.exit(-1);
         // fs.writeFileSync(`tests.json`, JSON.stringify(t.,
         //  null, 2));

package/dist/module/src/NodeSidecar.js

@@ -0,0 +1,11 @@
+import { Sidecar } from "./lib/Sidecar";
+import { PM_Node_Sidecar } from "./PM/nodeSidecar";
+export class NodeSidecar extends Sidecar {
+    constructor(t) {
+        super();
+        this.pm = new PM_Node_Sidecar(t);
+        this.pm.start(this.stop).then(() => {
+            this.start(JSON.parse(process.argv[2]));
+        });
+    }
+}

package/dist/module/src/PM/PM_WithEslintAndTsc.js

@@ -0,0 +1,182 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable no-async-promise-executor */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import ts from "typescript";
+import fs from "fs";
+import path from "path";
+import ansiC from "ansi-colors";
+import { ESLint } from "eslint";
+import tsc from "tsc-prog";
+import { lintPather, promptPather, tscPather } from "../utils";
+import { PM_Base } from "./base.js";
+const eslint = new ESLint();
+const formatter = await eslint.loadFormatter("./node_modules/testeranto/dist/prebuild/esbuildConfigs/eslint-formatter-testeranto.mjs");
+export class PM_WithEslintAndTsc extends PM_Base {
+    constructor(configs, name, mode) {
+        super(configs);
+        this.summary = {};
+        this.tscCheck = async ({ entrypoint, addableFiles, platform, }) => {
+            console.log(ansiC.green(ansiC.inverse(`tsc < ${entrypoint}`)));
+            this.typeCheckIsRunning(entrypoint);
+            const program = tsc.createProgramFromConfig({
+                basePath: process.cwd(), // always required, used for relative paths
+                configFilePath: "tsconfig.json", // config to inherit from (optional)
+                compilerOptions: {
+                    outDir: tscPather(entrypoint, platform, this.name),
+                    // declaration: true,
+                    // skipLibCheck: true,
+                    noEmit: true,
+                },
+                include: addableFiles, //["src/**/*"],
+                // exclude: ["node_modules", "../testeranto"],
+                // exclude: ["**/*.test.ts", "**/*.spec.ts"],
+            });
+            const tscPath = tscPather(entrypoint, platform, this.name);
+            const allDiagnostics = program.getSemanticDiagnostics();
+            const results = [];
+            allDiagnostics.forEach((diagnostic) => {
+                if (diagnostic.file) {
+                    const { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+                    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+                    results.push(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+                }
+                else {
+                    results.push(ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+                }
+            });
+            fs.writeFileSync(tscPath, results.join("\n"));
+            this.typeCheckIsNowDone(entrypoint, results.length);
+        };
+        this.eslintCheck = async (entrypoint, platform, addableFiles) => {
+            console.log(ansiC.green(ansiC.inverse(`eslint < ${entrypoint}`)));
+            this.lintIsRunning(entrypoint);
+            const results = (await eslint.lintFiles(addableFiles))
+                .filter((r) => r.messages.length)
+                .filter((r) => {
+                return r.messages[0].ruleId !== null;
+            })
+                .map((r) => {
+                delete r.source;
+                return r;
+            });
+            fs.writeFileSync(lintPather(entrypoint, platform, this.name), await formatter.format(results));
+            this.lintIsNowDone(entrypoint, results.length);
+        };
+        this.makePrompt = async (entryPoint, addableFiles, platform) => {
+            this.summary[entryPoint].prompt = "?";
+            const promptPath = promptPather(entryPoint, platform, this.name);
+            const testPaths = path.join("testeranto", "reports", this.name, entryPoint.split(".").slice(0, -1).join("."), platform, `tests.json`);
+            const featuresPath = path.join("testeranto", "reports", this.name, platform, entryPoint.split(".").slice(0, -1).join("."), `featurePrompt.txt`);
+            const logPath = path.join("testeranto", "reports", this.name, entryPoint.split(".").slice(0, -1).join("."), platform, `console_log.txt`);
+            const lintPath = path.join("testeranto", "reports", this.name, entryPoint.split(".").slice(0, -1).join("."), platform, `lint_errors.json`);
+            const typePath = path.join("testeranto", "reports", this.name, entryPoint.split(".").slice(0, -1).join("."), platform, `type_errors.txt`);
+            const messagePath = path.join("testeranto", "reports", this.name, entryPoint.split(".").slice(0, -1).join("."), platform, `message`);
+            fs.writeFileSync(promptPath, `
+${addableFiles
+                .map((x) => {
+                return `/add ${x}`;
+            })
+                .join("\n")}
+
+/read ${testPaths}
+/read ${logPath}
+/read ${typePath}
+/read ${lintPath}
+`);
+            fs.writeFileSync(messagePath, `Fix the failing tests described in ${testPaths} and ${logPath}. DO NOT refactor beyond what is necessary. Always prefer minimal changes, focusing mostly on keeping the BDD tests passing`);
+            this.summary[entryPoint].prompt = `aider --model deepseek/deepseek-chat --load testeranto/${this.name}/reports/${platform}/${entryPoint
+                .split(".")
+                .slice(0, -1)
+                .join(".")}/prompt.txt`;
+            this.checkForShutdown();
+        };
+        this.typeCheckIsRunning = (src) => {
+            this.summary[src].typeErrors = "?";
+        };
+        this.typeCheckIsNowDone = (src, failures) => {
+            this.summary[src].typeErrors = failures;
+            this.writeBigBoard();
+            this.checkForShutdown();
+        };
+        this.lintIsRunning = (src) => {
+            this.summary[src].staticErrors = "?";
+            this.writeBigBoard();
+        };
+        this.lintIsNowDone = (src, failures) => {
+            this.summary[src].staticErrors = failures;
+            this.writeBigBoard();
+            this.checkForShutdown();
+        };
+        this.bddTestIsRunning = (src) => {
+            this.summary[src].runTimeError = "?";
+            this.writeBigBoard();
+        };
+        this.bddTestIsNowDone = (src, failures) => {
+            this.summary[src].runTimeError = failures;
+            this.writeBigBoard();
+            this.checkForShutdown();
+        };
+        this.writeBigBoard = () => {
+            fs.writeFileSync(`./testeranto/reports/${this.name}/summary.json`, JSON.stringify(this.summary, null, 2));
+        };
+        this.checkForShutdown = () => {
+            console.log(ansiC.inverse(`checkForShutdown`));
+            this.writeBigBoard();
+            if (this.mode === "dev")
+                return;
+            let inflight = false;
+            Object.keys(this.summary).forEach((k) => {
+                if (this.summary[k].prompt === "?") {
+                    console.log(ansiC.blue(ansiC.inverse(`🕕 prompt ${k}`)));
+                    inflight = true;
+                }
+            });
+            Object.keys(this.summary).forEach((k) => {
+                if (this.summary[k].runTimeError === "?") {
+                    console.log(ansiC.blue(ansiC.inverse(`🕕 runTimeError ${k}`)));
+                    inflight = true;
+                }
+            });
+            Object.keys(this.summary).forEach((k) => {
+                if (this.summary[k].staticErrors === "?") {
+                    console.log(ansiC.blue(ansiC.inverse(`🕕 staticErrors ${k}`)));
+                    inflight = true;
+                }
+            });
+            Object.keys(this.summary).forEach((k) => {
+                if (this.summary[k].typeErrors === "?") {
+                    console.log(ansiC.blue(ansiC.inverse(`🕕 typeErrors ${k}`)));
+                    inflight = true;
+                }
+            });
+            this.writeBigBoard();
+            if (!inflight) {
+                this.browser.disconnect().then(() => {
+                    console.log(ansiC.inverse(`${this.name} has been tested. Goodbye.`));
+                    process.exit();
+                });
+            }
+        };
+        this.name = name;
+        this.mode = mode;
+        this.configs.tests.forEach(([t, rt, tr, sidecars]) => {
+            this.summary[t] = {
+                runTimeError: "?",
+                typeErrors: "?",
+                staticErrors: "?",
+                prompt: "?",
+                failingFeatures: {},
+            };
+            sidecars.forEach(([t]) => {
+                this.summary[t] = {
+                    // runTimeError: "?",
+                    typeErrors: "?",
+                    staticErrors: "?",
+                    // prompt: "?",
+                    // failingFeatures: {},
+                };
+            });
+        });
+    }
+}

package/dist/module/src/PM/__tests__/nodeSidecar.testeranto.js

@@ -0,0 +1,104 @@
+import { PM_Node_Sidecar } from "../nodeSidecar";
+import Testeranto from "../../Node";
+const specification = (Suite, Given, When, Then) => {
+    return [
+        Suite.SidecarInitialized("Sidecar message passing works correctly", {
+            basicSend: Given.SidecarReady(["can send and receive messages"], [When.SendTestMessage("test-message")], [Then.MessageReceived("test-message")]),
+            cleanup: Given.SidecarReady(["cleans up listeners after message"], [When.VerifyCleanup()], [Then.ListenersCleaned()]),
+        }, []),
+    ];
+};
+const implementation = {
+    suites: { SidecarInitialized: (x) => x },
+    givens: {
+        SidecarReady: () => {
+            const config = {
+                name: "test-sidecar",
+                fs: "/tmp",
+                ports: [3001],
+                browserWSEndpoint: "",
+            };
+            return new PM_Node_Sidecar(config);
+        },
+    },
+    whens: {
+        SendTestMessage: (message) => async (sidecar) => {
+            let callbackFn;
+            const mockProcess = {
+                on: (event, callback) => {
+                    if (event === "message") {
+                        callbackFn = callback;
+                        callback(JSON.stringify({
+                            key: "mock-key",
+                            payload: message,
+                        }));
+                    }
+                    return mockProcess;
+                },
+                addListener: () => mockProcess,
+                removeListener: () => mockProcess
+            };
+            process = mockProcess;
+            let writeCalled = false;
+            sidecar.client.write = (data) => {
+                writeCalled = true;
+                return true;
+            };
+            await sidecar.send("test-command", message);
+            return { writeCalled, callbackFn };
+        },
+        VerifyCleanup: () => async (sidecar) => {
+            let addListenerCalled = false;
+            let removeListenerCalled = false;
+            const mockProcess = {
+                addListener: () => {
+                    addListenerCalled = true;
+                    return mockProcess;
+                },
+                removeListener: () => {
+                    removeListenerCalled = true;
+                    return mockProcess;
+                }
+            };
+            process = mockProcess;
+            await sidecar.send("test-command", "test");
+            return { addListenerCalled, removeListenerCalled };
+        },
+    },
+    thens: {
+        MessageReceived: (expected) => (actual) => {
+            if (actual !== expected) {
+                throw new Error(`Expected "${expected}" but got "${actual}"`);
+            }
+            return actual;
+        },
+        ListenersCleaned: () => (result, { removeListenerCalled }) => {
+            if (!removeListenerCalled) {
+                throw new Error("Expected removeListener to be called");
+            }
+            return result;
+        },
+    },
+    checks: { SidecarState: () => "unknown" },
+};
+const testInterface = {
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        const sidecar = initializer();
+        sidecar.client = {
+            write: () => true,
+            end: () => { },
+            on: () => { },
+        };
+        return sidecar;
+    },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        try {
+            await whenCB(store, testResource, pm);
+        }
+        catch (e) {
+            console.error("Error in andWhen:", e);
+            throw e;
+        }
+    },
+};
+export default Testeranto(() => new PM_Node_Sidecar({}), specification, implementation, testInterface);

package/dist/module/src/PM/__tests__/pureSidecar.testeranto.js

@@ -0,0 +1,89 @@
+import { PM_Pure_Sidecar } from "../pureSidecar";
+import Testeranto from "../../Node";
+const specification = (Suite, Given, When, Then) => {
+    return [
+        Suite.SidecarInitialized("Pure Sidecar message passing works correctly", {
+            basicSend: Given.SidecarReady(["can send and receive messages"], [When.SendTestMessage("test-message")], [Then.MessageReceived("test-message")]),
+            cleanup: Given.SidecarReady(["cleans up listeners after message"], [When.VerifyCleanup()], [Then.ListenersCleaned()]),
+        }, []),
+    ];
+};
+const implementation = {
+    suites: { SidecarInitialized: (x) => x },
+    givens: {
+        SidecarReady: () => {
+            const config = {
+                name: "test-pure-sidecar",
+                fs: "/tmp",
+                ports: [3001],
+                browserWSEndpoint: "",
+            };
+            return new PM_Pure_Sidecar(config);
+        },
+    },
+    whens: {
+        SendTestMessage: (message) => async (sidecar) => {
+            let callbackFn;
+            process.on = (event, callback) => {
+                if (event === "message") {
+                    callbackFn = callback;
+                    callback(JSON.stringify({
+                        key: "mock-key",
+                        payload: message,
+                    }));
+                }
+            };
+            let writeCalled = false;
+            sidecar.client.write = (data) => {
+                writeCalled = true;
+                return true;
+            };
+            await sidecar.send("test-command", message);
+            return { writeCalled, callbackFn };
+        },
+        VerifyCleanup: () => async (sidecar) => {
+            let addListenerCalled = false;
+            let removeListenerCalled = false;
+            process.addListener = () => (addListenerCalled = true);
+            process.removeListener = () => (removeListenerCalled = true);
+            await sidecar.send("test-command", "test");
+            return { addListenerCalled, removeListenerCalled };
+        },
+    },
+    thens: {
+        MessageReceived: (expected) => (actual) => {
+            if (actual !== expected) {
+                throw new Error(`Expected "${expected}" but got "${actual}"`);
+            }
+            return actual;
+        },
+        ListenersCleaned: () => (result, { removeListenerCalled }) => {
+            if (!removeListenerCalled) {
+                throw new Error("Expected removeListener to be called");
+            }
+            return result;
+        },
+    },
+    checks: { SidecarState: () => "unknown" },
+};
+const testInterface = {
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        const sidecar = initializer();
+        sidecar.client = {
+            write: () => true,
+            end: () => { },
+            on: () => { },
+        };
+        return sidecar;
+    },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        try {
+            await whenCB(store, testResource, pm);
+        }
+        catch (e) {
+            console.error("Error in andWhen:", e);
+            throw e;
+        }
+    },
+};
+export default Testeranto(() => new PM_Pure_Sidecar({}), specification, implementation, testInterface);

package/dist/module/src/PM/__tests__/webSidecar.testeranto.js

@@ -0,0 +1,89 @@
+import { PM_Web_Sidecar } from "../webSidecar";
+import Testeranto from "../../Node";
+const specification = (Suite, Given, When, Then) => {
+    return [
+        Suite.SidecarInitialized("Web Sidecar message passing works correctly", {
+            basicSend: Given.SidecarReady(["can send and receive messages"], [When.SendTestMessage("test-message")], [Then.MessageReceived("test-message")]),
+            cleanup: Given.SidecarReady(["cleans up listeners after message"], [When.VerifyCleanup()], [Then.ListenersCleaned()]),
+        }, []),
+    ];
+};
+const implementation = {
+    suites: { SidecarInitialized: (x) => x },
+    givens: {
+        SidecarReady: () => {
+            const config = {
+                name: "test-web-sidecar",
+                fs: "/tmp",
+                ports: [3001],
+                browserWSEndpoint: "",
+            };
+            return new PM_Web_Sidecar(config);
+        },
+    },
+    whens: {
+        SendTestMessage: (message) => async (sidecar) => {
+            let callbackFn;
+            process.on = (event, callback) => {
+                if (event === "message") {
+                    callbackFn = callback;
+                    callback(JSON.stringify({
+                        key: "mock-key",
+                        payload: message,
+                    }));
+                }
+            };
+            let writeCalled = false;
+            sidecar.client.write = (data) => {
+                writeCalled = true;
+                return true;
+            };
+            await sidecar.send("test-command", message);
+            return { writeCalled, callbackFn };
+        },
+        VerifyCleanup: () => async (sidecar) => {
+            let addListenerCalled = false;
+            let removeListenerCalled = false;
+            process.addListener = () => (addListenerCalled = true);
+            process.removeListener = () => (removeListenerCalled = true);
+            await sidecar.send("test-command", "test");
+            return { addListenerCalled, removeListenerCalled };
+        },
+    },
+    thens: {
+        MessageReceived: (expected) => (actual) => {
+            if (actual !== expected) {
+                throw new Error(`Expected "${expected}" but got "${actual}"`);
+            }
+            return actual;
+        },
+        ListenersCleaned: () => (result, { removeListenerCalled }) => {
+            if (!removeListenerCalled) {
+                throw new Error("Expected removeListener to be called");
+            }
+            return result;
+        },
+    },
+    checks: { SidecarState: () => "unknown" },
+};
+const testInterface = {
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        const sidecar = initializer();
+        sidecar.client = {
+            write: () => true,
+            end: () => { },
+            on: () => { },
+        };
+        return sidecar;
+    },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        try {
+            await whenCB(store, testResource, pm);
+        }
+        catch (e) {
+            console.error("Error in andWhen:", e);
+            throw e;
+        }
+    },
+};
+export default Testeranto(() => new PM_Web_Sidecar({}), specification, implementation, testInterface);

package/dist/module/src/PM/base.js

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import fs from "fs";
 import path from "path";
 const fileStreams3 = [];
@@ -10,7 +12,7 @@ export class PM_Base {
         this.configs = configs;
     }
     customclose() {
-        throw new Error("Method not implemented.");
+        throw new Error("customclose not implemented.");
     }
     waitForSelector(p, s) {
         return new Promise((res) => {
@@ -32,8 +34,8 @@ export class PM_Base {
             });
         });
     }
-    newPage() {
-        return this.browser.newPage();
+    async newPage() {
+        return (await this.browser.newPage()).mainFrame()._id;
     }
     goto(p, url) {
         return new Promise((res) => {
@@ -47,9 +49,9 @@ export class PM_Base {
     $(selector, p) {
         return new Promise((res) => {
             this.doInPage(p, async (page) => {
-                const x = page.$(selector);
-                const y = await x;
-                res(y !== null);
+                const x = await page.$(selector);
+                const y = await (x === null || x === void 0 ? void 0 : x.jsonValue());
+                res(y);
             });
         });
     }
@@ -76,7 +78,7 @@ export class PM_Base {
         await sPromise;
         return sPromise;
     }
-    async customScreenShot(ssOpts, testName, page) {
+    async customScreenShot(ssOpts, testName, pageUid) {
         const p = ssOpts.path;
         const dir = path.dirname(p);
         fs.mkdirSync(dir, {
@@ -86,6 +88,7 @@ export class PM_Base {
             files[testName] = new Set();
         }
         files[testName].add(ssOpts.path);
+        const page = (await this.browser.pages()).find((p) => p.mainFrame()._id === pageUid);
         const sPromise = page.screenshot(Object.assign(Object.assign({}, ssOpts), { path: p }));
         if (!screenshots[testName]) {
             screenshots[testName] = [];
@@ -164,7 +167,6 @@ export class PM_Base {
                         res();
                     }
                     else {
-                        /* @ts-ignore:next-line */
                         const pipeStream = value;
                         const myFile = fs.createWriteStream(fPath);
                         pipeStream.pipe(myFile);
@@ -183,8 +185,8 @@ export class PM_Base {
             res(x);
         });
     }
-    page() {
-        throw new Error("Method not implemented.");
+    page(p) {
+        return p;
     }
     click(selector, page) {
         return page.click(selector);
@@ -199,14 +201,28 @@ export class PM_Base {
             return page.keyboard.type(value);
         });
     }
-    getValue(value, p) {
+    // setValue(value: string, p: string) {
+    //   this.doInPage(p, (page) => {
+    //     return page.keyboard.type(value);
+    //   });
+    // }
+    getAttribute(selector, attribute, p) {
         this.doInPage(p, (page) => {
-            return page.keyboard.type(value);
+            return page.$eval(selector, (input) => input.getAttribute(attribute));
         });
     }
-    getAttribute(selector, attribute, p) {
-        this.doInPage(p, (page) => {
-            return page.$eval(selector, (input) => input.getAttribute("value"));
+    async getInnerHtml(selector, p) {
+        return new Promise((res, rej) => {
+            this.doInPage(p, async (page) => {
+                const e = await page.$(selector);
+                if (!e) {
+                    rej();
+                }
+                else {
+                    const text = await (await e.getProperty("textContent")).jsonValue();
+                    res(text);
+                }
+            });
         });
     }
     isDisabled(selector, p) {
@@ -221,7 +237,8 @@ export class PM_Base {
     }
     async doInPage(p, cb) {
         (await this.browser.pages()).forEach((page) => {
-            if (page.mainFrame()._id === p) {
+            const frame = page.mainFrame();
+            if (frame._id === p) {
                 return cb(page);
             }
         });