@jitsusama/agentic-harness.core 0.1.0 → 0.3.0

package/dist/web/hydration/capture.js

@@ -0,0 +1,96 @@
+/**
+ * Reading the server render and the hydrated page side by side.
+ *
+ * The server's HTML is fetched from inside the page, so it
+ * travels with the session's own cookies and headers, and it is
+ * parsed with DOMParser, which builds a document without running
+ * a single script: exactly what the browser had before hydration
+ * ran. Both documents are reduced to the same compact shape,
+ * text and tag counts, because the judgment belongs to the pure
+ * side and whole DOM trees do not fit through a capture.
+ */
+/** Texts shorter than this are markup lint, not content. */
+export const MIN_TEXT_CHARS = 3;
+/** How many texts to carry per side. */
+export const MAX_TEXTS = 500;
+/** How much of each text to keep. */
+export const MAX_TEXT_CHARS = 120;
+/**
+ * The expression that reads both renders.
+ *
+ * Async because the server render is a fetch; evaluate it with
+ * awaitPromise. Scripts, styles and noscript are excluded from
+ * both sides: they are machinery, not content, and noscript text
+ * is visible in exactly one of the two renders by definition.
+ */
+export const HYDRATION_CAPTURE = `(async () => {
+	const MIN_TEXT = ${MIN_TEXT_CHARS};
+	const MAX_TEXTS = ${MAX_TEXTS};
+	const MAX_CHARS = ${MAX_TEXT_CHARS};
+	const MACHINERY = new Set(["script", "style", "noscript", "template"]);
+
+	const textsOf = (root) => {
+		const walker = document.createTreeWalker(
+			root,
+			NodeFilter.SHOW_TEXT,
+			null,
+		);
+		const texts = [];
+		while (walker.nextNode() && texts.length < MAX_TEXTS) {
+			const node = walker.currentNode;
+			const parent = node.parentElement;
+			if (!parent) continue;
+			if (MACHINERY.has(parent.tagName.toLowerCase())) continue;
+			const text = (node.textContent || "")
+				.replace(/\\s+/g, " ")
+				.trim()
+				.slice(0, MAX_CHARS);
+			if (text.length >= MIN_TEXT) texts.push(text);
+		}
+		return texts;
+	};
+
+	const tagsOf = (root) => {
+		const counts = {};
+		for (const el of root.querySelectorAll("*")) {
+			const tag = el.tagName.toLowerCase();
+			if (MACHINERY.has(tag) || tag === "link" || tag === "meta") continue;
+			counts[tag] = (counts[tag] || 0) + 1;
+		}
+		return counts;
+	};
+
+	let fetched = false;
+	let status;
+	let serverTexts = [];
+	let serverTags = {};
+	try {
+		const response = await fetch(location.href, {
+			headers: { accept: "text/html" },
+			credentials: "include",
+			cache: "no-store",
+		});
+		status = response.status;
+		if (response.ok) {
+			const html = await response.text();
+			const server = new DOMParser().parseFromString(html, "text/html");
+			const root = server.body || server.documentElement;
+			serverTexts = textsOf(root);
+			serverTags = tagsOf(root);
+			fetched = true;
+		}
+	} catch (error) {
+		// fetched stays false, which the judge reports honestly.
+	}
+
+	const live = document.body || document.documentElement;
+	return {
+		url: location.href,
+		fetched,
+		...(status === undefined ? {} : { status }),
+		serverTexts,
+		serverTags,
+		clientTexts: textsOf(live),
+		clientTags: tagsOf(live),
+	};
+})()`;

package/dist/web/hydration/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Whether the page the server sent is the page the person got.
+ *
+ * The capture reads both renders from inside the page; the judge
+ * is pure and takes serialized data, so it can judge a stored
+ * capture as easily as a live one. Nothing here can start a
+ * browser.
+ */
+export { HYDRATION_CAPTURE, type HydrationCapture, MAX_TEXT_CHARS, MAX_TEXTS, MIN_TEXT_CHARS, } from "./capture.js";
+export { type ConsoleLine, type HydrationReport, judgeHydration, renderHydration, SHELL_FLOOR_TEXTS, SHELL_MIN_CLIENT_TEXTS, TAG_DRIFT_MIN, type TagDrift, } from "./judge.js";

package/dist/web/hydration/index.js

@@ -0,0 +1,10 @@
+/**
+ * Whether the page the server sent is the page the person got.
+ *
+ * The capture reads both renders from inside the page; the judge
+ * is pure and takes serialized data, so it can judge a stored
+ * capture as easily as a live one. Nothing here can start a
+ * browser.
+ */
+export { HYDRATION_CAPTURE, MAX_TEXT_CHARS, MAX_TEXTS, MIN_TEXT_CHARS, } from "./capture.js";
+export { judgeHydration, renderHydration, SHELL_FLOOR_TEXTS, SHELL_MIN_CLIENT_TEXTS, TAG_DRIFT_MIN, } from "./judge.js";

package/dist/web/hydration/judge.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Whether the page the server sent is the page the person got.
+ *
+ * A hydration mismatch ships silently: the markup is valid, the
+ * console line scrolls past, and the visitor sees content flash,
+ * flip or vanish. The judgment here is over three kinds of
+ * evidence: content in the server render that is gone after
+ * hydration, content that only exists after hydration, and the
+ * framework's own hydration warnings caught in the console.
+ *
+ * Framework-agnostic on purpose. The console recognizers know
+ * the words React and Vue use, but the DOM comparison knows
+ * nothing about any framework: a server render and a hydrated
+ * document disagree or they do not.
+ *
+ * Adapted from the hydration-safety check in Carolyn McNeillie's
+ * review-page skill set, generalized from its React framing.
+ */
+import { type Standing } from "../audit/verdict.js";
+import type { HydrationCapture } from "./capture.js";
+/** One console line, as the session's telemetry records it. */
+export interface ConsoleLine {
+    readonly level: string;
+    readonly text: string;
+}
+/** A tag whose count moved between the renders. */
+export interface TagDrift {
+    readonly tag: string;
+    readonly server: number;
+    readonly client: number;
+}
+/** Everything the judge concluded. */
+export interface HydrationReport {
+    readonly standing: Standing;
+    /** Server content that is gone after hydration. */
+    readonly vanished: readonly string[];
+    /** Content that only exists after hydration. */
+    readonly appeared: readonly string[];
+    readonly drift: readonly TagDrift[];
+    /** The framework's own hydration complaints. */
+    readonly warnings: readonly string[];
+    /** True when there was no server render worth comparing. */
+    readonly shell: boolean;
+    readonly fetched: boolean;
+    readonly status?: number;
+}
+/** Fewer server texts than this is a shell, not a render. */
+export declare const SHELL_FLOOR_TEXTS = 5;
+/** ...when the client has at least this many. */
+export declare const SHELL_MIN_CLIENT_TEXTS = 20;
+/** A tag count moving less than this is churn, not drift. */
+export declare const TAG_DRIFT_MIN = 5;
+/** Judge a capture beside what the console said during load. */
+export declare function judgeHydration(capture: HydrationCapture, consoleLines?: readonly ConsoleLine[]): HydrationReport;
+/** Say whether the server render survived hydration. */
+export declare function renderHydration(report: HydrationReport): string;

package/dist/web/hydration/judge.js

@@ -0,0 +1,191 @@
+/**
+ * Whether the page the server sent is the page the person got.
+ *
+ * A hydration mismatch ships silently: the markup is valid, the
+ * console line scrolls past, and the visitor sees content flash,
+ * flip or vanish. The judgment here is over three kinds of
+ * evidence: content in the server render that is gone after
+ * hydration, content that only exists after hydration, and the
+ * framework's own hydration warnings caught in the console.
+ *
+ * Framework-agnostic on purpose. The console recognizers know
+ * the words React and Vue use, but the DOM comparison knows
+ * nothing about any framework: a server render and a hydrated
+ * document disagree or they do not.
+ *
+ * Adapted from the hydration-safety check in Carolyn McNeillie's
+ * review-page skill set, generalized from its React framing.
+ */
+import { count, renderVerdict } from "../audit/verdict.js";
+/**
+ * What a hydration complaint looks like in a console.
+ *
+ * React 17 says "Text content does not match server-rendered
+ * HTML", React 18 and 19 say "Hydration failed" and "an error
+ * occurred during hydration", Vue says "Hydration node mismatch".
+ * The word stem covers all but the first, which gets its own
+ * pattern.
+ */
+const COMPLAINTS = [/hydrat/i, /did not match/i, /server.rendered/i];
+/** Console levels worth reading complaints from. */
+const SPOKEN_LEVELS = new Set(["error", "warning", "warn"]);
+/** Fewer server texts than this is a shell, not a render. */
+export const SHELL_FLOOR_TEXTS = 5;
+/** ...when the client has at least this many. */
+export const SHELL_MIN_CLIENT_TEXTS = 20;
+/** A tag count moving less than this is churn, not drift. */
+export const TAG_DRIFT_MIN = 5;
+function multiset(texts) {
+    const counts = new Map();
+    for (const text of texts)
+        counts.set(text, (counts.get(text) ?? 0) + 1);
+    return counts;
+}
+function difference(from, take) {
+    const remaining = multiset(take);
+    const out = [];
+    for (const text of from) {
+        const left = remaining.get(text) ?? 0;
+        if (left > 0) {
+            remaining.set(text, left - 1);
+        }
+        else {
+            out.push(text);
+        }
+    }
+    return out;
+}
+/** Judge a capture beside what the console said during load. */
+export function judgeHydration(capture, consoleLines = []) {
+    const warnings = consoleLines
+        .filter((line) => SPOKEN_LEVELS.has(line.level))
+        .filter((line) => COMPLAINTS.some((pattern) => pattern.test(line.text)))
+        .map((line) => line.text);
+    const base = {
+        warnings,
+        fetched: capture.fetched,
+        ...(capture.status === undefined ? {} : { status: capture.status }),
+    };
+    if (!capture.fetched) {
+        return {
+            ...base,
+            standing: warnings.length > 0 ? "fail" : "warn",
+            vanished: [],
+            appeared: [],
+            drift: [],
+            shell: false,
+        };
+    }
+    // A client-rendered page has no server render to hold it to:
+    // every text would read as appeared, which is noise about an
+    // architecture, not findings about a bug.
+    const shell = capture.serverTexts.length < SHELL_FLOOR_TEXTS &&
+        capture.clientTexts.length >= SHELL_MIN_CLIENT_TEXTS;
+    if (shell) {
+        return {
+            ...base,
+            standing: warnings.length > 0 ? "fail" : "warn",
+            vanished: [],
+            appeared: [],
+            drift: [],
+            shell: true,
+        };
+    }
+    const vanished = difference(capture.serverTexts, capture.clientTexts);
+    const appeared = difference(capture.clientTexts, capture.serverTexts);
+    const tags = new Set([
+        ...Object.keys(capture.serverTags),
+        ...Object.keys(capture.clientTags),
+    ]);
+    const drift = [];
+    for (const tag of tags) {
+        const server = capture.serverTags[tag] ?? 0;
+        const client = capture.clientTags[tag] ?? 0;
+        if (Math.abs(client - server) >= TAG_DRIFT_MIN) {
+            drift.push({ tag, server, client });
+        }
+    }
+    drift.sort((a, b) => Math.abs(b.client - b.server) - Math.abs(a.client - a.server));
+    // The framework saying hydration failed, or server content a
+    // person was sent no longer being there, is a failure. Content
+    // that only appeared is a warning: a client-only widget is
+    // legitimate, and this cannot tell it from a bug.
+    const standing = warnings.length > 0 || vanished.length > 0
+        ? "fail"
+        : appeared.length > 0 || drift.length > 0
+            ? "warn"
+            : "pass";
+    return { ...base, standing, vanished, appeared, drift, shell: false };
+}
+/** How many texts to name per list before counting the rest. */
+const MAX_LISTED = 5;
+function listed(texts) {
+    const lines = texts.slice(0, MAX_LISTED).map((text) => `    "${text}"`);
+    if (texts.length > MAX_LISTED) {
+        lines.push(`    ... and ${texts.length - MAX_LISTED} more.`);
+    }
+    return lines;
+}
+/** Say whether the server render survived hydration. */
+export function renderHydration(report) {
+    if (!report.fetched) {
+        return renderVerdict({
+            standing: report.standing,
+            headline: report.warnings.length > 0
+                ? "The console complained about hydration, and the server " +
+                    "render could not be fetched to say what diverged."
+                : "The server render could not be fetched, so nothing " +
+                    "was compared.",
+            measured: `Fetching the page's own URL from inside it ` +
+                `${report.status === undefined ? "threw" : `answered ${report.status}`}. ` +
+                `The comparison needs the HTML the server sends before ` +
+                `any script runs.`,
+        }, report.warnings.map((line) => `  ${line}`).join("\n"));
+    }
+    if (report.shell) {
+        return renderVerdict({
+            standing: report.standing,
+            headline: "The page is client-rendered: the server sends a shell, " +
+                "so there is no server render to hold the page to.",
+            measured: "Hydration cannot mismatch when nothing is hydrated; " +
+                "whether a shell is acceptable here is a judgment call, " +
+                "so this is not a pass.",
+        }, report.warnings.map((line) => `  ${line}`).join("\n"));
+    }
+    const parts = [];
+    if (report.warnings.length > 0) {
+        parts.push(`The framework complained during hydration:`, ...report.warnings.map((line) => `    ${line}`));
+    }
+    if (report.vanished.length > 0) {
+        parts.push(`Server content gone after hydration ` +
+            `(${count(report.vanished.length, "text")}):`, ...listed(report.vanished));
+    }
+    if (report.appeared.length > 0) {
+        parts.push(`Content that only exists after hydration ` +
+            `(${count(report.appeared.length, "text")}):`, ...listed(report.appeared));
+    }
+    if (report.drift.length > 0) {
+        parts.push("Element counts that moved:", ...report.drift.map((one) => `    <${one.tag}>  ${one.server} on the server, ` +
+            `${one.client} after hydration`));
+    }
+    const headline = report.standing === "pass"
+        ? "The hydrated page says what the server sent."
+        : report.standing === "fail"
+            ? report.warnings.length > 0
+                ? "The framework itself reported a hydration failure."
+                : `${count(report.vanished.length, "server text")} ` +
+                    `vanished during hydration.`
+            : `The renders agree on shared content, but ` +
+                `${count(report.appeared.length, "text")} and ` +
+                `${count(report.drift.length, "tag count", "tag counts")} ` +
+                `exist only after hydration.`;
+    return renderVerdict({
+        standing: report.standing,
+        headline,
+        measured: "Compared the HTML the server sends, parsed without running " +
+            "a script, against the live document. A page that renders " +
+            "the time or a locale will differ between the two fetches; " +
+            "paired vanished and appeared texts of the same shape are " +
+            "that, not a bug.",
+    }, parts.join("\n"));
+}

package/dist/web/index.d.ts

@@ -21,6 +21,7 @@
  * - `envelope/`  paging, budgets and the on-disk artifact sink
  * - `environment/` emulation, storage, network shaping, status
  * - `evaluate/`  running an expression and surviving the result
+ * - `hydration/` whether the server render survived hydration
  * - `input/`     key chords, pointer paths, touch gestures
  * - `perf/`      web vitals from the browser's own observers
  * - `snapshot/`  the whole page flattened, frames and shadow

package/dist/web/index.js

@@ -21,6 +21,7 @@
  * - `envelope/`  paging, budgets and the on-disk artifact sink
  * - `environment/` emulation, storage, network shaping, status
  * - `evaluate/`  running an expression and surviving the result
+ * - `hydration/` whether the server render survived hydration
  * - `input/`     key chords, pointer paths, touch gestures
  * - `perf/`      web vitals from the browser's own observers
  * - `snapshot/`  the whole page flattened, frames and shadow

package/dist/web/perf/index.d.ts

@@ -11,4 +11,4 @@ export { observerBootstrap, readVitalsSource } from "./probe.js";
 export { foldProfile, type Hotspot, type Hotspots, type RawProfile, type RawProfileNode, renderHotspots, } from "./profile.js";
 export { categoriesFor, type FrameStory, foldTrace, type RawTraceEvent, type RequestSpan, renderTrace, type TaskCost, type TimerStory, TRACE_CATEGORIES, type TraceCapture, type TraceProfile, } from "./trace.js";
 export { renderVitals } from "./view.js";
-export { cumulativeShift, type LongTask, type Measure, measure, type Rating, rate, SESSION_CAP_MS, SESSION_GAP_MS, type Shift, THRESHOLDS, type Vitals, worstShiftSources, } from "./vitals.js";
+export { cumulativeShift, type LongTask, type Measure, measure, measureSamples, type Rating, rate, SESSION_CAP_MS, SESSION_GAP_MS, type Shift, type Spread, THRESHOLDS, type Vitals, worstShiftSources, } from "./vitals.js";

package/dist/web/perf/index.js

@@ -11,4 +11,4 @@ export { observerBootstrap, readVitalsSource } from "./probe.js";
 export { foldProfile, renderHotspots, } from "./profile.js";
 export { categoriesFor, foldTrace, renderTrace, TRACE_CATEGORIES, } from "./trace.js";
 export { renderVitals } from "./view.js";
-export { cumulativeShift, measure, rate, SESSION_CAP_MS, SESSION_GAP_MS, THRESHOLDS, worstShiftSources, } from "./vitals.js";
+export { cumulativeShift, measure, measureSamples, rate, SESSION_CAP_MS, SESSION_GAP_MS, THRESHOLDS, worstShiftSources, } from "./vitals.js";

package/dist/web/perf/view.js

@@ -47,12 +47,26 @@ export function renderVitals(vitals, measures) {
     // person to interact: nothing here observes event timing, so a
     // reader told only that four were measured has no way to know
     // responsiveness was never among them, and assumes it passed.
+    const sampled = Math.max(...measures.map((one) => one.spread?.samples ?? 1));
+    // A rating that changed between loads is the finding, not the
+    // median beside it: the median alone reads as settled.
+    const unstable = measures.filter((one) => one.spread?.straddles);
     const caveat = ` Interaction to next paint is not among them: it needs an ` +
         `interaction, and this measures a load.` +
+        (sampled <= 1 ? "" : ` Each value is the median of ${sampled} loads.`) +
+        (unstable.length === 0
+            ? ""
+            : ` Rated differently between loads: ${unstable
+                .map((one) => one.name)
+                .join(", ")}.`) +
         (missing.length === 0 ? "" : ` Not observed: ${missing.join("; ")}.`);
     const width = Math.max(...measures.map((one) => one.name.length));
     const lines = measures.map((one) => `  ${one.name.padEnd(width)}  ${MARK[one.rating].padEnd(4)}  ` +
         `${say(one.value, one.unit).padStart(9)}` +
+        `${one.spread && one.spread.samples > 1
+            ? `  ${say(one.spread.low, one.unit)}-${say(one.spread.high, one.unit)}` +
+                ` over ${one.spread.samples}`
+            : ""}` +
         `${one.detail ? `  ${one.detail}` : ""}`);
     const blame = worstShiftSources(vitals.shifts);
     if (blame.length > 0) {
@@ -71,7 +85,11 @@ export function renderVitals(vitals, measures) {
         // A partial capture cannot pass: an observer that never
         // installed reports nothing, which reads the same as a page
         // with nothing wrong.
-        standing: missing.length > 0 && overall(measures) === "pass"
+        // A pass that only holds on the median is not a pass: a
+        // metric that rated poor on any load is worth a look even
+        // when the middle run was fine.
+        standing: (missing.length > 0 || unstable.length > 0) &&
+            overall(measures) === "pass"
             ? "warn"
             : overall(measures),
         headline: failing.length === 0

package/dist/web/perf/vitals.d.ts

@@ -128,6 +128,15 @@ export declare function worstShiftSources(shifts: readonly Shift[], limit?: numb
     readonly node: string;
     readonly moved: number;
 }[];
+/** How a metric varied across repeated loads. */
+export interface Spread {
+    readonly low: number;
+    readonly high: number;
+    /** How many loads actually reported this metric. */
+    readonly samples: number;
+    /** Whether the rating differed between loads. */
+    readonly straddles: boolean;
+}
 /** One metric, rated. */
 export interface Measure {
     readonly name: string;
@@ -136,6 +145,26 @@ export interface Measure {
     readonly rating: Rating;
     /** What the value points at, when the browser said. */
     readonly detail?: string;
+    /** Present when the value is a median over several loads. */
+    readonly spread?: Spread;
 }
 /** Read the vitals into rated measures. */
 export declare function measure(vitals: Vitals): readonly Measure[];
+/**
+ * Read several captures of the same page into rated measures,
+ * one per metric, each the median over the loads that reported
+ * it.
+ *
+ * A single headless load drifts: the same page can rate good on
+ * one run and poor on the next without anything changing. The
+ * median is the defensible middle, and the spread is reported
+ * beside it because a rating that straddles the runs is the
+ * finding, not the number.
+ *
+ * The rating is taken from the sample nearest the median rather
+ * than re-derived, so a metric keeps exactly the thresholds
+ * `measure` gave it. For an even count the worse of the two
+ * middle samples decides, which errs toward the reading a
+ * person would want to hear about.
+ */
+export declare function measureSamples(samples: readonly Vitals[]): readonly Measure[];

package/dist/web/perf/vitals.js

@@ -173,3 +173,73 @@ export function measure(vitals) {
     }
     return measures;
 }
+/**
+ * Read several captures of the same page into rated measures,
+ * one per metric, each the median over the loads that reported
+ * it.
+ *
+ * A single headless load drifts: the same page can rate good on
+ * one run and poor on the next without anything changing. The
+ * median is the defensible middle, and the spread is reported
+ * beside it because a rating that straddles the runs is the
+ * finding, not the number.
+ *
+ * The rating is taken from the sample nearest the median rather
+ * than re-derived, so a metric keeps exactly the thresholds
+ * `measure` gave it. For an even count the worse of the two
+ * middle samples decides, which errs toward the reading a
+ * person would want to hear about.
+ */
+export function measureSamples(samples) {
+    const first = samples[0];
+    if (first === undefined)
+        return [];
+    if (samples.length === 1)
+        return measure(first);
+    const order = [];
+    const byName = new Map();
+    for (const capture of samples) {
+        for (const one of measure(capture)) {
+            const group = byName.get(one.name);
+            if (group === undefined) {
+                byName.set(one.name, [one]);
+                order.push(one.name);
+            }
+            else {
+                group.push(one);
+            }
+        }
+    }
+    return order.map((name) => {
+        // Set above for every name in order; the map cannot miss.
+        const group = byName.get(name);
+        const sorted = [...group].sort((a, b) => a.value - b.value);
+        const mid = Math.floor(sorted.length / 2);
+        const upper = sorted[mid];
+        const lower = sorted[Math.max(0, mid - 1)];
+        const odd = sorted.length % 2 === 1;
+        const median = odd ? upper.value : (lower.value + upper.value) / 2;
+        const worseMiddle = SEVERITY_ORDER.indexOf(lower.rating) >=
+            SEVERITY_ORDER.indexOf(upper.rating)
+            ? lower
+            : upper;
+        const nearest = odd ? upper : worseMiddle;
+        const low = sorted[0].value;
+        const high = sorted[sorted.length - 1].value;
+        return {
+            name,
+            value: median,
+            unit: nearest.unit,
+            rating: nearest.rating,
+            ...(nearest.detail === undefined ? {} : { detail: nearest.detail }),
+            spread: {
+                low,
+                high,
+                samples: group.length,
+                straddles: new Set(group.map((one) => one.rating)).size > 1,
+            },
+        };
+    });
+}
+/** Mildest to worst, for choosing the reading to stand on. */
+const SEVERITY_ORDER = ["good", "needs-improvement", "poor"];

package/dist/web/session.d.ts

@@ -18,9 +18,10 @@ import { type Animation, type BoxModel, type DelegatedListeners, type HoverRepor
 import { type Divergence, type EmulationState, type NetworkRule, type ObservedEnvironment, type SavedState, type SessionStatus, type StorageSnapshot, type TabRecord, type ThrottleConditions } from "./environment/index.js";
 import { type ChordRefusal, type Point, type PointerEventStep, type TouchStep } from "./input/index.js";
 import { type Settled, type WaitCondition, type WaitOutcome } from "./wait/index.js";
-import { type A11yFinding, type BehindReport, type CapturedTarget, type ConformanceBar, type ContrastLevel, type PageBox, type PairReport, type StructureNode, type VisualNode } from "./audit/index.js";
-import { type StyleSample } from "./design/index.js";
+import { type A11yFinding, type BehindReport, type CapturedTarget, type ConformanceBar, type ContrastLevel, type MotionCapture, type PageBox, type PairReport, type StructureNode, type VisualNode } from "./audit/index.js";
+import { type StyleSample, type TextBlock } from "./design/index.js";
 import { type EvalFrame, type EvalOutcome } from "./evaluate/index.js";
+import { type HydrationCapture } from "./hydration/index.js";
 import { type HeapComparison, type Hotspots, type LayerReport, type TraceCapture, type TraceProfile, type Vitals } from "./perf/index.js";
 import { type IndexedNode } from "./snapshot/index.js";
 import { type PropertyTrace, type StyleGroup } from "./styles/index.js";
@@ -810,6 +811,18 @@ export declare class BrowserSession {
      * a click or a navigation without disturbing what it reports.
      */
     focusHolder(): Promise<FocusHolder | undefined>;
+    /**
+     * What the page keeps doing when asked to hold still.
+     *
+     * Emulates prefers-reduced-motion: reduce, reloads so the page
+     * decides its motion under the preference rather than being
+     * caught mid-flight, reads what is still moving, then puts the
+     * emulation back exactly as it was. The reload matters: a page
+     * picks most of its motion at load, so flipping the preference
+     * on a settled page measures its reaction to a change, not its
+     * behaviour for a visitor who arrived with the preference set.
+     */
+    motionUnderReduce(): Promise<MotionCapture>;
     structure(): Promise<readonly StructureNode[]>;
     /**
      * What the layout actually did, as the browser measured it.
@@ -828,6 +841,22 @@ export declare class BrowserSession {
      * criterion turns on.
      */
     targets(): Promise<readonly CapturedTarget[]>;
+    /**
+     * Both renders of the current page: what the server sends and
+     * what hydration made of it.
+     *
+     * The server render is fetched from inside the page, so it
+     * travels with the session's cookies, and parsed without
+     * running a script. Judging the capture is the hydration
+     * subdomain's job; pair it with logs() so the framework's own
+     * complaints are read beside the comparison.
+     */
+    hydration(): Promise<HydrationCapture>;
+    /**
+     * How the page's text blocks wrap, measured from real line
+     * boxes rather than estimated from fonts.
+     */
+    typography(): Promise<readonly TextBlock[]>;
     layout(): Promise<{
         readonly nodes: readonly VisualNode[];
         readonly viewport: PageBox;