@parity/product-lab 0.0.1-placeholder → 0.1.0

package/core/application/src/recordings/record-runs.js

@@ -0,0 +1,426 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+import { describeFailure } from "@parity/product-lab/domain";
+import { RecordingHealth, RunRecording, StepConsoleErrors } from "@parity/product-lab/domain/recordings";
+import { NO_HOST_LOGS, readHostLogs } from "./host-logs.js";
+import { SETTLE_TIMEOUT_MS, StepChainReader } from "./step-chain-reader.js";
+import { HealthSampler } from "./health-sampler.js";
+import { RecordingDraft } from "./recording-draft.js";
+import { Deadline } from "./deadline.js";
+const FEATURE_JOB = /^feature:(.*)#(\d+)$/;
+const NO_SOURCE = "No frame source: the environment offers no capture (LabEnvironment.frames) and no lab window registered one";
+const WRITTEN_KEPT = 500;
+export class RecordRuns {
+    options;
+    open = new Map();
+    writes = new Set();
+    watchedFeatureRuns = new Set();
+    written = new Map();
+    unsubscribe;
+    lastFailure;
+    constructor(options) {
+        this.options = options;
+    }
+    start() {
+        if (this.unsubscribe || this.options.stores.settings.mode === "off")
+            return;
+        const events = this.options.events.subscribe((event) => this.onRuntimeEvent(event));
+        const settling = this.options.state.beforeClose.add(async () => {
+            await Promise.all([this.settleCaptures(), this.keepOpenHostLogs()]);
+        });
+        this.unsubscribe = () => {
+            events();
+            settling();
+        };
+    }
+    async close() {
+        for (const key of [...this.open.keys()])
+            this.finalize(key, "the runtime closed");
+        await Promise.allSettled([...this.writes]);
+        this.unsubscribe?.();
+        this.unsubscribe = undefined;
+    }
+    async settleCaptures() {
+        const pending = [...this.open.values()].flatMap((draft) => [...draft.pending]);
+        if (!pending.length)
+            return;
+        const deadline = new Deadline(this.options.stores.settings.captureTimeoutMs, (ms, signal) => this.options.clock.sleep(ms, signal));
+        await deadline.all(pending);
+        deadline.stop();
+    }
+    keepHostLogs(draft) {
+        const mode = this.options.stores.settings.hostLogs;
+        if (draft.hostLogs || mode === "off")
+            return draft.hostLogs;
+        if (mode === "failed" && draft.status() !== "failed" && !draft.hasFailedStep())
+            return undefined;
+        if (draft.active.closed)
+            return undefined;
+        draft.hostLogs = readHostLogs(draft.active.environment, this.options.files, draft.everyIdentity(), draft.names(), this.options.stores.settings.hostLogBytes).catch((error) => ({
+            ...NO_HOST_LOGS,
+            gaps: [`The hosts' logs could not be read: ${describeFailure(error)}`],
+        }));
+        return draft.hostLogs;
+    }
+    async keepOpenHostLogs() {
+        await Promise.all([...this.open.values()].map((draft) => this.keepHostLogs(draft)));
+    }
+    async flush() {
+        await Promise.allSettled([...this.writes]);
+    }
+    liveStepHealth(runId, step) {
+        for (const draft of this.open.values()) {
+            const entry = draft.runs.find((item) => item.run.id === runId);
+            if (!entry)
+                continue;
+            const recorded = entry.run.record.steps[step];
+            if (recorded?.startedAt === undefined)
+                return { none: `step ${step} has not started` };
+            const index = draft.index(entry.run, step);
+            const window = { index, startedAt: recorded.startedAt, ...(recorded.finishedAt !== undefined ? { finishedAt: recorded.finishedAt } : {}) };
+            const health = draft.health ? RecordingHealth.DEFAULT.steps([window], draft.health.sampled()) : [];
+            return health.length ? { health, live: true } : { none: "nothing was sampled in or before the step yet" };
+        }
+        return undefined;
+    }
+    writtenTo(key) {
+        return this.written.get(key);
+    }
+    remember(draft, recording) {
+        this.written.set(draft.key, { recording });
+        for (const entry of draft.runs)
+            if (entry.base !== undefined)
+                this.written.set(`run:${entry.run.id}`, { recording, base: entry.base });
+        for (const key of this.written.keys()) {
+            if (this.written.size <= WRITTEN_KEPT)
+                break;
+            this.written.delete(key);
+        }
+    }
+    async closeScenario(title) {
+        for (const draft of [...this.open.values()])
+            if (draft.kind === "feature" && draft.title === title)
+                this.finalize(draft.key, "the load ended");
+        await this.flush();
+    }
+    now() {
+        return this.options.clock.date().getTime();
+    }
+    onRuntimeEvent(event) {
+        if (event.type === "run-started")
+            this.runStarted(event.runId);
+        else if (event.type === "run-finished")
+            this.runFinished(event.runId);
+        else if (event.type === "feature-paused")
+            this.featurePaused(event.featureRun, event.checkpoint.scenario, event.identities);
+        else if (event.type === "environment-stopped" || event.type === "environment-reset" || event.type === "environment-switched")
+            for (const key of [...this.open.keys()])
+                this.finalize(key, `the environment ${event.type.slice("environment-".length)}`);
+    }
+    runStarted(runId) {
+        const active = this.options.state.active;
+        const run = active?.run(runId);
+        if (!active || !run)
+            return;
+        const match = FEATURE_JOB.exec(run.record.scenarioId);
+        const draft = match ? this.featureDraft(active, match[1], run.record.startedAt) : this.scenarioDraft(active, run);
+        const featureStep = match ? Number(match[2]) : undefined;
+        const unsubscribe = run.onEvent((event) => this.onRunEvent(draft, run, event));
+        draft.follow(run, unsubscribe, featureStep);
+    }
+    environmentOf(active) {
+        return { id: active.key, label: active.label(this.options.state.environments()), provider: active.environment.provider, session: active.session };
+    }
+    scenarioDraft(active, run) {
+        const scenario = active.environment.scenarios.find((item) => item.id === run.record.scenarioId);
+        const draft = new RecordingDraft(`run:${run.id}`, "scenario", scenario?.title ?? run.record.scenarioId, active, this.environmentOf(active), this.options.state.name, run.record.startedAt);
+        this.open.set(draft.key, draft);
+        return draft;
+    }
+    featureDraft(active, scenario, startedAt) {
+        const feature = this.options.featureRun();
+        const owner = feature?.active ? feature : undefined;
+        const key = owner ? `feature-run:${owner.id}:${scenario}` : `feature:${active.session}:${scenario}`;
+        for (const other of [...this.open.values()])
+            if (other.kind === "feature" && other.key !== key)
+                this.finalize(other.key, "the next scenario started");
+        const existing = this.open.get(key);
+        if (existing)
+            return existing;
+        const draft = new RecordingDraft(key, "feature", scenario, active, this.environmentOf(active), this.options.state.name, startedAt, owner?.id);
+        const source = this.options.state.scenarioSources.get(scenario);
+        if (source)
+            draft.feature = { ...source, tags: [...source.tags], ...(source.fixture ? { fixture: { ...source.fixture } } : {}) };
+        draft.race = this.options.state.scenarioRaces.get(scenario);
+        this.open.set(key, draft);
+        if (owner && !this.watchedFeatureRuns.has(owner.id)) {
+            this.watchedFeatureRuns.add(owner.id);
+            void owner.completion.then((record) => {
+                this.watchedFeatureRuns.delete(owner.id);
+                for (const item of [...this.open.values()]) {
+                    if (item.featureRun !== owner.id)
+                        continue;
+                    const result = record.scenarios.find((entry) => entry.name === item.title);
+                    if (result) {
+                        item.featureStatus = result.status === "passed" ? "passed" : "failed";
+                        item.feature = {
+                            uri: result.uri,
+                            ...(result.line !== undefined ? { line: result.line } : {}),
+                            tags: [...result.tags],
+                            ...(result.fixture ? { fixture: { name: result.fixture.name, action: result.fixture.action } } : {}),
+                            ...(item.feature?.startNotKept ? { startNotKept: true } : {}),
+                        };
+                    }
+                    else if (record.status === "failed" || record.status === "error")
+                        item.featureStatus = "failed";
+                    this.finalize(item.key, `feature run ${record.status}`);
+                }
+            });
+        }
+        return draft;
+    }
+    onRunEvent(draft, run, event) {
+        if (event.type === "status") {
+            if (event.status === "paused")
+                this.checkpoint(draft, run);
+            if (event.status === "failed" || event.status === "cancelled") {
+                const answered = run.checked();
+                draft.checks.add(answered);
+                void answered.finally(() => draft.checks.delete(answered));
+            }
+            return;
+        }
+        if (event.type !== "step")
+            return;
+        const index = draft.index(run, event.step);
+        if (index === undefined)
+            return;
+        const actor = run.record.steps[event.step]?.actor;
+        if (event.status === "running") {
+            draft.running.add(index);
+            const conditions = actor ? this.options.state.actorConditions.get(actor) : undefined;
+            if (conditions)
+                draft.stepConditions.set(index, { ...conditions });
+            this.sampleHealth(draft);
+            this.observe(draft, index, "start");
+            this.chainReader(draft)?.stepStarted(index);
+            if (actor)
+                draft.hostRequests?.stepStarted(index, actor);
+            this.readUiCalls(draft);
+            this.capture(draft, actor, "before", index);
+            this.noteVideo(draft, actor);
+        }
+        else if (event.status === "complete" || event.status === "failed") {
+            draft.running.delete(index);
+            if (!draft.running.size)
+                draft.health?.idle();
+            this.observe(draft, index, "end");
+            this.capture(draft, actor, "after", index);
+            if (event.status === "failed")
+                for (const other of draft.everyIdentity())
+                    if (other !== actor)
+                        this.capture(draft, other, "after", index);
+            this.readChainChanges(draft, index, actor);
+            draft.hostRequests?.stepEnded(index);
+            this.readUiCalls(draft, index);
+        }
+        else {
+            draft.running.delete(index);
+            if (!draft.running.size)
+                draft.health?.idle();
+        }
+    }
+    featurePaused(featureRun, scenario, identities) {
+        const draft = [...this.open.values()].find((item) => item.kind === "feature" && item.featureRun === featureRun && item.title === scenario);
+        if (!draft)
+            return;
+        const done = draft.runs.flatMap((entry) => entry.run.record.steps.flatMap((step, position) => (step.status === "complete" || step.status === "failed" ? [draft.index(entry.run, position)] : []))).filter((item) => item !== undefined);
+        const after = done.length ? Math.max(...done) : undefined;
+        for (const actor of new Set([...draft.runs.flatMap((entry) => RecordingDraft.identities(entry.run)), ...identities]))
+            this.capture(draft, actor, "checkpoint", after);
+    }
+    checkpoint(draft, run) {
+        const done = run.record.steps.flatMap((step, position) => (step.status === "complete" ? [draft.index(run, position)] : [])).filter((item) => item !== undefined);
+        const after = done.length ? Math.max(...done) : undefined;
+        for (const actor of RecordingDraft.identities(run))
+            this.capture(draft, actor, "checkpoint", after);
+    }
+    readUiCalls(draft, index) {
+        const source = this.options.sources.current(draft.active.closed ? undefined : draft.active.environment);
+        if (!source?.uiCalls)
+            return;
+        const read = source.uiCalls(draft.uiCursor?.source === source ? draft.uiCursor.next : undefined);
+        draft.uiCursor = { source, next: read.next };
+        if (index === undefined)
+            return;
+        draft.uiCalls ??= { source: source.source, steps: new Map() };
+        draft.uiCalls.steps.set(index, [...(draft.uiCalls.steps.get(index) ?? []), ...read.calls]);
+    }
+    readChainChanges(draft, index, actor) {
+        const reader = this.chainReader(draft);
+        if (!reader)
+            return;
+        const environment = draft.active.environment;
+        const account = actor ? environment.actors().find((item) => item.id === actor)?.account : undefined;
+        const start = draft.observations.find((observation) => observation.step === index && observation.at === "start");
+        void reader.stepEnded({ index, ...(actor ? { actor } : {}), ...(account ? { account } : {}) }, start);
+    }
+    sampleHealth(draft) {
+        if (draft.active.closed)
+            return;
+        draft.health ??= new HealthSampler({
+            clock: this.options.clock,
+            ...(this.options.machine ? { machine: this.options.machine } : {}),
+            ...(this.options.healthIntervalMs ? { intervalMs: this.options.healthIntervalMs } : {}),
+            chains: () => draft.active.closed
+                ? []
+                : draft.active.activity.snapshot().chains.map((chain) => ({ id: chain.id, ...(chain.best ? { best: chain.best.number } : {}), ...(chain.finalized ? { finalized: chain.finalized.number } : {}), ...(chain.error ? { error: chain.error } : {}) })),
+        });
+        draft.health.running();
+    }
+    chainReader(draft) {
+        const environment = draft.active.environment;
+        if (draft.active.closed || !environment.chains)
+            return undefined;
+        return (draft.chainReader ??= new StepChainReader(() => (draft.active.closed ? undefined : environment.chains?.()), () => environment.actors().flatMap((item) => (item.account ? [item.account] : []))));
+    }
+    observe(draft, step, at) {
+        const chains = draft.active.activity.snapshot().chains.map((chain) => ({
+            id: chain.id,
+            label: chain.label,
+            ...(chain.best ? { best: chain.best } : {}),
+            ...(chain.finalized ? { finalized: chain.finalized } : {}),
+            observedAt: chain.observedAt,
+            ...(chain.error ? { error: chain.error } : {}),
+        }));
+        draft.observations.push({ step, at, recordedAt: this.now(), chains });
+    }
+    capture(draft, actor, phase, step) {
+        if (this.options.stores.settings.mode !== "frames" || !actor)
+            return;
+        const source = this.options.sources.current(draft.active.closed ? undefined : draft.active.environment);
+        const frame = {
+            id: `f${draft.frames.length + 1}`,
+            ...(step !== undefined ? { step } : {}),
+            actor,
+            phase,
+            status: "unavailable",
+            reason: NO_SOURCE,
+            requestedAt: this.now(),
+            overlapping: [...draft.running].sort((a, b) => a - b),
+            media: source?.media ?? "unknown",
+            ...(source ? { source: source.source } : {}),
+        };
+        draft.frames.push(frame);
+        if (!source)
+            return;
+        Object.assign(frame, { status: "failed", reason: "The capture had not finished when the recording closed" });
+        const limit = this.options.stores.settings.captureTimeoutMs;
+        const deadline = new Deadline(limit, (ms, signal) => this.options.clock.sleep(ms, signal));
+        const work = deadline
+            .race(Promise.resolve().then(() => source.capture(actor, { signal: deadline.signal, timeoutMs: limit })), "late")
+            .then((result) => {
+            const done = { capturedAt: this.now(), overlapping: [...draft.running].sort((a, b) => a - b) };
+            if (result === "late")
+                Object.assign(frame, { reason: `The capture took longer than ${limit} ms` });
+            else if (result.status === "captured") {
+                delete frame.reason;
+                Object.assign(frame, { ...done, status: "captured", file: `${frame.id}.png`, mediaType: result.mediaType, bytes: result.bytes.length });
+                draft.images.set(frame.id, result.bytes);
+            }
+            else
+                Object.assign(frame, { status: "unavailable", reason: result.reason });
+        }, (error) => {
+            Object.assign(frame, { reason: `The capture failed: ${describeFailure(error)}` });
+        })
+            .finally(() => deadline.stop());
+        draft.pending.add(work);
+        void work.finally(() => draft.pending.delete(work));
+    }
+    noteVideo(draft, actor) {
+        if (!actor)
+            return;
+        const source = this.options.sources.current(draft.active.closed ? undefined : draft.active.environment);
+        if (!source?.video)
+            return;
+        const work = Promise.resolve()
+            .then(() => source.video(actor))
+            .then((video) => {
+            if (video && !draft.videos.has(video.name))
+                draft.videos.set(video.name, { source: video.source ?? source.source, ...(video.scope === "window" ? {} : { actor }), file: `videos/${video.name}`, mediaType: video.mediaType, openedAt: video.openedAt, ...(video.viewport ? { viewport: video.viewport } : {}) });
+        }, (error) => {
+            draft.videoProblems.add(`The video of ${actor}'s page could not be named: ${describeFailure(error)}`);
+        });
+        draft.pending.add(work);
+        void work.finally(() => draft.pending.delete(work));
+    }
+    runFinished(runId) {
+        const key = `run:${runId}`;
+        if (this.open.has(key))
+            this.finalize(key);
+    }
+    finalize(key, closedBy) {
+        const draft = this.open.get(key);
+        if (!draft)
+            return;
+        this.open.delete(key);
+        if (draft.kind === "feature")
+            this.applyOutcome(draft);
+        void this.keepHostLogs(draft);
+        const write = this.write(draft, closedBy).catch((error) => {
+            const message = this.options.redactor.text(`Recording "${draft.title}" was not written: ${describeFailure(error)}`);
+            this.lastFailure = { at: this.now(), error: message };
+            this.options.events.emit({ type: "recording-failed", title: draft.title, error: message });
+        });
+        this.writes.add(write);
+        void write.finally(() => this.writes.delete(write));
+    }
+    applyOutcome(draft) {
+        const outcome = this.options.state.scenarioOutcomes.get(draft.title);
+        if (!outcome)
+            return;
+        this.options.state.scenarioOutcomes.delete(draft.title);
+        if (outcome.status === "skipped")
+            return;
+        draft.featureStatus ??= outcome.status;
+        const failure = outcome.failure;
+        if (outcome.status === "failed" && failure && !draft.hasFailedStep())
+            draft.runnerFailure = { ...(failure.step >= 0 ? { featureStep: failure.step + 1 } : {}), step: failure.text, error: failure.error };
+    }
+    async write(draft, closedBy) {
+        await Promise.allSettled([...draft.pending, ...draft.checks]);
+        for (const entry of draft.runs)
+            entry.unsubscribe();
+        draft.console.close();
+        const target = this.options.stores.current();
+        if ("disabled" in target)
+            throw new Error(target.disabled);
+        draft.sync(this.options.collect);
+        const now = this.now();
+        const id = `${draft.startedAt}-${draft.key.replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 120)}`.replace(/-+$/, "");
+        const mode = this.options.stores.settings.mode === "steps" ? "steps" : "frames";
+        await draft.chainReader?.settle(SETTLE_TIMEOUT_MS, (ms, signal) => this.options.clock.sleep(ms, signal));
+        const health = draft.health?.stop();
+        const asked = await draft.hostRequests?.settle(SETTLE_TIMEOUT_MS, (ms, signal) => this.options.clock.sleep(ms, signal));
+        const built = draft.build({ id, now, mode, ...(closedBy ? { closedBy } : {}) });
+        const withChains = draft.chainReader?.used ? { ...built, chainChanges: draft.chainReader.result() } : built;
+        const rules = new StepConsoleErrors([], draft.active.environment.consoleAllowed ?? {});
+        const data = { ...withChains, console: draft.console.result(built.steps, rules), ...(asked ? { hostRequests: asked } : {}), ...(draft.uiCalls ? { uiCalls: { source: draft.uiCalls.source, steps: [...draft.uiCalls.steps].sort(([a], [b]) => a - b).map(([step, calls]) => ({ step, calls })) } } : {}), ...(health ? { health } : {}) };
+        const featureSteps = draft.kind === "feature" ? this.options.state.scenarioSteps.get(draft.title) : undefined;
+        if (featureSteps?.length) {
+            this.options.state.scenarioSteps.delete(draft.title);
+            const readings = this.options.state.featureStepReadings.get(draft.title);
+            Object.assign(data, { featureSteps: featureSteps.map((step) => ({ ...step, ...(readings?.get(step.featureStep - 1)?.length ? { readings: [...readings.get(step.featureStep - 1)] } : {}) })), startedAt: Math.min(data.startedAt, ...featureSteps.map((step) => step.startedAt)) });
+        }
+        const kept = (await draft.hostLogs) ?? NO_HOST_LOGS;
+        const files = new Map([...kept.files].map(([file, bytes]) => [file, new TextEncoder().encode(this.options.redactor.text(new TextDecoder().decode(bytes)))]));
+        if (kept.logs.length)
+            data.hostLogs = kept.logs.map((log) => ({ ...log, bytes: files.get(log.file)?.length ?? log.bytes }));
+        if (kept.gaps.length)
+            data.capture = { ...data.capture, notes: [...data.capture.notes, ...kept.gaps] };
+        const recording = RunRecording.of(this.options.redactor.value(data));
+        const report = await target.store.save(recording, draft.images, this.options.stores.settings.retention, now, files);
+        this.remember(draft, report.id);
+        this.options.events.emit({ type: "recording-saved", recording: report.id, title: recording.data.title, removed: report.removed.map((item) => item.id) });
+    }
+}

package/core/application/src/recordings/recording-draft.d.ts

@@ -0,0 +1,108 @@
+import type { KeptHostLogs } from "./host-logs.js";
+import type { StepChainReader } from "./step-chain-reader.js";
+import { ConsoleCollector } from "./console-collector.js";
+import { StepHostRequestReader } from "./step-host-request-reader.js";
+import type { HealthSampler } from "./health-sampler.js";
+import type { RecordedFeature, RecordedFrame, RecordedStep, RecordedVideo, RecordingStatus, RecordedConditions, RunnerFailure, RunRecordingData, ChainObservation, RecordedUiCall } from "@parity/product-lab/domain/recordings";
+import { type RaceJitter } from "@parity/product-lab/domain";
+import type { ActiveEnvironment } from "../environment/active-environment.js";
+import type { CollectEvidence } from "../runs/collect-evidence.js";
+import type { ScenarioRun } from "../runs/scenario-run.js";
+/** A run the recording covers: where its steps start in the recording, and how to stop following it. */
+interface DraftRun {
+    run: ScenarioRun;
+    base: number | undefined;
+    featureStep?: number;
+    unsubscribe: () => void;
+}
+export declare class RecordingDraft {
+    readonly key: string;
+    readonly kind: "scenario" | "feature";
+    readonly title: string;
+    /** The environment session the runs ran in (kept: the runtime drops it when the environment stops). */
+    readonly active: ActiveEnvironment;
+    /** The environment as the recording names it (taken when the recording began). */
+    readonly environment: RunRecordingData["environment"];
+    readonly lab: string;
+    readonly startedAt: number;
+    readonly featureRun?: string | undefined;
+    readonly runs: DraftRun[];
+    readonly steps: RecordedStep[];
+    readonly frames: RecordedFrame[];
+    readonly images: Map<string, Uint8Array<ArrayBufferLike>>;
+    readonly observations: ChainObservation[];
+    /** Captures still in progress. */
+    readonly pending: Set<Promise<void>>;
+    /** The lab's checks after this recording's failed runs: only its write waits for them, never a scenario's end. */
+    readonly checks: Set<Promise<void>>;
+    /** The session's people as each run began: a runner that closes them before the write still names them (backlog 110). */
+    private readonly seen;
+    /** Backlog 18b: the videos of the pages the recording's steps acted in, by file; and why one could not be named. */
+    readonly videos: Map<string, RecordedVideo>;
+    readonly videoProblems: Set<string>;
+    /** Backlog 22: what each step changed on the chains, read as each step ended. */
+    chainReader?: StepChainReader;
+    /** Backlog 23: what the identities' apps print while the recording is made (listening from its start). */
+    readonly console: ConsoleCollector;
+    /** Backlog 41: what each step's identity's apps asked their hosts for; none when the environment keeps no record. */
+    readonly hostRequests: StepHostRequestReader | undefined;
+    /**
+     * Backlog 110: what each step did on screen, by recording index, from the frame source that kept its UI calls (the
+     * lab window's), and where the next read starts; none when no source kept any.
+     */
+    uiCalls: {
+        source: string;
+        steps: Map<number, RecordedUiCall[]>;
+    } | undefined;
+    uiCursor: {
+        source: object;
+        next: number;
+    } | undefined;
+    /** Backlog 25: machine and chain health, sampled from the first step until the recording is written. */
+    health?: HealthSampler;
+    /** Steps of the recording running now (what a capture completing now overlaps). */
+    readonly running: Set<number>;
+    /** The feature run's verdict for this scenario, once it completed (in-process feature runs). */
+    featureStatus: RecordingStatus | undefined;
+    /** Backlog 192: its hosts' logs, read once while their sessions were open (`RecordRuns.keepHostLogs`). */
+    hostLogs: Promise<KeptHostLogs> | undefined;
+    /** The feature scenario it covers: where its runner said it was written, then its feature run's report (in-process). */
+    feature: RecordedFeature | undefined;
+    /** Backlog 32: the scenario's race jitter, read when the recording is written (its waits so far). */
+    race: {
+        runSeed: string;
+        jitter: RaceJitter;
+    } | undefined;
+    /** Backlog 31: each step's identity's conditions as it started, by recording index. */
+    readonly stepConditions: Map<number, RecordedConditions>;
+    /** A failure its runner reported outside the lab's runs (a custom step, a hook): no recorded step holds it. */
+    runnerFailure: RunnerFailure | undefined;
+    constructor(key: string, kind: "scenario" | "feature", title: string, 
+    /** The environment session the runs ran in (kept: the runtime drops it when the environment stops). */
+    active: ActiveEnvironment, 
+    /** The environment as the recording names it (taken when the recording began). */
+    environment: RunRecordingData["environment"], lab: string, startedAt: number, featureRun?: string | undefined);
+    follow(run: ScenarioRun, unsubscribe: () => void, featureStep?: number): void;
+    /** Step `runStep` of `run` as numbered in the recording (its steps are numbered when the first one is seen). */
+    index(run: ScenarioRun, runStep: number): number | undefined;
+    /** Copy what each run recorded into its steps (titles, identities, times, outcomes, evidence and blocks). */
+    sync(collect: CollectEvidence): void;
+    /** The identities of a run: every step's, each binding's and the run's own. */
+    static identities(run: ScenarioRun): string[];
+    /** Every identity of the runs recorded so far (backlog 110: a failed step takes each one's frame). */
+    everyIdentity(): string[];
+    /** Each identity's name as the recording gives it (seen while recording, or the environment's now), by id. */
+    names(): Map<string, string>;
+    /** Whether a recorded run's step failed. */
+    hasFailedStep(): boolean;
+    status(): RecordingStatus;
+    /** Run-local indexes become recording indexes; unattributed entries keep their empty step list. */
+    private recordingEvidence;
+    build(options: {
+        id: string;
+        now: number;
+        mode: "frames" | "steps";
+        closedBy?: string;
+    }): RunRecordingData;
+}
+export {};