@cevek/screentest 0.4.0 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -14560,9 +14560,24 @@ var projectInfoSchema = external_exports.object({
14560
14560
  /** Current git branch, or `null` if not a git repo (or `git` not on PATH). */
14561
14561
  branch: external_exports.string().nullable()
14562
14562
  });
14563
+ var rendererSchema = external_exports.object({
14564
+ fingerprint: external_exports.string().min(1),
14565
+ label: external_exports.string()
14566
+ });
14563
14567
  var docSchema = external_exports.object({
14564
14568
  /** Optional for backward compatibility with pre-0.3 doc.json files. */
14565
14569
  project: projectInfoSchema.optional(),
14570
+ /**
14571
+ * `current` shot this run's actuals; `baseline` is what snapshot.json
14572
+ * records for its hashes (null when it records none). `mismatch`: the
14573
+ * renderers differ AND the diffs look like it (see generateDoc). Optional
14574
+ * for pre-0.5 doc.json files.
14575
+ */
14576
+ renderer: external_exports.object({
14577
+ current: rendererSchema,
14578
+ baseline: rendererSchema.nullable(),
14579
+ mismatch: external_exports.boolean()
14580
+ }).optional(),
14566
14581
  groups: external_exports.array(groupItemSchema)
14567
14582
  });
14568
14583
  var snapshotTestSchema = external_exports.object({
@@ -14576,6 +14591,7 @@ var snapshotGroupSchema = external_exports.lazy(
14576
14591
  })
14577
14592
  );
14578
14593
  var snapshotDocSchema = external_exports.object({
14594
+ renderer: rendererSchema.optional(),
14579
14595
  groups: external_exports.array(snapshotGroupSchema)
14580
14596
  });
14581
14597
  var apiDocResponseSchema = external_exports.object({
@@ -14859,6 +14875,9 @@ async function withFileLock(absPath, fn) {
14859
14875
  function isSnapshotGroup(x) {
14860
14876
  return Array.isArray(x.items);
14861
14877
  }
14878
+ function hasAnyHash(items) {
14879
+ return items.some((n) => isSnapshotGroup(n) ? hasAnyHash(n.items) : n.hash !== null);
14880
+ }
14862
14881
  function upsertHash(doc, path, hash2) {
14863
14882
  if (path.length === 0) throw new Error("Empty path for upsertHash");
14864
14883
  const testName = path[path.length - 1];
@@ -14950,7 +14969,9 @@ async function patchSnapshot(args) {
14950
14969
  throw err;
14951
14970
  }
14952
14971
  }
14972
+ const fresh = !doc.renderer && !hasAnyHash(doc.groups);
14953
14973
  upsertHash(doc, args.path, args.hash);
14974
+ if (args.renderer && fresh) doc = { renderer: args.renderer, groups: doc.groups };
14954
14975
  await atomicWriteJson(abs, doc);
14955
14976
  });
14956
14977
  }
@@ -14990,7 +15011,8 @@ function acceptRoute(state) {
14990
15011
  docDir: state.docDir,
14991
15012
  patchSnapshotJsonFile: entry.item.patchSnapshotJsonFile,
14992
15013
  path: [...entry.parents, entry.name],
14993
- hash: hash2
15014
+ hash: hash2,
15015
+ renderer: state.doc.renderer?.current
14994
15016
  });
14995
15017
  res.json({
14996
15018
  hash: hash2,
@@ -15256,6 +15278,27 @@ function detectBranch(projectRoot) {
15256
15278
  const branch = r.stdout.trim();
15257
15279
  return branch || null;
15258
15280
  }
15281
+ async function readRunRenderer(runFile) {
15282
+ try {
15283
+ const run3 = JSON.parse(await fs4.readFile(runFile, "utf8"));
15284
+ const parsed = rendererSchema.safeParse(run3.renderer);
15285
+ return parsed.success ? parsed.data : null;
15286
+ } catch {
15287
+ return null;
15288
+ }
15289
+ }
15290
+ function baselineRenderer(snap) {
15291
+ const parsed = rendererSchema.safeParse(snap.renderer);
15292
+ return parsed.success ? parsed.data : null;
15293
+ }
15294
+ async function writeSnapshotRenderer(snapshotFile, renderer) {
15295
+ const raw = JSON.parse(await fs4.readFile(snapshotFile, "utf8"));
15296
+ const { renderer: _old, ...rest } = raw;
15297
+ await fs4.writeFile(snapshotFile, JSON.stringify({ renderer, ...rest }, null, 2) + "\n");
15298
+ }
15299
+ function describeRenderer(r) {
15300
+ return `${r.label} [${r.fingerprint}]`;
15301
+ }
15259
15302
  function isGroup(node) {
15260
15303
  return Array.isArray(node.items);
15261
15304
  }
@@ -15319,8 +15362,9 @@ function countLeaves(doc) {
15319
15362
  for (const g of doc.groups) walk(g.items);
15320
15363
  return n;
15321
15364
  }
15322
- async function generateDoc(projectRoot, snapshotFile, actualDir, docFile, cacheDir, opts = {}) {
15323
- const detectDeletions = opts.detectDeletions ?? true;
15365
+ async function generateDoc(paths, opts = {}) {
15366
+ const { projectRoot, snapshotFile, actualDir, docFile, cacheDir } = paths;
15367
+ const fullRun = opts.fullRun ?? true;
15324
15368
  const snap = await readSnapshot(snapshotFile);
15325
15369
  const expectedByPath = indexSnapshot(snap);
15326
15370
  const actuals = await walkActual(actualDir);
@@ -15358,7 +15402,7 @@ async function generateDoc(projectRoot, snapshotFile, actualDir, docFile, cacheD
15358
15402
  });
15359
15403
  summary.change++;
15360
15404
  }
15361
- if (detectDeletions) {
15405
+ if (fullRun) {
15362
15406
  for (const [key, hash2] of expectedByPath) {
15363
15407
  if (seen.has(key) || !hash2) continue;
15364
15408
  insertLeaf(doc, key.split("/"), {
@@ -15369,13 +15413,47 @@ async function generateDoc(projectRoot, snapshotFile, actualDir, docFile, cacheD
15369
15413
  summary.deleted++;
15370
15414
  }
15371
15415
  }
15416
+ const current = await readRunRenderer(paths.runFile);
15417
+ let baseline = baselineRenderer(snap);
15418
+ const allMatched = fullRun && summary.change === 0 && summary.unchanged > 0;
15419
+ if (current && allMatched && baseline?.fingerprint !== current.fingerprint && !process.env.CI) {
15420
+ await writeSnapshotRenderer(snapshotFile, current);
15421
+ process.stdout.write(
15422
+ `[screentest] recorded renderer ${describeRenderer(current)} in ${relative(projectRoot, snapshotFile)}` + (baseline ? ` (was ${describeRenderer(baseline)})` : "") + ` \u2014 every screenshot matched under it. Commit it with the baselines.
15423
+ `
15424
+ );
15425
+ baseline = current;
15426
+ }
15427
+ const mismatch = !!current && !!baseline && baseline.fingerprint !== current.fingerprint && summary.change > 0 && summary.change >= summary.unchanged;
15428
+ if (current) doc.renderer = { current, baseline, mismatch };
15372
15429
  await fs4.mkdir(cacheDir, { recursive: true });
15373
15430
  await fs4.writeFile(docFile, JSON.stringify(doc, null, 2));
15374
15431
  const total = countLeaves(doc);
15375
- const deletedSummary = detectDeletions ? `deleted: ${summary.deleted}, ` : "";
15432
+ if (mismatch && current && baseline) {
15433
+ process.stderr.write(
15434
+ `
15435
+ [screentest] RENDERER CHANGED \u2014 the diffs below are likely not app changes.
15436
+ [screentest] baselines: ${describeRenderer(baseline)}
15437
+ [screentest] this run: ${describeRenderer(current)}
15438
+ [screentest] Re-run with the baseline renderer, or accept everything to
15439
+ [screentest] move the baselines to this one.
15440
+
15441
+ `
15442
+ );
15443
+ } else if (current && !baseline && summary.change > 0 && summary.unchanged === 0) {
15444
+ process.stderr.write(
15445
+ `
15446
+ [screentest] Every screenshot changed, and ${relative(projectRoot, snapshotFile)}
15447
+ [screentest] records no renderer to compare with. Make sure this run used
15448
+ [screentest] the same renderer as the baselines before accepting.
15449
+
15450
+ `
15451
+ );
15452
+ }
15453
+ const deletedSummary = fullRun ? `deleted: ${summary.deleted}, ` : "";
15376
15454
  process.stdout.write(
15377
15455
  `Wrote ${docFile}
15378
- ${total} diff${total === 1 ? "" : "s"} to review (new: ${summary.new}, change: ${summary.change}, ${deletedSummary}unchanged: ${summary.unchanged}${detectDeletions ? "" : "; deletion detection disabled \u2014 subset run"})
15456
+ ${total} diff${total === 1 ? "" : "s"} to review (new: ${summary.new}, change: ${summary.change}, ${deletedSummary}unchanged: ${summary.unchanged}${fullRun ? "" : "; deletion detection disabled \u2014 subset run"})
15379
15457
  `
15380
15458
  );
15381
15459
  return total;
@@ -15392,7 +15470,8 @@ function resolveRunnerPaths(cwd = process.cwd()) {
15392
15470
  snapshotFile: resolveSnapshotFile(projectRoot),
15393
15471
  cacheDir,
15394
15472
  actualDir: join4(cacheDir, "actual"),
15395
- docFile: join4(cacheDir, "doc.json")
15473
+ docFile: join4(cacheDir, "doc.json"),
15474
+ runFile: join4(cacheDir, "run.json")
15396
15475
  };
15397
15476
  }
15398
15477
  function resolveSnapshotFile(projectRoot) {
@@ -15415,13 +15494,7 @@ function run(cmd, argv) {
15415
15494
  }
15416
15495
  async function runReview() {
15417
15496
  const paths = resolveRunnerPaths();
15418
- const total = await generateDoc(
15419
- paths.projectRoot,
15420
- paths.snapshotFile,
15421
- paths.actualDir,
15422
- paths.docFile,
15423
- paths.cacheDir
15424
- );
15497
+ const total = await generateDoc(paths);
15425
15498
  if (total === 0) {
15426
15499
  process.stdout.write("Nothing to review \u2014 all snapshots match.\n");
15427
15500
  return 0;
@@ -15477,9 +15550,9 @@ Tip: add a script to package.json so you can just \`npm run screentest\`:
15477
15550
  // src/daemon.ts
15478
15551
  import { spawn as spawn2, spawnSync as spawnSync2 } from "child_process";
15479
15552
  import { existsSync as existsSync4 } from "fs";
15553
+ import { request } from "http";
15480
15554
  import { dirname as dirname6, resolve as resolve8 } from "path";
15481
15555
  import { fileURLToPath as fileURLToPath4 } from "url";
15482
- import { createConnection } from "net";
15483
15556
  var IMAGE_NAME = "cevek/screentest-firefox";
15484
15557
  var IMAGE_TAG = "pw-1.60.0";
15485
15558
  var FULL_IMAGE = `${IMAGE_NAME}:${IMAGE_TAG}`;
@@ -15487,23 +15560,27 @@ var CONTAINER_NAME = "screentest-firefox";
15487
15560
  var PORT = 5180;
15488
15561
  var WS_PATH = "screentest-firefox";
15489
15562
  var WS_ENDPOINT = `ws://localhost:${PORT}/${WS_PATH}`;
15563
+ var START_TIMEOUT_MS = 3e4;
15490
15564
  function run2(cmd, argv) {
15491
15565
  return new Promise((resolveExit) => {
15492
15566
  const p = spawn2(cmd, argv, { stdio: "inherit" });
15567
+ p.on("error", () => resolveExit(127));
15493
15568
  p.on("exit", (code) => resolveExit(code ?? 0));
15494
15569
  });
15495
15570
  }
15496
15571
  function daemonState() {
15497
15572
  const ps = spawnSync2(
15498
15573
  "docker",
15499
- ["ps", "-a", "-f", `name=^${CONTAINER_NAME}$`, "--format", "{{.Status}} {{.Image}}"],
15574
+ ["ps", "-a", "-f", `name=^${CONTAINER_NAME}$`, "--format", "{{.State}} {{.Image}}"],
15500
15575
  { stdio: "pipe", encoding: "utf8" }
15501
15576
  );
15502
- const line = ps.stdout.trim();
15503
- if (line.startsWith("Up")) {
15504
- const tab = line.indexOf(" ");
15505
- const image = tab === -1 ? "" : line.slice(tab + 1).trim();
15506
- return { state: "running", image };
15577
+ if (ps.error) return { state: "no-docker", reason: ps.error.message };
15578
+ if (ps.status !== 0) return { state: "no-docker", reason: ps.stderr.trim() };
15579
+ const [status = "", image = ""] = ps.stdout.trim().split(" ");
15580
+ if (status === "running") return { state: "running", image: image.trim() };
15581
+ if (status === "paused") return { state: "paused" };
15582
+ if (status === "created" || status === "restarting" || status === "removing") {
15583
+ return { state: "transitional", status };
15507
15584
  }
15508
15585
  const img = spawnSync2("docker", ["image", "inspect", FULL_IMAGE], { stdio: "pipe" });
15509
15586
  if (img.status !== 0) return { state: "missing-image" };
@@ -15540,75 +15617,115 @@ async function buildImage() {
15540
15617
  }
15541
15618
  return true;
15542
15619
  }
15543
- function probePort() {
15620
+ function probeServer() {
15544
15621
  return new Promise((resolveProbe) => {
15545
- const s = createConnection({ host: "127.0.0.1", port: PORT });
15546
- s.once("connect", () => {
15547
- s.end();
15622
+ const req = request({ host: "127.0.0.1", port: PORT, path: `/${WS_PATH}`, timeout: 1e3 });
15623
+ req.once("response", (res) => {
15624
+ res.resume();
15548
15625
  resolveProbe(true);
15549
15626
  });
15550
- s.once("error", () => resolveProbe(false));
15627
+ req.once("timeout", () => req.destroy());
15628
+ req.once("error", () => resolveProbe(false));
15629
+ req.end();
15551
15630
  });
15552
15631
  }
15553
15632
  async function waitForReady(timeoutMs = 1e4) {
15554
15633
  const start = Date.now();
15555
15634
  while (Date.now() - start < timeoutMs) {
15556
- if (await probePort()) return true;
15557
- await new Promise((r) => setTimeout(r, 150));
15635
+ if (await probeServer()) return true;
15636
+ await sleep(150);
15558
15637
  }
15559
15638
  return false;
15560
15639
  }
15561
- async function startDaemon() {
15562
- const s = daemonState();
15563
- if (s.state === "running") {
15564
- if (s.image !== FULL_IMAGE) {
15565
- process.stderr.write(
15566
- `screentest-firefox daemon is running, but on a different image:
15640
+ function sleep(ms) {
15641
+ return new Promise((r) => setTimeout(r, ms));
15642
+ }
15643
+ function assertUsable(s) {
15644
+ if (s.state === "no-docker") {
15645
+ throw new Error(
15646
+ `docker is not available \u2014 screentest renders only in the pinned Firefox
15647
+ container (${FULL_IMAGE}). Start Docker, then re-run.
15648
+ docker said: ${s.reason}
15649
+ `
15650
+ );
15651
+ }
15652
+ if (s.state === "paused") {
15653
+ throw new Error(`screentest-firefox daemon is paused.
15654
+ \u2192 docker unpause ${CONTAINER_NAME}
15655
+ `);
15656
+ }
15657
+ if (s.state === "running" && s.image !== FULL_IMAGE) {
15658
+ throw new Error(
15659
+ `screentest-firefox daemon is running, but on a different image:
15567
15660
  running: ${s.image}
15568
15661
  this @cevek/screentest wants: ${FULL_IMAGE}
15569
15662
  \u2192 stop it first: screentest stop
15570
15663
  \u2192 then re-run: screentest serve
15664
+ `
15665
+ );
15666
+ }
15667
+ }
15668
+ function startContainer() {
15669
+ spawnSync2("docker", ["rm", CONTAINER_NAME], { stdio: "pipe" });
15670
+ const r = spawnSync2(
15671
+ "docker",
15672
+ ["run", "-d", "--rm", "--name", CONTAINER_NAME, "--network=host", FULL_IMAGE],
15673
+ { stdio: "pipe", encoding: "utf8" }
15674
+ );
15675
+ return { ok: !r.error && r.status === 0, stderr: r.stderr?.trim() ?? String(r.error) };
15676
+ }
15677
+ async function ensureDaemon() {
15678
+ const deadline = Date.now() + START_TIMEOUT_MS;
15679
+ let started = false;
15680
+ let lastError = "";
15681
+ for (; ; ) {
15682
+ const s = daemonState();
15683
+ assertUsable(s);
15684
+ if (s.state === "running") {
15685
+ if (await waitForReady()) return { started };
15686
+ spawnSync2("docker", ["logs", CONTAINER_NAME], { stdio: "inherit" });
15687
+ throw new Error(
15688
+ `screentest-firefox daemon container is up but never answered on port ${PORT}.
15571
15689
  `
15572
15690
  );
15573
- return 1;
15574
15691
  }
15575
- process.stdout.write(`screentest-firefox daemon already running at ${WS_ENDPOINT}
15576
- `);
15577
- return 0;
15578
- }
15579
- if (s.state === "missing-image") {
15580
- if (!await buildImage()) return 1;
15581
- }
15582
- spawnSync2("docker", ["rm", "-f", CONTAINER_NAME], { stdio: "pipe" });
15583
- process.stderr.write(`Starting screentest-firefox daemon (port ${PORT})\u2026
15692
+ if (Date.now() > deadline) {
15693
+ throw new Error(
15694
+ `screentest-firefox daemon did not come up within ${START_TIMEOUT_MS / 1e3}s` + (s.state === "transitional" ? ` (container stuck in "${s.status}")` : "") + (lastError ? `:
15695
+ ${lastError}` : "") + `
15696
+ `
15697
+ );
15698
+ }
15699
+ if (s.state === "missing-image" && !await buildImage()) {
15700
+ throw new Error(`could not build ${FULL_IMAGE}
15584
15701
  `);
15585
- const code = await run2("docker", [
15586
- "run",
15587
- "-d",
15588
- "--rm",
15589
- "--name",
15590
- CONTAINER_NAME,
15591
- "--network=host",
15592
- FULL_IMAGE
15593
- ]);
15594
- if (code !== 0) {
15595
- process.stderr.write(`docker run failed (exit ${code})
15702
+ }
15703
+ if (s.state === "stopped" || s.state === "missing-image") {
15704
+ if (!started) process.stderr.write(`Starting screentest-firefox daemon (port ${PORT})\u2026
15596
15705
  `);
15597
- return code;
15706
+ const r = startContainer();
15707
+ if (r.ok) started = true;
15708
+ else lastError = r.stderr;
15709
+ }
15710
+ await sleep(300);
15598
15711
  }
15599
- if (!await waitForReady()) {
15600
- process.stderr.write(`Daemon container started but port ${PORT} never opened. Logs:
15601
- `);
15602
- spawnSync2("docker", ["logs", CONTAINER_NAME], { stdio: "inherit" });
15712
+ }
15713
+ async function startDaemon() {
15714
+ try {
15715
+ const { started } = await ensureDaemon();
15716
+ process.stdout.write(
15717
+ `screentest-firefox daemon ${started ? "ready" : "already running"} at ${WS_ENDPOINT}
15718
+ `
15719
+ );
15720
+ return 0;
15721
+ } catch (err) {
15722
+ process.stderr.write(err instanceof Error ? err.message : String(err));
15603
15723
  return 1;
15604
15724
  }
15605
- process.stdout.write(`screentest-firefox daemon ready at ${WS_ENDPOINT}
15606
- `);
15607
- return 0;
15608
15725
  }
15609
15726
  async function stopDaemon() {
15610
15727
  const s = daemonState();
15611
- if (s.state !== "running") {
15728
+ if (s.state !== "running" && s.state !== "paused") {
15612
15729
  process.stdout.write("screentest-firefox daemon is not running\n");
15613
15730
  return 0;
15614
15731
  }
@@ -15618,6 +15735,26 @@ async function stopDaemon() {
15618
15735
  }
15619
15736
  async function printStatus() {
15620
15737
  const s = daemonState();
15738
+ if (s.state === "no-docker") {
15739
+ process.stdout.write(
15740
+ `screentest-firefox daemon: unknown (docker is not available: ${s.reason})
15741
+ `
15742
+ );
15743
+ return 1;
15744
+ }
15745
+ if (s.state === "paused") {
15746
+ process.stdout.write(
15747
+ `screentest-firefox daemon: paused
15748
+ \u2192 docker unpause ${CONTAINER_NAME}
15749
+ `
15750
+ );
15751
+ return 0;
15752
+ }
15753
+ if (s.state === "transitional") {
15754
+ process.stdout.write(`screentest-firefox daemon: ${s.status}
15755
+ `);
15756
+ return 0;
15757
+ }
15621
15758
  if (s.state === "running") {
15622
15759
  const match = s.image === FULL_IMAGE ? "(matches this @cevek/screentest)" : "(MISMATCH!)";
15623
15760
  process.stdout.write(
@@ -15640,14 +15777,14 @@ async function printStatus() {
15640
15777
  if (s.state === "stopped") {
15641
15778
  process.stdout.write(
15642
15779
  `screentest-firefox daemon: stopped (image ${FULL_IMAGE} exists)
15643
- start it with: screentest serve
15780
+ starts automatically on the next test run, or now with: screentest serve
15644
15781
  `
15645
15782
  );
15646
15783
  return 0;
15647
15784
  }
15648
15785
  process.stdout.write(
15649
15786
  `screentest-firefox daemon: not installed (image ${FULL_IMAGE} missing)
15650
- build + start with: screentest serve
15787
+ built + started automatically on the next test run, or now with: screentest serve
15651
15788
  `
15652
15789
  );
15653
15790
  return 0;
@@ -15940,7 +16077,8 @@ function printHelp() {
15940
16077
  "",
15941
16078
  " screentest serve start the shared Firefox browser-server daemon",
15942
16079
  " (builds the image on first run). One daemon per",
15943
- " machine \u2014 used by every project",
16080
+ " machine \u2014 used by every project. Test runs start",
16081
+ " it on their own; `serve` just does it up front",
15944
16082
  " screentest stop stop the daemon",
15945
16083
  " screentest status show whether the daemon is running",
15946
16084
  "",
@@ -15963,8 +16101,8 @@ function printHelp() {
15963
16101
  "Running screenshot tests:",
15964
16102
  " Add to your package.json scripts (or run directly):",
15965
16103
  ' "screentest": "vitest run --config vitest.screentest.config.ts"',
15966
- " The vitest globalSetup we ship handles pre-flight (wipe actualDir, locate",
15967
- " the daemon) and post-flight (build doc.json, auto-launch the review UI",
16104
+ " The vitest globalSetup we ship handles pre-flight (wipe actualDir, start",
16105
+ " the daemon if needed) and post-flight (build doc.json, auto-launch the review UI",
15968
16106
  " if there are diffs).",
15969
16107
  "",
15970
16108
  "Env vars (UI mode):",
package/dist/runner.js CHANGED
@@ -14,7 +14,8 @@ function resolveRunnerPaths(cwd = process.cwd()) {
14
14
  snapshotFile: resolveSnapshotFile(projectRoot),
15
15
  cacheDir,
16
16
  actualDir: join(cacheDir, "actual"),
17
- docFile: join(cacheDir, "doc.json")
17
+ docFile: join(cacheDir, "doc.json"),
18
+ runFile: join(cacheDir, "run.json")
18
19
  };
19
20
  }
20
21
  function resolveSnapshotFile(projectRoot) {
@@ -198,15 +199,19 @@ async function compareSnapshot(target, name, opts = {}) {
198
199
  // src/runner/browser.ts
199
200
  import { inject } from "vitest";
200
201
  import { firefox } from "playwright";
202
+
203
+ // src/runner/context-defaults.ts
204
+ var CONTEXT_DEFAULTS = {
205
+ viewport: { width: 1280, height: 800 },
206
+ deviceScaleFactor: 1,
207
+ reducedMotion: "reduce"
208
+ };
209
+
210
+ // src/runner/browser.ts
201
211
  async function newPage(opts = {}) {
202
212
  const wsEndpoint = inject("wsEndpoint");
203
213
  const browser = await firefox.connect(wsEndpoint);
204
- const ctx = await browser.newContext({
205
- viewport: { width: 1280, height: 800 },
206
- deviceScaleFactor: 1,
207
- reducedMotion: "reduce",
208
- ...opts
209
- });
214
+ const ctx = await browser.newContext({ ...CONTEXT_DEFAULTS, ...opts });
210
215
  const page = await ctx.newPage();
211
216
  return {
212
217
  ctx,