flashwright 1.64.1-flashwright.1 → 1.64.1-flashwright.2

package/README.md

@@ -13,4 +13,6 @@ npx playwright install chromium
 
 Without the test runner, `playwright` is `flashwright` and `playwright-core` is `flashwright-core`. See the [project page](https://github.com/xcodebeast/flashwright) for benchmarks, speed options and the differences from Playwright.
 
+Re-running tests, like an agent checking its work? Outside CI, a warm session keeps the browser between runs, so one test re-runs in about 0.1 s instead of 0.7 s with Playwright ([warm session](https://github.com/xcodebeast/flashwright#warm-session); `FLASHWRIGHT_SESSION=0` turns it off).
+
 Flashwright is an independent fork and is not affiliated with Microsoft. Apache-2.0, like Playwright.

package/cli.js

@@ -24,16 +24,14 @@ if (nodeModule.enableCompileCache && !process.env.NODE_DISABLE_COMPILE_CACHE) {
     process.env.NODE_COMPILE_CACHE = directory;
 }
 
-// Flashwright: compile Playwright's bundles with code caches that include their lazily compiled
-// functions (see codeCache.ts).
-require('./lib/codeCache').installCodeCache(process.argv[2] === 'test' ? 'runner' : 'cli');
-
-// Flashwright: start the first test worker while the CLI loads.
-require('./lib/runner/workerStandby').prespawnWorkerForTestCommand(process.argv);
-// Flashwright: `cli` commands only forward to a browser session; skip loading every command.
-if (process.argv[2] === 'cli') {
-  require('playwright-core/lib/coreBundle').runCliClient();
-} else {
-  const { program } = require('./lib/program');
-  program.parse(process.argv);
-}
+// Flashwright: runs the command here, or in a runner process that the warm session prepared
+// ahead of time (see session.ts). `cli` commands only forward to a browser session.
+require('./lib/runner/session').runCli(process.argv, {
+  // Compiles Playwright's bundles with code caches that include their lazily compiled functions.
+  installCodeCache: role => require('./lib/codeCache').installCodeCache(role),
+  // Starts the first test workers while the CLI loads.
+  prespawnWorkers: argv => require('./lib/runner/workerStandby').prespawnWorkerForTestCommand(argv),
+  retargetWorkers: argv => require('./lib/runner/workerStandby').retargetStandbys(argv),
+  loadProgram: () => require('./lib/program').program,
+  runCliClient: () => require('playwright-core/lib/coreBundle').runCliClient(),
+});

package/lib/cli/testActions.js

@@ -37,6 +37,7 @@ var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_common = require("../common");
 var import_runner = require("../runner");
+var import_session = require("../runner/session");
 const { gracefullyProcessExitDoNotHang } = require("playwright-core/lib/coreBundle").utils;
 async function runTests(args, opts) {
   const cliOverrides = overridesFromOptions(opts);
@@ -90,7 +91,7 @@ async function runTests(args, opts) {
   }
   const status = await import_runner.testRunner.runAllTestsWithConfig(config, options);
   const exitCode = status === "interrupted" ? 130 : status === "passed" ? 0 : 1;
-  gracefullyProcessExitDoNotHang(exitCode);
+  gracefullyProcessExitDoNotHang(exitCode, () => (0, import_session.flushSessionBrowsers)(exitCode));
 }
 async function runTestServerAction(opts) {
   const host = opts.host;

package/lib/index.js

@@ -213,6 +213,7 @@ const playwrightFixtures = {
     playwright._defaultLaunchOptions = options;
     await use(options);
     playwright._defaultLaunchOptions = void 0;
+    await (0, import_speculativeBrowser.returnSpeculativeBrowser)();
   }, { scope: "worker", auto: true, box: true }],
   browser: [async ({ playwright, browserName, _browserOptions, connectOptions, _recycleContext }, use, workerInfo) => {
     if (!["chromium", "firefox", "webkit"].includes(browserName))
@@ -239,6 +240,8 @@ const playwrightFixtures = {
     if (process.env.PLAYWRIGHT_DASHBOARD)
       await browser.bind(`worker-${workerInfo.parallelIndex}`);
     await use(browser);
+    if (await (0, import_speculativeBrowser.handBrowsersToSession)(browser, true))
+      return;
     if (browser.contexts().length)
       await browser.close({ reason: "Test ended." });
     else

package/lib/runner/index.js

@@ -1896,6 +1896,7 @@ var import_fs3 = __toESM(require("fs"));
 var import_child_process = __toESM(require("child_process"));
 var import_events = require("events");
 var import_workerStandby = require("./workerStandby");
+var import_session = require("./session");
 var debug3 = require("playwright-core/lib/utilsBundle").debug;
 var { assert } = require("playwright-core/lib/coreBundle").iso;
 var { monotonicTime: monotonicTime3, timeOrigin } = require("playwright-core/lib/coreBundle").iso;
@@ -1944,7 +1945,10 @@ var ProcessHost = class extends import_events.EventEmitter {
     });
     this.process.on("error", (e) => {
     });
-    this.process.on("message", (message) => {
+    (0, import_session.trackSessionWorker)(this.process);
+    this.process.on("message", (message, handle) => {
+      if ((0, import_session.receiveWorkerMessage)(this.process, message, handle))
+        return;
       if (debug3.enabled("pw:test:protocol"))
         debug3("pw:test:protocol")("\u25C0 RECV " + JSON.stringify(message));
       if (message.method === "__env_produced__") {

package/lib/runner/index.js.txt

@@ -1,5 +1,5 @@
 # packages/playwright/lib/runner/index.js
-# total: 321.2 KB
+# total: 321.4 KB
 
 ## Inlined (49)
    1.3 KB  packages/playwright/src/isomorphic/events.ts
@@ -35,7 +35,7 @@
    1.7 KB  packages/playwright/src/runner/lastRun.ts
    1.6 KB  packages/playwright/src/runner/loaderHost.ts
   13.3 KB  packages/playwright/src/runner/loadUtils.ts
-   6.3 KB  packages/playwright/src/runner/processHost.ts
+   6.5 KB  packages/playwright/src/runner/processHost.ts
    7.9 KB  packages/playwright/src/runner/projectUtils.ts
    5.5 KB  packages/playwright/src/runner/rebase.ts
    3.4 KB  packages/playwright/src/runner/reporters.ts
@@ -52,12 +52,13 @@
   13.0 KB  packages/playwright/src/runner/watchMode.ts
    2.1 KB  packages/playwright/src/runner/workerHost.ts
 
-## External (9)
+## External (10)
   ../common
   ../loader/loaderProcessEntry.js
   ../transform/babelBundle
   ../util
   ../worker/workerProcessEntry.js
+  ./session
   ./workerStandby
   playwright-core
   playwright-core/lib/coreBundle

package/lib/runner/session.js

@@ -0,0 +1,723 @@
+"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/session.ts
+var session_exports = {};
+__export(session_exports, {
+  flushSessionBrowsers: () => flushSessionBrowsers,
+  receiveWorkerMessage: () => receiveWorkerMessage,
+  requestSessionBrowser: () => requestSessionBrowser,
+  runCli: () => runCli,
+  sessionStandbyEnv: () => sessionStandbyEnv,
+  trackSessionWorker: () => trackSessionWorker
+});
+module.exports = __toCommonJS(session_exports);
+var import_child_process = __toESM(require("child_process"));
+var import_crypto = __toESM(require("crypto"));
+var import_fs = __toESM(require("fs"));
+var import_inspector = __toESM(require("inspector"));
+var import_net = __toESM(require("net"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_url = __toESM(require("url"));
+var kIdleTimeout = (Number(process.env.FLASHWRIGHT_SESSION_TIMEOUT) || 5 * 60) * 1e3;
+var kVolatileEnv = /* @__PURE__ */ new Set(["_", "PWD", "OLDPWD", "SHLVL", "COLUMNS", "LINES"]);
+var kInteractiveArgs = ["--ui", "--ui-host", "--ui-port", "--debug", "--list", "-h", "--help"];
+var kBrowserMessage = "__flashwright_browser__";
+var kBrowserRequest = "__flashwright_browser_request__";
+var kReturnBrowser = "__flashwright_return_browser__";
+var kBrowserReturned = "__flashwright_browser_returned__";
+var kMaxBrowsers = 8;
+function runCli(argv, hooks) {
+  if (argv[2] === "cli") {
+    hooks.installCodeCache("cli");
+    hooks.runCliClient();
+    return;
+  }
+  if (process.env.FLASHWRIGHT_SESSION_ROLE === "warm") {
+    runWarmProcess(hooks).catch((error) => {
+      process.stderr.write(`Flashwright session: ${error.stack || error}
+`);
+      process.exit(1);
+    });
+    return;
+  }
+  if (argv[2] === "test" && sessionRequested() && !argv.some((arg) => kInteractiveArgs.includes(arg.split("=")[0]))) {
+    const request = createRequest(argv);
+    runInSession(request).then((outcome) => runLocally(argv, hooks, outcome === "start" ? request : void 0), () => runLocally(argv, hooks));
+    return;
+  }
+  runLocally(argv, hooks);
+}
+function runLocally(argv, hooks, startSessionWith) {
+  hooks.installCodeCache(argv[2] === "test" ? "runner" : "cli");
+  if (startSessionWith)
+    startSession(startSessionWith);
+  if (argv[2] === "test")
+    hooks.prespawnWorkers(argv);
+  hooks.loadProgram().parse(argv);
+}
+function sessionRequested() {
+  if (process.env.PWDEBUG || process.env.PWTEST_WATCH || import_inspector.default.url() || process.platform === "win32")
+    return false;
+  const value = process.env.FLASHWRIGHT_SESSION;
+  if (value)
+    return value !== "0" && value !== "false";
+  return !process.env.CI;
+}
+function buildStamp() {
+  const files = ["program.js", "common/index.js", "runner/index.js", "runner/session.js", "worker/workerProcessEntry.js"].map((file) => import_path.default.join(__dirname, "..", file));
+  try {
+    files.push(require.resolve("playwright-core/lib/coreBundle"));
+  } catch {
+  }
+  return files.map((file) => {
+    try {
+      const stat = import_fs.default.statSync(file);
+      return `${file}:${stat.size}:${stat.mtimeMs}`;
+    } catch {
+      return file;
+    }
+  }).join("|");
+}
+function terminalProfile() {
+  return {
+    stdout: process.stdout.isTTY ? `${process.stdout.columns || 0}x${process.stdout.rows || 0}` : "false",
+    stdinTTY: !!process.stdin.isTTY
+  };
+}
+function stableEnv(env) {
+  const result = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (value !== void 0 && !kVolatileEnv.has(key) && !key.startsWith("FLASHWRIGHT_SESSION_"))
+      result[key] = value;
+  }
+  return result;
+}
+function createRequest(argv) {
+  return {
+    type: "run",
+    argv,
+    cwd: process.cwd(),
+    env: stableEnv(process.env),
+    execPath: process.execPath,
+    execArgv: process.execArgv,
+    cliPath: argv[1],
+    build: buildStamp(),
+    profile: terminalProfile()
+  };
+}
+function warmKey(request) {
+  const env = Object.entries(stableEnv(request.env)).sort(([a], [b]) => a < b ? -1 : 1);
+  return import_crypto.default.createHash("sha1").update(JSON.stringify([env, request.execPath, request.execArgv, request.cliPath, request.build, request.profile])).digest("hex");
+}
+function sessionSocketPath(cwd) {
+  const uid = import_os.default.userInfo().uid;
+  const directory = import_path.default.join(import_os.default.tmpdir(), `fw-${uid}`);
+  try {
+    import_fs.default.mkdirSync(directory, { mode: 448 });
+  } catch {
+  }
+  try {
+    const stat = import_fs.default.statSync(directory);
+    if (!stat.isDirectory() || stat.uid !== uid || stat.mode & 63)
+      return;
+  } catch {
+    return;
+  }
+  const id = import_crypto.default.createHash("sha1").update([import_path.default.join(__dirname, ".."), process.execPath, cwd].join("\0")).digest("hex").slice(0, 16);
+  const socketFile = import_path.default.join(directory, `${id}.sock`);
+  return Buffer.byteLength(socketFile) < 100 ? socketFile : void 0;
+}
+function runInSession(request) {
+  const socketFile = sessionSocketPath(request.cwd);
+  if (!socketFile)
+    return Promise.resolve("local");
+  return new Promise((resolve) => {
+    const socket = import_net.default.connect(socketFile);
+    let started = false;
+    let exited = false;
+    let buffer = "";
+    const lost = () => {
+      process.stderr.write("Flashwright session: the connection to the test run was lost.\n");
+      process.exit(1);
+    };
+    socket.on("error", () => {
+      if (started)
+        lost();
+      else
+        resolve("start");
+    });
+    socket.on("close", () => {
+      if (!started)
+        resolve("local");
+      else if (!exited)
+        lost();
+    });
+    socket.on("connect", () => socket.write(JSON.stringify(request) + "\n"));
+    socket.on("data", (chunk) => {
+      buffer += chunk.toString();
+      let newline;
+      while ((newline = buffer.indexOf("\n")) !== -1) {
+        const message = JSON.parse(buffer.slice(0, newline));
+        buffer = buffer.slice(newline + 1);
+        if (message.type === "cold") {
+          socket.destroy();
+          resolve(message.stale ? "start" : "local");
+        } else if (message.type === "started") {
+          started = true;
+          let interrupted = false;
+          for (const signal of ["SIGINT", "SIGTERM"]) {
+            process.on(signal, () => {
+              if (interrupted)
+                process.exit(130);
+              interrupted = true;
+              socket.write(JSON.stringify({ type: "signal", signal }) + "\n");
+            });
+          }
+        } else if (message.type === "stdout" || message.type === "stderr") {
+          (message.type === "stdout" ? process.stdout : process.stderr).write(Buffer.from(message.data, "base64"));
+        } else if (message.type === "exit") {
+          exited = true;
+          socket.destroy();
+          const code = message.code ?? (message.signal === "SIGINT" ? 130 : 1);
+          process.stdout.write("", () => process.stderr.write("", () => process.exit(code)));
+        }
+      }
+    });
+  });
+}
+function startSession(request) {
+  const socketFile = sessionSocketPath(request.cwd);
+  if (!socketFile)
+    return;
+  const child = import_child_process.default.spawn(process.execPath, [__filename, "--flashwright-session", socketFile, request.build], {
+    detached: true,
+    stdio: ["ignore", "ignore", "ignore", "ipc"],
+    env: { ...process.env, FLASHWRIGHT_SESSION_ROLE: "session" }
+  });
+  child.on("error", () => {
+  });
+  child.unref();
+  child.channel?.unref?.();
+  child.send({ method: "request", params: request });
+  joinSession(child, false);
+}
+var sessionChannel;
+var offersBrowsers = false;
+var lastRequestId = 0;
+var standbyRequests = /* @__PURE__ */ new Map();
+var workerParts = /* @__PURE__ */ new Map();
+var pendingSends = /* @__PURE__ */ new Set();
+var sessionWorkers = /* @__PURE__ */ new Set();
+var sessionStandbys = /* @__PURE__ */ new Set();
+function joinSession(channel, offers) {
+  sessionChannel = channel;
+  offersBrowsers = offers;
+  process.env.FLASHWRIGHT_SESSION_HANDOFF = "1";
+}
+function sessionStandbyEnv() {
+  return offersBrowsers && sessionChannel?.connected ? { FLASHWRIGHT_SESSION_OFFER: "1" } : {};
+}
+function requestSessionBrowser(child) {
+  if (!sessionChannel)
+    return;
+  sessionStandbys.add(child);
+  child.once("exit", () => sessionStandbys.delete(child));
+  if (!offersBrowsers || !sessionChannel.connected)
+    return;
+  const id = String(++lastRequestId);
+  standbyRequests.set(id, child);
+  child.once("exit", () => standbyRequests.delete(id));
+  sessionChannel.send({ method: kBrowserRequest, params: { id } });
+}
+function receiveWorkerMessage(child, message, handle) {
+  if (message?.method !== kBrowserMessage)
+    return false;
+  const browser = collectBrowserPart(workerParts, message, handle);
+  if (browser)
+    forwardBrowser(browser);
+  return true;
+}
+function trackSessionWorker(child) {
+  if (!sessionChannel)
+    return;
+  sessionStandbys.delete(child);
+  sessionWorkers.add(child);
+  child.once("disconnect", () => sessionWorkers.delete(child));
+}
+function forwardBrowser(browser) {
+  if (!sessionChannel?.connected || browser.read.readableLength) {
+    killBrowser(browser);
+    return;
+  }
+  pendingSends.add(sendBrowser(sessionChannel, browser));
+}
+async function flushSessionBrowsers(exitCode) {
+  if (!sessionChannel)
+    return;
+  await Promise.all([...sessionStandbys].map(returnStandbyBrowser));
+  const deadline = Date.now() + 2e3;
+  while (sessionWorkers.size && Date.now() < deadline)
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  await Promise.all(pendingSends);
+  for (const parts of workerParts.values())
+    killBrowser(parts);
+  workerParts.clear();
+  if (outputBytes && exitCode !== void 0 && sessionChannel.connected)
+    await new Promise((resolve) => sessionChannel.send({ type: "exiting", code: exitCode, ...outputBytes }, void 0, resolve));
+  if (sessionChannel.connected)
+    sessionChannel.disconnect();
+}
+var outputBytes;
+function countOutputBytes() {
+  outputBytes = { stdout: 0, stderr: 0 };
+  for (const name of ["stdout", "stderr"]) {
+    const stream = process[name];
+    const write = stream.write;
+    stream.write = function(chunk, encoding, callback) {
+      outputBytes[name] += typeof chunk === "string" ? Buffer.byteLength(chunk, typeof encoding === "string" ? encoding : "utf8") : chunk.length;
+      return write.apply(this, arguments);
+    };
+  }
+}
+function returnStandbyBrowser(child) {
+  if (!child.connected)
+    return Promise.resolve();
+  return new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timer);
+      child.off("message", onMessage);
+      resolve();
+    };
+    const timer = setTimeout(done, 2e3);
+    const onMessage = (message, handle) => {
+      if (message?.method === kBrowserReturned)
+        done();
+      else if (message?.method === kBrowserMessage)
+        receiveWorkerMessage(child, message, handle);
+    };
+    child.on("message", onMessage);
+    child.once("exit", done);
+    child.send({ method: kReturnBrowser });
+  });
+}
+function onSessionMessage(message, handle) {
+  if (message?.method !== kBrowserMessage)
+    return;
+  const child = standbyRequests.get(message.params.id);
+  if (message.params.part !== "write")
+    standbyRequests.delete(message.params.id);
+  if (child?.connected) {
+    child.send(message, handle);
+    return;
+  }
+  const browser = collectBrowserPart(workerParts, message, handle);
+  if (browser)
+    forwardBrowser(browser);
+}
+function collectBrowserPart(parts, message, handle) {
+  const { id, part, metadata } = message.params;
+  if (!part || !handle)
+    return;
+  const browser = parts.get(id) ?? { id };
+  browser[part] = handle;
+  if (metadata)
+    browser.metadata = metadata;
+  parts.set(id, browser);
+  if (!browser.write || !browser.read || !browser.metadata)
+    return;
+  parts.delete(id);
+  return browser;
+}
+function sendBrowser(channel, browser) {
+  const { id, metadata } = browser;
+  return new Promise((resolve) => {
+    channel.send({ method: kBrowserMessage, params: { id, part: "write", metadata } }, browser.write, (error) => {
+      if (error) {
+        killBrowser(browser);
+        resolve();
+        return;
+      }
+      channel.send({ method: kBrowserMessage, params: { id, part: "read" } }, browser.read, () => {
+        channel.send({ method: kBrowserMessage, params: { id, sent: true } }, void 0, () => resolve());
+      });
+    });
+  });
+}
+function killBrowser(browser) {
+  browser.write?.destroy();
+  browser.read?.destroy();
+  if (!browser.metadata)
+    return;
+  try {
+    process.kill(-browser.metadata.pid, "SIGKILL");
+  } catch {
+  }
+  const directories = browser.metadata.tempDirectories;
+  setTimeout(() => {
+    for (const directory of directories)
+      import_fs.default.rm(directory, { recursive: true, force: true, maxRetries: 5 }, () => {
+      });
+  }, 500).unref();
+}
+function runSession(socketFile, build) {
+  const warmProcesses = [];
+  const browsers = [];
+  const waiting = [];
+  let startingRunKey;
+  let lastRequest;
+  let idleTimer;
+  let activeRuns = 0;
+  const shutdown = () => {
+    for (const warm of warmProcesses.splice(0))
+      warm.child.kill();
+    for (const browser of browsers.splice(0))
+      killBrowser(browser);
+    server.close();
+    try {
+      import_fs.default.unlinkSync(socketFile);
+    } catch {
+    }
+    process.exit(0);
+  };
+  const resetIdleTimer = () => {
+    clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => {
+      if (!activeRuns && !startingRunKey)
+        shutdown();
+    }, kIdleTimeout);
+  };
+  const runsThatMayHandOver = (key) => (startingRunKey === key ? 1 : 0) + warmProcesses.filter((warm) => warm.running && warm.connected && warm.key === key).length;
+  const answer = (warm, id) => {
+    let browser;
+    for (const candidate of browsers) {
+      if (candidate.key === warm.key && (!browser || (candidate.metadata.lastUsed ?? 0) > (browser.metadata.lastUsed ?? 0)))
+        browser = candidate;
+    }
+    if (browser)
+      remove(browser);
+    if (!warm.child.connected) {
+      if (browser)
+        browsers.push(browser);
+      return;
+    }
+    if (!browser) {
+      warm.child.send({ method: kBrowserMessage, params: { id, none: true } });
+      return;
+    }
+    browser.read.removeAllListeners("data");
+    browser.read.removeAllListeners("close");
+    browser.read.pause();
+    void sendBrowser(warm.child, { ...browser, id });
+  };
+  const onBrowserRequest = (warm, id) => {
+    if (browsers.some((browser) => browser.key === warm.key) || warm.running || !runsThatMayHandOver(warm.key))
+      answer(warm, id);
+    else
+      waiting.push({ warm, id });
+  };
+  const answerWaiting = (predicate) => {
+    for (const entry of waiting.filter(predicate)) {
+      waiting.splice(waiting.indexOf(entry), 1);
+      answer(entry.warm, entry.id);
+    }
+  };
+  const onBrowserReturned = (key, browser) => {
+    if (browser.read.readableLength) {
+      killBrowser(browser);
+      return;
+    }
+    const pooled = { ...browser, key };
+    browser.read.on("data", () => {
+      remove(pooled);
+      killBrowser(pooled);
+    });
+    browser.read.on("close", () => {
+      remove(pooled);
+      killBrowser(pooled);
+    });
+    browsers.push(pooled);
+    const entry = waiting.find((entry2) => entry2.warm.key === key);
+    if (entry) {
+      waiting.splice(waiting.indexOf(entry), 1);
+      answer(entry.warm, entry.id);
+    }
+    const sameKind = browsers.filter((browser2) => browser2.key === key).sort((a, b) => (a.metadata.lastUsed ?? 0) - (b.metadata.lastUsed ?? 0));
+    for (const extra of sameKind.slice(0, Math.max(0, sameKind.length - kMaxBrowsers))) {
+      remove(extra);
+      killBrowser(extra);
+    }
+  };
+  const remove = (browser) => {
+    const index = browsers.indexOf(browser);
+    if (index !== -1)
+      browsers.splice(index, 1);
+  };
+  const spawnWarm = (request) => {
+    const key = warmKey(request);
+    if (warmProcesses.some((warm2) => warm2.key === key && !warm2.running))
+      return;
+    const standbys = browsers.filter((browser) => browser.key === key).length;
+    const child = import_child_process.default.spawn(request.execPath, [...request.execArgv, request.cliPath, ...request.argv.slice(2)], {
+      cwd: request.cwd,
+      env: { ...warmEnv(request), FLASHWRIGHT_SESSION_ROLE: "warm", FLASHWRIGHT_SESSION_STANDBYS: String(standbys) },
+      stdio: ["ignore", "pipe", "pipe", "ipc"]
+    });
+    const warm = { child, key, ready: Promise.resolve(false), running: false, connected: true, parts: /* @__PURE__ */ new Map() };
+    warm.ready = new Promise((resolve) => {
+      child.on("message", (message, handle2) => {
+        if (message?.type === "warm") {
+          resolve(true);
+        } else if (message?.type === "exiting") {
+          warm.exiting?.(message);
+        } else if (message?.method === kBrowserRequest) {
+          onBrowserRequest(warm, message.params.id);
+        } else if (message?.method === kBrowserMessage) {
+          const browser = collectBrowserPart(warm.parts, message, handle2);
+          if (browser)
+            onBrowserReturned(key, browser);
+        }
+      });
+      child.once("exit", () => resolve(false));
+    });
+    warmProcesses.push(warm);
+    child.once("disconnect", () => {
+      warm.connected = false;
+      for (const parts2 of warm.parts.values())
+        killBrowser(parts2);
+      warm.parts.clear();
+      answerWaiting((entry) => entry.warm === warm || !runsThatMayHandOver(entry.warm.key));
+    });
+    child.once("exit", () => {
+      const index = warmProcesses.indexOf(warm);
+      if (index !== -1)
+        warmProcesses.splice(index, 1);
+    });
+  };
+  const handle = async (socket, request) => {
+    resetIdleTimer();
+    if (request.build !== build) {
+      socket.end(JSON.stringify({ type: "cold", stale: true }) + "\n");
+      shutdown();
+      return;
+    }
+    lastRequest = request;
+    const key = warmKey(request);
+    const index = warmProcesses.findIndex((warm2) => warm2.key === key && !warm2.running);
+    const warm = index === -1 ? void 0 : warmProcesses[index];
+    if (!warm || !await warm.ready) {
+      warm?.child.kill();
+      socket.end(JSON.stringify({ type: "cold" }) + "\n");
+      if (!startingRunKey)
+        spawnWarm(request);
+      return;
+    }
+    activeRuns++;
+    warm.running = true;
+    answerWaiting((entry) => entry.warm === warm);
+    const send = (message) => {
+      if (!socket.destroyed)
+        socket.write(JSON.stringify(message) + "\n");
+    };
+    send({ type: "started" });
+    const relayed = { stdout: 0, stderr: 0 };
+    let exiting;
+    let finished = false;
+    const finish = (code, signal) => {
+      if (finished)
+        return;
+      finished = true;
+      send({ type: "exit", code, signal });
+      socket.end();
+    };
+    const finishIfRelayed = () => {
+      if (exiting && relayed.stdout >= exiting.stdout && relayed.stderr >= exiting.stderr)
+        finish(exiting.code, null);
+    };
+    warm.exiting = (message) => {
+      exiting = message;
+      finishIfRelayed();
+    };
+    for (const name of ["stdout", "stderr"]) {
+      warm.child[name].on("data", (data) => {
+        send({ type: name, data: data.toString("base64") });
+        relayed[name] += data.length;
+        finishIfRelayed();
+      });
+    }
+    let buffer = "";
+    socket.on("data", (chunk) => {
+      buffer += chunk.toString();
+      let newline;
+      while ((newline = buffer.indexOf("\n")) !== -1) {
+        const message = JSON.parse(buffer.slice(0, newline));
+        buffer = buffer.slice(newline + 1);
+        if (message.type === "signal")
+          warm.child.kill(message.signal);
+      }
+    });
+    socket.on("close", () => {
+      if (warm.child.exitCode === null && warm.child.signalCode === null)
+        warm.child.kill("SIGINT");
+    });
+    warm.child.once("exit", (code, signal) => {
+      activeRuns--;
+      resetIdleTimer();
+      if (warm.child.stdout.readableEnded && warm.child.stderr.readableEnded)
+        finish(code, signal);
+      else
+        warm.child.once("close", () => finish(code, signal));
+      spawnWarm(lastRequest ?? request);
+    });
+    warm.child.send(request);
+  };
+  const listen = () => server.listen(socketFile, () => import_fs.default.chmodSync(socketFile, 384));
+  const server = import_net.default.createServer((socket) => {
+    let buffer = "";
+    const onData = (chunk) => {
+      buffer += chunk.toString();
+      const newline = buffer.indexOf("\n");
+      if (newline === -1)
+        return;
+      socket.off("data", onData);
+      const request = JSON.parse(buffer.slice(0, newline));
+      handle(socket, request).catch(() => socket.destroy());
+    };
+    socket.on("data", onData);
+    socket.on("error", () => {
+    });
+  });
+  server.on("error", (error) => {
+    if (error.code !== "EADDRINUSE")
+      process.exit(0);
+    const probe = import_net.default.connect(socketFile);
+    probe.on("connect", () => process.exit(0));
+    probe.on("error", () => {
+      try {
+        import_fs.default.unlinkSync(socketFile);
+      } catch {
+      }
+      listen();
+    });
+  });
+  listen();
+  resetIdleTimer();
+  process.on("SIGTERM", shutdown);
+  const parts = /* @__PURE__ */ new Map();
+  process.on("message", (message, handle2) => {
+    if (message?.method === "request") {
+      lastRequest = message.params;
+      startingRunKey = warmKey(message.params);
+    } else if (message?.method === kBrowserMessage && startingRunKey) {
+      const browser = collectBrowserPart(parts, message, handle2);
+      if (browser)
+        onBrowserReturned(startingRunKey, browser);
+    }
+  });
+  process.on("disconnect", () => {
+    for (const browser of parts.values())
+      killBrowser(browser);
+    parts.clear();
+    startingRunKey = void 0;
+    resetIdleTimer();
+    if (lastRequest)
+      spawnWarm(lastRequest);
+  });
+}
+function warmEnv(request) {
+  const env = { ...request.env };
+  const injected = [];
+  if (request.profile.stdout !== "false") {
+    for (const [key, value] of [["PLAYWRIGHT_FORCE_TTY", request.profile.stdout], ["FORCE_COLOR", "1"]]) {
+      if (env[key] === void 0) {
+        env[key] = value;
+        injected.push(key);
+      }
+    }
+  }
+  env.FLASHWRIGHT_SESSION_INJECTED = injected.join(",");
+  return env;
+}
+async function runWarmProcess(hooks) {
+  joinSession(process, true);
+  process.on("message", onSessionMessage);
+  hooks.installCodeCache("runner");
+  const program = hooks.loadProgram();
+  require(import_path.default.join(__dirname, "index.js"));
+  const packageRoot = import_path.default.join(__dirname, "..", "..");
+  require(import_path.default.join(packageRoot, "test.js"));
+  await import(import_url.default.pathToFileURL(import_path.default.join(packageRoot, "test.mjs")).href).catch(() => {
+  });
+  await import(import_url.default.pathToFileURL(import_path.default.join(import_path.default.dirname(process.argv[1]), "index.mjs")).href).catch(() => {
+  });
+  for (const key of (process.env.FLASHWRIGHT_SESSION_INJECTED || "").split(",").filter(Boolean))
+    delete process.env[key];
+  delete process.env.FLASHWRIGHT_SESSION_INJECTED;
+  delete process.env.FLASHWRIGHT_SESSION_ROLE;
+  hooks.prespawnWorkers(process.argv);
+  const request = await new Promise((resolve) => {
+    const onMessage = (message) => {
+      if (message?.type !== "run")
+        return;
+      process.off("message", onMessage);
+      resolve(message);
+    };
+    process.on("message", onMessage);
+    process.send({ type: "warm" });
+  });
+  process.channel?.unref();
+  process.chdir(request.cwd);
+  for (const key of Object.keys(process.env)) {
+    if (!(key in request.env) && key !== "FLASHWRIGHT_SESSION_HANDOFF")
+      delete process.env[key];
+  }
+  Object.assign(process.env, request.env);
+  process.argv = request.argv;
+  if (request.profile.stdout !== "false") {
+    const [columns, rows] = request.profile.stdout.split("x").map(Number);
+    Object.assign(process.stdout, { isTTY: true, columns, rows });
+  }
+  if (request.profile.stdinTTY)
+    Object.assign(process.stdin, { isTTY: true });
+  countOutputBytes();
+  hooks.retargetWorkers(request.argv);
+  program.parse(request.argv);
+}
+if (process.argv[2] === "--flashwright-session")
+  runSession(process.argv[3], process.argv[4]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  flushSessionBrowsers,
+  receiveWorkerMessage,
+  requestSessionBrowser,
+  runCli,
+  sessionStandbyEnv,
+  trackSessionWorker
+});

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

@@ -36,6 +36,7 @@ __export(workerStandby_exports, {
   prespawnWorkerForTestCommand: () => prespawnWorkerForTestCommand,
   recordWorkerCount: () => recordWorkerCount,
   recordWorkerRestart: () => recordWorkerRestart,
+  retargetStandbys: () => retargetStandbys,
   takeStandby: () => takeStandby,
   workerEntryScript: () => workerEntryScript,
   workerEnv: () => workerEnv
@@ -46,6 +47,7 @@ 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;
@@ -78,7 +80,8 @@ function prespawnWorkerForTestCommand(argv) {
   cpus = import_os.default.availableParallelism?.() ?? import_os.default.cpus().length;
   const hint = readWorkerCountHints()[hintKey];
   hadHint = !!hint;
-  const count = Math.max(1, Math.min(hint?.workers || 1, cpus));
+  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();
@@ -89,7 +92,7 @@ function prespawnWorkerForTestCommand(argv) {
 }
 function spawnStandby(waitsForNextPhase = false) {
   const entryScript = workerEntryScript();
-  const env = { ...workerEnv({}), PLAYWRIGHT_TEST: "1", FLASHWRIGHT_SPECULATIVE_BROWSER: waitsForNextPhase ? "next-phase" : "1" };
+  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,
@@ -97,6 +100,7 @@ function spawnStandby(waitsForNextPhase = false) {
   });
   child.on("error", () => {
   });
+  (0, import_session.requestSessionBrowser)(child);
   const ready = new Promise((resolve) => {
     const onMessage = (message) => {
       if (message?.method === "ready") {
@@ -128,6 +132,10 @@ 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);
 }
@@ -191,6 +199,7 @@ function writeWorkerCountHint() {
   prespawnWorkerForTestCommand,
   recordWorkerCount,
   recordWorkerRestart,
+  retargetStandbys,
   takeStandby,
   workerEntryScript,
   workerEnv

package/lib/runner/workerStandby.js.txt

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

package/lib/speculativeBrowser.js

@@ -28,9 +28,11 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 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);
@@ -41,11 +43,100 @@ 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 playwright = require("playwright-core");
-  const launch = playwright.chromium.launch(speculativeOptions).catch(() => void 0);
+  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;
@@ -100,6 +191,13 @@ function isPlainJSON(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)
@@ -121,8 +219,10 @@ async function takeSpeculativeBrowser(browserName, options) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  handBrowsersToSession,
   launchSpeculativeBrowser,
   prepareSpeculativeContext,
   rememberRecycledContext,
+  returnSpeculativeBrowser,
   takeSpeculativeBrowser
 });

package/lib/worker/workerProcessEntry.js

@@ -1865,11 +1865,100 @@ var import_path4 = __toESM(require("path"));
 var speculativeOptions = { handleSIGINT: false, headless: true, ...process.env.FLASHWRIGHT_ISOLATION === "strict" ? {} : { recycleContexts: true } };
 var speculativeKey = /* @__PURE__ */ Symbol.for("flashwright.speculativeBrowser");
 function launchSpeculativeBrowser() {
-  const playwright = require("playwright-core");
-  const launch = playwright.chromium.launch(speculativeOptions).catch(() => void 0);
+  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;
 }
+var kBrowserMessage = "__flashwright_browser__";
+var offerKey = /* @__PURE__ */ Symbol.for("flashwright.browserOffer");
+var offeredLastUsed = 0;
+var 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_fs4.default.rmSync(directory, { recursive: true, force: true, maxRetries: 5 });
+    } catch {
+    }
+  }
+}
 function prepareSpeculativeContext() {
   const launch = globalThis[speculativeKey];
   const hint = speculativeOptions.recycleContexts ? readContextHint() : void 0;
@@ -1894,6 +1983,13 @@ function readContextHint() {
   const key = process.env.FLASHWRIGHT_CONTEXT_HINT_KEY;
   return key ? readContextHints()[key] : void 0;
 }
+async function returnSpeculativeBrowser() {
+  const launch = globalThis[speculativeKey];
+  if (!launch || !process.env.FLASHWRIGHT_SESSION_HANDOFF)
+    return;
+  delete globalThis[speculativeKey];
+  await handBrowsersToSession(await launch, false);
+}
 
 // packages/playwright/src/worker/workerProcessEntry.ts
 var kSpareIdleTime = 100;
@@ -1901,6 +1997,10 @@ if (process.env.FLASHWRIGHT_SPECULATIVE_BROWSER) {
   let initialized = false;
   process.on("message", (message) => initialized ||= message?.method === "__init__");
   const idleTime = process.env.FLASHWRIGHT_SPECULATIVE_BROWSER === "next-phase" ? 0 : kSpareIdleTime;
+  process.on("message", (message) => {
+    if (message?.method === "__flashwright_return_browser__" && !initialized)
+      void returnSpeculativeBrowser().finally(() => process.send?.({ method: "__flashwright_browser_returned__" }));
+  });
   void launchSpeculativeBrowser().then(() => setTimeout(() => {
     if (initialized)
       return;

package/lib/worker/workerProcessEntry.js.txt

@@ -1,8 +1,8 @@
 # packages/playwright/lib/worker/workerProcessEntry.js
-# total: 76.4 KB
+# total: 79.7 KB
 
 ## Inlined (9)
-   1.4 KB  packages/playwright/src/speculativeBrowser.ts
+   4.6 KB  packages/playwright/src/speculativeBrowser.ts
    3.7 KB  packages/playwright/src/util.ts
    8.7 KB  packages/playwright/src/worker/fixtureRunner.ts
   21.3 KB  packages/playwright/src/worker/testInfo.ts
@@ -10,7 +10,7 @@
    5.4 KB  packages/playwright/src/worker/timeoutManager.ts
    0.3 KB  packages/playwright/src/worker/util.ts
   21.3 KB  packages/playwright/src/worker/workerMain.ts
-   0.7 KB  packages/playwright/src/worker/workerProcessEntry.ts
+   1.0 KB  packages/playwright/src/worker/workerProcessEntry.ts
 
 ## External (7)
   ../codeCache

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flashwright",
-  "version": "1.64.1-flashwright.1",
+  "version": "1.64.1-flashwright.2",
   "description": "Flashwright: a faster drop-in replacement for Playwright (fork of Playwright 1.64.1)",
   "repository": {
     "type": "git",
@@ -22,6 +22,7 @@
     "./lib/common": "./lib/common/index.js",
     "./lib/program": "./lib/program.js",
     "./lib/runner/workerStandby": "./lib/runner/workerStandby.js",
+    "./lib/runner/session": "./lib/runner/session.js",
     "./lib/codeCache": "./lib/codeCache.js",
     "./lib/runner": "./lib/runner/index.js",
     "./lib/transform/babelBundle": "./lib/transform/babelBundle.js",
@@ -47,7 +48,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "playwright-core": "npm:flashwright-core@1.64.1-flashwright.1"
+    "playwright-core": "npm:flashwright-core@1.64.1-flashwright.2"
   },
   "bugs": {
     "url": "https://github.com/xcodebeast/flashwright/issues"