Frontend developer comparing old and new DOM states alongside View Transition promise results in browser developer tools.

A View Transition Started. Did the Old and New DOM States Match

Fri, Nov 20, 2026

A same-document view transition can produce a deceptively green signal. The DOM ends in the requested state. transition.finished fulfills. The page looks usable. Yet none of those facts, by itself, proves that the browser successfully created the old/new transition states you intended.

That distinction is built into the API. document.startViewTransition() captures the old state before invoking the update callback; after that callback successfully settles, the browser captures the new state and prepares the transition pseudo-elements. updateCallbackDone tracks the update callback. ready tracks whether the transition actually became ready to animate. finished tracks arrival at the end state and can still fulfill when animation setup failed or skipTransition() was used.

The operational acceptance question is therefore narrower and stricter:

Did the controlled old DOM state exist at the capture boundary, did the update callback create the independently specified new DOM state, did the transition reach the readiness state expected for this case, and did any skip or rejection agree with the documented lifecycle?

This playbook answers that question with an isolated localhost fixture, synthetic state, an independently authored expected-case manifest, a pinned browser/runtime tuple, a negative control, a machine-readable evidence ledger, and explicit recovery decisions. The fixture below has not been executed for this article. Every behavioral outcome remains EXPECTED / NOT EXECUTED until the exact pinned environment runs it and preserves its raw evidence.

Define the exact acceptance contract

Do not make finished your acceptance oracle. MDN defines updateCallbackDone as fulfilling when the update callback’s returned promise fulfills, while ready fulfills only when the transition pseudo-element tree exists and animation is about to start. finished fulfills after the end state is reached; importantly, it still fulfills when animation fails to start or is explicitly skipped, provided the update callback itself did not reject.

The CSS View Transitions Level 1 specification is even more useful operationally. It defines the order as old-state capture, update-callback execution, new-state capture, pseudo-element setup, then ready resolution. It also specifies that skipping does not suppress the update callback.

The acceptance contract for this laboratory is:

Assertion

Evidence required

Reject or hold when

Old source state

Canonical DOM sample immediately before startViewTransition() and unchanged state at callback entry

State differs before the controlled callback

Update execution

Callback count, callback-entry state, applied synthetic input

Callback missing, duplicated, or input identity lost

New DOM state

State sampled after mutation, at updateCallbackDone, and finally

Independent manifest does not match

Transition readiness

Fulfillment or rejection of ready, including rejection name

Result differs from case manifest

Skip semantics

Explicit skip intent plus ready, updateCallbackDone, finished outcomes

Skip is inferred only from appearance

Callback failure

Rejection identity propagated through the relevant promises

Failure is converted into a generic green result

Runtime identity

Exact Node, Playwright, Chromium, OS, source digest and manifest digest

Environment cannot be reconstructed

Evidence completeness

One raw ledger row per declared case

Case is absent, partially written, or overwritten

This is deliberately analogous in discipline, not subject matter, to Refonte’s CSS transition lifecycle validation, where an apparently correct final style is not accepted as proof of the intended lifecycle event. That neighboring article validates transitionend versus transitioncancel; it does not address the View Transitions API, old/new captures, ViewTransition promises, or update-callback reconciliation.

One important limit belongs in the contract: the public API does not expose the captured old bitmap or a byte-for-byte new snapshot for direct inspection. MDN describes ::view-transition-old() as a static snapshot and ::view-transition-new() as a live representation of the new view, but this fixture validates the DOM states feeding those lifecycle boundaries rather than claiming pixel identity.

Pin the tested version and environment

Version-specific behavior must be tied to the runtime that actually produced the evidence. The proposed commissioning baseline is Node.js 22.20.0, Playwright 1.64.1, and the Playwright-managed Chromium associated with the 1.64 release line. Node identifies 22.20.0 as an LTS release; Playwright 1.64 release notes identify Chromium 156.0.8078.4 for that release.

Do not silently substitute system Chrome. Playwright documents that each Playwright version expects particular browser binaries and that upgrading Playwright can require reinstalling its browsers.

Use an exact package declaration:

{
  "name": "view-transition-state-contract",
  "private": true,
  "type": "module",
  "engines": {
    "node": "22.20.0"
  },
  "scripts": {
    "test": "node harness.mjs"
  },
  "dependencies": {
    "playwright": "1.64.1"
  }
}

Bootstrap once with:

node --version
npm install --save-exact [email protected]
npx playwright install chromium
npm test

After the first bootstrap, commit package-lock.json and use npm ci for qualification runs. The harness records the actual installed package version and its own source digest when executed.

The browser viewport is fixed at 1280×720. The fixture uses no external fonts, images, network APIs, timers supplied by a backend, production data, authentication or persistent storage. Every transition state is a short synthetic token.

Record the runtime fingerprint

The bounded pass condition is simple: PASS only if the runtime row can identify the executable environment without relying on prose outside the artifact.

The harness records:

node version
Playwright package version
browser.version()
navigator.userAgent
navigator.platform
process.platform / process.arch
viewport
fixture URL
harness SHA-256
manifest SHA-256
execution timestamp

If any required field is absent, the behavioral rows may still be diagnostically useful, but the release decision is HOLD because the version-specific result cannot be reproduced responsibly.

Create the disposable fixture

The fixture must make the relevant lifecycle easy to observe and hard to contaminate. It uses one document, one state-bearing element, two optional duplicate-name elements, inline CSS, and an owned loopback HTTP server. The approach is related to Refonte’s content-visibility lifecycle fixture, which similarly separates browser lifecycle evidence from a merely plausible final rendering; the API and evidence here are otherwise different.

The page served by the harness is intentionally small:

<!doctype html>
<meta charset="utf-8">
<title>View Transition State Contract</title>
<style>
  :root { font-family: sans-serif; }
  #state {
    view-transition-name: state-card;
    padding: 24px;
  }

  .duplicate {
    view-transition-name: duplicate-card;
  }

  ::view-transition-group(*) {
    animation-duration: 60ms;
  }
</style>

<main>
  <div id="state" data-state="unset">unset</div>
  <div id="duplicate-a"></div>
  <div id="duplicate-b"></div>
</main>

The named #state element gives the transition an explicit state-bearing participant. For one boundary case, both otherwise inert duplicate elements receive the same view-transition-name, deliberately creating a transition setup error. MDN lists duplicate transition names as a reason ready can reject, and its View Transition guide notes that duplicate names can cause the transition to be skipped.

The fixture is disposable at two levels. A fresh browser context is created for every case, so one transition cannot leave DOM, animation or storage state for the next case. The localhost server is read-only and keeps no business state.

That isolation does not prove anything about a production framework, router, hydration process, image pipeline or long-lived SPA. It proves only the documented browser lifecycle against these authored inputs.

Author an independent expected-case manifest

The oracle must be written before examining runtime results. Do not let the harness synthesize its expected values from the same branch that performs the DOM mutation; that would let an implementation bug rewrite its own answer key.

Store this as expected-cases.json:

{
  "schema": 1,
  "cases": [
    {
      "id": "C01_SYNC",
      "mode": "sync",
      "initial": "old-A",
      "requested": "new-B",
      "applied": "new-B",
      "duplicateName": false,
      "skip": false,
      "rejectUpdate": false,
      "expected": {
        "old": "old-A",
        "new": "new-B",
        "updateCallbackDone": "fulfilled",
        "ready": "fulfilled",
        "finished": "fulfilled",
        "oracleMatch": true
      }
    },
    {
      "id": "C02_ASYNC",
      "mode": "async",
      "initial": "old-A",
      "requested": "new-B",
      "applied": "new-B",
      "duplicateName": false,
      "skip": false,
      "rejectUpdate": false,
      "expected": {
        "old": "old-A",
        "new": "new-B",
        "updateCallbackDone": "fulfilled",
        "ready": "fulfilled",
        "finished": "fulfilled",
        "oracleMatch": true
      }
    },
    {
      "id": "C03_EXPLICIT_SKIP",
      "mode": "sync",
      "initial": "old-A",
      "requested": "new-B",
      "applied": "new-B",
      "duplicateName": false,
      "skip": true,
      "rejectUpdate": false,
      "expected": {
        "old": "old-A",
        "new": "new-B",
        "updateCallbackDone": "fulfilled",
        "ready": "rejected",
        "readyError": "AbortError",
        "finished": "fulfilled",
        "oracleMatch": true
      }
    },
    {
      "id": "C04_UPDATE_REJECTS",
      "mode": "sync",
      "initial": "old-A",
      "requested": "new-B",
      "applied": "new-B",
      "duplicateName": false,
      "skip": false,
      "rejectUpdate": true,
      "expected": {
        "old": "old-A",
        "new": "old-A",
        "updateCallbackDone": "rejected",
        "ready": "rejected",
        "finished": "rejected",
        "oracleMatch": false
      }
    },
    {
      "id": "C05_DUPLICATE_NAME",
      "mode": "sync",
      "initial": "old-A",
      "requested": "new-B",
      "applied": "new-B",
      "duplicateName": true,
      "skip": false,
      "rejectUpdate": false,
      "expected": {
        "old": "old-A",
        "new": "new-B",
        "updateCallbackDone": "fulfilled",
        "ready": "rejected",
        "readyError": "InvalidStateError",
        "finished": "fulfilled",
        "oracleMatch": true
      }
    },
    {
      "id": "C06_NEGATIVE_WRONG_STATE",
      "mode": "sync",
      "initial": "old-A",
      "requested": "new-B",
      "applied": "wrong-C",
      "duplicateName": false,
      "skip": false,
      "rejectUpdate": false,
      "expected": {
        "old": "old-A",
        "new": "new-B",
        "updateCallbackDone": "fulfilled",
        "ready": "fulfilled",
        "finished": "fulfilled",
        "oracleMatch": false
      }
    }
  ]
}

The expected rejection of ready after a pre-readiness skipTransition() follows the specification: skipTransition() uses an AbortError; the update callback still runs; if the callback fulfills, finished reaches fulfillment even though animation did not proceed normally.

Keep a negative control

C06_NEGATIVE_WRONG_STATE is the falsification control. Lifecycle promises are expected to look healthy: the callback fulfills, transition setup succeeds and finished fulfills. But the callback deliberately writes wrong-C while the independent contract requires new-B.

The pass condition for the control itself is that the comparator reports oracleMatch: false. If this row comes back as a state match, the harness is not trustworthy and the entire batch is HOLD.

A negative control is more valuable here than another green transition. It proves the acceptance layer can distinguish “the API lifecycle completed” from “the intended application state was created.”

Reproduce the misleading success signal

C05_DUPLICATE_NAME is the cleanest demonstration of the misleading green signal.

The Level 1 algorithm requires the update callback to be called even if the transition has already been skipped. The specification explicitly frames DOM state change as independent from the visual enhancement. ready, however, rejects when the transition cannot begin. finished still fulfills when setup fails or a transition is skipped, assuming the update callback fulfilled.

Therefore this expected row is valid as a specification-derived test hypothesis:

old source DOM             old-A
update callback            runs
new DOM                    new-B
updateCallbackDone         fulfilled
ready                      rejected: InvalidStateError
finished                   fulfilled

Status: EXPECTED / NOT EXECUTED.

If an application checked only:

await transition.finished;
console.log("success");

it could classify the operation as a successful view transition even though the transition never reached the normal readiness boundary.

That does not mean finished is defective. It means the signal answers a different question. MDN describes it as the point at which the end state is visible and interactive, and explicitly says skipped or failed-to-start animations can still lead to fulfillment.

The acceptance gate must consequently inspect at least three independent dimensions: callback completion, transition readiness and reconciled DOM state.

Run the controlled comparison

The executable harness below serves the fixture, launches the pinned Playwright browser, creates a fresh context for each manifest row, captures lifecycle settlements and writes artifacts/evidence.json. It uses the same evidence principle as Refonte’s Playwright request-routing coverage: a plausible application-visible result does not replace an independent observation of the mechanism being qualified.

Save as harness.mjs:

import http from "node:http";
import { mkdir, readFile, writeFile } from "node:fs/promises";
import { createHash } from "node:crypto";
import { chromium } from "playwright";

const sha256 = (bytes) =>
  createHash("sha256").update(bytes).digest("hex");

const manifestBytes = await readFile("expected-cases.json");
const manifest = JSON.parse(manifestBytes);

const html = <!doctype html>
<meta charset="utf-8">
<title>VT contract</title>
<style>
  #state { view-transition-name: state-card; padding:24px; }
  .duplicate { view-transition-name: duplicate-card; }
  ::view-transition-group(*) { animation-duration:60ms; }
</style>
<main>
  <div id="state" data-state="unset">unset</div>
  <div id="duplicate-a"></div>
  <div id="duplicate-b"></div>
</main>;

const server = http.createServer((req, res) => {
  if (req.url === "/" || req.url.startsWith("/?")) {
    res.writeHead(200, {
      "content-type": "text/html; charset=utf-8",
      "cache-control": "no-store"
    });
    res.end(html);
    return;
  }
  res.writeHead(404).end("not found");
});

await new Promise((resolve) =>
  server.listen(0, "127.0.0.1", resolve)
);

const { port } = server.address();
const baseURL = http://127.0.0.1:${port}/;
let browser;

try {
  browser = await chromium.launch({ headless: true });

  const packageBytes =
    await readFile("node_modules/playwright/package.json");
  const playwrightVersion =
    JSON.parse(packageBytes).version;
  const harnessBytes = await readFile(new URL(import.meta.url));

  const rows = [];

  for (const c of manifest.cases) {
    const context = await browser.newContext({
      viewport: { width: 1280, height: 720 },
      locale: "en-US",
      timezoneId: "UTC"
    });

    const page = await context.newPage();
    await page.goto(baseURL, { waitUntil: "load" });

    const actual = await page.evaluate(async (c) => {
      const el = document.querySelector("#state");
      const da = document.querySelector("#duplicate-a");
      const db = document.querySelector("#duplicate-b");
      const events = [];

      const state = () => ({
        text: el.textContent,
        dataState: el.dataset.state
      });

      el.textContent = c.initial;
      el.dataset.state = c.initial;

      if (c.duplicateName) {
        da.className = "duplicate";
        db.className = "duplicate";
      }

      const oldDom = state();
      let callbackCount = 0;
      let atUpdateDone = null;
      let atReady = null;
      let pseudoProbe = null;

      const transition = document.startViewTransition(
        async () => {
          callbackCount++;
          events.push({
            event: "callback-start",
            state: state()
          });

          if (c.mode === "async") {
            await new Promise((resolve) =>
              setTimeout(resolve, 25)
            );
          }

          if (c.rejectUpdate) {
            events.push({
              event: "callback-reject",
              state: state()
            });
            throw new Error("VT_UPDATE_REJECT");
          }

          el.textContent = c.applied;
          el.dataset.state = c.applied;

          events.push({
            event: "callback-mutated",
            state: state()
          });
        }
      );

      const observe = (name, promise, onFulfilled) =>
        promise.then(
          () => {
            onFulfilled?.();
            return { name, status: "fulfilled" };
          },
          (error) => ({
            name,
            status: "rejected",
            errorName: error?.name ?? "Unknown",
            message: String(error?.message ?? error)
          })
        );

      const updateP = observe(
        "updateCallbackDone",
        transition.updateCallbackDone,
        () => { atUpdateDone = state(); }
      );

      const readyP = observe(
        "ready",
        transition.ready,
        () => {
          atReady = state();
          pseudoProbe = {
            oldDisplay: getComputedStyle(
              document.documentElement,
              "::view-transition-old(root)"
            ).display,
            newDisplay: getComputedStyle(
              document.documentElement,
              "::view-transition-new(root)"
            ).display
          };
        }
      );

      const finishedP = observe(
        "finished",
        transition.finished
      );

      if (c.skip) transition.skipTransition();

      const settlements =
        await Promise.all([updateP, readyP, finishedP]);

      return {
        oldDom,
        callbackCount,
        events,
        atUpdateDone,
        atReady,
        finalDom: state(),
        pseudoProbe,
        settlements
      };
    }, c);

    const byName = Object.fromEntries(
      actual.settlements.map((x) => [x.name, x])
    );

    const observedNew =
      actual.atUpdateDone?.dataState ??
      actual.finalDom.dataState;

    const oracleMatch =
      actual.oldDom.dataState === c.expected.old &&
      observedNew === c.expected.new &&
      actual.finalDom.dataState === c.expected.new;

    const lifecycleMatch =
      byName.updateCallbackDone.status ===
        c.expected.updateCallbackDone &&
      byName.ready.status === c.expected.ready &&
      byName.finished.status === c.expected.finished &&
      (!c.expected.readyError ||
        byName.ready.errorName === c.expected.readyError);

    rows.push({
      caseId: c.id,
      input: {
        mode: c.mode,
        initial: c.initial,
        requested: c.requested,
        applied: c.applied,
        duplicateName: c.duplicateName,
        skip: c.skip,
        rejectUpdate: c.rejectUpdate
      },
      expected: c.expected,
      actual,
      derived: {
        oracleMatch,
        lifecycleMatch,
        expectedOracleResultMatched:
          oracleMatch === c.expected.oracleMatch
      }
    });

    await context.close();
  }

  const probeContext = await browser.newContext({
    viewport: { width: 1280, height: 720 }
  });
  const probePage = await probeContext.newPage();
  await probePage.goto(baseURL);

  const browserProbe = await probePage.evaluate(() => ({
    userAgent: navigator.userAgent,
    platform: navigator.platform,
    visibilityState: document.visibilityState,
    supportsStartViewTransition:
      typeof document.startViewTransition === "function"
  }));

  const report = {
    schema: 1,
    generatedAt: new Date().toISOString(),
    status: "OBSERVED_EXECUTION",
    environment: {
      node: process.version,
      playwright: playwrightVersion,
      chromium: browser.version(),
      os: {
        platform: process.platform,
        arch: process.arch
      },
      viewport: { width: 1280, height: 720 },
      fixtureURL: baseURL,
      browserProbe,
      harnessSha256: sha256(harnessBytes),
      manifestSha256: sha256(manifestBytes)
    },
    cases: rows
  };

  await mkdir("artifacts", { recursive: true });
  await writeFile(
    "artifacts/evidence.json",
    JSON.stringify(report, null, 2)
  );

  const negative = rows.find(
    (r) => r.caseId === "C06_NEGATIVE_WRONG_STATE"
  );

  const complete =
    rows.length === manifest.cases.length &&
    rows.every((r) =>
      r.derived.lifecycleMatch &&
      r.derived.expectedOracleResultMatched
    ) &&
    negative &&
    negative.derived.oracleMatch === false;

  if (!complete) process.exitCode = 1;
} finally {
  await browser?.close();
  await new Promise((resolve) => server.close(resolve));
}

The harness does not promote expectations into observations. Until artifacts/evidence.json exists from the pinned run, all six rows remain EXPECTED / NOT EXECUTED.

Preserve failures before cleanup

The pass condition is that evidence is written before an engineer changes the fixture, manifest or browser version.

On failure, preserve:

expected-cases.json
harness.mjs
package.json
package-lock.json
artifacts/evidence.json
git commit SHA
git diff --exit-code result
npm --version
node --version
npx playwright --version

Do not “repair” a mismatch and then overwrite the failing artifact. Create a new run identifier or archive path. First-failure evidence is the basis for deciding whether the defect belongs to application state, test construction, runtime behavior or an unsupported assumption.

Test error and boundary cases

The boundary cases matter because the API deliberately decouples DOM update success from animation success.

C03_EXPLICIT_SKIP validates a direct skipTransition() call. MDN says the method skips the animation part but does not skip the associated view update. The Level 1 specification states that calling it before ready resolves rejects ready and uses AbortError; finished subsequently follows the update-callback outcome.

Expected row:

Case

updateCallbackDone

ready

finished

New DOM

C03

fulfilled

rejected AbortError

fulfilled

new-B

Status: EXPECTED / NOT EXECUTED.

C04_UPDATE_REJECTS isolates update failure. startViewTransition() documentation says that if the callback’s promise rejects, the transition is abandoned. The spec makes updateCallbackDone reject with that reason and skips the transition; finished rejects when the update callback rejects.

Expected row:

Case

updateCallbackDone

ready

finished

Final DOM

C04

rejected

rejected

rejected

old-A

Status: EXPECTED / NOT EXECUTED.

C05_DUPLICATE_NAME tests readiness failure independently from update success. The expected DOM still becomes new-B; updateCallbackDone and finished fulfill, while ready rejects with InvalidStateError.

There are intentionally excluded boundaries. The spec also skips a transition when the document is hidden at startViewTransition() time and can skip when the snapshot containing-block size changes. Those are documented cases, but this fixture does not pretend that headless tab visibility or viewport mutation has been made sufficiently deterministic here.

Capture the per-case evidence ledger

A useful evidence ledger is not a row saying PASS. It preserves enough state to reconstruct why the decision was made.

For each case, retain:

Field

Meaning

caseId

Stable identity joining manifest and result

input.initial

Authored old state

input.requested

Independent target contract

input.applied

What the synthetic callback actually writes

actual.oldDom

DOM immediately before transition start

callbackCount

Whether the update ran exactly once

events

Callback entry, mutation or rejection chronology

atUpdateDone

State when callback completion is observed

atReady

State when readiness is observed

settlements

All three promise outcomes

finalDom

Reconciled post-transition state

oracleMatch

Independent state-contract comparison

lifecycleMatch

Manifest-versus-promise comparison

environment

Browser/runtime/source identity

The case-by-case ledger before execution is:

Case

Purpose

Expected result

Publication state

Decision if observed exactly

C01

synchronous healthy update

all promises fulfill; new-B

EXPECTED / NOT EXECUTED

ACCEPT

C02

asynchronous healthy update

callback settles before readiness; new-B

EXPECTED / NOT EXECUTED

ACCEPT

C03

explicit skip

ready rejects; update and finish fulfill

EXPECTED / NOT EXECUTED

ACCEPT only where skip is intended

C04

callback rejection

update, ready and finished reject; old state remains

EXPECTED / NOT EXECUTED

REPAIR required success path

C05

duplicate transition name

new state applies; ready rejects; finish fulfills

EXPECTED / NOT EXECUTED

REPAIR

C06

wrong DOM negative control

lifecycle green, state oracle false

EXPECTED / NOT EXECUTED

REPAIR; batch valid only if mismatch detected

Overall release status now: HOLD (NOT EXECUTED).

Audit missing evidence

One bounded audit should run before anyone reviews semantics:

declared manifest rows == ledger rows
case IDs unique
no unknown case IDs
runtime record present
manifest digest present
harness digest present
every case has all three promise settlements
negative-control row exists
negative-control oracleMatch == false

If the browser process crashes after three cases, do not mark the remaining rows failed. Mark them NOT EXECUTED and choose RERUN if the environment can be restored unchanged. If evidence cannot establish which version actually ran, choose HOLD.

Missing evidence is neither a successful test nor a semantic product failure.

Reconcile observed state with expected state

State reconciliation is where this playbook differs from a lifecycle-demo article. The browser can satisfy its View Transition contract while the application creates the wrong state.

The pattern is closely related to the ownership problem in Refonte’s fetch stale-response UI validation: an asynchronous operation can complete normally and still be unauthorized to own the current UI. That article validates request ordering and stale writes; here the equivalent question is whether the update callback committed the state identified by this transition case.

For healthy cases, reconcile four state observations:

oldDom.dataState
callback-start state
atUpdateDone.dataState
finalDom.dataState

For C01 and C02 the required relation is:

oldDom == "old-A"
callback-entry == "old-A"
atUpdateDone == "new-B"
finalDom == "new-B"

The callback-entry equality is especially useful. The specification captures old state before scheduling the update callback, so in this isolated fixture the callback should enter with the authored old state still intact.

For ready-fulfilling cases, atReady should also equal new-B, because activation captures the new state and sets up the transition pseudo-elements before resolving ready.

Do not overstate what that proves. It proves the controlled DOM source state agrees with the independent state contract at the relevant lifecycle boundaries. It does not prove that a rasterized old image had a particular pixel checksum, nor that every composited visual detail matched a screenshot.

A mismatch therefore gets classified by boundary:

old source wrong          -> fixture/input defect or earlier mutation
callback entry wrong      -> uncontrolled mutation/race
callback applies wrong    -> application/update defect
updateDone right,
final wrong               -> post-update state ownership defect
ready rejects unexpectedly -> transition configuration/runtime investigation

This makes repair local instead of speculative.

Separate documented behavior from observations

Every claim in the ledger should carry one of four epistemic labels.

Documented behavior comes from MDN or the CSSWG draft. Examples: the old state is captured before the update callback; updateCallbackDone follows the callback promise; ready represents pseudo-element readiness; skipTransition() does not suppress the callback; finished can fulfill after a skipped transition.

Engineering inference is what the acceptance design concludes from that contract. For example, “finished alone is insufficient evidence that a transition reached ready” follows directly from documented skip behavior, but the decision to make ready mandatory for a specific release path is an engineering policy.

Proposed experiment is the executable fixture in this article.

Observed result exists only after the pinned harness runs. None exists here.

That separation is particularly important because CSSWG drafts can evolve and MDN pages can be updated. Version-lock the runtime and retain the documentation-access date in the review record rather than treating this article as an immutable browser guarantee.

Bound the repair

The repair boundary is one failed assertion, not “View Transitions are broken.”

A failure may justify changing:

the update callback
a duplicate view-transition-name
a state ownership guard
a fixture assumption
a manifest expectation proven incorrect by authoritative documentation

It does not justify changing all of them together.

Pass condition: one identified cause explains the preserved failure, one repair addresses that cause, and the independent expected manifest remains unchanged unless the requirement itself was formally corrected.

Repair the smallest failing boundary

Suppose C05 produces the expected InvalidStateError. The smallest repair is not “wait longer.” The documented problem is duplicate transition names, so remove the unintended duplicate name and rerun the same semantic case.

Suppose C06 reaches finished but the final state is wrong-C. Do not touch transition timing. The lifecycle is behaving correctly; the callback committed the wrong state. Repair the update mapping so requested: new-B produces new-B.

Suppose C02 leaves atUpdateDone correct but the final DOM changes afterward. The failure is beyond callback completion. Find the later state writer and establish ownership. Adding another await transition.finished does not solve an unauthorized post-update mutation.

Suppose C03 unexpectedly reports ready: fulfilled even though skipTransition() was synchronously called before waiting for it. Preserve the complete artifact before interpreting it. The spec states that a pre-readiness skip should reject ready; a contradictory observation is therefore HOLD until runtime identity, call ordering and reproduction are established.

The repair protocol is:

  1. Preserve the failed ledger and source digests.

  2. Classify the failed boundary: input, callback, readiness, state reconciliation, runtime or harness.

  3. Change one cause.

  4. Keep the original expectation unless requirements or authoritative semantics changed.

  5. Run the negative control.

  6. Run the repaired case in a fresh context.

  7. Run the full batch once with the same pinned runtime.

  8. Compare old and repaired evidence rather than replacing the first artifact.

A repair is complete only after post-repair verification. A code diff is not evidence that the lifecycle now matches the contract.

Validate rollback and safe rerun

A rerun is valid only if the starting conditions are equivalent. Refonte’s Playwright retry evidence playbook makes the same general distinction: a later green attempt must not erase the first failure, and fresh browser state does not automatically reset every external state boundary. This fixture avoids external mutable systems, but the evidence-retention principle still applies.

For this laboratory, safe rerun requires:

same manifest digest
same harness digest, unless testing a named repair
same package-lock
same Playwright version
same Chromium build
same viewport
fresh BrowserContext
fresh fixture load
no retries hidden inside the harness
unique evidence output

Rollback means restore the last known-good application/update implementation, not modify the oracle so the failing implementation passes.

If a runtime upgrade is the reason for rerun, treat that as a new qualification set. A Chromium 156 result must not be silently combined with a later browser as if the rows came from one runtime.

The Level 1 spec also notes that starting another document transition while one is active can skip the existing transition with AbortError, and that asynchronous update callbacks may consequently overlap or execute out of the developer’s expected sequence. This fixture deliberately does not qualify overlapping application transitions. If the real application allows them, add a separate deterministic ownership experiment rather than assuming the six rows above cover concurrency.

Assign an operational owner

Every non-ACCEPT decision needs an owner at the boundary that can change the cause.

A wrong-C state maps to the component or state-update owner. Duplicate view-transition-name maps to the styling/component owner. A browser/version contradiction maps first to the browser-test or frontend-platform owner for reproduction. Missing runtime evidence maps to the harness/CI owner.

The pass condition is not a person’s name inside the fixture. It is that the release record identifies one accountable team or role, the failed assertion, the preserved artifact and the required exit evidence.

An unowned HOLD tends to become an accidental ACCEPT.

Apply the ACCEPT / REPAIR / RERUN / HOLD gate

Use the four decisions literally.

Decision

Evidence rule

ACCEPT

Required cases executed in the pinned environment; lifecycle settlements match the independent manifest; DOM reconciliation matches; negative control proves mismatch detection; no required evidence is missing

REPAIR

Evidence is complete and identifies a deterministic application, CSS or harness defect that violates the contract

RERUN

The case did not receive a valid execution because of an environmental interruption or an explicitly repaired fixture; original evidence remains preserved

HOLD

Required cases are unexecuted, runtime identity is missing, documentation and observation conflict, negative control fails, or evidence cannot distinguish competing causes

Apply it conservatively.

A deliberate skipTransition() case can be ACCEPT when skipping is the declared behavior and the new DOM reconciles correctly. The API explicitly treats the state change as independent from animation.

An unexpected ready rejection with a correct final DOM is REPAIR, not ACCEPT, for a path whose contract requires an actual transition.

A callback rejection is REPAIR when the required operation should have created a new state.

A crash before the case ran is RERUN, not REPAIR.

A result collected against an unknown Chrome binary is HOLD.

A negative control that unexpectedly reports oracleMatch: true is HOLD for the entire suite because the state oracle has failed its falsification test.

Pending execution, the decision is:

HOLD (EXPECTED / NOT EXECUTED).

That is not a prediction of browser failure. It is the only defensible status before the pinned fixture has produced an evidence ledger.

The acceptance sequence is therefore compact: old source state → update callback → callback completion → new-state reconciliation → transition readiness → final state → negative control → evidence completeness. The green signal at any single point is insufficient.

Connect the practice to Refonte Learning

The Refonte Learning Frontend Development program page currently describes a four-month program with an indicated commitment of 10–12 hours per week. It lists HTML5/CSS3, JavaScript ES6+, responsive web design, React, Redux, APIs/AJAX, Git, accessibility and performance optimization among the competencies, plus practical projects and a capstone. The page states that a basic understanding of programming concepts is expected and that familiarity with HTML/CSS is a plus; a separate admissions section currently states that applicants should be working toward a bachelor’s or higher-level degree.

The same page identifies an educational mentor and states that successful completion offers a Training Certificate and a Certificate of Internship; it also describes a “Potential Internship.”

Engineers looking for structured coverage of the underlying HTML, CSS, JavaScript, SPA and frontend foundations can review the Refonte Learning Frontend Development Program. The acceptance method in this playbook remains independently reproducible: pin the runtime, author the oracle first, run the disposable fixture, preserve the first evidence, reconcile the DOM state against the declared case, verify the negative control after repair, and do not convert EXPECTED / NOT EXECUTED into ACCEPT until the browser actually produced the ledger.