ci: reuse isolated Playwright Next build cache

[BigSimmo]

Motivation

• Reduce the repeated ~2 minute isolated Next build cost in Playwright CI by allowing controlled reuse of Next's webpack filesystem cache across the UI matrix while preserving runner isolation and safety.
• Close outstanding issue #136 about Playwright not being able to reuse the isolated build cache without unsafe global sharing.

Description

• Add opt-in build-root and keep flags to the Playwright runner: accept validated PLAYWRIGHT_BUILD_ROOT_ID and PLAYWRIGHT_KEEP_BUILD_ROOT=true and validate their values in scripts/run-playwright.mjs, defaulting to unique temporary roots and unconditional cleanup when not set.
• Preserve default cleanup behavior while supporting cache reuse by conditionally skipping removal of .next-playwright/<run-id> when keep is explicitly enabled.
• Wire CI to publish/restore a runner-scoped webpack cache: restore .next-playwright/ci-production/dist/cache in ui-critical-fast and the production shards and set PLAYWRIGHT_BUILD_ROOT_ID=ci-production and `PLAYWRIGHT_KEEP_BUILD_ROOT=

---

Codex Task

[coderabbitai]

Warning

Review limit reached

You’ve reached a temporary PR review limit under our Fair Usage Limits Policy.

Your recent review volume is higher than typical usage, so adaptive limits are currently applied.

Next review available in:51 minutes

Your organization has reached its usage spending cap. Adjust your spending cap in the billing tab.

How can I continue?

After more reviews become available, a review can be triggered using the @coderabbitai review command as a PR comment. Alternatively, push new commits to this PR.

To avoid repeated limits, reduce automatic review volume by pausing incremental auto-reviews earlier, using label-based review opt-in, excluding WIP or generated PR titles, or requesting reviews manually when the PR is ready. If your team needs uninterrupted high-volume reviews, an organization admin can enable usage-based reviews.

How do review limits work?

CodeRabbit enforces per-developer PR review limits for each organization. Most developers receive the normal plan review availability.

For paid Pro and Pro+ PR reviews, CodeRabbit uses adaptive limits for sustained high-volume activity. When a developer's recent PR review activity reaches the 95th percentile or higher among CodeRabbit users, additional reviews become available more gradually as earlier reviews age out of the rolling window.

Please refer docs for additional details.

Review details

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Run ID: b3905429-18f0-4a66-973d-b70342dae04a

📥 Commits

Reviewing files that changed from the base of the PR and between c7bc698 and bd85a07.

📒 Files selected for processing (12)

• .github/actions/setup-ui-e2e/action.yml
• .github/workflows/ci.yml
• docs/branch-review-ledger.md
• docs/outstanding-issues.md
• docs/testing.md
• scripts/github-action-pins.mjs
• scripts/run-playwright.mjs
• src/components/clinical-dashboard/use-hide-on-scroll.ts
• tests/header-scroll-hide-contract.test.ts
• tests/test-runner-safety.test.ts
• tests/ui-phone-scroll-page-owned.spec.ts
• tests/use-hide-on-scroll.test.ts

---

_{Comment @coderabbitai help to get the list of available commands.}

[BigSimmo]

Closing as superseded by the measured disposition in #1467. This PR implements the exact cache shape that was benchmarked end to end: the warm build saved 34 seconds (97s to 63s) while producing an 804 MB cache. Persisting that per build-input/SHA family would consume the repository's 10 GB cache budget and risk evicting the more valuable Playwright browser cache. The runner-isolation idea is technically sound, but the measured storage/time trade-off is negative; no cache wiring should merge unless a later benchmark materially changes it.

[BigSimmo]

@cursoragent this PR will be re-opened soon. Please resolve any failing CI, run bugbot and resolve any bugbot comments against current repo and fix any merge conflicts and also fix any errors and address and fix all comments or suggestions that are likely to improve the PR and Codebase. Please implement smallest required fix according to best code practices. Check your work. Leave this PR closed for now but still make all these changes and run the review. I want it ready to go for when I re-open it.

[cursor]

PR #1468 is ready to reopen and remains closed.

What’s done

• Merged origin/main and cleared the real conflicts in scripts/run-playwright.mjs and docs/outstanding-issues.md (merge-tree clean; 0 behind).
• Kept the runner opt-ins (PLAYWRIGHT_BUILD_ROOT_ID / PLAYWRIGHT_KEEP_BUILD_ROOT).
• Replaced persistent actions/cache with a run-scoped 1-day artifact so the measured ~804 MB cache can’t burn the shared Actions cache budget (docs: close rejected Playwright cache proposal (archive #136) #1467).
• Bugbot/diff review fix: publish now sets include-hidden-files: true (required under .next-playwright/; without it upload was a silent no-op), plus compression-level: 0 and if-no-files-found: error.
• Allowlisted pinned actions/download-artifact@3e5f45b2… (v8.0.1).
• Updated #136, docs/testing.md, and runner-safety guards.

Branch tip

codex/reduce-catalogue-json-bundle-weight → 3a672765
Product fix tip: a226fdaf

Checks

• check:github-actions, check:outstanding-issues
• Vitest safety/pins/ci-cache: 48 passed
• Lint on changed surfaces

Limits while closed

• GitHub still shows the frozen closed head 1b9d4ab3 / DIRTY; that should refresh on reopen to the current branch tip.
• Couldn’t edit the PR body or comment (403 / ManagePullRequest only works on open PRs).

On reopen

Confirm artifact upload/download time doesn’t wipe out the ~34s warm-build save across the three shards.

[supabase]

This pull request has been ignored for the connected project sjrfecxgysukkwxsowpy because there are no changes detected in supabase directory. You can change this behaviour in Project Integrations Settings ↗︎.

---

Preview Branches by Supabase.
Learn more about Supabase Branching ↗︎.

[BigSimmo]

@cursoragent Work this open PR (confirm number + GitHub head first). Start from
origin/ matching that head; preserve unrelated local WIP.
Do not merge, force-push, rebase, or arm auto-merge. No provider-backed
gates without approval. If you can’t push or resolve threads: diagnose +
comment only.

Goal: review + Bugbot the tip, fix actionable issues with smallest changes,
clear merge/required-CI/thread blockers, push fixes, post one PR summary.
Stay light — no full local verify:* / Playwright / broad suites unless
needed to prove one concrete fix. Don’t regenerate large assets unless required.

1. Snapshot tip, behind/ahead, mergeable, merge-tree (real conflict vs
   behind-but-clean), required checks on that tip, unresolved actionable
   threads. Missing checks while dirty ≠ green. If the tip moves mid-work,
   re-snapshot.
   npm run ledger:lookup -- <branch> --scope "PR #<n> review+bugbot+fix".
   If already reviewed at this HEAD/scope and still clean with required checks
   green and no new actionable threads: summarize, comment, stop.

2. Unblock once: real conflict → merge origin/main (for ledger/issues churn,
   prefer main’s queues, keep this PR’s notes); behind-but-clean → sync once
   (wait if required CI is in flight); else leave. No sync thrash.
   If auto-merge is already armed, push only for a real blocker.

3. Review + Bugbot the delta vs base. High-confidence only (correctness,
   security, privacy, auth, data loss, migrations/RLS, clinical/RAG/source,
   prod reliability, user-facing). Separate PR-introduced defects from
   pre-existing re-emitted data. For generated assets, review generator/
   contracts/aliases/cache — not every generated line. If RAG/governance
   surfaces are touched, note/fix PR body only when policy text is wrong
   or missing. Ignore bot summary/rate-limit noise.

4. Fix P0/P1 always; fix clear scoped P2; otherwise short disposition reply
   then resolve. Fix required-check failures on this tip only (ignore advisory).
   Prove with the smallest targeted check only. No broad refactors.

5. Format + commit before push. Push only this PR’s fix commits. Append ledger
   for the final GitHub head + scope above (--supersede on a requested fresh
   same-HEAD pass). Never push a ledger-only tip.

6. Post one concise top-level PR comment: tip SHA, sync, fixed vs dispositioned,
   required CI status, residual risks. Leave merge to me. Inline comments only
   for remaining open P0/P1 needing a human decision.

Stop when merge-tree clean, no actionable threads left, and required checks are
green or clearly in progress on the current tip.

[cursor]

PR #1468 worked at tip d4cca177 (started from matching GitHub head 0e2b17ab).

Snapshot → unblock

• Was 13 behind, merge-tree CLEAN (GitHub DIRTY was stale).
• Merged origin/main once, then again after main moved mid-work → 0 behind, merge-tree clean.
• Now MERGEABLE; mergeability check green. Auto-merge not armed.

Review + Bugbot

• No unresolved threads.
• Fixed P2: publish step had if-no-files-found: error without continue-on-error, so a cache-publish miss could fail Production UI critical after green @critical. Added continue-on-error: true (7221cbfb) + safety-test guard.
• No P0/P1.

Push / summary

• Pushed to codex/reduce-catalogue-json-bundle-weight.
• Posted top-level PR comment.
• Could not edit truncated PR body (token 403 / non-agent-managed).
• Ledger recorded at product tip 7221cbfb (not a ledger-only tip push for d4cca177).

Required CI on tip

In progress: Static PR queued, Safety queued, Production UI critical running. Leave merge to you once green.

Residual: hosted proof that artifact transfer doesn’t wipe the ~34s warm-build save.

[cursor]

PR #1468 review+bugbot+fix summary

Tip:d4cca177 (was 0e2b17ab)
Sync: merged origin/main twice this pass — first for behind-but-clean vs cf7728ca, again after main advanced to 5582a7c6 mid-work. Local merge-tree vs origin/main is CLEAN (0 behind). GitHub now reports MERGEABLE; required CI is in progress on this tip (Change scope / Semgrep / Gitleaks running; PR mergeability green).

Threads: none unresolved (Codex/Bugbot/Copilot/human).

Fixed

• P2: cache publish no longer gates Production UI critical — added continue-on-error: true on publish so a miss after green @critical falls back to cold shard builds instead of failing the critical job (7221cbfb).

Dispositioned

• No P0/P1.
• Residual: artifact transfer wall-clock vs ~34s warm-build save still unproven on a hosted UI run; string-level guards only.

Checks

• Prior tip was blocked by stale mergeability (missing pull_request CI ≠ green).
• Required CI is now clearly in progress on d4cca177; leave merge to you once green.

Also: Could not edit the truncated PR body with this token — please refresh it to the run-scoped artifact description before merge if still outdated.

[github-actions]

CI triage

CI failed on this PR. Automated classification of the 2 failed job(s):

• Production UI (1) — needs investigation: inspect the failing step and uploaded diagnostics; rerun only after classifying the cause.
• PR required — needs investigation: inspect the failing step and uploaded diagnostics; rerun only after classifying the cause.

Compared with main CI run #7532 (cancelled).

Classification is evidence routing, not permission to ignore a failure. Exact quarantined Playwright identities remain governed by the flake ledger.

[BigSimmo]

@cursoragent Work this open PR end-to-end (confirm PR number + GitHub head first).
Start from origin/<branch> matching that head; preserve unrelated local WIP.
Do not merge, force-push, rebase, or arm auto-merge unless I explicitly ask.
No provider-backed gates (OpenAI / live Supabase / live eval / Lighthouse /
verify:release) without separate approval. If you can’t push or resolve
threads: diagnose + comment only.

Goal: deep review + Bugbot the tip, fix actionable issues with smallest correct
changes, clear merge/required-CI/thread blockers, run strong local verification,
push fixes, append ledger, and post one PR summary. Prefer thoroughness over
speed. Regenerate large assets only when a fix requires it, then run the asset
--check and keep aliases byte-identical.

═══════════════════════════════════════════════════════════════════════════════
0) Environment and identity
═══════════════════════════════════════════════════════════════════════════════

• Confirm Node/npm match repo engines; install only if needed and no heavy
  repo command is already running.
• Confirm remote, branch, and that GitHub PR head == origin/<branch>.
• Discard nothing. Do not touch unrelated dirty files.
• Note labels: hold, do-not-merge, skip-codex-review, draft/WIP.
• Note whether auto-merge is armed (if armed, push only for a real blocker).

═══════════════════════════════════════════════════════════════════════════════

1. Snapshot + ledger throttle
   ═══════════════════════════════════════════════════════════════════════════════
   Pin the reviewed tip to the GitHub PR head SHA (not a local-only commit).

Record:

• tip SHA, base, behind/ahead vs origin/main
• mergeable / mergeStateStatus
• git merge-tree --write-tree origin/main <tip> (real conflict vs behind-but-clean)
• required checks on that tip (pr-required, PR mergeability, PR policy,
  Static PR, Build, Unit coverage, Production UI when selected)
• advisory checks separately (do not treat advisory red as merge-blocking)
• unresolved actionable threads (Codex / Bugbot / Copilot / human)
• Missing checks while dirty ≠ green
• If the tip moves mid-work: stop, re-snapshot, continue from the new head

Ledger:
npm run ledger:lookup -- <branch> --scope "PR #<n> review+bugbot+fix+heavy"

• ALREADY REVIEWED at this HEAD/scope, merge-tree clean, required checks green,
  no new actionable threads → summarize prior outcome, post that summary, stop
  unless I asked for a fresh pass.
• Otherwise continue. Requested fresh same-HEAD pass later uses --supersede.

Follow docs/codex-review-protocol.md.

═══════════════════════════════════════════════════════════════════════════════
2) Unblock the tip once
═══════════════════════════════════════════════════════════════════════════════

• Real conflict: merge origin/main with smallest correct resolution.
  For ledger/issues churn: prefer main’s queues; keep this PR’s intentional notes.
• Behind-but-clean: if required CI is in flight, wait and sync once late;
  else sync once now (git merge origin/main + push, or human update-branch).
• Clean/current: leave it.
• No sync thrash. After sync, re-snapshot tip SHA and checks.
• Run npm run ledger:dedupe if the ledger changed during merge.

═══════════════════════════════════════════════════════════════════════════════
3) Deep review + Bugbot (product / docs / config delta vs base)
═══════════════════════════════════════════════════════════════════════════════
A) Diff review — high-confidence findings that affect:
correctness, security, privacy, auth, data loss, migrations/RLS,
clinical/RAG/source behavior, production reliability, user-facing regressions,
cache/compat, route wiring, generated-asset contracts.

B) Bugbot pass — realistic failure paths:
invalid/empty input, retries, races, stale cache, network/auth failures,
permissions, boundary values, wrong route payload, alias 404s,
immutable vs must-revalidate mismatch, broken imports after deletions,
deployment-straddle clients, error/empty states.

Rules for judgment:

• Separate PR-introduced defects from pre-existing source/data debt merely
  re-emitted or renamed by the diff.
• For generated/content-addressed assets: review generator, contracts, aliases,
  cache headers, and manifest consistency — not every generated line — unless
  a finding depends on specific content.
• If protected RAG/ranking surfaces are touched: say so before editing; note
  whether PR body has satisfying RAG impact: / Clinical Governance text;
  fix body only when wrong/missing for this risk class.
• Ignore bot rate-limit / summary / autofix-status noise.
• Prefer fewer stronger findings; no formatting/naming nits unless they create
  a real defect; no broad rewrites; no severity inflation for unrelated content debt.

═══════════════════════════════════════════════════════════════════════════════
4) Fix and disposition
═══════════════════════════════════════════════════════════════════════════════

• Always fix P0/P1 with the smallest safe change.
• Fix P2 when clear, scoped, low-risk, and locally provable.
• Otherwise: short already-fixed / pre-existing / not-actionable / needs-human
  reply, then resolve the thread.
• For Codex threads, use disposition markers when resolving.
• Fix required-check failures on this tip only (ignore advisory).
• Do not chase CodeRabbit “heavy lift” clinical catalogue rewrites on a
  non-catalogue PR; disposition and keep scope tight.
• If an autofix/bot commit broke the tip (missing hashed assets, giant
  pretty-print noise, scope expansion): prefer revert of that commit over
  untangling it, then re-verify.

═══════════════════════════════════════════════════════════════════════════════
5) Heavy verification (local, offline)
═══════════════════════════════════════════════════════════════════════════════
Run the strongest relevant offline gates after fixes (skip only what is
clearly unrelated to the delta):

Baseline / always for non-trivial fixes:

1. npm run format and commit the result before any push
2. Smallest targeted proof for each fixed defect
   (focused Vitest file, script --check, etc.)
3. npm run verify:cheap
4. npm run verify:pr-local
   (use -- --dry-run --files <paths> first if selection is unclear)

Add when the delta warrants it:

• UI / shell / routing / styling / phone-chrome:
  npm run ensure, then npm run verify:phone-chrome and/or npm run verify:ui
• Therapy / generated catalogue assets:
  node scripts/build-therapies-index.mjs --check (and alias byte-parity)
• Auth / privacy / clinical / ingestion / source-governance:
  smallest domain check + npm run check:production-readiness
• Outstanding-issues / ledger touched:
  npm run check:outstanding-issues, npm run check:branch-review-ledger
  (or ledger:dedupe after merges)

Do NOT run without explicit approval:

• verify:release, verify:lighthouse, eval:*, test:live,
  check:supabase-project, or any live provider workflow.

If a gate fails: fix the dependency-related/PR-related cause with the smallest
change, rerun the smallest failing gate, then continue outward.

═══════════════════════════════════════════════════════════════════════════════
6) Publish
═══════════════════════════════════════════════════════════════════════════════

• Tip hygiene: no secrets, junk, caches, or unrelated WIP.
• Format + commit before push.
• Push only this PR’s fix commits to the PR branch (no unrelated locals).
• Append ledger for the final GitHub head + scope
  "PR #<n> review+bugbot+fix+heavy"
  (--supersede on a requested fresh same-HEAD pass).
• Never push a tip whose only delta is a review-ledger append.
  If product/CI/thread fixes exist, include the ledger row in that push;
  if review found nothing to change, append ledger locally and leave unpushed.
• After main sync that touched the ledger: npm run ledger:dedupe when needed.

═══════════════════════════════════════════════════════════════════════════════
7) PR comment (required)
═══════════════════════════════════════════════════════════════════════════════
Post one concise top-level PR comment covering:

• tip SHA reviewed/fixed
• sync done / not needed (merge-tree result)
• findings fixed vs dispositioned (with severities)
• threads handled
• required CI status on this tip
• local heavy gates run + decisive pass/fail lines
• residual risks / follow-ups
• merge left to me

Inline comments only for remaining open P0/P1 that still need a human decision.
No nit spam.

═══════════════════════════════════════════════════════════════════════════════
Stop when
═══════════════════════════════════════════════════════════════════════════════

• merge-tree clean vs origin/main
• no unresolved actionable threads
• required checks green or clearly in progress on the current tip
• heavy local gates above have passed for the touched scope
• summary comment posted
• merge decision left to me

[cursor]

PR #1468 worked end-to-end. Tip is now 5334d908 (product/sync 4d1f776a).

Snapshot → unblock

• Was DIRTY at d4cca177 vs a99de86d; local merge-tree was already clean.
• Pushed main sync → GitHub MERGEABLE; required CI re-running (Change scope / Semgrep / Gitleaks in progress). Auto-merge off; labels: codex only.

Review + Bugbot

• No PR-introduced P0/P1/P2 in the cache wiring (opt-ins, run-scoped artifact, pins, safety guards).
• Production UI (1) Services settle failure dispositioned as pre-existing fix: close bug-hunter stale-state paths (re-open) #146 — not caused by this cache PR; did not loosen the 0.5px anchor tolerance.

Heavy local gates

• verify:cheap: 445 files / 4659 passed
• verify:pr-local: PASS + RAG fixtures (36 golden / 23 suites)

Publish

• Pushed sync + ledger; summary comment posted.
• Merge left to you once required checks go green on 5334d908.

[cursor]

PR #1468 review+bugbot+fix+heavy summary

Tip:5334d908 (product/sync tip 4d1f776a; started from GitHub head d4cca177)
Sync: merged origin/main once — was DIRTY/CONFLICTING vs a99de86d. Local merge-tree vs origin/main is CLEAN (0 behind). Auto-merge not armed. Labels: codex only.

Threads: none unresolved (Codex / Bugbot / Copilot / human).

Deep review + Bugbot (delta vs main)

• No PR-introduced P0/P1/P2 in the cache wiring (run-playwright opt-ins, run-scoped artifact publish/restore, pin allowlist, runner-safety guards).
• Checked: hidden-path upload (include-hidden-files), publish/restore continue-on-error cold-build fallback, env validation, Next cache/ retention across rebuild, no actions/cache budget burn.

Fixed

• Merge blocker only: synced main so refs/pull/1468/merge can build again.

Dispositioned

• Production UI (1) failure on tip d4cca177 — tests/ui-phone-scroll-page-owned.spec.ts:577 Services viewport settle after shrink. Pre-existing fix: close bug-hunter stale-state paths (re-open) #146 family, not attributable to this cache PR (no phone-chrome/product UI delta; warm webpack cache only). Did not loosen the 0.5px anchor tolerance. Leave as residual / separate reopen of fix: close bug-hunter stale-state paths (re-open) #146 if it recurs on the new tip.
• Residual optimization risk: publish+restore both continue-on-error — correctness preserved via cold build, but a silent artifact plumbing break would lose the warm-build win without failing CI.

Local heavy gates

• npm run format — clean
• npm run verify:cheap — PASS (Test Files 445 passed (445) / Tests 4659 passed | 4 skipped)
• npm run verify:pr-local (scoped files) — PASS + Offline RAG fixture and manifest validation passed (36 golden cases, 23 suites); build skipped (no build-affecting product source)
• Not run (need approval / out of scope): verify:ui, verify:release, provider gates

Required CI on this tip

• Re-triggered by the sync push; treat prior missing/failed checks on the dirty head as stale. Leave merge to you once green on 5334d908.

Also: PR body may still mention truncated/actions/cache wording — this token cannot edit it (403 / not agent-managed). Please refresh to the run-scoped artifact description before merge if still outdated.

[BigSimmo]

@cursoragent fix merge conflict

[cursor]

Merge conflict cleared on PR #1468.

GitHub’s DIRTY was behind-but-clean vs f6f48330 (perf: shrink Therapy Compass browse payload), not a content fight — git merge origin/main applied cleanly.

• Tip: 25d16f1c
• merge-tree vs origin/main: CLEAN (0 behind)
• GitHub: MERGEABLE (checks re-running; leave merge to you)

[BigSimmo]

@cursoragent resolve merge conflict

[cursor]

Merge conflict cleared on PR #1468.

GitHub DIRTY was behind-but-clean vs d766d53a (answer-home notices mockups) — git merge origin/main applied with no content conflicts.

• Tip: 33676f83
• merge-tree vs origin/main: CLEAN (0 behind)
• GitHub: MERGEABLE (checks re-running; leave merge to you)

[BigSimmo]

@cursoragent resolve merge conflict

[cursor]

Merge conflict cleared on PR #1468.

GitHub DIRTY was behind-but-clean vs c7bc6989 (refactor(rag): extract second-stage ranking) — merge applied with no content conflicts.

• Tip: 7e04180a
• merge-tree vs origin/main: CLEAN (0 behind)
• GitHub: MERGEABLE (checks re-running; leave merge to you)

[BigSimmo]

@cursoragent stop the failing CI and fix and prevent happening again

[cursor]

Fixed the recurring Production UI (1) failure and pushed to tip bd85a07f.

Cause:#146 Services viewport-settle flake — a mid-page viewport shrink re-showed chrome under CI load and never re-settled (not caused by the build-cache change).

Fix / prevention

• Hold phone chrome hidden across viewport range changes while still mid-page (unless deliberate upward reveal travel)
• Re-sample scroll metrics on resize
• Stronger unit/contract coverage + clearer Playwright failure diagnostics (0.5px anchor tolerance unchanged)

Proof: Vitest 52 passed; Services e2e 1 passed. Required CI restarted on the new tip — leave merge to you.

[cursor]

CI fix: Production UI (1) / #146 Services viewport settle

Tip:bd85a07f (was 7e04180a)

Cause:Production UI (1) failed on tests/ui-phone-scroll-page-owned.spec.ts:577 when a mid-page viewport-range change (toolbar-style shrink) re-showed shared chrome under CI load and never re-settled within 10s. Not introduced by the build-cache wiring; same #146 family as runs 30605792683 / 30614151026.

Fix

• computeScrollHideUpdate holds hide across maxOffset range changes while the offset stays past the hide band and upward travel is below reveal intent.
• Document/container scroll reporters re-sample on resize so maxOffset updates without waiting for a user scroll.
• Playwright poll now returns structured diagnostics (chromeHidden / anchorStable / geometry) without loosening the 0.5px anchor tolerance.
• Contract + unit coverage for the hold and resize listener; #146 archive note updated.

Local proof

• Vitest: use-hide-on-scroll + header-scroll-hide-contract — 52 passed
• npm run test:e2e:pr -- --grep "Services results keep a continuous browser viewport" — 1 passed

Required CI re-triggered on this tip; leave merge to you.