@povio/lightning-panda 0.0.0-stage → 0.0.17

package/dist/index.js

@@ -0,0 +1,948 @@
+// src/index.ts
+import { spawn } from "node:child_process";
+import { createServer } from "node:net";
+
+// src/binary.ts
+import { statSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+function resolveBinary({
+  platform = process.platform,
+  arch = process.arch,
+  root = fileURLToPath(new URL("../", import.meta.url)),
+  env = process.env
+} = {}) {
+  if (env.LIGHTNINGPANDA_BIN)
+    return env.LIGHTNINGPANDA_BIN;
+  const bundled = join(root, "native", `${platform}-${arch}`, "lightningpanda");
+  if (statSync(bundled, { throwIfNoEntry: false })?.isFile())
+    return bundled;
+  const sibling = join(root, "..", "lightningpanda");
+  if (statSync(sibling, { throwIfNoEntry: false })?.isFile())
+    return sibling;
+  if (platform !== "darwin" || !["arm64", "x64"].includes(arch)) {
+    throw new Error(`Lightningpanda has no bundled browser for ${platform}-${arch}. The browser supports macOS 14+ on arm64 and x64. Use Lightningpanda.connect() for a remote browser, or set LIGHTNINGPANDA_BIN.`);
+  }
+  throw new Error(`Missing bundled browser: ${bundled}. Reinstall @povio/lightning-panda or set LIGHTNINGPANDA_BIN to a built browser.`);
+}
+
+// src/cdp.ts
+class CdpError extends Error {
+  method;
+  code;
+  data;
+  constructor(method, code, message, data) {
+    super(`${method}: ${message}`);
+    this.method = method;
+    this.code = code;
+    this.data = data;
+  }
+}
+
+class Cdp {
+  ws;
+  nextId = 1;
+  pending = new Map;
+  closed = null;
+  constructor(ws) {
+    this.ws = ws;
+    ws.addEventListener("message", (ev) => this.onMessage(String(ev.data)));
+    ws.addEventListener("close", () => this.fail(new Error("CDP connection closed")));
+    ws.addEventListener("error", () => this.fail(new Error("CDP connection failed")));
+  }
+  static open(url) {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(url);
+      ws.addEventListener("open", () => resolve(new Cdp(ws)), { once: true });
+      ws.addEventListener("error", () => reject(new Error(`cannot connect to ${url}`)), { once: true });
+    });
+  }
+  send(method, params = {}, sessionId) {
+    if (this.closed)
+      return Promise.reject(this.closed);
+    const id = this.nextId++;
+    const msg = { id, method, params };
+    if (sessionId)
+      msg.sessionId = sessionId;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { method, resolve, reject });
+      this.ws.send(JSON.stringify(msg));
+    });
+  }
+  post(method, params = {}, sessionId) {
+    this.send(method, params, sessionId).catch(() => {});
+  }
+  close() {
+    this.ws.close();
+  }
+  onMessage(text) {
+    const msg = JSON.parse(text);
+    if (typeof msg.id !== "number")
+      return;
+    const p = this.pending.get(msg.id);
+    if (!p)
+      return;
+    this.pending.delete(msg.id);
+    if (msg.error)
+      p.reject(new CdpError(p.method, msg.error.code, msg.error.message, msg.error.data));
+    else
+      p.resolve(msg.result);
+  }
+  fail(error) {
+    this.closed ??= error;
+    for (const p of this.pending.values())
+      p.reject(error);
+    this.pending.clear();
+  }
+}
+
+// src/steps.ts
+var pattern = (t) => {
+  if (typeof t === "string")
+    return t;
+  const flags = t.flags.replace(/[gyu]/g, "");
+  return flags ? { regex: t.source, flags } : { regex: t.source };
+};
+
+class Locator {
+  spec;
+  constructor(spec) {
+    this.spec = spec;
+  }
+  with(filter) {
+    if (this.spec.nth !== undefined)
+      throw new Error("filter before first() / last() / nth()");
+    return new Locator({ ...this.spec, filter: { ...this.spec.filter, ...filter } });
+  }
+  visible(visible = true) {
+    return this.with({ visible });
+  }
+  hasText(text) {
+    return this.with({ hasText: pattern(text) });
+  }
+  hasNotText(text) {
+    return this.with({ hasNotText: pattern(text) });
+  }
+  has(inner) {
+    return this.with({ has: inner.spec });
+  }
+  hasNot(inner) {
+    return this.with({ hasNot: inner.spec });
+  }
+  nth(index) {
+    return new Locator({ ...this.spec, nth: index });
+  }
+  first() {
+    return this.nth(0);
+  }
+  last() {
+    return this.nth(-1);
+  }
+  inner(spec) {
+    const { frame, ...within } = this.spec;
+    return new Locator({ ...spec, within, ...frame ? { frame } : {} });
+  }
+  locator(css) {
+    return this.inner({ css });
+  }
+  role(role, name, opts = {}) {
+    return this.inner(roleSpec(role, name, opts));
+  }
+  button(name, opts) {
+    return this.role("button", name, opts);
+  }
+  link(name, opts) {
+    return this.role("link", name, opts);
+  }
+  textbox(name, opts) {
+    return this.role("textbox", name, opts);
+  }
+  text(text, opts = {}) {
+    return this.inner(textSpec(text, opts));
+  }
+  label(text, opts = {}) {
+    return this.inner({ label: pattern(text), ...exact(opts) });
+  }
+  placeholder(text, opts = {}) {
+    return this.inner({ placeholder: pattern(text), ...exact(opts) });
+  }
+  testId(id) {
+    return this.inner({ testId: id });
+  }
+  frame() {
+    return new FrameScope(this);
+  }
+  inFrame(frame) {
+    return new Locator({ ...this.spec, frame: frame.spec });
+  }
+  click(opts = {}) {
+    return act(this, "click", undefined, opts);
+  }
+  dblclick(opts = {}) {
+    return act(this, "dblclick", undefined, opts);
+  }
+  hover(opts = {}) {
+    return act(this, "hover", undefined, opts);
+  }
+  fill(value, opts = {}) {
+    return act(this, "fill", value, opts);
+  }
+  type(text, opts = {}) {
+    return act(this, "type", text, opts);
+  }
+  press(key, opts = {}) {
+    return act(this, "press", key, opts);
+  }
+  check(opts = {}) {
+    return act(this, "check", undefined, opts);
+  }
+  uncheck(opts = {}) {
+    return act(this, "uncheck", undefined, opts);
+  }
+  focus() {
+    return act(this, "focus", undefined, { settle: false });
+  }
+  blur() {
+    return act(this, "blur", undefined, { settle: false });
+  }
+  upload(files, opts = {}) {
+    return typeof files === "string" ? act(this, "upload", files, opts) : act(this, "upload", undefined, { ...opts, files });
+  }
+  dropFiles(files, opts = {}) {
+    return typeof files === "string" ? act(this, "dropFiles", files, opts) : act(this, "dropFiles", undefined, { ...opts, files });
+  }
+  drag(to, opts = {}) {
+    return act(this, "drag", undefined, { ...opts, to: to.spec });
+  }
+  wheel(deltaX, deltaY, opts = {}) {
+    return act(this, "wheel", undefined, { ...opts, deltaX, deltaY });
+  }
+  matchScreenshot(name, opts = {}) {
+    return new ScreenshotStep(name, { ...opts, locator: this.spec }, callerDir());
+  }
+  read(as, what = "text", property) {
+    if (what === "css" && !property)
+      throw new Error("read(as, 'css', property) needs the property");
+    const body = { locator: this.spec, read: what, as, ...property === undefined ? {} : { property } };
+    return { toStep: () => ({ read: body }) };
+  }
+}
+
+class FrameScope {
+  frameLocator;
+  constructor(frameLocator) {
+    this.frameLocator = frameLocator;
+  }
+  locator(css) {
+    return css_(css).inFrame(this.frameLocator);
+  }
+  role(role, name, opts = {}) {
+    return new Locator(roleSpec(role, name, opts)).inFrame(this.frameLocator);
+  }
+  button(name, opts) {
+    return this.role("button", name, opts);
+  }
+  link(name, opts) {
+    return this.role("link", name, opts);
+  }
+  textbox(name, opts) {
+    return this.role("textbox", name, opts);
+  }
+  text(text, opts = {}) {
+    return new Locator(textSpec(text, opts)).inFrame(this.frameLocator);
+  }
+  label(text, opts = {}) {
+    return new Locator({ label: pattern(text), ...exact(opts) }).inFrame(this.frameLocator);
+  }
+  placeholder(text, opts = {}) {
+    return new Locator({ placeholder: pattern(text), ...exact(opts) }).inFrame(this.frameLocator);
+  }
+  testId(id) {
+    return new Locator({ testId: id }).inFrame(this.frameLocator);
+  }
+  frame(inner) {
+    return inner.inFrame(this.frameLocator).frame();
+  }
+}
+var exact = (opts) => opts.exact ? { exact: true } : {};
+var roleSpec = (role, name, opts) => ({
+  role,
+  ...name === undefined ? {} : { name: pattern(name) },
+  ...exact(opts)
+});
+var textSpec = (text, opts) => ({ text: pattern(text), ...exact(opts) });
+function act(loc, action, value, opts) {
+  return { toStep: () => ({ act: { locator: loc.spec, action, ...value === undefined ? {} : { value }, ...opts } }) };
+}
+var css_ = (selector) => new Locator({ css: selector });
+var css = css_;
+var testId = (id, attribute) => new Locator(attribute ? { testId: id, testIdAttribute: attribute } : { testId: id });
+var text = (t, opts = {}) => new Locator(textSpec(t, opts));
+var label = (t, opts = {}) => new Locator({ label: pattern(t), ...exact(opts) });
+var placeholder = (t, opts = {}) => new Locator({ placeholder: pattern(t), ...exact(opts) });
+var role = (r, name, opts = {}) => new Locator(roleSpec(r, name, opts));
+var button = (name, opts) => role("button", name, opts);
+var link = (name, opts) => role("link", name, opts);
+var dialog = (name, opts) => role("dialog", name, opts);
+var heading = (name, opts) => role("heading", name, opts);
+var textbox = (name, opts) => role("textbox", name, opts);
+var checkbox = (name, opts) => role("checkbox", name, opts);
+var combobox = (name, opts) => role("combobox", name, opts);
+var option = (name, opts) => role("option", name, opts);
+var row = (name, opts) => role("row", name, opts);
+var cell = (name, opts) => role("cell", name, opts);
+var tab = (name, opts) => role("tab", name, opts);
+var menuitem = (name, opts) => role("menuitem", name, opts);
+var inFrame = (frame) => frame.frame();
+
+class Check {
+  loc;
+  negate;
+  constructor(loc, negate = false) {
+    this.loc = loc;
+    this.negate = negate;
+  }
+  get not() {
+    return new Check(this.loc, !this.negate);
+  }
+  step(assert, expected, opts = {}, extra = {}) {
+    const body = {
+      locator: this.loc.spec,
+      assert,
+      ...expected === undefined ? {} : { expected },
+      ...this.negate ? { not: true } : {},
+      ...extra,
+      ...opts
+    };
+    return { toStep: () => ({ check: body }) };
+  }
+  visible(opts) {
+    return this.step("visible", undefined, opts);
+  }
+  hidden(opts) {
+    return this.step("hidden", undefined, opts);
+  }
+  text(expected, opts) {
+    return this.step("text", expected, opts);
+  }
+  containsText(expected, opts) {
+    return this.step("containsText", expected, opts);
+  }
+  value(expected, opts) {
+    return this.step("value", expected, opts);
+  }
+  count(expected, opts) {
+    return this.step("count", expected, opts);
+  }
+  checked(expected = true, opts) {
+    return this.step("checked", expected, opts);
+  }
+  css(property, expected, opts) {
+    return this.step("css", expected, opts, { property });
+  }
+  focused(expected = true, opts) {
+    return this.step("focused", expected, opts);
+  }
+  name(expected, opts) {
+    return this.step("name", expected, opts);
+  }
+  enabled(expected = true, opts) {
+    return this.step("enabled", expected, opts);
+  }
+  disabled(opts) {
+    return this.step("enabled", false, opts);
+  }
+}
+
+class RequestCheck {
+  m;
+  constructor(m) {
+    this.m = m;
+  }
+  status(status) {
+    return new RequestCheck({ ...this.m, status });
+  }
+  count(count) {
+    return new RequestCheck({ ...this.m, count });
+  }
+  body(body) {
+    return new RequestCheck({ ...this.m, body: pattern(body) });
+  }
+  bodyKeys(keys) {
+    return new RequestCheck({ ...this.m, bodyKeys: keys });
+  }
+  headers(headers) {
+    const wire = Object.fromEntries(Object.entries(headers).map(([k, v]) => [k, pattern(v)]));
+    return new RequestCheck({ ...this.m, headers: wire });
+  }
+  state(state) {
+    return new RequestCheck({ ...this.m, state });
+  }
+  scope(scope) {
+    return new RequestCheck({ ...this.m, scope });
+  }
+  timeout(timeout) {
+    return new RequestCheck({ ...this.m, timeout });
+  }
+  toStep() {
+    return { request: this.m };
+  }
+}
+var check = Object.assign((loc) => new Check(loc), {
+  request: (method, path) => new RequestCheck(typeof path === "string" ? { method, path } : { method, url: pattern(path) })
+});
+var goto = (url, waitUntil = "load") => ({
+  toStep: () => ({ goto: { url, waitUntil } })
+});
+var route = (url, opts = {}) => ({ toStep: () => ({ route: { url, ...opts } }) });
+var evaluate = (expression, as, opts = {}) => ({
+  toStep: () => ({ eval: { expression, ...as ? { as } : {}, ...opts } })
+});
+var loaded = (opts = {}) => ({ toStep: () => ({ loaded: opts }) });
+var idle = (opts = {}) => ({
+  toStep: () => ({ idle: opts.timeout === undefined ? {} : { timeout: opts.timeout } })
+});
+var reload = (opts = {}) => ({ toStep: () => ({ reload: opts }) });
+var waitForUrl = (url, opts = {}) => ({
+  toStep: () => ({ url: { url: pattern(url), ...opts } })
+});
+var mock = (url, opts = {}) => ({
+  toStep: () => ({ mock: { url: pattern(url), ...opts } })
+});
+var unmock = (url) => ({
+  toStep: () => ({ unmock: url === undefined ? {} : { url: pattern(url) } })
+});
+var release = (hold) => ({ toStep: () => ({ release: { hold } }) });
+var viewport = (width, height) => ({
+  toStep: () => ({ viewport: { width, height } })
+});
+var media = (opts) => ({ toStep: () => ({ media: opts }) });
+var downloadCount = (as) => ({
+  toStep: () => ({ downloadCount: { as } })
+});
+var download = (opts = {}) => ({
+  toStep: () => ({ download: opts })
+});
+var switchTo = (target) => ({ toStep: () => ({ page: { target } }) });
+var popup = (as, opts = {}) => ({
+  toStep: () => ({ popup: { ...as ? { as } : {}, ...opts } })
+});
+var mouse = (action, opts = {}) => ({
+  toStep: () => ({ mouse: { action, ...opts } })
+});
+var wheel = (loc, deltaX, deltaY, opts = {}) => loc.wheel(deltaX, deltaY, opts);
+
+class ScreenshotStep {
+  name;
+  opts;
+  testDir;
+  wire = {};
+  constructor(name, opts, testDir) {
+    this.name = name;
+    this.opts = opts;
+    this.testDir = testDir;
+    if (!/^[\w.@-][\w.@/-]*$/.test(name) || name.includes("..")) {
+      throw new Error(`screenshot name '${name}': use letters, digits, '.', '-', '_', '@' and '/'`);
+    }
+  }
+  toStep() {
+    const { dir: _dir, ...opts } = this.opts;
+    return { matchScreenshot: { name: this.name, ...opts, ...this.wire } };
+  }
+}
+var matchScreenshot = (name, opts = {}) => new ScreenshotStep(name, opts, callerDir());
+function callerDir() {
+  const here = import.meta.url.replace(/^file:\/\//, "").replace(/[^/]*$/, "");
+  for (const line of (new Error().stack ?? "").split(`
+`).slice(1)) {
+    const m = /(?:\(|at )(?:file:\/\/)?(\/[^():]+):\d+:\d+\)?\s*$/.exec(line);
+    if (m && !m[1].startsWith(here))
+      return m[1].replace(/\/[^/]*$/, "");
+  }
+  return process.cwd();
+}
+
+// src/screenshots.ts
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+var updateMode = () => ["1", "true", "all"].includes(process.env.LP_UPDATE_SNAPSHOTS ?? "") || process.argv.includes("--update-snapshots") || process.argv.includes("-u");
+
+class ScreenshotMismatchError extends Error {
+  result;
+  constructor(message, result) {
+    super(message);
+    this.result = result;
+  }
+}
+var paths = (step) => {
+  const base = join2(step.opts.dir ?? join2(step.testDir, "__screenshots__"), step.name);
+  return { png: `${base}.png`, meta: `${base}.json`, actual: `${base}.actual.png`, diff: `${base}.diff.png` };
+};
+function prepare(step, sent) {
+  const p = paths(step);
+  step.wire = {};
+  if (updateMode() || !existsSync(p.png)) {
+    step.wire = { update: true };
+    return;
+  }
+  const png = readFileSync(p.png);
+  const digest = createHash("sha1").update(png).digest("hex");
+  const key = `${p.png}`;
+  step.wire.name = key;
+  if (sent.get(key) !== digest) {
+    step.wire.baseline = png.toString("base64");
+    try {
+      const meta = JSON.parse(readFileSync(p.meta, "utf8"));
+      if (meta.sceneHash)
+        step.wire.sceneHash = meta.sceneHash;
+    } catch {}
+    sent.set(key, digest);
+  }
+}
+var toResult = (step, r) => ({
+  name: step.name,
+  pass: r.pass,
+  hashHit: r.hashHit,
+  recorded: r.recorded,
+  diffPixels: r.diffPixels,
+  sceneHash: r.sceneHash,
+  width: r.width,
+  height: r.height,
+  ms: r.ms
+});
+function settle(step, r) {
+  const p = paths(step);
+  const result = toResult(step, r);
+  rmSync(p.actual, { force: true });
+  rmSync(p.diff, { force: true });
+  if (r.recorded) {
+    const existed = existsSync(p.png);
+    mkdirSync(dirname(p.png), { recursive: true });
+    writeFileSync(p.png, Buffer.from(r.actual, "base64"));
+    writeFileSync(p.meta, JSON.stringify({ sceneHash: r.sceneHash, width: r.width, height: r.height }, null, 2) + `
+`);
+    result.files = { baseline: p.png };
+    if (!updateMode()) {
+      const what = existed ? "was replaced" : "did not exist";
+      throw new ScreenshotMismatchError(`screenshot '${step.name}': the baseline ${what}; wrote ${p.png}`, result);
+    }
+  }
+  return result;
+}
+function mismatch(step, data, message) {
+  const p = paths(step);
+  const result = toResult(step, data);
+  mkdirSync(dirname(p.actual), { recursive: true });
+  writeFileSync(p.actual, Buffer.from(data.actual, "base64"));
+  writeFileSync(p.diff, Buffer.from(data.diff, "base64"));
+  result.files = { baseline: p.png, actual: p.actual, diff: p.diff };
+  return new ScreenshotMismatchError(`${message}
+  actual: ${p.actual}
+  diff:   ${p.diff}`, result);
+}
+
+// src/index.ts
+class RunError extends Error {
+  step;
+  constructor(message, step) {
+    super(message);
+    this.step = step;
+  }
+}
+var storageScript = (entries) => `(() => { try { const s = window.localStorage; for (const [k, v] of Object.entries(${JSON.stringify(entries)})) s.setItem(k, v); } catch {} })();`;
+
+class Lightningpanda {
+  wsUrl;
+  conns;
+  child;
+  profiles = new Map;
+  profileMutation = Promise.resolve();
+  turn = 0;
+  fork = false;
+  stats = { prepared: 0, preparedBooting: 0, fresh: 0 };
+  constructor(wsUrl, conns, child) {
+    this.wsUrl = wsUrl;
+    this.conns = conns;
+    this.child = child;
+  }
+  async detect() {
+    try {
+      const { fork } = await this.cdp.send("Lightningpanda.capabilities");
+      this.fork = fork === true;
+    } catch (e) {
+      if (!(e instanceof CdpError))
+        throw e;
+    }
+    return this;
+  }
+  get cdp() {
+    return this.conns[0].cdp;
+  }
+  static async connect(wsUrl, opts = {}) {
+    return new Lightningpanda(wsUrl, await openConns(wsUrl, opts)).detect();
+  }
+  static async launch(opts = {}) {
+    const port = await freePort();
+    const child = spawn(opts.bin ?? resolveBinary(), ["serve", "--host", "127.0.0.1", "--port", String(port), ...opts.args ?? []], {
+      stdio: ["ignore", "ignore", "inherit"],
+      detached: process.platform !== "win32"
+    });
+    let spawnError;
+    child.once("error", (error) => {
+      spawnError = error;
+    });
+    const deadline = Date.now() + 15000;
+    for (;; ) {
+      try {
+        const r = await fetch(`http://127.0.0.1:${port}/json/version`);
+        const v = await r.json();
+        const url = v.webSocketDebuggerUrl ?? `ws://127.0.0.1:${port}/`;
+        return await new Lightningpanda(url, await openConns(url, opts), child).detect();
+      } catch (e) {
+        if (spawnError || child.exitCode !== null || child.signalCode !== null || Date.now() > deadline) {
+          stopLaunchedBrowser(child);
+          throw new Error(`lightningpanda serve did not start: ${spawnError ?? e}`);
+        }
+        await new Promise((r) => setTimeout(r, 5));
+      }
+    }
+  }
+  updateProfiles(change) {
+    const result = this.profileMutation.then(change);
+    this.profileMutation = result.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return result;
+  }
+  async profile(name, profile) {
+    return this.updateProfiles(async () => {
+      const base = profile.base === undefined ? undefined : this.profiles.get(profile.base)?.ids?.[0];
+      if (profile.base !== undefined && base === undefined)
+        throw new Error(`no prepared profile ${profile.base} to start from`);
+      const scripts = [...profile.localStorage ? [storageScript(profile.localStorage)] : [], ...profile.initScripts ?? []];
+      if (profile.prepare === false) {
+        this.profiles.set(name, { ids: null, profile, scripts });
+        return;
+      }
+      const conns = this.fork ? this.conns.slice(0, 1) : this.conns;
+      const ids = await Promise.all(conns.map(async (c) => {
+        const { profileId } = await c.cdp.send("Lightningpanda.registerPreparedPage", {
+          url: profile.url,
+          initScripts: scripts,
+          ...profile.viewport ? { viewport: profile.viewport } : {},
+          pool: profile.pool ?? 2,
+          ...profile.setup?.length ? { setup: profile.setup.map((s) => s.toStep()) } : {},
+          ...base !== undefined ? { base } : {}
+        });
+        return profileId;
+      }));
+      this.profiles.set(name, { ids, profile, scripts });
+    });
+  }
+  async releaseProfile(name) {
+    return this.updateProfiles(async () => {
+      const entry = this.profiles.get(name);
+      if (!entry)
+        return;
+      if (entry.ids) {
+        const conns = this.fork ? this.conns.slice(0, 1) : this.conns;
+        await Promise.all(conns.map(async (conn, i) => {
+          const profileId = entry.ids[i];
+          const shared = [...this.profiles].some(([alias, other]) => alias !== name && other.ids?.[i] === profileId);
+          if (!shared)
+            await conn.cdp.send("Lightningpanda.unregisterPreparedPage", { profileId });
+        }));
+      }
+      this.profiles.delete(name);
+    });
+  }
+  async warm(name, timeoutMs = 5000) {
+    const entry = this.profiles.get(name);
+    if (!entry?.ids)
+      return;
+    const deadline = Date.now() + timeoutMs;
+    if (this.fork) {
+      for (;; ) {
+        const cdp = await Cdp.open(this.forkUrl(entry.ids[0]));
+        const { pages } = await cdp.send("Lightningpanda.preparedPages").finally(() => cdp.close());
+        if (pages.some((p) => p.profileId === entry.ids[0] && p.ready))
+          return;
+        if (Date.now() > deadline)
+          throw new Error(`no booted page for ${name} after ${timeoutMs} ms`);
+        await new Promise((r) => setTimeout(r, 10));
+      }
+    }
+    await Promise.all(this.conns.map(async (c, i) => {
+      for (;; ) {
+        const { pages } = await c.cdp.send("Lightningpanda.preparedPages");
+        const ready = pages.filter((p) => p.profileId === entry.ids[i] && p.ready);
+        if (ready.length >= (entry.profile.pool ?? 2))
+          return;
+        if (Date.now() > deadline)
+          throw new Error(`no booted page for ${name} after ${timeoutMs} ms`);
+        await new Promise((r) => setTimeout(r, 2));
+      }
+    }));
+  }
+  pick() {
+    const n = this.conns.length;
+    let best = this.turn % n;
+    for (let k = 1;k < n; k++) {
+      const i = (this.turn + k) % n;
+      if (this.conns[i].open < this.conns[best].open)
+        best = i;
+    }
+    this.turn = best + 1;
+    return best;
+  }
+  async page(opts = {}) {
+    const entry = opts.as === undefined ? undefined : this.profiles.get(opts.as);
+    if (opts.as !== undefined && !entry)
+      throw new Error(`no profile ${opts.as}: declare it with lp.profile()`);
+    if (!this.fork) {
+      const index = this.pick();
+      return this.openPage(this.conns[index], index, entry, opts);
+    }
+    const conn = { cdp: await Cdp.open(this.forkUrl(entry?.ids?.[0])), open: 0, baselines: new Map, own: true };
+    try {
+      return await this.openPage(conn, 0, entry, opts);
+    } catch (e) {
+      conn.cdp.close();
+      throw e;
+    }
+  }
+  async openPage(conn, index, entry, opts) {
+    const first = [];
+    let page;
+    const extra = opts.initScripts ?? [];
+    if (entry?.ids && extra.length === 0) {
+      try {
+        const r = await conn.cdp.send("Lightningpanda.acquirePreparedPage", { profileId: entry.ids[index], attach: true });
+        page = new Page(conn, r.sessionId, r.targetId, r.browserContextId);
+        this.stats.prepared++;
+        if (!r.ready) {
+          this.stats.preparedBooting++;
+          first.push(loaded());
+        }
+      } catch (e) {
+        if (!(e instanceof CdpError) || e.code !== -32602)
+          throw e;
+      }
+    }
+    if (!page) {
+      page = await freshPage(conn, entry, extra);
+      this.stats.fresh++;
+      if (entry && !opts.url)
+        first.push(goto(entry.profile.url));
+    }
+    if (opts.url)
+      first.push(goto(opts.url));
+    if (opts.route)
+      first.push(route(opts.route));
+    page.prefix = first;
+    return page;
+  }
+  forkUrl(profileId) {
+    if (profileId === undefined)
+      return this.wsUrl;
+    const url = new URL(this.wsUrl);
+    url.searchParams.set("profile", String(profileId));
+    return url.toString();
+  }
+  close() {
+    for (const c of this.conns)
+      c.cdp.close();
+    if (this.child) {
+      const child = this.child;
+      this.child = undefined;
+      stopLaunchedBrowser(child);
+    }
+  }
+}
+function stopLaunchedBrowser(child) {
+  if (process.platform === "win32" || !child.pid) {
+    child.kill();
+    return;
+  }
+  try {
+    process.kill(-child.pid, "SIGTERM");
+  } catch (error) {
+    if (error.code !== "ESRCH")
+      throw error;
+  }
+}
+async function openConns(wsUrl, opts) {
+  const n = Math.max(1, opts.connections ?? 1);
+  const cdps = await Promise.all(Array.from({ length: n }, () => Cdp.open(wsUrl)));
+  return cdps.map((cdp) => ({ cdp, open: 0, baselines: new Map }));
+}
+async function freshPage(conn, entry, extra = []) {
+  const cdp = conn.cdp;
+  const { browserContextId } = await cdp.send("Target.createBrowserContext");
+  const { targetId } = await cdp.send("Target.createTarget", { url: "about:blank", browserContextId });
+  const { sessionId } = await cdp.send("Target.attachToTarget", { targetId, flatten: true });
+  for (const source of [...entry?.scripts ?? [], ...extra]) {
+    await cdp.send("Page.addScriptToEvaluateOnNewDocument", { source }, sessionId);
+  }
+  const v = entry?.profile.viewport;
+  if (v)
+    await cdp.send("Emulation.setDeviceMetricsOverride", { ...v, deviceScaleFactor: 1, mobile: false }, sessionId);
+  return new Page(conn, sessionId, targetId, browserContextId);
+}
+
+class Page {
+  conn;
+  sessionId;
+  targetId;
+  browserContextId;
+  prefix = [];
+  closed = false;
+  constructor(conn, sessionId, targetId, browserContextId) {
+    this.conn = conn;
+    this.sessionId = sessionId;
+    this.targetId = targetId;
+    this.browserContextId = browserContextId;
+    conn.open++;
+  }
+  get cdp() {
+    return this.conn.cdp;
+  }
+  async run(steps2, opts = {}) {
+    const prefix = this.prefix;
+    this.prefix = [];
+    const all = [...prefix, ...steps2];
+    for (const s of all)
+      if (s instanceof ScreenshotStep)
+        prepare(s, this.conn.baselines);
+    const wire = all.map((s) => s.toStep());
+    let r;
+    try {
+      r = await this.cdp.send("LP.run", { steps: wire, ...opts }, this.sessionId);
+    } catch (e) {
+      const m = e instanceof CdpError ? /step (\d+)/.exec(e.message) : null;
+      if (!m)
+        throw e;
+      const index = Number(m[1]) - prefix.length;
+      const where = index < 0 ? `opening the page (${prefix[Number(m[1])] && JSON.stringify(prefix[Number(m[1])].toStep())})` : `step ${index}`;
+      const message = e.message.replace(/^LP\.run: step \d+/, where);
+      const failed = all[Number(m[1])];
+      const data = e.data;
+      if (failed instanceof ScreenshotStep && data?.diff) {
+        throw mismatch(failed, data, message);
+      }
+      for (const s of all)
+        if (s instanceof ScreenshotStep)
+          this.conn.baselines.delete(String(s.wire.name ?? ""));
+      throw new RunError(message, index);
+    }
+    const screenshots = {};
+    all.forEach((s, i) => {
+      if (s instanceof ScreenshotStep)
+        screenshots[s.name] = settle(s, r.results[i]);
+    });
+    return { values: r.reads, screenshots, results: r.results.slice(prefix.length), requests: r.requests, ms: r.ms };
+  }
+  async matchScreenshot(name, opts = {}) {
+    const step = matchScreenshot(name, opts);
+    const r = await this.run([step]);
+    return r.screenshots[step.name];
+  }
+  async addInitScript(source) {
+    await this.cdp.send("Page.addScriptToEvaluateOnNewDocument", { source }, this.sessionId);
+  }
+  send(method, params = {}) {
+    return this.cdp.send(method, params, this.sessionId);
+  }
+  close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    this.conn.open--;
+    if (this.conn.own) {
+      this.cdp.close();
+      return;
+    }
+    this.cdp.post("Target.closeTarget", { targetId: this.targetId });
+    this.cdp.post("Target.disposeBrowserContext", { browserContextId: this.browserContextId });
+  }
+  async[Symbol.asyncDispose]() {
+    this.close();
+  }
+}
+function freePort() {
+  return new Promise((resolve, reject) => {
+    const s = createServer();
+    s.listen(0, "127.0.0.1", () => {
+      const port = s.address().port;
+      s.close(() => resolve(port));
+    });
+    s.on("error", reject);
+  });
+}
+var screenshotMatchers = {
+  async toMatchScreenshot(page, name, opts = {}) {
+    try {
+      const r = await page.matchScreenshot(name, opts);
+      return { pass: true, message: () => `expected screenshot '${name}' not to match (${r.diffPixels} pixels differ)` };
+    } catch (e) {
+      if (e instanceof ScreenshotMismatchError)
+        return { pass: false, message: () => e.message };
+      throw e;
+    }
+  }
+};
+export {
+  Cdp,
+  CdpError,
+  FrameScope,
+  Lightningpanda,
+  Locator,
+  Page,
+  RunError,
+  ScreenshotMismatchError,
+  ScreenshotStep,
+  button,
+  cell,
+  check,
+  checkbox,
+  combobox,
+  css,
+  dialog,
+  download,
+  downloadCount,
+  evaluate,
+  goto,
+  heading,
+  idle,
+  inFrame,
+  label,
+  link,
+  loaded,
+  matchScreenshot,
+  media,
+  menuitem,
+  mock,
+  mouse,
+  option,
+  placeholder,
+  popup,
+  release,
+  reload,
+  role,
+  route,
+  row,
+  screenshotMatchers,
+  switchTo,
+  tab,
+  testId,
+  text,
+  textbox,
+  unmock,
+  updateMode,
+  viewport,
+  waitForUrl,
+  wheel
+};