@parity/product-lab 0.0.1-placeholder → 0.1.0

package/core/application/src/apps/app-update-hub.js

@@ -0,0 +1,116 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+export class AppUpdateHub {
+    options;
+    followed = new Map();
+    attached = new Set();
+    listeners = new Set();
+    policy;
+    restartNumber = 0;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    follow(app, entry = {}) {
+        const quiet = entry.protocol === "none";
+        this.followed.set(app, { ...(entry.label ? { label: entry.label } : {}), ...(entry.protocol && !quiet ? { declared: entry.protocol } : {}), ...(quiet ? { quiet } : {}) });
+    }
+    attach(actorId, app, updates, answering, options = {}) {
+        if (!this.followed.has(app))
+            this.follow(app);
+        const entry = { actorId, app, updates, source: options.source ?? app, status: options.starting ? "starting" : "ready", active: true };
+        this.attached.add(entry);
+        updates.deliverWhen(this.policy ? (update) => this.policy(actorId, app, update) : undefined);
+        const stop = updates.subscribe((event) => {
+            if (event.type === "unknown-socket" && event.refused) {
+                const followed = this.followed.get(app);
+                if (followed)
+                    followed.refused = true;
+            }
+            if (event.type === "connected") {
+                entry.episode = undefined;
+                return this.emit(entry, event);
+            }
+            if (event.type !== "lost")
+                return this.emit(entry, event);
+            let episode = entry.episode;
+            if (!episode) {
+                episode = { id: `restart-${++this.restartNumber}`, protocol: event.protocol, recipients: new Set(), emitted: new Set() };
+                for (const candidate of this.attached)
+                    if (candidate.app === app && candidate.source === entry.source && !candidate.episode)
+                        candidate.episode = episode;
+                episode.recipients.add(entry);
+                const current = episode;
+                if (!answering) {
+                    current.result = { answers: event.answers !== false, ...(event.detail ? { detail: event.detail } : {}) };
+                    this.answered(current);
+                }
+                else {
+                    Promise.resolve().then(answering).then(() => { current.result = { answers: true }; this.answered(current); }, (error) => { current.result = { answers: false, detail: error instanceof Error ? error.message : String(error) }; this.answered(current); });
+                }
+            }
+            else {
+                episode.recipients.add(entry);
+                this.answered(episode);
+            }
+        });
+        return () => {
+            if (!entry.active)
+                return;
+            entry.active = false;
+            stop();
+            updates.deliverWhen(undefined);
+            this.attached.delete(entry);
+            entry.episode?.recipients.delete(entry);
+            entry.episode?.emitted.delete(entry);
+            entry.episode = undefined;
+            this.emit(entry, { type: "identity-detached" });
+        };
+    }
+    async ready(actorId, app) {
+        for (const entry of this.attached)
+            if (entry.actorId === actorId && entry.app === app)
+                entry.status = "ready";
+        await Promise.all([...this.listeners].map(async (listener) => {
+            await listener({ type: "identity-ready", actorId, app });
+        }));
+    }
+    identities() {
+        return [...this.attached].map(({ actorId, app, status }) => ({ actorId, app, status }));
+    }
+    apps() {
+        return [...this.followed].map(([app, entry]) => {
+            const protocol = entry.refused ? undefined : entry.declared ?? [...this.attached].find((item) => item.app === app && item.updates.protocol() !== undefined)?.updates.protocol();
+            return { app, ...(entry.label ? { label: entry.label } : {}), ...(protocol ? { protocol } : {}), ...(entry.quiet ? { quiet: true } : {}) };
+        });
+    }
+    deliverWhen(policy) {
+        this.policy = policy;
+        for (const entry of this.attached)
+            entry.updates.deliverWhen(policy ? (update) => policy(entry.actorId, entry.app, update) : undefined);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    answered(episode) {
+        if (!episode.result)
+            return;
+        for (const entry of episode.recipients)
+            if (entry.active && !episode.emitted.has(entry)) {
+                episode.emitted.add(entry);
+                this.emit(entry, { type: "lost", protocol: episode.protocol, ...episode.result, episode: episode.id });
+            }
+    }
+    emit(entry, event) {
+        const root = this.options.root?.replace(/\/+$/, "");
+        const shown = event.type === "update" && root ? { ...event, paths: event.paths.map((path) => path.startsWith(`${root}/`) ? path.slice(root.length + 1) : path) } : event;
+        for (const listener of [...this.listeners]) {
+            try {
+                Promise.resolve(listener({ ...shown, actorId: entry.actorId, app: entry.app })).catch(() => {
+                });
+            }
+            catch {
+            }
+        }
+    }
+}

package/core/application/src/apps/inspect-app-framing.d.ts

@@ -0,0 +1,9 @@
+import { type AppFramingInspection, type AppFramingInspectionRequest } from "@parity/product-lab/domain";
+import type { AppFramingInspector, DocumentHeadersReader } from "@parity/product-lab/ports/system";
+/** Reads once through the system port; domain policy decides, and unavailable evidence stays unknown. */
+export declare class InspectAppFraming {
+    private readonly documents?;
+    private readonly inspect?;
+    constructor(documents?: DocumentHeadersReader | undefined, inspect?: AppFramingInspector | undefined);
+    execute(request: AppFramingInspectionRequest): Promise<AppFramingInspection>;
+}

package/core/application/src/apps/inspect-app-framing.js

@@ -0,0 +1,25 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+import { LoopbackUrl, inspectFramingDocument } from "@parity/product-lab/domain";
+export class InspectAppFraming {
+    documents;
+    inspect;
+    constructor(documents, inspect) {
+        this.documents = documents;
+        this.inspect = inspect;
+    }
+    async execute(request) {
+        if (!LoopbackUrl.test(request.url, { protocols: ["http:", "https:"] }))
+            return inspectFramingDocument(request, undefined, "The app's document is not a loopback HTTP address: not asked");
+        try {
+            if (this.inspect)
+                return await this.inspect(request);
+            if (!this.documents)
+                return inspectFramingDocument(request);
+            return inspectFramingDocument(request, await this.documents.read(request.url));
+        }
+        catch (error) {
+            return inspectFramingDocument(request, undefined, error instanceof Error ? error.message : String(error));
+        }
+    }
+}

package/core/application/src/bisect/bisect-regression.d.ts

@@ -0,0 +1,52 @@
+import type { BisectRequest, BisectRunReport, SuiteRowRecord } from "@parity/product-lab/ports/driving";
+import type { FeatureScenarioResult } from "@parity/product-lab/ports/features";
+import type { ChangeSource, Clock, CommandRunner, FileSystem, IdGenerator, MachineMetrics, Redactor } from "@parity/product-lab/ports/system";
+import type { VersionSource } from "@parity/product-lab/ports/versions";
+import type { LabState } from "../lab/lab-state.js";
+export { BISECT_MIN_FREE_DISK } from "./probe-session.js";
+export declare const BISECT_REPORT_FILE = "product-lab-bisect.json";
+export declare const BISECT_SUMMARY_FILE = "summary.md";
+export interface BisectRegressionDeps {
+    state: LabState;
+    files?: FileSystem;
+    /** One scenario of one row with pinned versions, in this runtime (RunSuite.probe). */
+    probeRow(request: {
+        suite: string;
+        row: string;
+        scenario: {
+            name: string;
+            uri: string;
+        };
+        candidates: Readonly<Record<string, string>>;
+        directory: string;
+        signal?: AbortSignal;
+        onOutput?: (text: string) => void;
+    }): Promise<SuiteRowRecord>;
+    sources?: readonly VersionSource[];
+    changes?: ChangeSource;
+    commands?: CommandRunner;
+    /** The scenarios of the report a probe's worktree wrote (the feature runner's reader); absent: no worktree probe. */
+    readReport?(report: string, directory: string): FeatureScenarioResult[];
+    machine?: MachineMetrics;
+    /** The lab's cache directory: probe worktrees and the package manager's cache go under it. */
+    cacheDir?: string;
+    clock: Clock;
+    ids: IdGenerator;
+    redactor: Redactor;
+}
+export declare class BisectRegression {
+    private readonly deps;
+    constructor(deps: BisectRegressionDeps);
+    execute(request: BisectRequest): Promise<BisectRunReport>;
+    /**
+     * When the lab's source is not an axis, the commit the runs had it at, if this checkout no longer matches it (another
+     * tree, or uncommitted changes): the probes then run from a worktree there. Undefined when this checkout is the runs'.
+     */
+    private labCommit;
+    /** The change to bisect: by key, or by row and scenario name; refused with what there is when it is not one. */
+    private change;
+    /** The values an axis moves through, its good end first and its bad end last. */
+    private range;
+    private bisect;
+    private finish;
+}

package/core/application/src/bisect/bisect-regression.js

@@ -0,0 +1,168 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+import { Bisection, bisectPlan, bisectSummary, compareSuiteRuns, defaultProbeBudget, } from "@parity/product-lab/domain/suites";
+import { ComponentId, VersionSelector } from "@parity/product-lab/domain/versions";
+import { readSuiteRecord } from "../suites/compare-suite-runs.js";
+import { summarizeSuiteRun } from "../suites/summarize-suite-run.js";
+import { BISECT_MIN_FREE_DISK, GB, ProbeSession } from "./probe-session.js";
+export { BISECT_MIN_FREE_DISK } from "./probe-session.js";
+export const BISECT_REPORT_FILE = "product-lab-bisect.json";
+export const BISECT_SUMMARY_FILE = "summary.md";
+export class BisectRegression {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async execute(request) {
+        const { clock, files } = this.deps;
+        if (!files)
+            throw new Error("This runtime cannot read suite records");
+        const startedAt = clock.now();
+        const wall = () => clock.date().getTime();
+        const previous = readSuiteRecord(files, request.previous, "previous");
+        const current = readSuiteRecord(files, request.current, "current");
+        const change = this.change(compareSuiteRuns(summarizeSuiteRun(previous), summarizeSuiteRun(current)).changes, request);
+        const base = { kind: "product-lab-bisect", schemaVersion: 1, row: change.row, scenario: change.scenario, previous: request.previous, current: request.current, startedAt: wall() };
+        const plan = bisectPlan(change);
+        if (plan.status === "refused")
+            return this.finish(request, { ...base, status: "refused", reason: plan.reason, probes: [], finishedAt: wall() });
+        const ranged = await Promise.all(plan.axes.map((axis) => this.range(axis, request.signal)));
+        const refusal = ranged.find((range) => "refused" in range);
+        if (refusal)
+            return this.finish(request, { ...base, status: "refused", reason: `Not bisected (${change.row}, "${change.scenario.name}"): ${refusal.refused}`, probes: [], finishedAt: wall() });
+        const ranges = ranged;
+        const runs = request.runs ?? 2;
+        if (!Number.isInteger(runs) || runs < 1 || runs > 5)
+            throw new Error("--runs takes 1 to 5 runs per probe");
+        const longest = Math.max(...ranges.map((range) => range.values.length));
+        const maxProbes = request.maxProbes ?? defaultProbeBudget(longest);
+        if (request.dryRun) {
+            const axes = ranges.map((range) => ({ component: range.axis.component, kind: range.axis.kind, candidates: range.values }));
+            const most = 2 + (ranges.length > 1 ? ranges.length : 0) + maxProbes;
+            return this.finish(request, { ...base, status: "planned", plan: { axes, maxProbes: most }, probes: [], finishedAt: wall() });
+        }
+        const where = this.deps.cacheDir ?? this.deps.state.lab.root;
+        const free = this.deps.machine?.freeDiskBytes?.(where);
+        if (free !== undefined && free < BISECT_MIN_FREE_DISK)
+            return this.finish(request, { ...base, status: "refused", reason: `Not bisected: ${GB(free)} free at ${where}, below the 15 GB a bisect needs (a probe of the lab's source installs its dependencies)`, probes: [], finishedAt: wall() });
+        const fixedCommit = plan.axes.some((axis) => axis.kind === "app") ? undefined : await this.labCommit(previous, change);
+        const session = new ProbeSession(this.deps, request, previous, change, runs, request.directory.replace(/\/+$/, ""), fixedCommit);
+        if (fixedCommit)
+            session.note(`This checkout is not at the runs' lab source, so every probe runs from a worktree at ${fixedCommit.slice(0, 12)}.`);
+        try {
+            return this.finish(request, await this.bisect(session, base, ranges, maxProbes, request, startedAt));
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async labCommit(previous, change) {
+        const combination = previous.rows.find((row) => row.id === change.row)?.combination ?? {};
+        const recorded = Object.entries(combination).find(([id]) => id.startsWith("app:"))?.[1];
+        if (!recorded?.commit)
+            return undefined;
+        const now = await this.deps.changes?.revision?.({ root: this.deps.state.lab.root }).catch(() => undefined);
+        if (!now || (now.tree === recorded.digests.tree && !now.uncommitted))
+            return undefined;
+        if (!this.deps.changes?.checkout || !this.deps.changes.removeCheckout)
+            throw new Error(`This checkout is not at the runs' lab source (${recorded.commit.slice(0, 12)}), and this runtime cannot check that commit out`);
+        return recorded.commit;
+    }
+    change(changes, request) {
+        const matching = changes.filter((change) => request.change ? change.key === request.change : (!request.row || change.row === request.row) && (!request.scenario || change.scenario.name === request.scenario));
+        const listed = changes.map((change) => `${change.row} "${change.scenario.name}" (${change.change}, key ${change.key})`).join("; ") || "none";
+        if (!matching.length)
+            throw new Error(`The compare finds no such change (it finds: ${listed})`);
+        if (matching.length > 1)
+            throw new Error(`Several changes match; name one with --change <key> or --row and --scenario (${listed})`);
+        return matching[0];
+    }
+    async range(axis, signal) {
+        if (axis.kind === "app") {
+            const { good, bad } = axis;
+            if (bad.digests.uncommitted || good.digests.uncommitted)
+                return { refused: `${axis.component}: a run had uncommitted changes in the lab's directory, so its end is not a commit` };
+            if (!good.commit || !bad.commit)
+                return { refused: `${axis.component}: a run's record names no commit (records from before 4 October 2026); run the suite again` };
+            const changes = this.deps.changes;
+            if (!changes?.commits || !changes.checkout || !changes.removeCheckout)
+                return { refused: `${axis.component}: this runtime cannot list or check out the lab's commits` };
+            const commits = await changes.commits({ root: this.deps.state.lab.root, from: good.commit, to: bad.commit });
+            if (!commits.length)
+                return { refused: `${axis.component}: no commit changed the lab's directory between ${good.commit.slice(0, 12)} and ${bad.commit.slice(0, 12)}` };
+            return { axis, values: [good.commit, ...commits] };
+        }
+        const component = ComponentId.parse(axis.component);
+        const source = (this.deps.sources ?? []).find((candidate) => candidate.publishedVersions && candidate.supports(component, VersionSelector.LATEST_RELEASE));
+        if (!source?.publishedVersions)
+            return { refused: `${axis.component}: no version source can list its releases (declare it in versions.sources or versions.npm)` };
+        try {
+            const { versions } = await source.publishedVersions({ component, from: axis.good.version, to: axis.bad.version, ...(signal ? { signal } : {}) });
+            return { axis, values: versions };
+        }
+        catch (error) {
+            return { refused: `${axis.component}: ${error instanceof Error ? error.message : String(error)}` };
+        }
+    }
+    async bisect(session, base, ranges, maxProbes, request, startedAt) {
+        const { clock } = this.deps;
+        const good = Object.fromEntries(ranges.map((range) => [range.axis.component, range.values[0]]));
+        const out = (status, extra = {}) => ({ ...base, status, probes: session.probes, finishedAt: clock.date().getTime(), ...extra });
+        const overTime = () => request.budgetMs !== undefined && clock.now() - startedAt >= request.budgetMs;
+        let target = ranges[0];
+        const known = new Map();
+        if (ranges.length > 1) {
+            const goodEnd = await session.probe(good, "end", "all", "good");
+            if (goodEnd.verdict !== "good")
+                return out("ends-disagree", { axis: { component: target.axis.component, kind: target.axis.kind, candidates: target.values, outcome: { kind: "ends-disagree", good: goodEnd.verdict, bad: "bad" } } });
+            const culprits = [];
+            for (const range of ranges) {
+                const alone = await session.probe({ ...good, [range.axis.component]: range.values.at(-1) }, "axis", range.axis.component, range.values.at(-1));
+                if (alone.verdict === "flaky")
+                    return out("flaky", { axis: { component: range.axis.component, kind: range.axis.kind, candidates: range.values, outcome: { kind: "flaky", at: range.values.at(-1) } } });
+                if (alone.verdict === "bad")
+                    culprits.push(range);
+            }
+            if (!culprits.length)
+                return out("combination", { reason: `Each of ${ranges.map((range) => range.axis.component).join(", ")}, moved alone to its new value, still passes.` });
+            target = culprits[0];
+            known.set(target.values[0], "good");
+            known.set(target.values.at(-1), "bad");
+            if (culprits.length > 1)
+                session.note(`${culprits.map((range) => range.axis.component).join(" and ")} each fail alone; ${target.axis.component} is bisected.`);
+        }
+        const bisection = new Bisection(target.values, maxProbes);
+        for (const [value, verdict] of known)
+            bisection.record(value, verdict);
+        const axisOut = (outcome, extra = {}) => out(outcome.kind, { axis: { component: target.axis.component, kind: target.axis.kind, candidates: target.values, outcome }, ...extra });
+        for (let value = bisection.next(); value !== undefined; value = bisection.next()) {
+            if (overTime() || request.signal?.aborted)
+                return axisOut(bisection.stop(), { reason: request.signal?.aborted ? "Stopped: interrupted." : `Stopped: the time budget of ${request.budgetMs} ms ran out.` });
+            const index = target.values.indexOf(value);
+            const purpose = index === 0 || index === target.values.length - 1 ? "end" : "bisect";
+            const judged = await session.probe({ ...good, [target.axis.component]: value }, purpose, target.axis.component, value);
+            bisection.record(value, judged.verdict);
+        }
+        const outcome = bisection.outcome() ?? bisection.stop();
+        const firstBad = outcome.kind === "found" || outcome.kind === "skipped" ? outcome.firstBad : undefined;
+        const reproduce = firstBad ? session.reproduce({ ...good, [target.axis.component]: firstBad }, target.axis) : undefined;
+        return axisOut(outcome, { ...(reproduce ? { reproduce } : {}), ...(session.notes.length ? { reason: session.notes.join(" ") } : {}) });
+    }
+    finish(request, report) {
+        const files = this.deps.files;
+        const directory = request.directory.replace(/\/+$/, "");
+        const paths = { report: `${directory}/${BISECT_REPORT_FILE}`, summary: `${directory}/${BISECT_SUMMARY_FILE}` };
+        const redacted = this.deps.redactor.value({ ...report, files: paths });
+        files.makeDirectory(directory);
+        files.writePrivateJson(paths.report, redacted);
+        const summary = redacted.status === "planned" ? plannedSummary(redacted) : bisectSummary(redacted);
+        files.writePrivateBytes(paths.summary, new TextEncoder().encode(summary));
+        return redacted;
+    }
+}
+function plannedSummary(report) {
+    const lines = [`Dry run: "${report.scenario.name}" (row ${report.row}) would be bisected over ${report.plan.axes.map((axis) => `${axis.component} (${axis.candidates.length} values)`).join(", ")}, in at most ${report.plan.maxProbes} probes. Nothing ran.`, ""];
+    for (const axis of report.plan.axes)
+        lines.push(`- ${axis.component} (${axis.kind}): ${axis.candidates.join(", ")}`);
+    return `${lines.join("\n")}\n`;
+}

package/core/application/src/bisect/probe-session.d.ts

@@ -0,0 +1,52 @@
+import { type BisectAxis, type BisectProbe, type CompatibilityChange, type ProbeVerdict } from "@parity/product-lab/domain/suites";
+import type { BisectRequest, SuiteRunRecord } from "@parity/product-lab/ports/driving";
+import type { BisectRegressionDeps } from "./bisect-regression.js";
+/** A bisect does not start below this much free disk (a probe of the lab's source installs its dependencies). */
+export declare const BISECT_MIN_FREE_DISK: number;
+export declare const GB: (bytes: number) => string;
+/** The probes of one bisect: in this runtime, or from a worktree of the lab at a commit; every worktree removed at the end. */
+export declare class ProbeSession {
+    private readonly deps;
+    private readonly request;
+    private readonly previous;
+    private readonly change;
+    private readonly runs;
+    private readonly directory;
+    /** The lab's commit for every probe when the source is not an axis but this checkout has moved since the runs. */
+    private readonly fixedCommit?;
+    readonly probes: BisectProbe[];
+    readonly notes: string[];
+    private readonly checkouts;
+    /** The worktrees a probe used, once prepared: the rerun line installs and runs as they did. */
+    private readonly ready;
+    private readonly work;
+    private readonly row;
+    private count;
+    constructor(deps: BisectRegressionDeps, request: BisectRequest, previous: SuiteRunRecord, change: CompatibilityChange, runs: number, directory: string, 
+    /** The lab's commit for every probe when the source is not an axis but this checkout has moved since the runs. */
+    fixedCommit?: string | undefined);
+    note(text: string): void;
+    /** The app axis's commit for these values, when the probe must run from a worktree (its lab source is not this checkout's). */
+    private appCommit;
+    /** The row's versions for these values: every candidate the row resolved pinned to an exact version, and each moved runtime or host. */
+    private candidates;
+    probe(values: Readonly<Record<string, string>>, purpose: BisectProbe["purpose"], axis: string, value: string): Promise<{
+        verdict: ProbeVerdict;
+    }>;
+    /** A run of the row in this runtime, as a probe run. */
+    private fromRow;
+    private fromRun;
+    private fromScenarios;
+    /** A worktree of the lab at `commit` with its dependencies installed (once per commit), or why it cannot be. */
+    private prepare;
+    /** One run of the scenario from a worktree: its own product-lab, its lab configuration, the row's environment and host. */
+    private inWorktree;
+    /**
+     * What reruns these values as the row ran them: one shell command. For the lab's source, from the repository's top:
+     * a worktree at the commit, its dependencies installed frozen as the probe installed them, then the run from the lab's
+     * directory there.
+     */
+    reproduce(values: Readonly<Record<string, string>>, axis: BisectAxis): string;
+    /** Remove every worktree and the bisect's work directory, whatever happened. */
+    close(): Promise<void>;
+}

package/core/application/src/bisect/probe-session.js

@@ -0,0 +1,208 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+import { judgeProbe } from "@parity/product-lab/domain/suites";
+import { scenarioFailure } from "../suites/summarize-suite-run.js";
+export const BISECT_MIN_FREE_DISK = 15 * 1024 ** 3;
+const INSTALL_TIMEOUT_MS = 20 * 60_000;
+const PROBE_RUN_TIMEOUT_MS = 30 * 60_000;
+export const GB = (bytes) => `${(bytes / 1024 ** 3).toFixed(1)} GB`;
+const anchored = (name) => `^${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`;
+const quote = (text) => `'${text.replace(/'/g, `'\\''`)}'`;
+export class ProbeSession {
+    deps;
+    request;
+    previous;
+    change;
+    runs;
+    directory;
+    fixedCommit;
+    probes = [];
+    notes = [];
+    checkouts = new Map();
+    ready = new Map();
+    work;
+    row;
+    count = 0;
+    constructor(deps, request, previous, change, runs, directory, 
+    fixedCommit) {
+        this.deps = deps;
+        this.request = request;
+        this.previous = previous;
+        this.change = change;
+        this.runs = runs;
+        this.directory = directory;
+        this.fixedCommit = fixedCommit;
+        this.work = `${deps.cacheDir ?? `${deps.state.lab.root}/.product-lab/cache`}/bisect/${deps.ids.next().replace(/-/g, "").slice(0, 12)}`;
+        this.row = previous.rows.find((row) => row.id === change.row);
+    }
+    note(text) {
+        this.notes.push(text);
+    }
+    appCommit(values) {
+        const app = this.change.changed.find((component) => component.kind === "app");
+        return app ? values[app.id] : this.fixedCommit;
+    }
+    candidates(values) {
+        const combination = this.previous.rows.find((row) => row.id === this.change.row)?.combination ?? {};
+        const pinned = {};
+        for (const id of Object.keys(this.row?.candidates ?? {}))
+            pinned[id] = values[id] ?? combination[id]?.version ?? this.row.candidates[id];
+        for (const [id, value] of Object.entries(values))
+            if (!id.startsWith("app:"))
+                pinned[id] = value;
+        return pinned;
+    }
+    async probe(values, purpose, axis, value) {
+        const started = this.deps.clock.now();
+        const number = ++this.count;
+        const commit = this.appCommit(values);
+        const candidates = this.candidates(values);
+        this.request.onOutput?.(`probe ${number}: ${axis} ${value}${commit && axis !== this.change.changed.find((item) => item.kind === "app")?.id ? ` (lab at ${commit.slice(0, 12)})` : ""}\n`);
+        const runs = [];
+        let prepared;
+        if (commit) {
+            prepared = await this.prepare(commit);
+            this.ready.set(commit, prepared);
+        }
+        for (let run = 1; run <= this.runs; run++) {
+            const directory = `${this.directory}/probes/${String(number).padStart(2, "0")}-${run}`;
+            const began = this.deps.clock.now();
+            const result = prepared?.problem !== undefined
+                ? { status: "unsupported", reason: prepared.problem }
+                : prepared
+                    ? await this.inWorktree(prepared.checkout, candidates, directory)
+                    : this.fromRow(await this.deps.probeRow({ suite: this.previous.suite, row: this.change.row, scenario: this.change.scenario, candidates, directory, ...(this.request.signal ? { signal: this.request.signal } : {}), ...(this.request.onOutput ? { onOutput: this.request.onOutput } : {}) }));
+            runs.push({ ...result, durationMs: Math.round(this.deps.clock.now() - began) });
+            if (result.status === "unsupported")
+                break;
+        }
+        const expected = this.change.current.failure?.where === "step" ? this.change.current.failure.step : undefined;
+        const judged = judgeProbe(runs, expected);
+        this.probes.push({
+            axis,
+            value,
+            purpose,
+            verdict: judged.verdict,
+            reason: judged.reason,
+            runs: runs.map((run) => ({ status: run.status, ...(run.step ? { step: run.step } : {}), ...(run.reason ? { reason: run.reason } : {}), ...(run.durationMs !== undefined ? { durationMs: run.durationMs } : {}) })),
+            ...(prepared?.diskBytes !== undefined ? { diskBytes: prepared.diskBytes } : {}),
+            ...(prepared?.install ? { install: prepared.install } : {}),
+            startedAt: started,
+            durationMs: Math.round(this.deps.clock.now() - started),
+        });
+        this.request.onOutput?.(`probe ${number}: ${judged.verdict} (${judged.reason})\n`);
+        return judged;
+    }
+    fromRow(record) {
+        if (record.status === "unsupported")
+            return { status: "unsupported", reason: record.reason ?? "unsupported" };
+        return this.fromRun(record.run, record.reason);
+    }
+    fromRun(run, reason) {
+        return this.fromScenarios(run?.scenarios ?? [], reason ?? run?.error);
+    }
+    fromScenarios(scenarios, reason) {
+        const scenario = scenarios.find((item) => item.name === this.change.scenario.name && item.uri === this.change.scenario.uri);
+        if (!scenario)
+            return { status: "failed", failureClass: "infrastructure", reason: reason ?? "the scenario was not reported" };
+        if (scenario.status === "passed")
+            return { status: "passed" };
+        const failure = scenarioFailure(scenario);
+        return failure?.where === "step"
+            ? { status: "failed", failureClass: "behaviour", ...(failure.step ? { step: failure.step } : {}), reason: failure.error }
+            : { status: "failed", failureClass: "infrastructure", reason: failure?.error ?? `the scenario ${scenario.status}` };
+    }
+    prepare(commit) {
+        let prepared = this.checkouts.get(commit);
+        if (!prepared) {
+            prepared = (async () => {
+                const { changes, commands, files, machine } = this.deps;
+                const into = `${this.work}/checkouts/${commit.slice(0, 12)}`;
+                const free = machine?.freeDiskBytes?.(this.deps.cacheDir ?? this.work.slice(0, this.work.lastIndexOf("/bisect/")));
+                if (free !== undefined && free < BISECT_MIN_FREE_DISK)
+                    throw new Error(`Stopped: ${GB(free)} free, below the 15 GB a probe needs`);
+                files.makeDirectory(`${this.work}/checkouts`);
+                const checkout = await changes.checkout({ root: this.deps.state.lab.root, commit, into });
+                if (!checkout.lockfile)
+                    return { checkout, problem: `the lab's repository has no lockfile at ${commit.slice(0, 12)}, so its dependencies cannot be installed frozen` };
+                const manager = checkout.lockfile.name.startsWith("bun.") ? "bun" : checkout.lockfile.name === "package-lock.json" ? "npm" : undefined;
+                if (!manager || !commands)
+                    return { checkout, problem: manager ? "this runtime cannot run commands" : `${checkout.lockfile.name} installs are not supported yet (bun and npm are)` };
+                const cache = `${this.work.slice(0, this.work.lastIndexOf("/bisect/"))}/bisect/package-cache/${manager}`;
+                const cacheWarm = (files.listDirectory(cache)?.length ?? 0) > 0;
+                files.makeDirectory(cache);
+                const began = this.deps.clock.now();
+                const installed = await commands.run({
+                    command: manager,
+                    args: manager === "bun" ? ["install", "--frozen-lockfile"] : ["ci", "--no-audit", "--no-fund"],
+                    cwd: checkout.top,
+                    env: manager === "bun" ? { BUN_INSTALL_CACHE_DIR: cache } : { npm_config_cache: cache },
+                    timeoutMs: INSTALL_TIMEOUT_MS,
+                    outputFile: `${into}.install.log`,
+                    ...(this.request.signal ? { signal: this.request.signal } : {}),
+                });
+                const install = { lockfile: checkout.lockfile.name, digest: checkout.lockfile.sha256, cacheWarm, durationMs: Math.round(this.deps.clock.now() - began) };
+                const diskBytes = machine?.directoryBytes?.(checkout.top);
+                if (installed.code !== 0)
+                    return { checkout, install, ...(diskBytes !== undefined ? { diskBytes } : {}), problem: `${manager} install at ${commit.slice(0, 12)} exited ${installed.code} (${into}.install.log)` };
+                this.request.onOutput?.(`  ${commit.slice(0, 12)}: installed from ${checkout.lockfile.name} (${cacheWarm ? "package cache already held packages" : "empty package cache"})${diskBytes !== undefined ? `, ${GB(diskBytes)} on disk` : ""}\n`);
+                return { checkout, install, ...(diskBytes !== undefined ? { diskBytes } : {}) };
+            })();
+            this.checkouts.set(commit, prepared);
+        }
+        return prepared;
+    }
+    async inWorktree(checkout, candidates, directory) {
+        const { commands, files, state } = this.deps;
+        const lab = state.lab;
+        const config = `${checkout.labRoot}/${lab.path.slice(lab.path.lastIndexOf("/") + 1)}`;
+        let bin;
+        for (let at = checkout.labRoot; at.startsWith(checkout.top); at = at.slice(0, at.lastIndexOf("/"))) {
+            if (files.exists(`${at}/node_modules/.bin/product-lab`)) {
+                bin = `${at}/node_modules/.bin/product-lab`;
+                break;
+            }
+            if (at === checkout.top)
+                break;
+        }
+        if (!bin)
+            return { status: "unsupported", reason: "no product-lab is installed in the worktree" };
+        if (!this.deps.readReport)
+            return { status: "unsupported", reason: "this runtime cannot read a probe's report" };
+        files.makeDirectory(directory);
+        const result = await commands.run({
+            command: bin,
+            args: ["test", "--config", config, "--name", anchored(this.change.scenario.name), "--environment", this.row.environment, "--report-dir", directory, ...Object.entries(candidates).flatMap(([id, version]) => ["--candidate", `${id}@${version}`])],
+            cwd: checkout.labRoot,
+            env: this.row.host ? { PRODUCT_LAB_HOST: this.row.host } : {},
+            timeoutMs: PROBE_RUN_TIMEOUT_MS,
+            outputFile: `${directory}/output.log`,
+            ...(this.request.signal ? { signal: this.request.signal } : {}),
+        });
+        const report = `${directory}/product-lab-test.json`;
+        if (!files.exists(report))
+            return { status: "failed", failureClass: "infrastructure", reason: `the run exited ${result.code} with no report (${directory}/output.log)` };
+        return this.fromScenarios(this.deps.readReport(report, directory), `the run exited ${result.code} without reporting the scenario (${directory}/output.log)`);
+    }
+    reproduce(values, axis) {
+        const candidates = Object.entries(this.candidates(values)).map(([id, version]) => ` --candidate ${id}@${version}`).join("");
+        const host = this.row.host ? `PRODUCT_LAB_HOST=${this.row.host} ` : "";
+        const run = `${host}product-lab test --name ${quote(anchored(this.change.scenario.name))} --environment ${this.row.environment}${candidates}`;
+        const commit = this.appCommit(values);
+        if (axis.kind !== "app" || !commit)
+            return run;
+        const prepared = this.ready.get(commit);
+        const worktree = `../bisect-${commit.slice(0, 12)}`;
+        const install = prepared?.install?.lockfile === "package-lock.json" ? "npm ci" : "bun install --frozen-lockfile";
+        const lab = prepared ? prepared.checkout.labRoot.slice(prepared.checkout.top.length).replace(/^\/+/, "") : "";
+        return [`git worktree add ${worktree} ${commit}`, `cd ${worktree}`, install, ...(lab ? [`cd ${/^[\w./-]+$/.test(lab) ? lab : quote(lab)}`] : []), run].join(" && ");
+    }
+    async close() {
+        const { changes, files, state } = this.deps;
+        for (const [commit, prepared] of this.checkouts) {
+            const path = await prepared.then((value) => value.checkout.top, () => `${this.work}/checkouts/${commit.slice(0, 12)}`);
+            await changes?.removeCheckout?.({ root: state.lab.root, path }).catch((error) => this.notes.push(`Removing the worktree ${path} failed: ${error instanceof Error ? error.message : String(error)}`));
+        }
+        files?.remove(this.work);
+    }
+}