Skip to content

fix(cooperation): eliminate unresponsive-frame sync failures and session traps on heavy web apps (#766) - #769

Merged
NianJiuZst merged 7 commits into
Tencent:mainfrom
NianJiuZst:fix/766-unresponsive-frame-cooperation
Nov 18, 2026
Merged

NianJiuZst merged 7 commits into
Tencent:mainfrom
NianJiuZst:fix/766-unresponsive-frame-cooperation

Conversation

@NianJiuZst

@NianJiuZst NianJiuZst commented Nov 18, 2026 •

Copy link
Copy Markdown
Collaborator

Summary

Fixes #766.

Eliminates "A page frame is not responding" (cooperation_sync_required) synchronization/action failures, multiplied retry timeouts, session traps, recording/video/overlay hangs, and MV3 Service Worker liveness disconnects on heavy Canvas + CSS-in-JS web applications such as Lark Base / Feishu Bitable as well as genuinely wedged renderers.


Root Causes (Why)

  1. styleFacts() & DOM walk overhead in cooperation-capture.ts / dom-primitives.ts:
    • Even after a cross-origin CDN <link rel="stylesheet"> marked facts.readable = false, styleFacts() continued iterating and concatenating every inline CSS-in-JS rule.cssText string across hundreds/thousands of rules, textChanges ran invisibleAttribute (styleFacts()) before checking whether structural childList records already disqualified the batch, and controls, observeShadowSubtree, hasAddedSubframeElement, and isExtensionOverlayNode executed repeated querySelectorAll("*"), closest(), and unconditional V8→C++ chrome.dom.openOrClosedShadowRoot calls on every element.
  2. Dropped caller timeout_ms, missing transport/IPC headroom, and multiplied settle retry budgets:
    • CooperationController.command ignored params.timeout_ms on sync and enable (and left default 15000ms cooperate wait sweeps at 3000ms per frame), CooperationController.run omitted actionReplyTimeoutMs + signal on verifyEvidence and post-action tool.evaluate / tool.upload refreshes, lifecycle.rs hardcoded timeout_ms: None on CooperateAction::Sync, daemon tool_dispatch_transport_timeout (30s) + CLI/MCP IPC (35s) lacked snapshot headroom, and cooperate::settle::run repeated static timeout_ms across Sync -> Wait -> Sync -> Wait -> Sync (burning up to 55s–100s on a wedged page instead of bounding retries to remaining wall-clock budget).
  3. False negatives & redirect hazards in hidden-frames.ts ownedByHiddenElement:
    • ownedByHiddenElement required exact owners.length === siblings.length (failing closed whenever <object>/<embed> or un-navigated <iframe> placeholders existed), failed whenever a visible cross-origin widget iframe coexisted alongside a silent hidden cross-origin iframe (such as accounts.larksuite.com/session-tools/refresh), and did not treat unfocused pointer-events: none or offscreen position: fixed iframes as hidden.
  4. Session traps & unbounded recovery handoffs on navigate / reload against unresponsive or CdpReadGate-tripped tabs:
    • CooperationController.run only permitted navigate/reload escape on page_load_failed (rejecting auto-injected target context_id from ImplicitScopeRegistry and blocking subsequent escapes when a timed-out wedged navigation left tab.pendingUrl set), prepareNavigation rethrew CdpReadTimeoutError when CdpReadGate was already tripped instead of falling back to "browser", recoverBrowserNavigation post-commit CDP handoffs (Page.enable, Page.getFrameTree on networkidle / same-document recovery) and short-timeout_ms (< 6000ms) entry refresh / post-timeout observeTab could starve recovery or exceed daemon transport grace.
  5. Unbounded script injection, recording probes, & tabs.sendMessage calls to wedged frames:
    • Unbounded chrome.scripting.executeScript (ensureOverlayInjected, injectCooperationAllFrames, injectRecordFrameAllFrames, armCommittedFrame), tabs.sendMessage (pushOverlayStateForTab, hover/record bypassOverlay, RECORD_FRAME_START / recording sendToTab, CAPTURE_SUPPRESS / VIDEO_OVERLAY cleanup, resetAgentOverlays, COOPERATION_ARM_FRAME), and waitForDocumentSettled CDP probes hung navigate, record, video, screenshot, or session stop on wedged tabs/subframes and risked 5-minute MV3 Service Worker kRequestTimeout evictions.

Key Changes (What)

  • apps/extension/src/content/cooperation-capture.ts & dom-primitives.ts:
    • Short-circuit styleFacts() in $O(\text{sheets})$ immediately when any stylesheet is cross-origin unreadable, skip @font-face and @keyframes rules, defer invisibleAttribute checks until after structural childList filtering, and collect data-* attribute names directly (/^data-[-\w]+$/, including @scope) without full-sheet cssText concatenation.
    • Skip :focus root selector queries when no root has :focus, cache [aria-labelledby]/[aria-describedby] IDs per root, combine shadow-root + subframe discovery on added subtrees, gate openOrClosedShadowRoot behind WHATWG shadow-host tag checks, and replace querySelectorAll("*") walks with TreeWalker (FILTER_REJECT on extension overlays).
  • apps/extension/src/cooperation/browser-bridge.ts, controller.ts, crates/bsk-cli/src/daemon/tool_pipeline.rs, cli/cooperate.rs, cli/lifecycle.rs, cli/mcp/tools.rs, & cooperate/settle.rs:
    • Forward caller timeout_ms (up to 25000ms, including default 15000ms cooperate wait and post-action evaluate/upload + verifyEvidence refreshes, with matching daemon transport and CLI/MCP IPC snapshot headroom) and AbortSignal across bsk open, bsk sync, bsk cooperate sync|enable|wait, and MCP bsk_session(open|sync) into collectCooperationFrames, keeping a single in-flight COOPERATION_READ per frame while retiring silent hidden child frames once 3000ms has elapsed and their parent frame has answered.
    • Retry transient mid-observation document replacements ("Document changed during observation", effect_state: "none") and bound settle retries via cooperate::settle::run_bounded so Attempt 1 always runs and subsequent pauses/retries respect remaining wall-clock timeout_ms.
  • apps/extension/src/cooperation/hidden-frames.ts:
    • Treat unfocused pointer-events: none and completely offscreen position: fixed frames as hidden: true, allow owners.length >= siblings.length when every displayed owner matches a distinct other sibling, and safely disambiguate cross-origin siblings via exact-before-origin owner declaredSrc matching without allowing redirected displayed frames to claim hidden siblings.
  • apps/extension/src/cooperation/controller.ts & apps/extension/src/tools/navigation.ts:
    • Permit navigate, reload, navigate_back, and navigate_forward (without preconditions or human hold/activity, including when ImplicitScopeRegistry auto-injects a prior target context_id or when an uncommitted tab.pendingUrl remains set on a FrameUnresponsiveError tab) to leave tabs stuck on FrameUnresponsiveError or frame_unobservable, fall back to "browser" navigation on CdpReadTimeoutError in prepareNavigation, proportion precondition-free entry refresh when timeout_ms < 6000 while preserving original reportedTimeoutMs, detach observeTab on timed-out/failed navigations, and bound post-commit CDP handoffs (including Page.getFrameTree retries past transient CdpReadGate blocks on networkidle) in recoverBrowserNavigation to remaining timeoutMs.
  • apps/extension/src/entrypoints/background.ts, lib/heartbeat.ts, lib/keepalive.ts, lib/runtime-content-scripts.ts, lib/capture-suppress-bridge.ts, lib/recording/frame-coordinator.ts, lib/recording/document-settle.ts, cooperation/browser-bridge.ts, tools/dispatcher.ts, tools/observation.ts, tools/record.ts, & tools/tabs.ts:
    • Bound executeScriptBounded (ensureOverlayInjected, injectCooperationAllFrames, injectRecordFrameAllFrames, armCommittedFrame), pushOverlayStateForTab, hover/record bypassOverlay, RECORD_FRAME_START / recording sendToTab / waitForDocumentSettled (plus proven-hidden child-frame tolerance in RecordFrameCoordinator.stop), CAPTURE_SUPPRESS / VIDEO_OVERLAY cleanup / captureFullTabPng fallback, resetAgentOverlays, and COOPERATION_ARM_FRAME, and emit application-level system.heartbeat ticks on chrome.alarms wakeups without disturbing daemon silence-based liveness reaping.
  • Docs & Changelogs:
    • Updated CHANGELOG.md, CHANGELOG.zh-CN.md, and crates/bsk-cli/skill/references/interaction-details.md.

Verification

  • Real-Chrome Full-Stack E2E Tests:
    • Added end-to-end regression in apps/extension/src/cooperation/settlement.browser.test.ts exercising real bsk CLI + bsk daemon + MV3 extension + multi-process Chrome (--site-per-process):
      1. Heavy workspace with >3s main-frame hydration, unreadable cross-origin CDN <link rel="stylesheet">, large inline CSSOM/DOM, visible cross-origin widget OOPIF, <object> placeholder, and spinning hidden cross-origin accounts.test/session-tools/refresh OOPIF (cooperate sync --timeout-ms 15000, bsk sync, evaluate --unverified, click, read, screenshot, ledger status, and bsk record start + bsk record stop against an already-wedged hidden cross-origin accounts-rec.test/session-tools/refresh OOPIF).
      2. Genuinely wedged main-frame (for (;;) {}) renderer: settled bsk sync --timeout-ms 7000 stays bounded to a single attempt (< 12s, effect_state: "none", unfrozen ledger), tripping CdpReadGate via bsk snapshot (phase: "blocked") still falls back cleanly to browser navigation with bounded post-commit timeout (after 6000ms) on a synchronously wedged destination, and bsk navigate --wait-until networkidle --timeout 3s escapes to a healthy page and resumes sync + evaluate in the same session.
      3. Cross-document link click into a wedged page while hover bypass and daemon ImplicitScopeRegistry auto-injected context_id remain active: bsk navigate and bsk session stop both complete cleanly without hanging.
    • Extended hidden-frames.browser.test.ts to verify that a displayed cross-origin iframe that redirected to a third origin and hung is never falsely classified as hidden when a hidden iframe shares its initial declaredSrc origin.
    • Verified settlement.browser.test.ts, hidden-frames.browser.test.ts, cooperation-capture.browser.test.ts, navigation-history.browser.test.ts, navigation-same-document.browser.test.ts, navigation-wait.browser.test.ts, runtime-injection.browser.test.ts, video/capture.browser.test.ts, and BSK_COOP_FRAMES_ONLY=1 evals/browser/cases/regression/cooperation/run.mjs.
  • Workspace Suites & CI Gates:
    • pnpm lint, pnpm protocol:check, pnpm --filter @browser-skill/extension compile, pnpm ext:test (190 suites / 4,102 tests), i18n, vom, dsh-plugin + check-dsh-package.mjs, eval:browser:check, check-skill-bundles.mjs, check-crate-skill.mjs, scripts/*.test.mjs, check-changelog-sync.py.
    • cargo fmt --all -- --check, cargo clippy --workspace --all-targets --locked -- -D warnings, cargo test --workspace --locked.

…ion traps on heavy web apps (Tencent#766)

Why:
On heavy Canvas + CSS-in-JS web applications such as Lark Base / Feishu
Bitable (Tencent#766), `bsk cooperate sync`, `bsk sync`, and `bsk evaluate`
repeatedly failed with `"A page frame is not responding"` (`frame 0` and/or
hidden cross-origin `accounts.larksuite.com/session-tools/refresh` iframes)
while screenshots succeeded:
1. `cooperation-capture.ts` `styleFacts()` continued iterating and
   concatenating every inline CSSOM `rule.cssText` string even after a
   cross-origin CDN stylesheet had already set `facts.readable = false`,
   while `dom-primitives.ts` and `cooperation-capture.ts` performed repeated
   `querySelectorAll("*")`, `closest()`, and unconditional V8->C++
   `chrome.dom.openOrClosedShadowRoot` sweeps across thousands of nodes.
2. `CooperationController.command` ignored caller `timeout_ms` on `sync` and
   `enable` (and `lifecycle.rs` hardcoded `None` on `CooperateAction::Sync`,
   while daemon `ToolCooperate` and CLI/MCP IPC hardcoded `30s`/`35s` ceilings
   without snapshot headroom), aborting busy main frames at the fixed 3s
   per-frame IPC deadline even when `--timeout-ms 20000` was supplied, while
   `cooperate wait` re-broadcast duplicate `COOPERATION_READ` sweeps on every
   poll cycle.
3. `hidden-frames.ts` `ownedByHiddenElement` failed closed whenever
   `owners.length !== siblings.length` (e.g. `<object>`/`<embed>` or
   un-navigated `<iframe>` placeholders), whenever a visible cross-origin
   widget iframe coexisted alongside a silent hidden cross-origin iframe, or
   when an unfocused frame was hidden via `pointer-events: none` or offscreen
   `position: fixed`.
4. `CooperationController.run` only allowed `navigate`/`reload` escape from
   `page_load_failed` (and rejected auto-injected `target` `context_id` before
   probing `unrecoverableNavigationSource`), trapping sessions on
   `FrameUnresponsiveError` or `frame_unobservable` until `session stop` — and
   CDP preflight probes in `navigation.ts` waited indefinitely on wedged
   renderers instead of falling back to browser-process navigation.
5. Unbounded `ensureOverlayInjected` and `tabs.sendMessage` calls to wedged
   frames (`pushOverlayStateForTab`, hover/record `bypassOverlay`,
   `resetAgentOverlays`, and `COOPERATION_ARM_FRAME`) hung `navigate` /
   `session stop` on hovered wedged tabs and risked 5-minute Chromium
   `kRequestTimeout` MV3 Service Worker evictions.

What:
- Short-circuit `styleFacts()` in O(sheets) as soon as any stylesheet is
  cross-origin unreadable, skip `@font-face` and `@keyframes`, extract
  `data-*` attribute names directly (including `@scope`) without full-sheet
  `cssText` concatenation, skip `:focus` root queries when no root has
  `:focus`, cache `[aria-labelledby]`/`[aria-describedby]` IDs per root, and
  replace quadratic `querySelectorAll("*")` / `closest()` / unconditional
  `openOrClosedShadowRoot` walks with `TreeWalker` (`FILTER_REJECT` on
  extension overlays) and WHATWG shadow-host tag checks.
- Forward caller `timeout_ms` (up to `25000ms`, with matching daemon transport
  and CLI/MCP IPC snapshot headroom) and `AbortSignal` across `bsk open`,
  `bsk sync`, `bsk cooperate sync|enable|wait`, and MCP
  `bsk_session(open|sync)` into `collectCooperationFrames` with at most one
  in-flight `COOPERATION_READ` per frame while retiring provably hidden silent
  child frames after `3000ms`, and retry transient mid-observation document
  replacements in `--settle`.
- Teach `describeFrameOwners` (`includeDeclaredSrc`) and `ownedByHiddenElement`
  to recognize unfocused `pointer-events: none` and offscreen `position: fixed`
  frames, accept `owners.length >= siblings.length` when displayed owners all
  match distinct live siblings, and safely disambiguate cross-origin siblings
  via exact-before-origin owner `declaredSrc` matching without letting
  redirected displayed frames claim hidden siblings.
- Allow `navigate`, `reload`, `navigate_back`, and `navigate_forward` to
  leave tabs stuck on `FrameUnresponsiveError` or `frame_unobservable`
  (including when `ImplicitScopeRegistry` auto-injects a prior `target`
  `context_id` after a cross-document transition), and bound preflight CDP
  attachment/readiness probes in `navigation.ts` so wedged renderers fall back
  cleanly to `chrome.tabs` navigation recovery.
- Bound `ensureOverlayInjected`, `pushOverlayStateForTab`, hover/record
  `bypassOverlay`, `resetAgentOverlays`, and `COOPERATION_ARM_FRAME` calls to
  `3000ms`, and emit application-level `system.heartbeat` ticks on
  `chrome.alarms` wakeups without disturbing daemon silence-based liveness
  reaping.
- Add real-Chrome full-stack regression coverage in `settlement.browser.test.ts`
  and `hidden-frames.browser.test.ts` plus unit tests in `cooperate/settle.rs`,
  `lifecycle.rs`, and `daemon/ipc.rs`, and update bilingual changelogs and
  skill interaction references.

Fixes Tencent#766
@NianJiuZst
NianJiuZst force-pushed the fix/766-unresponsive-frame-cooperation branch from d780aed to 101db5e Compare November 18, 2026 09:13
…escape, and script injection (Tencent#766)

Why:
Full-stack verification on top of Tencent#769 uncovered five remaining timeout and
recovery gaps on genuinely wedged or slow renderers:
1. `settled_sync_with_conditions_using`, `cooperate sync --settle`, and MCP
   `bsk_session(action="sync", settle=true)` passed a static `timeout_ms` into
   `cooperate::settle::run`, multiplying `Sync -> Wait -> Sync -> Wait -> Sync`
   up to `55s–100s` on a wedged page instead of bounding retries to the
   caller's remaining wall-clock deadline.
2. When a wedged tab had already tripped `CdpReadGate` (e.g. after running
   `bsk snapshot` / `bsk get-html` per recovery guidance or after a
   `soft_detached` reattachment timeout), `prepareNavigation` rethrew
   `CdpReadTimeoutError` instead of falling back to browser-process navigation;
   additionally, `recoverBrowserNavigation`'s post-commit CDP handoff, entry
   `refresh` elapsed time on `failedLoadRecovery`, post-timeout `observeTab`,
   and uncommitted `tab.pendingUrl` on a timed-out wedged navigation could
   exceed daemon transport grace or block subsequent `navigate` escapes.
3. `CooperationController.command` defaulted `cooperate wait` (without
   `--timeout-ms`) to a `15000ms` loop deadline while leaving
   `requestedTimeoutMs` `undefined` (`3000ms` per-frame sweep), and
   `CooperationController.run` omitted `actionReplyTimeoutMs` / `signal` on
   `verifyEvidence` and post-action `tool.evaluate` / `tool.upload` refreshes.
4. `injectCooperationAllFrames`, `injectRecordFrameAllFrames`, and
   `armCommittedFrame` awaited unbounded `chrome.scripting.executeScript(...)`
   calls when repairing missing-receiver frames on wedged tabs.
5. `cooperation-capture.ts` ran `invisibleAttribute` (`styleFacts()`) before
   verifying structural `childList` batch eligibility and accepted punctuated
   `data-*` attribute names outside `DATA_ATTR_RE`, while `settle.rs` matched
   `"changed during observation"` broadly enough to include `"Control policy
   changed during observation"`.

What:
- Add `cooperate::settle::run_bounded` (`settle.rs`) and wire remaining
  wall-clock `timeout_ms` budgets across `lifecycle.rs`, `cooperate.rs`, and
  `mcp/tools.rs` so Attempt 1 always runs while subsequent `SETTLING_PAUSES`
  and `Wait`/`Sync` retries stop once the deadline elapses (preserving the last
  `Sync` error when an `unavailable` `Wait` exhausts budget), and narrow
  mid-observation retry matching to `"Document changed during observation"`.
- Fall back to `"browser"` navigation on `CdpReadTimeoutError` in
  `prepareNavigation`, bound `recoverBrowserNavigation` post-commit CDP
  handoffs (`acquireNavigationExecution`, `Page.enable`, `readMainFrameInfo`,
  `Page.setLifecycleEventsEnabled`) to remaining `timeoutMs`, deduct entry
  `refresh` elapsed time on `failedLoadRecovery`, detach `observeTab` on
  timed-out/failed navigations, and permit `FrameUnresponsiveError` navigation
  escape even when an uncommitted `tab.pendingUrl` remains set.
- Default `rawTimeoutMs` to `15000` for `cooperate wait` when `timeout_ms` is
  omitted, and forward bounded `actionReplyTimeoutMs` + `signal` into
  `verifyEvidence` and post-action `tool.evaluate` / `tool.upload` `refresh`.
- Introduce `executeScriptBounded(..., 3000)` and apply it across
  `ensureOverlayInjected`, `injectCooperationAllFrames`,
  `injectRecordFrameAllFrames`, and `armCommittedFrame`.
- Defer `invisibleAttribute` checks in `textChanges` until after non-attribute
  records qualify with zero unmatched removals, and require `/^data-[-\w]+$/`
  in `invisibleAttribute`.
- Cover bounded settled `bsk sync --timeout-ms` and `CdpReadGate`-tripped
  wedged `navigate` recovery in real-Chrome `settlement.browser.test.ts`, and
  sync `CHANGELOG.md`, `CHANGELOG.zh-CN.md`, and `interaction-details.md`.
…dged-early (Tencent#766)

Why:
In `settlement.browser.test.ts` Part 3, clicking `<a href=".../wedged">`
triggered a cross-site process swap (`healthy.test` -> `127.0.0.1`) followed by
a fixed 250ms sleep while `/wedged` deferred `for (;;) {}` via an 80ms
`setTimeout`. On slower 2-vCPU Linux CI runners, spawning the cross-site
renderer took ~200ms so `bsk navigate` arrived after `onCommitted` invalidated
the old context yet before `/wedged`'s 80ms timer wedged the main thread.

What:
- Point `#open-wedged` at `/wedged-early` (synchronous inline `for (;;) {}`
  with zero responsive window after commit) and await the HTTP server's
  `/wedged-early` response completion before issuing the recovery `navigate` /
  `session stop`.
…vigate escape (Tencent#766)

Why:
Chromium's Browser Process (`NavigationURLLoader`) fetches `/wedged-early` in
parallel with spawning a cross-site renderer process (`--site-per-process`), so
waiting only on the HTTP response callback still raced `RenderFrameHost` commit
on 2-vCPU Linux CI runners (`onBeforeNavigate` had invalidated `state.context`
while `webNavigation.getAllFrames` still observed the responsive `/escaped`
document).

What:
- Poll `bsk tab list --scope agent` (passive browser-process read that leaves
  `ImplicitScopeRegistry` untouched) until `tab.url` commits `/wedged-early`
  before issuing the recovery `navigate` and `session stop`.
…cape checks (Tencent#766)

Why:
On 2-vCPU Linux CI runners, navigating to `http://127.0.0.1:<port>/wedged-early`
after `http://127.0.0.1:<port>/wedged` had already entered `for (;;) {}` reused
the hung `127.0.0.1` `RenderProcessHost`, preventing `CommitNavigation` from
ever completing on the subsequent link-click scenarios.

What:
- Assign distinct site-isolated hostnames (`wedged1.test`..`wedged4.test`) via
  `--host-resolver-rules` for each wedged navigation step so every scenario
  commits into a fresh renderer process before wedging.
…nd overlay bounds on wedged frames (Tencent#766)

Why:
1. In `recoverBrowserNavigation`, `waitUntil === "networkidle"` (and non-commit
   same-document recovery) called `readMainFrameInfo`, which swallowed both
   `CdpReadTimeoutError` (when `CdpReadGate` had not yet settled a departing
   wedged renderer's pending read) and its internal 1500ms timeout into
   `{ frameId: null }`, causing `if (!frame.frameId) throw new Error("No main frame after navigation")`
   to abort recovery with `cdp_failed` instead of succeeding once the gate
   reopened or reporting `reached: "timeout"` at deadline.
2. On navigation escapes with a tight `timeout_ms` (`< 6000ms`, e.g. `--timeout 3s`),
   `CooperationController.run` spent the full 3000ms `DEFAULT_FRAME_REPLY_MS` on
   entry `refresh` and then clamped `req.params.timeout_ms` to `1ms`, starving
   `prepareNavigation` + `recoverBrowserNavigation` while also overwriting the
   caller's original `timeout_ms` in recovery timeout diagnostics.
3. On tabs hosting a wedged hidden cross-origin child OOPIF (such as Lark Base's
   `session-tools/refresh`), `bsk record start` and `bsk record stop` still hung
   on unbounded `RECORD_FRAME_START` `tabs.sendMessage`, unbounded
   `waitForDocumentSettled` CDP `Page.createIsolatedWorld` / `Runtime.evaluate`
   probes, and `RecordFrameCoordinator.stop` waiting for proven-hidden child
   frames, while `VideoManager.cleanup` (`VIDEO_OVERLAY` with `recording_id: null`)
   and `defaultSendToTab` (`CAPTURE_SUPPRESS` / `captureFullTabPng` fallback)
   lacked bounds on wedged tabs.

What:
- Query `Page.getFrameTree` directly within `recoverBrowserNavigation`'s
  `withinDeadline`, retrying briefly on `CdpReadTimeoutError` across cross-document
  commits and returning `false` (`reached: "timeout"`) when the deadline expires.
- Proportion precondition-free navigation entry `refresh` to `Math.max(200, Math.floor(timeout_ms / 2))`
  when `timeout_ms < 6000` and preserve the caller's original `timeout_ms` via
  `withReportedTimeoutMs` / `readReportedTimeoutMs`.
- Bound `RecordFrameCoordinator.#startFrame` (`3000ms`), recording `sendToTab`,
  `waitForDocumentSettled` CDP probes (`SETTLE_MAX_MS`), `VIDEO_OVERLAY` teardown,
  `CAPTURE_SUPPRESS` `defaultSendToTab` (with balancing `end`), and `captureFullTabPng`
  `Page.captureScreenshot` fallback (`10500ms`), and tolerate proven-hidden
  non-root child frames in `RecordFrameCoordinator.stop`.
- Extend real-Chrome E2E `settlement.browser.test.ts`, `navigation-recovery.test.ts`,
  and bilingual `CHANGELOG` entries.
@NianJiuZst
NianJiuZst merged commit aeebd10 into Tencent:main Nov 18, 2026
12 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

1 participant