flashwright 0.0.0-stage → 1.64.1-flashwright.2

package/lib/runner/session.js.txt

@@ -0,0 +1,8 @@
+# packages/playwright/lib/runner/session.js
+# total: 25.0 KB
+
+## Inlined (1)
+  23.4 KB  packages/playwright/src/runner/session.ts
+
+## External (1)
+  playwright-core/lib/coreBundle

package/lib/runner/workerStandby.js

@@ -0,0 +1,206 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/playwright/src/runner/workerStandby.ts
+var workerStandby_exports = {};
+__export(workerStandby_exports, {
+  discardStandbys: () => discardStandbys,
+  ensureStandbys: () => ensureStandbys,
+  ensureStandbysForConfig: () => ensureStandbysForConfig,
+  prespawnWorkerForTestCommand: () => prespawnWorkerForTestCommand,
+  recordWorkerCount: () => recordWorkerCount,
+  recordWorkerRestart: () => recordWorkerRestart,
+  retargetStandbys: () => retargetStandbys,
+  takeStandby: () => takeStandby,
+  workerEntryScript: () => workerEntryScript,
+  workerEnv: () => workerEnv
+});
+module.exports = __toCommonJS(workerStandby_exports);
+var import_child_process = __toESM(require("child_process"));
+var import_crypto = __toESM(require("crypto"));
+var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_session = require("./session");
+var standbys = [];
+var enabled = false;
+var hintKey;
+var workerCount = 0;
+var restartCount = 0;
+var keepSpare = false;
+var cpus = 1;
+var hadHint = false;
+var loadTimeEnvPattern = /^(PW|PLAYWRIGHT|DEBUG|NODE|FORCE_COLOR|TS_NODE|TSX)/;
+function workerEntryScript() {
+  return import_path.default.join(__dirname, "..", "worker", "workerProcessEntry.js");
+}
+function workerEnv(extraEnv) {
+  return {
+    ...process.env,
+    ...extraEnv,
+    FORCE_COLOR: "1",
+    DEBUG_COLORS: process.env.DEBUG_COLORS === void 0 ? "1" : process.env.DEBUG_COLORS
+  };
+}
+function prespawnWorkerForTestCommand(argv) {
+  if (enabled || argv[2] !== "test" || process.env.PW_DISABLE_WORKER_STANDBY || process.env.PWDEBUG)
+    return;
+  const interactive = ["--list", "--ui", "--ui-host", "--ui-port", "--debug", "-h", "--help", "--last-failed"];
+  if (argv.some((arg) => interactive.includes(arg.split("=")[0])))
+    return;
+  enabled = true;
+  hintKey = workerCountHintKey(argv);
+  process.env.FLASHWRIGHT_CONTEXT_HINT_KEY = hintKey;
+  cpus = import_os.default.availableParallelism?.() ?? import_os.default.cpus().length;
+  const hint = readWorkerCountHints()[hintKey];
+  hadHint = !!hint;
+  const sessionBrowsers = Number(process.env.FLASHWRIGHT_SESSION_STANDBYS) || 0;
+  const count = Math.max(1, Math.min(Math.max(hint?.workers || 1, sessionBrowsers), cpus));
+  keepSpare = !!hint?.restarts && count < cpus;
+  for (let i = 0; i < count + (keepSpare ? 1 : 0); i++)
+    spawnStandby();
+  process.once("exit", () => {
+    discardStandbys();
+    writeWorkerCountHint();
+  });
+}
+function spawnStandby(waitsForNextPhase = false) {
+  const entryScript = workerEntryScript();
+  const env = { ...workerEnv({}), PLAYWRIGHT_TEST: "1", FLASHWRIGHT_SPECULATIVE_BROWSER: waitsForNextPhase ? "next-phase" : "1", ...(0, import_session.sessionStandbyEnv)() };
+  const child = import_child_process.default.fork(entryScript, {
+    detached: false,
+    env,
+    stdio: ["ignore", "pipe", "pipe", "ipc"]
+  });
+  child.on("error", () => {
+  });
+  (0, import_session.requestSessionBrowser)(child);
+  const ready = new Promise((resolve) => {
+    const onMessage = (message) => {
+      if (message?.method === "ready") {
+        child.off("message", onMessage);
+        resolve(true);
+      }
+    };
+    child.on("message", onMessage);
+    child.once("exit", () => resolve(false));
+  });
+  standbys.push({ child, entryScript, env, ready });
+  child.unref();
+  child.channel?.unref?.();
+}
+function recordWorkerRestart(moreTestsToRun) {
+  restartCount++;
+  if (!moreTestsToRun)
+    return;
+  keepSpare = keepSpare || workerCount < cpus;
+  setImmediate(() => ensureStandbys(1));
+}
+function ensureStandbys(count, forNextPhase = false) {
+  if (!enabled)
+    return;
+  while (standbys.length < count)
+    spawnStandby(forNextPhase);
+}
+function ensureStandbysForConfig(configuredWorkers) {
+  if (enabled && !hadHint)
+    ensureStandbys(Math.min(configuredWorkers, cpus));
+}
+function retargetStandbys(argv) {
+  if (enabled)
+    hintKey = workerCountHintKey(argv);
+}
+function recordWorkerCount(count) {
+  workerCount = Math.max(workerCount, count);
+}
+function discardStandbys() {
+  for (const standby of standbys.splice(0))
+    release(standby.child);
+}
+function release(child) {
+  if (child.connected)
+    child.disconnect();
+}
+async function takeStandby(entryScript, env) {
+  const standby = standbys.shift();
+  if (!standby)
+    return;
+  if (keepSpare)
+    setImmediate(() => ensureStandbys(1));
+  const keys = /* @__PURE__ */ new Set([...Object.keys(env), ...Object.keys(standby.env)]);
+  const compatible = standby.entryScript === entryScript && [...keys].every((key) => !loadTimeEnvPattern.test(key) || env[key] === standby.env[key]);
+  if (!compatible || !await standby.ready) {
+    release(standby.child);
+    return;
+  }
+  standby.child.ref();
+  standby.child.channel?.ref?.();
+  return standby.child;
+}
+var hintFile = import_path.default.join(import_os.default.tmpdir(), "flashwright-worker-hints.json");
+var maxHints = 500;
+function workerCountHintKey(argv) {
+  const configIndex = argv.findIndex((arg) => arg === "-c" || arg === "--config" || arg.startsWith("--config="));
+  const config = configIndex === -1 ? "" : argv[configIndex].startsWith("--config=") ? argv[configIndex] : argv[configIndex + 1];
+  const workers = argv.find((arg) => arg.startsWith("--workers") || arg === "-j") ?? "";
+  return import_crypto.default.createHash("sha1").update([process.cwd(), config, workers].join("\0")).digest("hex").slice(0, 16);
+}
+function readWorkerCountHints() {
+  try {
+    return JSON.parse(import_fs.default.readFileSync(hintFile, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeWorkerCountHint() {
+  if (!workerCount || !hintKey)
+    return;
+  try {
+    const hints = readWorkerCountHints();
+    hints[hintKey] = { workers: workerCount, restarts: restartCount, usedAt: Date.now() };
+    const recent = Object.entries(hints).sort((a, b) => b[1].usedAt - a[1].usedAt).slice(0, maxHints);
+    const temporary = `${hintFile}.${process.pid}`;
+    import_fs.default.writeFileSync(temporary, JSON.stringify(Object.fromEntries(recent)));
+    import_fs.default.renameSync(temporary, hintFile);
+  } catch {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  discardStandbys,
+  ensureStandbys,
+  ensureStandbysForConfig,
+  prespawnWorkerForTestCommand,
+  recordWorkerCount,
+  recordWorkerRestart,
+  retargetStandbys,
+  takeStandby,
+  workerEntryScript,
+  workerEnv
+});

package/lib/runner/workerStandby.js.txt

@@ -0,0 +1,8 @@
+# packages/playwright/lib/runner/workerStandby.js
+# total: 7.6 KB
+
+## Inlined (1)
+  5.9 KB  packages/playwright/src/runner/workerStandby.ts
+
+## External (1)
+  ./session

package/lib/speculativeBrowser.js

@@ -0,0 +1,228 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var speculativeBrowser_exports = {};
+__export(speculativeBrowser_exports, {
+  handBrowsersToSession: () => handBrowsersToSession,
+  launchSpeculativeBrowser: () => launchSpeculativeBrowser,
+  prepareSpeculativeContext: () => prepareSpeculativeContext,
+  rememberRecycledContext: () => rememberRecycledContext,
+  returnSpeculativeBrowser: () => returnSpeculativeBrowser,
+  takeSpeculativeBrowser: () => takeSpeculativeBrowser
+});
+module.exports = __toCommonJS(speculativeBrowser_exports);
+var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_util = require("util");
+const speculativeOptions = { handleSIGINT: false, headless: true, ...process.env.FLASHWRIGHT_ISOLATION === "strict" ? {} : { recycleContexts: true } };
+const speculativeKey = /* @__PURE__ */ Symbol.for("flashwright.speculativeBrowser");
+function launchSpeculativeBrowser() {
+  const offered = process.env.FLASHWRIGHT_SESSION_OFFER ? receiveSessionBrowser() : Promise.resolve();
+  const launch = offered.then(() => require("playwright-core").chromium.launch(speculativeOptions)).catch(() => void 0);
+  globalThis[speculativeKey] = launch;
+  return launch;
+}
+const kBrowserMessage = "__flashwright_browser__";
+const offerKey = /* @__PURE__ */ Symbol.for("flashwright.browserOffer");
+let offeredLastUsed = 0;
+const kOfferTimeoutAfterInit = 500;
+function receiveSessionBrowser() {
+  return new Promise((resolve) => {
+    let answered = false;
+    let timer;
+    const answer = () => {
+      answered = true;
+      clearTimeout(timer);
+      resolve();
+    };
+    const parts = {};
+    const onMessage = (message, handle) => {
+      if (message?.method === "__init__" && !answered)
+        timer = setTimeout(answer, kOfferTimeoutAfterInit);
+      if (message?.method !== kBrowserMessage || message.params.sent)
+        return;
+      if (message.params.none) {
+        process.off("message", onMessage);
+        answer();
+        return;
+      }
+      parts[message.params.part] = handle;
+      parts.metadata ??= message.params.metadata;
+      if (!parts.write || !parts.read || !parts.metadata)
+        return;
+      process.off("message", onMessage);
+      if (answered) {
+        void sendToRunner(parts);
+        return;
+      }
+      globalThis[offerKey] = parts;
+      offeredLastUsed = parts.metadata.lastUsed ?? 0;
+      process.once("exit", () => {
+        if (globalThis[offerKey] === parts)
+          killHandedOverBrowser(parts.metadata);
+      });
+      answer();
+    };
+    process.on("message", onMessage);
+  });
+}
+async function handBrowsersToSession(browser, ranTests) {
+  if (!process.env.FLASHWRIGHT_SESSION_HANDOFF || !process.send)
+    return false;
+  const offer = globalThis[offerKey];
+  if (offer) {
+    delete globalThis[offerKey];
+    await sendToRunner(offer);
+  }
+  if (!browser)
+    return false;
+  const serverBrowser = browser._connection.toImpl?.(browser);
+  const handoff = await serverBrowser?.handoffForSession?.().catch(() => void 0);
+  if (!handoff)
+    return false;
+  handoff.metadata.lastUsed = ranTests ? Date.now() : offeredLastUsed;
+  await sendToRunner(handoff);
+  return true;
+}
+async function sendToRunner(browser) {
+  const id = `${process.pid}-${browser.metadata.pid}`;
+  const send = (params, handle) => new Promise((resolve) => {
+    if (!process.connected)
+      return resolve(false);
+    process.send({ method: kBrowserMessage, params }, handle, void 0, (error) => resolve(!error));
+  });
+  if (await send({ id, part: "write", metadata: browser.metadata }, browser.write) && await send({ id, part: "read" }, browser.read)) {
+    await send({ id, sent: true }, void 0);
+    return;
+  }
+  browser.write.destroy();
+  browser.read.destroy();
+  killHandedOverBrowser(browser.metadata);
+}
+function killHandedOverBrowser(metadata) {
+  try {
+    process.kill(-metadata.pid, "SIGKILL");
+  } catch {
+  }
+  for (const directory of metadata.tempDirectories) {
+    try {
+      import_fs.default.rmSync(directory, { recursive: true, force: true, maxRetries: 5 });
+    } catch {
+    }
+  }
+}
+function prepareSpeculativeContext() {
+  const launch = globalThis[speculativeKey];
+  const hint = speculativeOptions.recycleContexts ? readContextHint() : void 0;
+  if (!launch || !hint)
+    return;
+  globalThis[speculativeKey] = launch.then(async (browser) => {
+    const serverBrowser = browser && browser._connection.toImpl?.(browser);
+    await serverBrowser?.prepareRecycledContext(hint.params, { storageState: hint.storageState }).catch(() => {
+    });
+    return browser;
+  });
+}
+const contextHintFile = import_path.default.join(import_os.default.tmpdir(), "flashwright-context-hints.json");
+const maxContextHints = 200;
+let rememberedContextHint = false;
+function readContextHints() {
+  try {
+    return JSON.parse(import_fs.default.readFileSync(contextHintFile, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function readContextHint() {
+  const key = process.env.FLASHWRIGHT_CONTEXT_HINT_KEY;
+  return key ? readContextHints()[key] : void 0;
+}
+function rememberRecycledContext(browser) {
+  const key = process.env.FLASHWRIGHT_CONTEXT_HINT_KEY;
+  const params = { ...browser._lastRecycleParams };
+  const storageState = !!params.storageState;
+  delete params.storageState;
+  const mayHoldSecrets = params.httpCredentials || params.extraHTTPHeaders?.length || params.proxy || params.clientCertificates?.length;
+  if (rememberedContextHint || !key || !Object.keys(params).length || mayHoldSecrets || !isPlainJSON(params))
+    return;
+  rememberedContextHint = true;
+  try {
+    const hints = readContextHints();
+    if (JSON.stringify(hints[key]?.params) === JSON.stringify(params) && hints[key]?.storageState === storageState)
+      return;
+    hints[key] = { params, storageState, usedAt: Date.now() };
+    const recent = Object.entries(hints).sort((a, b) => b[1].usedAt - a[1].usedAt).slice(0, maxContextHints);
+    const temporary = `${contextHintFile}.${process.pid}`;
+    import_fs.default.writeFileSync(temporary, JSON.stringify(Object.fromEntries(recent)), { mode: 384 });
+    import_fs.default.renameSync(temporary, contextHintFile);
+  } catch {
+  }
+}
+function isPlainJSON(value) {
+  if (value === null || ["string", "number", "boolean", "undefined"].includes(typeof value))
+    return true;
+  if (Array.isArray(value))
+    return value.every(isPlainJSON);
+  return typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype && Object.values(value).every(isPlainJSON);
+}
+async function returnSpeculativeBrowser() {
+  const launch = globalThis[speculativeKey];
+  if (!launch || !process.env.FLASHWRIGHT_SESSION_HANDOFF)
+    return;
+  delete globalThis[speculativeKey];
+  await handBrowsersToSession(await launch, false);
+}
+async function takeSpeculativeBrowser(browserName, options) {
+  const launch = globalThis[speculativeKey];
+  if (!launch)
+    return;
+  delete globalThis[speculativeKey];
+  const { tracesDir, artifactsDir, ...rest } = options;
+  const browser = await launch;
+  if (!browser)
+    return;
+  const serverBrowser = browser._connection.toImpl?.(browser);
+  if (browserName !== "chromium" || !(0, import_util.isDeepStrictEqual)(rest, speculativeOptions) || !serverBrowser || !artifactsDir) {
+    browser._wrapApiCall(() => browser.close(), { internal: true }).catch(() => {
+    });
+    return;
+  }
+  await serverBrowser.setOutputDirs(artifactsDir, tracesDir || artifactsDir);
+  browser._connectToBrowserType(browser.browserType(), options, void 0);
+  return browser;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handBrowsersToSession,
+  launchSpeculativeBrowser,
+  prepareSpeculativeContext,
+  rememberRecycledContext,
+  returnSpeculativeBrowser,
+  takeSpeculativeBrowser
+});