flashwright 1.64.1-flashwright.1 → 1.64.1-flashwright.3

package/lib/runner/session.js

@@ -0,0 +1,748 @@
+"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,
+  isWarmSessionRun: () => isWarmSessionRun,
+  receiveWorkerMessage: () => receiveWorkerMessage,
+  requestSessionBrowser: () => requestSessionBrowser,
+  runCli: () => runCli,
+  sessionStandbyEnv: () => sessionStandbyEnv,
+  trackDetachedTeardown: () => trackDetachedTeardown,
+  trackSessionWorker: () => trackSessionWorker
+});
+module.exports = __toCommonJS(session_exports);
+var import_fs = __toESM(require("fs"));
+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 || debuggerAttached() || process.platform === "win32")
+    return false;
+  const value = process.env.FLASHWRIGHT_SESSION;
+  if (value)
+    return value !== "0" && value !== "false";
+  return !process.env.CI;
+}
+function debuggerAttached() {
+  if (!process.execArgv.length && !process.env.NODE_OPTIONS)
+    return false;
+  return !!require("inspector").url();
+}
+function childProcess() {
+  return require("child_process");
+}
+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));
+  const coreBundle = import_path.default.join(__dirname, "..", "..", "..", "playwright-core", "lib", "coreBundle.js");
+  try {
+    files.push(import_fs.default.existsSync(coreBundle) ? coreBundle : 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 require("crypto").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 = fnv1a64([import_path.default.join(__dirname, ".."), process.execPath, cwd].join("\0"));
+  const socketFile = import_path.default.join(directory, `${id}.sock`);
+  return Buffer.byteLength(socketFile) < 100 ? socketFile : void 0;
+}
+function fnv1a64(text) {
+  let hash = 0xcbf29ce484222325n;
+  for (const byte of Buffer.from(text))
+    hash = BigInt.asUintN(64, (hash ^ BigInt(byte)) * 0x100000001b3n);
+  return hash.toString(16).padStart(16, "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 = childProcess().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));
+}
+function isWarmSessionRun() {
+  return !!outputBytes;
+}
+var detachedTeardowns = /* @__PURE__ */ new Set();
+function trackDetachedTeardown(exited) {
+  detachedTeardowns.add(exited);
+  void exited.finally(() => detachedTeardowns.delete(exited));
+}
+async function flushSessionBrowsers(exitCode) {
+  if (!sessionChannel)
+    return;
+  if (outputBytes && exitCode !== void 0 && sessionChannel.connected)
+    await new Promise((resolve) => sessionChannel.send({ type: "exiting", code: exitCode, ...outputBytes }, void 0, resolve));
+  await Promise.all([...sessionStandbys].map(returnStandbyBrowser));
+  const deadline = Date.now() + 2e3;
+  while ((sessionWorkers.size || detachedTeardowns.size) && Date.now() < deadline)
+    await Promise.race([...detachedTeardowns, new Promise((resolve) => setTimeout(resolve, 5))]);
+  await Promise.all(pendingSends);
+  for (const parts of workerParts.values())
+    killBrowser(parts);
+  workerParts.clear();
+  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 = childProcess().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();
+      spawnWarm(lastRequest ?? request);
+    };
+    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 (!finished && 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));
+    });
+    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();
+  globalThis[/* @__PURE__ */ Symbol.for("flashwright.codeCache")]?.refreshAtExit();
+  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,
+  isWarmSessionRun,
+  receiveWorkerMessage,
+  requestSessionBrowser,
+  runCli,
+  sessionStandbyEnv,
+  trackDetachedTeardown,
+  trackSessionWorker
+});