The Tab Was Hidden. Should requestAnimationFrame Catch Up When It Returns?

A requestAnimationFrame() callback returning successfully is a weak acceptance signal. It proves that a callback was delivered. It does not prove what happened while the document was hidden, whether callbacks were suspended, what interval the next timestamp represents, or whether application state should advance through that interval.

The narrow release question is therefore: when a document becomes hidden and later visible, what should the application do with the delta between the last pre-hide requestAnimationFrame timestamp and the first post-resume timestamp? The HTML animation-frame algorithm supplies callbacks with a DOMHighResTimeStamp; the Page Visibility model separately defines visible, hidden, and visibilitychange. Current MDN documentation says browsers commonly pause requestAnimationFrame() callbacks in background tabs, while the High Resolution Time model says throttling or freezing callbacks should not distort the underlying monotonic clock. Those are related contracts, not one combined promise that an application should “catch up.”

This playbook treats raw timestamp behavior, visibility state, and application resume policy as separate evidence dimensions. The supplied laboratory environment was inspected, but it did not produce a defensible hidden-document transition under its available browser-automation path. Accordingly, every browser-behavior case below is marked EXPECTED / NOT EXECUTED. The release disposition is HOLD, followed by RERUN in a fixture that demonstrates a genuine hidden → visible transition. No missing observation is converted into a pass.

Define the acceptance contract

The contract must answer a narrower question than “does animation continue?” For this fixture, the application has a pause-while-hidden policy: logical animation time must not advance by the document’s hidden interval. The browser may expose a large raw timestamp gap after resumption; the application is expected to identify the visibility discontinuity and reset its integration baseline instead of feeding that entire gap into simulation state.

That policy is intentionally application-authored. The HTML Standard says requestAnimationFrame(callback) stores a one-shot callback, and when animation-frame callbacks run, each selected callback is removed and invoked with the current animation-frame timestamp. It does not describe a queue of one callback for every display refresh that occurred while the document could not render. MDN likewise describes requestAnimationFrame() as one-shot and says calls are commonly paused in background tabs or hidden iframes.

The accepted input is one locally served document, one deliberately hidden interval, one return to visible state, and a single recursively scheduled rAF loop. Required artifacts are: runtime identity, fixture revision, expected-case manifest, visibility event ledger, raw rAF timestamps, calculated raw deltas, policy-adjusted deltas, exceptions or warnings, and cleanup state.

The gate fails if any of the following occurs: the document never records hidden; the expected manifest is generated from observed output instead of being independently authored; the first resumed frame cannot be identified; evidence rows disappear during cleanup; or the policy-adjusted animation consumes the hidden interval.

This differs from Refonte’s HTML dialog focus lifecycle, which tests focus ownership across modal open/close states and explicitly treats its proposed browser matrix as unexecuted where evidence is absent. The evidence discipline is relevant, but its modal lifecycle, inputs and assertions are not reused here.

Pin versions and establish a baseline

The documentary baseline used here is dated November 9, 2026. The WHATWG HTML Living Standard pages opened for this review report Last Updated 6 November 2026. The animation-frame section defines the AnimationFrameProvider callback as receiving a DOMHighResTimeStamp; the visibility section defines document visibility as hidden or visible and fires visibilitychange when the state updates.

The available execution environment was:

Those values come from executed local inspection, not from a compatibility table.

A qualification attempt launched Chromium both headless and under Xvfb/Openbox and tried page switching and window minimization. In those automation paths, document.visibilityState remained visible; therefore those runs do not qualify as hidden-tab evidence. Playwright also launches Chromium with flags such as --disable-background-timer-throttling, --disable-backgrounding-occluded-windows, and --disable-renderer-backgrounding unless explicitly removed; even after removing those three flags in one qualification attempt, the environment still did not yield a defensible hidden transition. This is an executed environment finding, not a browser-semantics conclusion.

Check a negative control

Case N0_VISIBLE_ONLY deliberately stays visible for at least 1,000 ms.

Pass condition: zero visibilitychange rows with state hidden, continuously increasing rAF timestamps, and resumeCount === 0. The test must not infer a resume simply because one ordinary frame delta happens to be larger than its neighbors.

Status: EXPECTED / NOT EXECUTED in this fixture. The automation qualification attempts were not substituted for this case because they never established the fixture’s required visibility boundary.

Author an independent expected-case manifest

The expected manifest must exist before browser output. Its purpose is to prevent a common false positive: executing code, observing whatever happened, and then declaring those observations “expected.”

Save the following separately as expected-cases.json:

{
  "fixtureRevision": "raf-hidden-resume-v1",
  "policy": "pause-logical-time-while-hidden",
  "cases": [
    {
      "id": "N0_VISIBLE_ONLY",
      "requiresHiddenTransition": false,
      "expected": {
        "hiddenTransitions": 0,
        "resumeTransitions": 0,
        "policyMayConsumeResumeGap": false
      }
    },
    {
      "id": "H1_SHORT_HIDE",
      "requiresHiddenTransition": true,
      "targetHiddenMs": 250,
      "expected": {
        "sequence": ["visible", "hidden", "visible"],
        "firstResumeFrameExists": true,
        "policyDeltaOnFirstResumeFrameMs": 0
      }
    },
    {
      "id": "H2_LONG_HIDE",
      "requiresHiddenTransition": true,
      "targetHiddenMs": 2000,
      "expected": {
        "sequence": ["visible", "hidden", "visible"],
        "firstResumeFrameExists": true,
        "policyDeltaOnFirstResumeFrameMs": 0
      }
    },
    {
      "id": "H3_RAW_DELTA_NEGATIVE_CONTROL",
      "requiresHiddenTransition": true,
      "targetHiddenMs": 2000,
      "expected": {
        "rawResumeDeltaMayIncludeHiddenInterval": true,
        "rawResumeDeltaMustNotBeReleaseOracle": true
      }
    },
    {
      "id": "H4_REPAIRED_RESUME",
      "requiresHiddenTransition": true,
      "targetHiddenMs": 2000,
      "expected": {
        "resumeBaselineReset": true,
        "policyDeltaOnFirstResumeFrameMs": 0,
        "subsequentFramesUseRafTimestampDelta": true
      }
    }
  ]
}

Notice what is not encoded: no 16.67 ms frame interval, no guaranteed refresh rate, and no promise that every browser executes zero rAF callbacks while hidden. MDN says callbacks are paused in most browsers, while WHATWG’s visibility text says hiding can cause throttling but also notes other causes of throttling. That makes “no hidden callbacks everywhere” too strong as a portable normative oracle.

The independence rule resembles the discipline in Refonte’s Python asyncio.to_thread context capture: its expected binding rule is authored separately from observed worker context. Here, however, the oracle concerns browser visibility boundaries and time integration, not coroutine scheduling or ContextVar capture.

Construct the controlled fixture

The fixture is deliberately framework-free and network-free beyond loopback HTTP. It records evidence to the local server before cleanup.

Save this as server.mjs beside expected-cases.json:

import http from "node:http";
import fs from "node:fs";
import crypto from "node:crypto";

const PORT = 8765;
const evidence = [];
const startedAt = new Date().toISOString();

const probe = <!doctype html>
<meta charset="utf-8">
<title>rAF hidden/resume probe</title>
<button id="download">Download evidence</button>
<pre id="status"></pre>
<script type="module">
const params = new URLSearchParams(location.search);
const caseId = params.get("case") || "H2_LONG_HIDE";
const revision = "raf-hidden-resume-v1";

let frameOrdinal = 0;
let lastRawTs = null;
let policyLastTs = null;
let hiddenSeen = false;
let resumePending = false;
let resumeCount = 0;

const rows = [];

async function emit(kind, fields = {}) {
  const row = {
    revision,
    caseId,
    kind,
    visibility: document.visibilityState,
    perfNow: performance.now(),
    wallNow: Date.now(),
    ...fields
  };
  rows.push(row);
  document.querySelector("#status").textContent =
    JSON.stringify(row, null, 2);

  try {
    await fetch("/evidence", {
      method: "POST",
      headers: {"content-type": "application/json"},
      body: JSON.stringify(row),
      keepalive: true
    });
  } catch {}
}

async function recordRuntime() {
  let fullVersionList = null;
  try {
    if (navigator.userAgentData?.getHighEntropyValues) {
      fullVersionList =
        (await navigator.userAgentData.getHighEntropyValues(
          ["fullVersionList", "platformVersion"]
        )).fullVersionList;
    }
  } catch {}

  await emit("runtime", {
    userAgent: navigator.userAgent,
    fullVersionList,
    timeOrigin: performance.timeOrigin
  });
}

document.addEventListener("visibilitychange", () => {
  if (document.visibilityState === "hidden") {
    hiddenSeen = true;
    emit("visibility-hidden", {frameOrdinal, lastRawTs});
  } else {
    resumeCount++;
    resumePending = hiddenSeen;
    policyLastTs = null;
    emit("visibility-visible", {
      frameOrdinal,
      lastRawTs,
      resumeCount
    });
  }
});

function frame(ts) {
  frameOrdinal++;

  const rawDelta =
    lastRawTs === null ? null : ts - lastRawTs;

  let policyDelta;
  if (resumePending || policyLastTs === null) {
    policyDelta = 0;
    resumePending = false;
  } else {
    policyDelta = ts - policyLastTs;
  }

  emit("raf", {
    frameOrdinal,
    rawTs: ts,
    rawDelta,
    policyDelta,
    hiddenSeen,
    resumeCount
  });

  lastRawTs = ts;
  policyLastTs = ts;
  requestAnimationFrame(frame);
}

document.querySelector("#download").addEventListener("click", () => {
  const blob = new Blob(
    [JSON.stringify(rows, null, 2)],
    {type: "application/json"}
  );
  const a = document.createElement("a");
  a.href = URL.createObjectURL(blob);
  a.download = caseId + "-browser-evidence.json";
  a.click();
  URL.revokeObjectURL(a.href);
});

await recordRuntime();
emit("fixture-ready");
requestAnimationFrame(frame);
</script>;

const cover = <!doctype html>
<meta charset="utf-8">
<title>Cover tab</title>
<h1>Keep this tab selected during the hidden interval</h1>;

function send(res, status, type, body) {
  res.writeHead(status, {
    "content-type": type,
    "cache-control": "no-store"
  });
  res.end(body);
}

const server = http.createServer((req, res) => {
  const url = new URL(req.url, http://127.0.0.1:${PORT});

  if (req.method === "GET" && url.pathname === "/probe") {
    return send(res, 200, "text/html; charset=utf-8", probe);
  }

  if (req.method === "GET" && url.pathname === "/cover") {
    return send(res, 200, "text/html; charset=utf-8", cover);
  }

  if (req.method === "GET" && url.pathname === "/expected-cases.json") {
    return send(
      res,
      200,
      "application/json",
      fs.readFileSync("./expected-cases.json")
    );
  }

  if (req.method === "POST" && url.pathname === "/evidence") {
    let body = "";
    req.on("data", c => body += c);
    req.on("end", () => {
      try {
        evidence.push(JSON.parse(body));
        send(res, 204, "text/plain", "");
      } catch {
        send(res, 400, "text/plain", "invalid json");
      }
    });
    return;
  }

  if (req.method === "POST" && url.pathname === "/finish") {
    const artifact = {
      fixtureRevision: "raf-hidden-resume-v1",
      startedAt,
      finishedAt: new Date().toISOString(),
      node: process.version,
      platform: process.platform,
      arch: process.arch,
      evidence
    };

    const json = JSON.stringify(artifact, null, 2);
    const sha256 =
      crypto.createHash("sha256").update(json).digest("hex");

    fs.writeFileSync(
      "evidence.json",
      JSON.stringify({...artifact, sha256}, null, 2)
    );

    return send(
      res,
      200,
      "application/json",
      JSON.stringify({rows: evidence.length, sha256})
    );
  }

  send(res, 404, "text/plain", "not found");
});

server.listen(PORT, "127.0.0.1", () => {
  console.logprobe: http://127.0.0.1:${PORT}/probe?case=H2_LONG_HIDE);
  console.logcover: http://127.0.0.1:${PORT}/cover);
});

Run it with the pinned Node baseline:

Node.js 22.16.0
fixture revision raf-hidden-resume-v1

Then open the probe and cover pages as ordinary tabs in the same real browser window. Do not accept a run until the probe records visibility-hidden, later visibility-visible, and a following raf row.

Record the state before cleanup

For H2_LONG_HIDE, retain the last rAF row before visibility-hidden, both visibility rows, and the first two rAF rows after return.

Pass condition: those identities remain present in evidence.json, in order, after /finish is called. Cleanup must not delete or overwrite the only copy of evidence.

Status: EXPECTED / NOT EXECUTED.

Reproduce the misleading success

The misleading implementation is only a few lines:

let previous;

function animate(ts) {
  if (previous !== undefined) {
    const dt = ts - previous;
    position += velocityPerMs * dt;
  }

  previous = ts;
  requestAnimationFrame(animate);
}

requestAnimationFrame(animate);

Nothing here fails at the API level. requestAnimationFrame() continues to return a request ID, callbacks can resume later, and dt remains numeric. Yet if the first resumed timestamp is substantially later than the final pre-hide timestamp, the code advances position through the entire raw interval.

That is the false-positive success: the API call succeeded and the arithmetic is valid, but the application may have implemented the wrong resume policy.

MDN defines the callback timestamp as a DOMHighResTimeStamp, based on the window’s time origin, and notes that it is comparable to document.timeline.currentTime; multiple callbacks in one frame can receive the same timestamp. High Resolution Time describes its monotonic clock as independent of callback throttling: backgrounding may freeze or throttle callbacks, but that should not reduce the underlying clock’s accuracy.

Therefore the release test cannot be Number.isFinite(dt). It must ask whether dt crosses a visibility boundary and whether the product policy permits consuming that interval.

For this playbook:

raw timestamp delta         = diagnostic evidence
visibility transition       = discontinuity evidence
policy-adjusted delta       = application acceptance value

H3_RAW_DELTA_NEGATIVE_CONTROL specifically keeps the naïve raw-delta path in the fixture. Its expected result is not “browser bug”; its purpose is to demonstrate that a numerically valid raw delta can still violate the authored pause-on-hidden policy.

Status: EXPECTED / NOT EXECUTED.

Run a correct comparison case

The repaired comparison resets integration ownership when visibility resumes:

let previous = null;
let resumePending = false;

document.addEventListener("visibilitychange", () => {
  if (document.visibilityState === "visible") {
    resumePending = true;
  }
});

function animate(ts) {
  if (resumePending || previous === null) {
    previous = ts;
    resumePending = false;
    requestAnimationFrame(animate);
    return;
  }

  const dt = ts - previous;
  previous = ts;

  position += velocityPerMs * dt;
  requestAnimationFrame(animate);
}

requestAnimationFrame(animate);

The first post-resume frame is treated as a new timing baseline, not as a simulation step. The next ordinary visible frame resumes timestamp-delta integration.

This is not a claim that every animation should pause. A clock, countdown, media synchronization layer, or server-time visualization may deliberately want elapsed real time to remain visible after a tab returns. In that case the acceptance contract should state that requirement explicitly and use the appropriate time source. The repair above is correct only for the stated policy: logical animation state pauses while hidden.

That distinction mirrors the high-level lesson in Refonte’s scikit-learn OneHotEncoder unknown categories: successful transformation is not enough if representation semantics violate the independent input contract. Here the mechanisms are completely different; the analogous mistake is treating a valid rAF callback and valid number as proof that the timing semantics are acceptable.

Capture exceptions and warnings

The fixture should register:

window.addEventListener("error", event => {
  emit("window-error", {
    message: event.message,
    filename: event.filename,
    lineno: event.lineno,
    colno: event.colno
  });
});

window.addEventListener("unhandledrejection", event => {
  emit("unhandled-rejection", {
    reason: String(event.reason)
  });
});

Pass condition: required cases contain no uncatalogued window-error or unhandled-rejection rows. A warning or exception does not automatically classify the browser behavior; it makes evidence incomplete until explained.

Status: EXPECTED / NOT EXECUTED.

Test boundaries and failure modes

The first boundary is short hiding. A 250 ms target is deliberately close enough that scheduler noise matters. Do not assert a precise raw rAF delta. Assert only the observable sequence, identify the first resume frame, and verify that the policy delta is zero.

The second boundary is longer hiding, here 2,000 ms. Its role is to make accidental catch-up operationally obvious without turning timing into a benchmark.

The third is no actual hidden transition. Switching application focus is not equivalent to visibility. MDN explicitly notes that blur and focus are imperfect proxies: a window can lose focus without its document becoming hidden. A run that records only focus changes must therefore be rejected from this test.

The fourth boundary is browser or automation instrumentation that disables normal background behavior. Chrome DevTools Protocol exposes lifecycle controls, but its own documentation says CDP is not a supported compatibility API for third-party applications and can change without backwards compatibility. A synthetic lifecycle override can be useful for a separate unit test, but it must not silently replace the real hidden-tab acceptance case.

The fifth boundary is operating-system sleep. High Resolution Time currently specifies monotonic-clock behavior across freezing, while MDN documents historical platform divergence in whether performance.now() advances during OS sleep. System sleep is therefore outside this article’s acceptance boundary; it needs its own platform-specific test.

The sixth is multiple callbacks in one frame. MDN documents that rAF callbacks executed for the same frame share a timestamp even though earlier callbacks consume execution time. Do not infer duplicate work merely because equal timestamps appear.

Capture complete case-by-case evidence

The evidence ledger should be row-oriented, not summarized prematurely.

The local qualification work adds one separate row:

That row is important precisely because it is not upgraded into an application result.

Reject incomplete evidence

A case is incomplete if it contains visibility-visible but no preceding visibility-hidden, if it has a hidden event but no first post-return rAF row, if runtime identity is absent, or if the expected manifest cannot be matched to the fixture revision.

Measurable pass condition: every required case ID appears exactly once in the run manifest, every required state boundary has a matching ledger event, and every acceptance assertion can be recomputed from retained rows.

Status: EXPECTED / NOT EXECUTED.

Reconcile state, identity and counts

A release review should be able to answer five count questions without looking at screenshots:

• How many visibility-hidden transitions occurred?

• How many visibility-visible resumes occurred after a hide?

• How many rAF callbacks were recorded while hidden?

• Which exact rAF row was the final pre-hide frame?

• Which exact rAF row was the first post-resume frame?

Identity matters more than totals. A summary saying “400 frames recorded” cannot identify whether the resume frame used the wrong predecessor. Preserve frameOrdinal, caseId, visibility, raw timestamp, raw delta, policy delta and resume count on every relevant row.

This is where the approach differs from Refonte’s Python ZIP duplicate-member integrity. That article preserves individual archive-member occurrence identity because duplicate filenames can make a filename-only integrity scan misleading. The present fixture preserves frame identity because totals cannot prove which timestamp straddled the visibility boundary. The operational habit is similar; the domain, oracle and failure mechanism are not.

A useful reconciliation assertion is:

const firstResume = rows.find(
  r => r.kind === "raf" && r.resumeCount === 1
);

if (!firstResume) throw new Error("missing first resume frame");

if (firstResume.policyDelta !== 0) {
  throw new Error("hidden interval entered logical animation time");
}

Also ensure the same evidence file contains the preceding visibility-hidden and visibility-visible. A detached row copied into an issue tracker is supporting material, not the authoritative ledger.

Separate documentation from observation

Four evidence classes must remain visibly distinct.

Documented contract. WHATWG defines animation-frame callback storage and invocation, page visibility state, and visibilitychange. The current HTML snapshot reviewed here is dated November 6, 2026.

Documentation of common browser policy. MDN says most browsers pause rAF callbacks in background tabs or hidden iframes. That is useful compatibility guidance, but its “most browsers” wording is not a normative all-engine guarantee.

Clock model. High Resolution Time specifies monotonic timing and says callback throttling or freezing should not alter the monotonic clock’s accuracy.

Observed execution. In the available test environment, Chromium 144.0.7559.96 never provided a valid hidden-document transition through the tested automation paths. Consequently, no observed hidden-resume rAF delta is available.

The resulting inference is bounded: a large first-resume raw delta is compatible with the documented timing model and common background-rAF policy, but the available test environment did not execute a qualifying hidden-tab case. The documentation makes such a result plausible, but it does not establish an observed millisecond value.

Revalidate the repaired invariant

After repair, repeat H2_LONG_HIDE without changing the expected manifest.

Pass condition:

• visibility sequence = visible → hidden → visible

• first resumed rAF row exists

• first resumed policyDelta = 0

• next ordinary visible frame uses rAF timestamp delta

• no unexplained exception

If the raw resume delta changes between runs, that is not automatically a failure. The invariant concerns policy ownership at the visibility boundary, not scheduler determinism.

Status: EXPECTED / NOT EXECUTED.

Repair the workflow without masking errors

The repair has two layers. First, retain raw evidence exactly as delivered by the browser. Second, derive an application delta from explicit state.

Do not repair the fixture by clamping every large delta:

const dt = Math.min(rawDelta, 50);

That masks more than hidden-tab resume. A long main-thread task, debugger pause, machine contention, or other scheduling discontinuity can also produce a large interval. A global clamp converts distinct failure modes into the same number and weakens diagnosis.

Prefer visibility-owned state:

let baseline = null;
let resumedFromHidden = false;

document.addEventListener("visibilitychange", () => {
  if (document.hidden) {
    resumedFromHidden = false;
    return;
  }

  resumedFromHidden = true;
  baseline = null;
});

function onFrame(ts) {
  let delta = 0;

  if (baseline !== null && !resumedFromHidden) {
    delta = ts - baseline;
  }

  baseline = ts;
  resumedFromHidden = false;

  update(delta);
  requestAnimationFrame(onFrame);
}

If the application also needs protection against visible-tab stalls, add that as a separate policy with a separately named metric. For example, visibleLongFrameDelta can be capped or subdivided according to simulation requirements. Do not call that hidden-tab repair.

The strongest design records the following fields:

rawDeltaMs
acceptedSimulationDeltaMs
deltaPolicyReason

That prevents debugging from degenerating into “the numbers look small now.”

Validate rollback and rerun safety

Rollback is straightforward because the repair changes timing policy rather than persistent user data. Preserve the previous release artifact, fixture revision, expected manifest, and evidence format. Reverting should restore the earlier integration rule without requiring evidence migration.

Rerun safety is more demanding. Each execution must use a fresh run ID and must never append new rows to an old run while preserving the same identity:

const runId = crypto.randomUUID();

Write results to a unique file such as:

evidence-H2_LONG_HIDE-<runId>.json

A failed run stays retained. The next run does not erase it.

The related Refonte article on Java CompletableFuture cancellation separates a successful completion-handle operation from evidence that underlying work actually stopped. This rAF playbook applies the same high-level caution to a different interface boundary: a valid callback does not establish the application’s resume semantics. It does not reuse the Java article’s executor, interruption or effect-count workflow.

Assign operational ownership

Assign one owner to each proposition:

Pass condition: no critical assertion is owned only by “the browser” or “the test.” A responsible engineering role must own each decision.

Status: EXPECTED / NOT EXECUTED.

Apply the ACCEPT / REPAIR / RERUN / HOLD matrix

The release matrix is deliberately conservative.

For this evaluation, the final decision is HOLD. The reason is specific: the available browser execution path did not demonstrate the required document.visibilityState === "hidden" boundary, so no case can validly establish requestAnimationFrame hidden-tab resume delta behavior.

The next allowed transition is RERUN, not REPAIR. There is no executed browser result proving that the application implementation is wrong; the deficiency is evidence qualification. Once a real browser/tab environment records visible → hidden → visible, the same independently authored manifest can determine whether the implementation deserves ACCEPT or REPAIR.

The dialog article tests focus restoration and modal lifecycle; the asyncio.to_thread article tests context-capture timing; the OneHotEncoder article tests representation collisions; the ZIP article tests occurrence-level archive integrity; and the CompletableFuture article tests cancellation-versus-execution ownership. This playbook uses a visibility-boundary ledger connecting rAF timestamp identity, raw delta, document visibility, and an explicit resume-time policy. Their evidence does not establish browser behavior.

Build relevant skills with Refonte Learning

The Refonte Learning Frontend Development Program describes a 4-month program with 10–12 hours per week. Its published competencies include HTML5/CSS3, JavaScript ES6+, responsive web design, React, Redux, APIs/AJAX, Git, accessibility, and performance optimization. The page states that a basic understanding of programming concepts is required, HTML/CSS familiarity is a plus, and its admissions section says applicants must be working toward a bachelor’s degree or higher. It also describes a potential internship and states that successful completion can include a Training Certificate and Certificate of Internship.

The program page does not establish that this specific requestAnimationFrame timestamp-delta, document-visibility, and resume-policy laboratory is part of the curriculum. Coverage of this specialized laboratory should not be inferred from general frontend or performance topics.

For engineers who want broader practice in browser-side JavaScript, performance reasoning, accessible frontend implementation and controlled project work, the program is relevant at that skill-domain level. The acceptance standard for this article remains independent: do not release a hidden-tab timing change because rAF “worked.” Release only after a genuine visibility transition, an independently authored oracle, complete frame-level evidence, and the declared resume invariant all agree.