@parity/product-lab 0.1.1 → 0.2.0

package/core/domain/src/recordings/recording-settings.d.ts

@@ -9,6 +9,7 @@ export declare const RECORDING_VARIABLES: {
     readonly maxAgeDays: "PRODUCT_LAB_RECORDINGS_MAX_AGE_DAYS";
     readonly maxMb: "PRODUCT_LAB_RECORDINGS_MAX_MB";
     readonly video: "PRODUCT_LAB_RECORDINGS_VIDEO";
+    readonly settleTimeoutMs: "PRODUCT_LAB_RECORDINGS_SETTLE_MS";
     readonly hostLogs: "PRODUCT_LAB_RECORDINGS_HOST_LOGS";
     readonly hostLogKb: "PRODUCT_LAB_RECORDINGS_HOST_LOG_KB";
 };
@@ -25,13 +26,15 @@ export declare class RecordingSettings {
     static readonly DEFAULT: RecordingSettings;
     readonly mode: RecordingMode;
     readonly retention: RecordingRetention;
-    /** A capture that takes longer is recorded as failed (it never holds the run). */
+    /** A capture that takes longer is recorded as failed; only video feature boundaries wait for it. */
     readonly captureTimeoutMs: number;
     /**
      * Backlog 18b: headless identities' pages are recorded as video into the recordings directory's `videos/` folder,
      * and each recording refers to the videos of the pages its steps acted in. Default off (`product-lab test --video`).
      */
     readonly video: boolean;
+    /** Video feature after-frames compare screenshots for at most this long (default 3000 ms). */
+    readonly settleTimeoutMs: number;
     /**
      * Backlog 192: each host's own log is kept with a failed run's recording (`failed`), with every run's (`always`), or
      * never (`off`); at most `hostLogBytes` of each, its tail.
@@ -43,6 +46,7 @@ export declare class RecordingSettings {
         retention: RecordingRetention;
         captureTimeoutMs: number;
         video?: boolean;
+        settleTimeoutMs?: number;
         hostLogs?: HostLogsMode;
         hostLogBytes?: number;
     });

package/core/domain/src/recordings/recording-settings.js

@@ -9,6 +9,7 @@ export const RECORDING_VARIABLES = {
     maxAgeDays: "PRODUCT_LAB_RECORDINGS_MAX_AGE_DAYS",
     maxMb: "PRODUCT_LAB_RECORDINGS_MAX_MB",
     video: "PRODUCT_LAB_RECORDINGS_VIDEO",
+    settleTimeoutMs: "PRODUCT_LAB_RECORDINGS_SETTLE_MS",
     hostLogs: "PRODUCT_LAB_RECORDINGS_HOST_LOGS",
     hostLogKb: "PRODUCT_LAB_RECORDINGS_HOST_LOG_KB",
 };
@@ -21,6 +22,7 @@ export class RecordingSettings {
     retention;
     captureTimeoutMs;
     video;
+    settleTimeoutMs;
     hostLogs;
     hostLogBytes;
     constructor(settings) {
@@ -31,6 +33,10 @@ export class RecordingSettings {
         this.mode = settings.mode;
         this.retention = settings.retention;
         this.captureTimeoutMs = settings.captureTimeoutMs;
+        const settleTimeoutMs = settings.settleTimeoutMs ?? 3000;
+        if (!Number.isFinite(settleTimeoutMs) || settleTimeoutMs <= 0)
+            throw new RecordingFormatError("A frame stability wait needs a positive timeout");
+        this.settleTimeoutMs = Math.min(settleTimeoutMs, this.captureTimeoutMs - Math.min(1000, this.captureTimeoutMs / 2));
         this.video = settings.mode !== "off" && (settings.video ?? false);
         const hostLogs = settings.hostLogs ?? "failed";
         if (!["failed", "always", "off"].includes(hostLogs))
@@ -74,6 +80,7 @@ export class RecordingSettings {
             }),
             captureTimeoutMs: RecordingSettings.DEFAULT.captureTimeoutMs,
             video: video === "on",
+            settleTimeoutMs: number(RECORDING_VARIABLES.settleTimeoutMs, RecordingSettings.DEFAULT.settleTimeoutMs, 1, false),
             hostLogs,
             hostLogBytes: number(RECORDING_VARIABLES.hostLogKb, HOST_LOG_BYTES, 1024, true),
         });

package/core/domain/src/recordings/run-recording.d.ts

@@ -51,6 +51,8 @@ export declare class RunRecording {
         before: FrameChoice;
         after: FrameChoice;
     };
+    /** A cap frame remains available, with its uncertainty visible wherever the viewer chooses it. */
+    private labelStability;
     private framesOf;
     private before;
     private after;

package/core/domain/src/recordings/run-recording.js

@@ -179,6 +179,8 @@ export class RunRecording {
                 throw new RecordingFormatError(`Recording frame ${id} has an unknown status`);
             if (frame.step !== undefined && (typeof frame.step !== "number" || !Number.isInteger(frame.step) || frame.step < 0 || frame.step >= steps.length))
                 throw new RecordingFormatError(`Recording frame ${id} names step ${String(frame.step)}, which the recording does not have`);
+            if (frame.featureStep !== undefined && (typeof frame.featureStep !== "number" || !Number.isSafeInteger(frame.featureStep) || frame.featureStep < 1))
+                throw new RecordingFormatError("Recording frame featureStep must be a positive step number");
             time(`frames[${index}].requestedAt`, frame.requestedAt);
             if (!Array.isArray(frame.overlapping))
                 throw new RecordingFormatError(`Recording frame ${id} must list the steps it overlapped`);
@@ -239,7 +241,12 @@ export class RunRecording {
         const who = actor ?? step.actor;
         if (!who)
             return { before: RunRecording.missing("This step acted as no identity: pick one to see its app"), after: RunRecording.missing("This step acted as no identity: pick one to see its app") };
-        return { actor: who, before: this.before(step, who), after: this.after(step, who) };
+        return { actor: who, before: this.labelStability(this.before(step, who)), after: this.labelStability(this.after(step, who)) };
+    }
+    labelStability(choice) {
+        if (choice.status !== "captured" || choice.frame?.settled !== false)
+            return choice;
+        return { ...choice, note: `Taken at the stability cap; visual stability was not confirmed. ${choice.note.replace(/^Settled(?=:|,)/, "Capture")}` };
     }
     framesOf(actor) {
         return this.data.frames.filter((frame) => frame.actor === actor);

package/core/ports/README.md

@@ -456,3 +456,9 @@ JSON, only when `extrinsics(blockHash, { includeCallArguments: true })` requests
 neither copy nor retain arguments. Consumers can check transaction contents beside the exact finalized hash; absent
 is unknown, and `null` is a decoded call with no arguments. JSON conversion cuts nesting beyond 12 levels to `"…"`;
 `decoded: "complete"` describes SCALE decoding, not JSON depth coverage. The chain adapter owns decoding.
+
+## Held feature demos
+
+FeatureScenarioHandle optionally exposes startStep and finishStep for custom definitions: observation only, without scheduling their work. VideoEditRequest.stills supplies one complete recorded image per segment. DemoRequest.holdSeconds defaults to 2 and cannot be below 2. A full demo exports step-001.png and later images decoded from each encoded hold midpoint, with a caption band below the app.
+
+`CaptureOptions.loadComplete` optionally requests a read of the current document until loading completes, within `timeoutMs`; `CapturedFrame.loadComplete` reports when the source verified it. The recorder requests this only during video feature after-frame stability checks. Sources without this support leave the result absent.

package/core/ports/src/driven/recording/demo-ports.d.ts

@@ -18,6 +18,8 @@ export interface VideoEditRequest {
     readonly source: string;
     readonly plan: DemoPlan;
     readonly overlays: readonly VideoOverlay[];
+    /** Already composed recorded stills, one per plan segment; replaces the video inputs when supplied. */
+    readonly stills?: readonly Uint8Array[];
     /** Where the cut is written (its parent exists); replaced whole. */
     readonly out: string;
     readonly format: "mp4" | "webm";

package/core/ports/src/driven/recording/frame-capture.d.ts

@@ -7,6 +7,8 @@ export interface CapturedFrame {
     bytes: Uint8Array;
     /** How long the capture waited for the app's screen to settle (`CaptureOptions.settled`), when it was asked to. */
     settledMs?: number;
+    /** Whether the source verified the current document completed loading before this image. */
+    loadComplete?: boolean;
 }
 /** Why no image of that identity's app can be taken (no page, a surface that cannot be captured, …). */
 export interface UnavailableFrame {
@@ -35,6 +37,8 @@ export interface CaptureOptions {
     signal?: AbortSignal;
     timeoutMs?: number;
     mask?: readonly string[];
+    /** Read the current document until readyState is complete before imaging it, bounded by timeoutMs. */
+    loadComplete?: boolean;
     settled?: {
         readonly selectors: readonly string[];
         readonly timeoutMs: number;

package/core/ports/src/driving/demo.d.ts

@@ -8,6 +8,8 @@ export interface DemoRequest {
     out?: string;
     /** The longest the cut should be (default 60). */
     maxSeconds?: number;
+    /** Each after-step image is held this long (default 2, minimum 2 seconds). */
+    holdSeconds?: number;
     format?: "mp4" | "webm";
     /** Only the cut's plan: demo.json and demo.vtt, no video, no slide (needs no ffmpeg). */
     planOnly?: boolean;

package/core/ports/src/driving/feature-session.d.ts

@@ -230,6 +230,13 @@ export interface FeatureScenarioHandle {
     readonly name: string;
     /** Run step `index` once (a custom step is run by its own definition, not here). */
     run(index: number): Promise<FeatureStepTrace>;
+    /** Observe a direct/custom definition, without running it through the scheduler. Generated steps time themselves. */
+    startStep?(index: number): void;
+    /** Observe its after-state; only video runs await capture before the next step or pause. Skipped steps have no boundary. */
+    finishStep?(index: number, outcome: {
+        status: "passed" | "failed";
+        error?: string;
+    }): Promise<void>;
     /** The identity a scenario actor is bound to. */
     actor(name: string): ActorSession;
     /** The scenario's outputs so far. */

package/entrypoints/cli/README.md

@@ -795,9 +795,8 @@ blank. It loads no lab. `pr-suite.yml` posts it. Test: `tests/pr-comment.test.ts
 
 ## Recorded runs
 
-`product-lab demo [<recording-id>] [--actor <role> | --window] [--out <dir>] [--max-seconds 60] [--format mp4|webm] [--plan | --slide-only] [--failed] [--json]`
-(backlog 36) cuts a recorded feature scenario into a demo through `LabRuntime.demo`: about a
-minute, each action at real speed with its result held, waits sped up and labelled, a caption per Gherkin step in the
+`product-lab demo [<recording-id>] [--actor <role> | --window] [--out <dir>] [--max-seconds 60] [--hold-seconds 2] [--format mp4|webm] [--plan | --slide-only] [--failed] [--json]`
+(backlog 36) cuts a recorded feature scenario into a demo through `LabRuntime.demo`: one recorded after-state per step held for at least two seconds, a caption band below the app in the
 lab window's style, with `demo.vtt`, `demo.json` and a slide (`slide.png`, `slide.html`) in
 `<lab>/.product-lab/demos/<recording-id>`. The video needs `ffmpeg` and `ffprobe` on `PATH` (or `PRODUCT_LAB_FFMPEG`
 naming their folder; never bundled); `--plan` and `--slide-only` do not. Starts nothing. Exit 2 when refused (no such
@@ -893,3 +892,7 @@ failure; this detail does not change retries or cancellation. Test:
 `tests/abort-diagnostics.test.ts`.
 
 The generated minimal reference uses the released SDK's native PAPI 3 transaction creator and carries its app's current SDK and client install pins. Its file list and dependency test follow that source; no local signer bridge is copied. The rebased migration is awaiting qualification.
+
+## Held feature demos
+
+Demo holds default to 2 s per feature step; --hold-seconds tunes them upward and --max-seconds never shortens them. Captions occupy a separate band below the app. Full renders also write step-001.png and later files decoded from the midpoint of each hold. Direct/custom feature steps are recorded with their start/end times and after-state images. Default frames-only capture is asynchronous; --video awaits bounded after-step captures and retains a 2 s tail before scenario cleanup. Old footage without a matching after-state is refused rather than replaced with an unrelated screen.

package/entrypoints/cli/src/demo-command.d.ts

@@ -1,4 +1,4 @@
 import type { DemoReport, LabRuntime } from "@parity/product-lab/ports/driving";
-export declare const DEMO_USAGE = "Usage: product-lab demo [<recording-id>] [--actor <role> | --window] [--out <dir>] [--max-seconds 60]\n                        [--format mp4|webm] [--plan | --slide-only] [--failed] [--json] [--config lab.config.ts]\n\nA demo of a recorded feature scenario: its video cut to about a minute, every action at real speed with its result\nheld, waits sped up and labelled (\u00D78 waiting for finality), a caption per Gherkin step, plus demo.vtt (the captions),\ndemo.json (the edit, segment by segment) and a slide (slide.png, slide.html: the scenario, its steps, who and where,\nthe last screen). Record a run with video first (product-lab test --video, or the lab window's recording).\n  <recording-id>    default: the newest passed feature recording\n  --actor <role>    cut that actor's app video (default: the lab window's, else the actor in most steps)\n  --window          cut the lab window's video\n  --out <dir>       default: <lab>/.product-lab/demos/<recording-id>\n  --max-seconds <n> the longest the cut should be (default 60); over it the waits speed up first\n  --format mp4|webm default mp4 (H.264); webm is VP9\n  --plan            only demo.json and demo.vtt (needs no ffmpeg)\n  --slide-only      the plan and the slide, no video (needs no ffmpeg)\n  --failed          allow a failed run: every frame and the slide say it failed\n  --json            print the report as JSON\n  The video needs ffmpeg and ffprobe on PATH (or PRODUCT_LAB_FFMPEG naming their folder); product-lab never bundles them.\n  Exit code: 0 made, 2 refused (no such recording, no video, a failed run without --failed, no ffmpeg) or bad arguments,\n  1 when the lab does not load or the cut fails.";
+export declare const DEMO_USAGE = "Usage: product-lab demo [<recording-id>] [--actor <role> | --window] [--out <dir>] [--max-seconds 60] [--hold-seconds 2]\n                        [--format mp4|webm] [--plan | --slide-only] [--failed] [--json] [--config lab.config.ts]\n\nA demo of a recorded feature scenario: its real after-step images held for at least 2 seconds each,\nwith captions in a band under the app and step-001.png (one encoded midpoint PNG per step), plus demo.vtt (the captions),\ndemo.json (the edit, segment by segment) and a slide (slide.png, slide.html: the scenario, its steps, who and where,\nthe last screen). Record a run with video first (product-lab test --video, or the lab window's recording).\n  <recording-id>    default: the newest passed feature recording\n  --actor <role>    cut that actor's app video (default: the lab window's, else the actor in most steps)\n  --window          cut the lab window's video\n  --out <dir>       default: <lab>/.product-lab/demos/<recording-id>\n  --max-seconds <n> the target length (default 60); never shortens the step holds\n  --hold-seconds <n> hold each after-step image (default 2, minimum 2 seconds)\n  --format mp4|webm default mp4 (H.264); webm is VP9\n  --plan            only demo.json and demo.vtt (needs no ffmpeg)\n  --slide-only      the plan and the slide, no video (needs no ffmpeg)\n  --failed          allow a failed run: every frame and the slide say it failed\n  --json            print the report as JSON\n  The video needs ffmpeg and ffprobe on PATH (or PRODUCT_LAB_FFMPEG naming their folder); product-lab never bundles them.\n  Exit code: 0 made, 2 refused (no such recording, no video, a failed run without --failed, no ffmpeg) or bad arguments,\n  1 when the lab does not load or the cut fails.";
 export declare function renderDemo(report: DemoReport): string;
 export declare function runDemoCommand(runtime: LabRuntime, argv: string[], signal?: AbortSignal, out?: (text: string) => void, err?: (text: string) => void): Promise<number>;

package/entrypoints/cli/src/demo-command.js

@@ -2,18 +2,19 @@
 // SPDX-License-Identifier: Apache-2.0
 import { parseArgs } from "node:util";
 import { DemoRefusedError } from "@parity/product-lab/domain/recordings";
-export const DEMO_USAGE = `Usage: product-lab demo [<recording-id>] [--actor <role> | --window] [--out <dir>] [--max-seconds 60]
+export const DEMO_USAGE = `Usage: product-lab demo [<recording-id>] [--actor <role> | --window] [--out <dir>] [--max-seconds 60] [--hold-seconds 2]
                         [--format mp4|webm] [--plan | --slide-only] [--failed] [--json] [--config lab.config.ts]
 
-A demo of a recorded feature scenario: its video cut to about a minute, every action at real speed with its result
-held, waits sped up and labelled (×8 waiting for finality), a caption per Gherkin step, plus demo.vtt (the captions),
+A demo of a recorded feature scenario: its real after-step images held for at least 2 seconds each,
+with captions in a band under the app and step-001.png (one encoded midpoint PNG per step), plus demo.vtt (the captions),
 demo.json (the edit, segment by segment) and a slide (slide.png, slide.html: the scenario, its steps, who and where,
 the last screen). Record a run with video first (product-lab test --video, or the lab window's recording).
   <recording-id>    default: the newest passed feature recording
   --actor <role>    cut that actor's app video (default: the lab window's, else the actor in most steps)
   --window          cut the lab window's video
   --out <dir>       default: <lab>/.product-lab/demos/<recording-id>
-  --max-seconds <n> the longest the cut should be (default 60); over it the waits speed up first
+  --max-seconds <n> the target length (default 60); never shortens the step holds
+  --hold-seconds <n> hold each after-step image (default 2, minimum 2 seconds)
   --format mp4|webm default mp4 (H.264); webm is VP9
   --plan            only demo.json and demo.vtt (needs no ffmpeg)
   --slide-only      the plan and the slide, no video (needs no ffmpeg)
@@ -48,6 +49,7 @@ export async function runDemoCommand(runtime, argv, signal, out = (text) => proc
                 window: { type: "boolean" },
                 out: { type: "string" },
                 "max-seconds": { type: "string" },
+                "hold-seconds": { type: "string" },
                 format: { type: "string" },
                 plan: { type: "boolean" },
                 "slide-only": { type: "boolean" },
@@ -66,12 +68,14 @@ export async function runDemoCommand(runtime, argv, signal, out = (text) => proc
         return 0;
     }
     const maxSeconds = values["max-seconds"] === undefined ? undefined : Number(values["max-seconds"]);
+    const holdSeconds = values["hold-seconds"] === undefined ? undefined : Number(values["hold-seconds"]);
     const problem = positionals.length > 1 ? `Unexpected arguments: ${positionals.slice(1).join(" ")}`
         : values.actor !== undefined && values.window ? "--actor and --window cannot be used together"
             : values.plan && values["slide-only"] ? "--plan and --slide-only cannot be used together"
                 : values.format !== undefined && values.format !== "mp4" && values.format !== "webm" ? `--format must be mp4 or webm, not ${values.format}`
                     : maxSeconds !== undefined && !(Number.isFinite(maxSeconds) && maxSeconds >= 5) ? `--max-seconds must be a number of seconds, at least 5, not ${values["max-seconds"]}`
-                        : undefined;
+                        : holdSeconds !== undefined && !(Number.isFinite(holdSeconds) && holdSeconds >= 2) ? `--hold-seconds must be a number of seconds, at least 2, not ${values["hold-seconds"]}`
+                            : undefined;
     if (problem) {
         err(`${problem}\n${DEMO_USAGE}\n`);
         return 2;
@@ -84,6 +88,7 @@ export async function runDemoCommand(runtime, argv, signal, out = (text) => proc
             ...(values.window ? { window: true } : {}),
             ...(values.out !== undefined ? { out: values.out } : {}),
             ...(maxSeconds !== undefined ? { maxSeconds } : {}),
+            ...(holdSeconds !== undefined ? { holdSeconds } : {}),
             ...(values.format ? { format: values.format } : {}),
             ...(values.plan ? { planOnly: true } : {}),
             ...(values["slide-only"] ? { slideOnly: true } : {}),

package/entrypoints/mcp/README.md

@@ -202,3 +202,6 @@ the file. Neither live script is part of the unit suite.
 
 The reload test creates its ES-module lab in an OS temporary directory, linking this package's `node_modules`.
 Concurrent lint can no longer discover a generated lab under the repository's `tests/` without a TypeScript project.
+
+Design-resource hashes track the current topic text, including the distinction between passive frames-only
+capture and awaited video capture at feature boundaries.

package/entrypoints/panel/README.md

@@ -417,9 +417,10 @@ Every running actor's app tile has a compact, browser-like address bar in the co
   (`data-frame`), so a re-created frame never receives an old frame's address. The bar never shows a guessed location.
 
 Tests: `node --import tsx --test entrypoints/panel/tests/address-bar.test.ts` (served shell, headless Chromium,
-loopback fixture apps on ephemeral ports; a normal tab and the lab window via `openLabWindow`, including real
-`framenavigated` reports and the acting guard). Optional `ADDRESS_BAR_SCREENS=<directory>` writes review screenshots
-(unset: none).
+loopback fixture apps on ephemeral ports that count browser requests by `Sec-Fetch-Dest`, which Chromium sends
+to these loopback origins, ignoring a local port probe without that header;
+a normal tab and the lab window via `openLabWindow`, including real `framenavigated` reports and the acting guard).
+Optional `ADDRESS_BAR_SCREENS=<directory>` writes review screenshots (unset: none).
 
 ## Visible execution: `@product-lab/shell/visible`
 
@@ -1771,3 +1772,5 @@ Framing reuse (item82): the framing section above retains the original item66 be
 The drawer puts its existing tabs in a full-width row below the title and Close control. Tabs wrap at narrow widths, keeping Recordings reachable without replacing the live app frame. Watch controls the displayed app in a window opened through `openLabWindow`; the server can keep running in the background while that window remains visible.
 
 Opening a recording displays its captured screenshots over the mounted app, with Play/Pause and previous/next screenshot controls. The viewer labels its fixed1.5s image cadence and absence of video; it cannot recover typing or clicks between captures. Back to live restores the app and run controls. Active runs are checked before and after loading the recording, using the latest panel snapshot. The run audit remains available even with zero recorded steps, and incomplete audits explicitly explain that proof is missing.
+
+Recording captures of tiles and detached windows honor `CaptureOptions.loadComplete` before taking their image and report `loadComplete: true` when checked. Only video feature after-frame checks request this wait; normal captures retain their existing policy. Tests: `tests/window-frames.test.ts` and `tests/detached-identities.test.ts`.

package/entrypoints/panel/src/visible/detached-identities.js

@@ -195,6 +195,10 @@ export function detachedFrameCapture(tiles, detached, options = {}) {
             const timeoutMs = captureOptions?.timeoutMs ?? options.timeoutMs ?? DETACHED_CAPTURE_TIMEOUT_MS;
             if (signal?.aborted)
                 throw new Error(`${window.actor.name}'s detached window was not captured: the recorder stopped waiting`);
+            if (captureOptions?.loadComplete) {
+                await window.app.waitForFunction(() => document.readyState === "complete", undefined, { timeout: timeoutMs });
+                signal?.throwIfAborted();
+            }
             const started = Date.now();
             const unsettled = captureOptions?.settled?.selectors.length ? await settle(window.app, captureOptions.settled) : undefined;
             if (unsettled)
@@ -211,7 +215,7 @@ export function detachedFrameCapture(tiles, detached, options = {}) {
                     throw new Error(`${window.actor.name}'s detached window gave no frame within ${timeoutMs} ms`, { cause: error });
                 throw new Error(`${window.actor.name}'s detached window could not be captured: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
             }
-            return { status: "captured", mediaType: "image/png", bytes: new Uint8Array(bytes), ...settled };
+            return { status: "captured", mediaType: "image/png", bytes: new Uint8Array(bytes), ...settled, ...(captureOptions?.loadComplete ? { loadComplete: true } : {}) };
         },
     };
 }

package/entrypoints/panel/src/visible/window-frames.js

@@ -13,6 +13,19 @@ export function windowFrameCapture(page, frameSelector, media, videos, uiCalls)
         video: () => windowVideo(page, videos, { source: "lab-window", scope: "window" }),
         async capture(actorId, options) {
             const selector = frameSelector(actorId);
+            if (options?.loadComplete) {
+                const element = await page.locator(selector).elementHandle({ timeout: options.timeoutMs });
+                try {
+                    const app = await element?.contentFrame();
+                    if (!app)
+                        return { status: "unavailable", reason: "The displayed app has no current document" };
+                    await app.waitForLoadState("load", { timeout: options.timeoutMs });
+                }
+                finally {
+                    await element?.dispose();
+                }
+                options.signal?.throwIfAborted();
+            }
             const started = Date.now();
             const unsettled = options?.settled?.selectors.length ? await settle(page.frameLocator(selector), options.settled) : undefined;
             if (unsettled)
@@ -45,7 +58,7 @@ export function windowFrameCapture(page, frameSelector, media, videos, uiCalls)
                     const bytes = await cutInWorker(await shot, view.width, { rect: { x, y, width, height } });
                     const after = await page.evaluate(steadyFrameBox, { selector, settleMs: 0 });
                     if (!("moving" in after) && sameBox(after, box))
-                        return { status: "captured", mediaType: "image/png", bytes: new Uint8Array(bytes), ...settled };
+                        return { status: "captured", mediaType: "image/png", bytes: new Uint8Array(bytes), ...settled, ...(options?.loadComplete ? { loadComplete: true } : {}) };
                 }
                 finally {
                     if (!shot)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parity/product-lab",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "type": "module",
   "description": "Run and test Polkadot products against real local chains, hosts and browsers: the framework and the product-lab CLI.",
   "license": "Apache-2.0",