@itmetsam/samurai-framework 0.20.0 → 0.21.0

package/dist/flows/run/handlers/types.d.ts

@@ -1,4 +1,5 @@
-import type { AnyNodeDefinition, ExpressionContext, FlowFile, FlowNodeModel } from "../../core/index.js";
+import type { AnyNodeDefinition, ExpressionContext, FlowFacts, FlowFile, FlowNodeModel } from "../../core/index.js";
+import type { OutputsById } from "../branch-context.js";
 import type { RunEvent } from "../../../runner/reporter.js";
 import type { SupportedBrowser } from "../../../types/browser.js";
 import type { NodeResult, NodeTest } from "../events.js";
@@ -10,11 +11,18 @@ export interface HandlerRun {
         variables: Record<string, unknown>;
     };
     context: ExpressionContext;
+    /** The outputs the nodes that ran saved, by node id: where wired inputs come from */
+    outputsById: OutputsById;
+    /** The project's tests' inputs and outputs and its groups' tests; without them no input is wired */
+    facts?: FlowFacts;
     nodeTests: Record<string, NodeTest[]>;
-    /** The browsers of the nodes that have their own (a Group node's group); the others use the project's */
+    /** The browser this run is in: a flow runs once per browser */
+    browser: SupportedBrowser;
+    /** The browsers each node runs in; a node not listed runs in every one */
     nodeBrowsers?: Record<string, SupportedBrowser[]>;
     signal: AbortSignal;
-    runTests: (nodeId: string, tests: NodeTest[], onEvent: (e: RunEvent) => void, browsers?: SupportedBrowser[]) => Promise<"passed" | "failed" | "cancelled">;
+    /** Runs a node's tests in `browser`, with values for their inputs */
+    runTests: (nodeId: string, tests: NodeTest[], onEvent: (e: RunEvent) => void, inputs?: Record<string, string>) => Promise<"passed" | "failed" | "cancelled">;
     sleep: (ms: number, signal: AbortSignal) => Promise<void>;
     onTestEvent: (nodeId: string, e: RunEvent) => void;
     /** Definitions of kinds core doesn't have (steps), for expression scopes */

package/dist/flows/run/node-folder.d.ts

@@ -1,5 +1,10 @@
+import type { RunEvent } from "../../runner/reporter.js";
+import type { SupportedBrowser } from "../../types/browser.js";
 /**
- * The folder a flow node's screenshots go in, relative to `runFlowInProject`'s `outputDir`, with `/` separators:
- * `nodes/` and the node id cleaned for a file name. A node's screenshot paths are relative to this folder.
+ * The folder a flow node writes to in one browser's run, relative to `runFlowInProject`'s `outputDir`, with `/`
+ * separators: the browser, `nodes/` and the node id cleaned for a file name. A node's screenshot paths already
+ * start with it (they are relative to `outputDir`), so an app needs this only to show or open the folder.
  */
-export declare function nodeFolder(nodeId: string): string;
+export declare function nodeFolder(nodeId: string, browser: SupportedBrowser): string;
+/** A node's test event with its screenshot paths (relative to the node's folder) made relative to `outputDir` */
+export declare function inNodeFolder(event: RunEvent, folder: string): RunEvent;

package/dist/flows/run/node-folder.js

@@ -1,8 +1,32 @@
 import { cleanName } from "../../browser/evidence.js";
 /**
- * The folder a flow node's screenshots go in, relative to `runFlowInProject`'s `outputDir`, with `/` separators:
- * `nodes/` and the node id cleaned for a file name. A node's screenshot paths are relative to this folder.
+ * The folder a flow node writes to in one browser's run, relative to `runFlowInProject`'s `outputDir`, with `/`
+ * separators: the browser, `nodes/` and the node id cleaned for a file name. A node's screenshot paths already
+ * start with it (they are relative to `outputDir`), so an app needs this only to show or open the folder.
  */
-export function nodeFolder(nodeId) {
-    return `nodes/${cleanName(nodeId)}`;
+export function nodeFolder(nodeId, browser) {
+    return `${browser}/nodes/${cleanName(nodeId)}`;
+}
+const withFolder = (result, folder) => "screenshots" in result && result.screenshots
+    ? {
+        ...result,
+        screenshots: result.screenshots.map((s) => ({
+            ...s,
+            path: `${folder}/${s.path}`,
+        })),
+    }
+    : result;
+/** A node's test event with its screenshot paths (relative to the node's folder) made relative to `outputDir` */
+export function inNodeFolder(event, folder) {
+    if (event.type === "test-end")
+        return { ...event, result: withFolder(event.result, folder) };
+    if (event.type === "run-end")
+        return {
+            ...event,
+            summary: {
+                ...event.summary,
+                tests: event.summary.tests.map((t) => withFolder(t, folder)),
+            },
+        };
+    return event;
 }

package/dist/flows/run/node-inputs.d.ts

@@ -0,0 +1,5 @@
+import { type FlowNodeModel } from "../core/index.js";
+import type { NodeTest } from "./events.js";
+import type { HandlerRun, Outcome } from "./handlers/types.js";
+/** Runs a Test or Group node's tests with the inputs it resolves; an input that can't be resolved fails the node */
+export declare function runWiredTests(node: FlowNodeModel, run: HandlerRun, list: NodeTest[]): Promise<Outcome>;

package/dist/flows/run/node-inputs.js

@@ -0,0 +1,62 @@
+import { evaluateText, wiringAt } from "../core/index.js";
+import { problemAt, runNodeTests } from "./handlers/support.js";
+/** What a node's title is in a message: its title, else its key, else its id */
+const titleOf = (node, id) => node?.title || node?.key || id;
+/** The value of an override expression as an input: text as is, a number or a boolean as text, else an error */
+function expressionValue(node, run, expression) {
+    const problem = problemAt(node, run, expression);
+    if (problem)
+        return { error: problem };
+    let value;
+    try {
+        value = evaluateText(expression, run.context);
+    }
+    catch (e) {
+        return { error: e.message };
+    }
+    if (typeof value === "string")
+        return { value };
+    if (typeof value === "number" || typeof value === "boolean")
+        return { value: String(value) };
+    return { error: "the expression gave no text" };
+}
+/**
+ * The values a Test or Group node sends for its inputs, by `wiringAt`: an earlier node's saved output, an override
+ * expression's value, nothing for "use the default". An input whose source saved nothing, an override that gives
+ * no text, or an input with no source is an error, and the node's tests must not run.
+ */
+function resolveNodeInputs(node, run) {
+    const inputs = {};
+    const wiring = wiringAt(run.flow, node.id, {
+        ...(run.facts && { facts: run.facts }),
+    });
+    for (const [name, source] of Object.entries(wiring)) {
+        if (source.from === "default")
+            continue;
+        if (source.from === "none")
+            return { error: `input "${name}" has no source` };
+        if (source.from === "node") {
+            const value = run.outputsById[source.nodeId]?.[source.output];
+            if (typeof value !== "string") {
+                const producer = run.flow.nodes.find((n) => n.id === source.nodeId);
+                return {
+                    error: `input "${name}": ${titleOf(producer, source.nodeId)} saved no ${source.output}`,
+                };
+            }
+            inputs[name] = value;
+            continue;
+        }
+        const result = expressionValue(node, run, source.expression);
+        if ("error" in result)
+            return { error: `input "${name}": ${result.error}` };
+        inputs[name] = result.value;
+    }
+    return { inputs };
+}
+/** Runs a Test or Group node's tests with the inputs it resolves; an input that can't be resolved fails the node */
+export function runWiredTests(node, run, list) {
+    const resolved = resolveNodeInputs(node, run);
+    if ("error" in resolved)
+        return Promise.resolve({ status: "failed", error: resolved.error });
+    return runNodeTests(node, run, list, resolved.inputs);
+}

package/dist/flows/run/node-pool.d.ts

@@ -3,7 +3,7 @@ import type { WorkerPool } from "../../runner/worker-pool.js";
 import type { WorkItem } from "../../runner/worker-protocol.js";
 import type { SupportedBrowser } from "../../types/browser.js";
 import type { NodeTest } from "./events.js";
-/** The work items of a node: each test in each browser, the browsers one after the other */
-export declare function itemsOf(tests: NodeTest[], browsers: readonly SupportedBrowser[], outputDir?: string): WorkItem[];
+/** The work items of a node in one browser's run: each of its tests, in that browser, with the node's inputs */
+export declare function itemsOf(tests: NodeTest[], browser: SupportedBrowser, outputDir?: string, inputs?: Record<string, string>): WorkItem[];
 /** Runs the tests of a node on the pool and reports them as a run would */
 export declare function runOnPool(pool: Pick<WorkerPool, "run">, items: WorkItem[], onEvent: (event: RunEvent) => void, signal: AbortSignal): Promise<"passed" | "failed" | "cancelled">;

package/dist/flows/run/node-pool.js

@@ -1,13 +1,13 @@
-/** The work items of a node: each test in each browser, the browsers one after the other */
-export function itemsOf(tests, browsers, outputDir) {
-    return browsers
-        .flatMap((browser) => tests.map((t) => ({
+/** The work items of a node in one browser's run: each of its tests, in that browser, with the node's inputs */
+export function itemsOf(tests, browser, outputDir, inputs) {
+    return tests.map((t, index) => ({
+        index,
         file: t.file,
         testName: t.name,
         browser,
         ...(outputDir !== undefined && { outputDir }),
-    })))
-        .map((item, index) => ({ ...item, index }));
+        ...(inputs && { inputs }),
+    }));
 }
 /** Runs the tests of a node on the pool and reports them as a run would */
 export async function runOnPool(pool, items, onEvent, signal) {

package/dist/flows/run/node-runner.d.ts

@@ -0,0 +1,24 @@
+import type { runTests } from "../../runner/run.js";
+import type { WorkerPool } from "../../runner/worker-pool.js";
+import type { SupportedBrowser } from "../../types/browser.js";
+import type { SamuraiTestConfig } from "../../types/config.js";
+import type { RunFlowInProjectOptions } from "./project-options.js";
+import type { RunFlowOptions } from "./run.js";
+/** What every node's tests share in a project's flow run */
+export interface NodeRunnerInput {
+    projectDir: string;
+    config: SamuraiTestConfig;
+    options: RunFlowInProjectOptions;
+    /** The environment the expressions see, when the project defines it */
+    environment?: string;
+    retries: number;
+    run: typeof runTests;
+    /** The run's worker pool, when `workers` is above 1 */
+    pool?: Pick<WorkerPool, "run">;
+}
+/**
+ * How a Test or Group node runs its tests in one browser's run of a project's flow: on the pool, else through
+ * `runTests` in this process. With an `outputDir`, each node writes to its own `nodeFolder` in it, and its
+ * screenshot paths are made relative to `outputDir`.
+ */
+export declare function nodeRunner(input: NodeRunnerInput, browser: SupportedBrowser): RunFlowOptions["runTests"];

package/dist/flows/run/node-runner.js

@@ -0,0 +1,48 @@
+import path from "node:path";
+import { inNodeFolder, nodeFolder } from "./node-folder.js";
+import { itemsOf, runOnPool } from "./node-pool.js";
+/**
+ * How a Test or Group node runs its tests in one browser's run of a project's flow: on the pool, else through
+ * `runTests` in this process. With an `outputDir`, each node writes to its own `nodeFolder` in it, and its
+ * screenshot paths are made relative to `outputDir`.
+ */
+export function nodeRunner(input, browser) {
+    const { projectDir, config, options, environment, retries, run, pool } = input;
+    return async ({ nodeId, tests, onEvent: onTestEvent, signal, inputs }) => {
+        // Each node gets a folder of its own per browser: the same test in two nodes would overwrite its screenshots
+        const folder = nodeFolder(nodeId, browser);
+        const outputDir = options.outputDir !== undefined
+            ? path.join(options.outputDir, ...folder.split("/"))
+            : undefined;
+        // Screenshot paths come relative to the node's folder: make them relative to outputDir
+        const onEvent = outputDir !== undefined
+            ? (e) => onTestEvent(inNodeFolder(e, folder))
+            : onTestEvent;
+        if (pool)
+            return runOnPool(pool, itemsOf(tests, browser, outputDir, inputs), onEvent, signal);
+        const summary = await run({
+            projectDir,
+            config,
+            ...(options.dataDir !== undefined && { dataDir: options.dataDir }),
+            ...(environment !== undefined && { environment }),
+            ...(options.headless !== undefined && { headless: options.headless }),
+            ...(options.timeout !== undefined && { timeout: options.timeout }),
+            ...(options.expectTimeout !== undefined && {
+                expectTimeout: options.expectTimeout,
+            }),
+            ...(options.port !== undefined && { port: options.port }),
+            ...(retries > 0 && { retries }),
+            browsers: [browser],
+            files: [...new Set(tests.map((t) => t.file))],
+            testNames: tests.map((t) => t.name),
+            ...(inputs && { inputs }),
+            reportPath: false,
+            ...(outputDir !== undefined && { outputDir }),
+            signal,
+            onEvent,
+        });
+        if (signal.aborted)
+            return "cancelled";
+        return summary.status === "success" ? "passed" : "failed";
+    };
+}

package/dist/flows/run/per-browser.d.ts

@@ -0,0 +1,21 @@
+import type { FlowFile } from "../core/index.js";
+import type { SupportedBrowser } from "../../types/browser.js";
+import type { FlowEvent, FlowRunResult, FlowSummary } from "./events.js";
+/**
+ * The browsers a flow runs in, one run each: the union of its nodes' browsers (`nodeBrowsers`, a Test node's
+ * the project's and a Group node's its group's), in the order the flow's nodes first name them. `only` keeps
+ * those of its browsers, in the flow's order; one no node uses is ignored, and none left is an error. A flow
+ * without Test or Group nodes runs once, in the first of `only`, else the first of `projectBrowsers`.
+ */
+export declare function flowBrowsers(nodeBrowsers: Record<string, readonly SupportedBrowser[]>, flow: Pick<FlowFile, "nodes">, projectBrowsers: readonly SupportedBrowser[], only?: readonly SupportedBrowser[]): SupportedBrowser[];
+/**
+ * Walks the flow once per browser, one after the other, then sends `flow-done`. The runs are independent: a
+ * failed one (an `onFailure: "stop"` included) ends that browser's run only. An abort stops them all: the runs
+ * left are not started. The result is cancelled only when a run was cut short or a browser was not started.
+ */
+export declare function runPerBrowser(input: {
+    browsers: readonly SupportedBrowser[];
+    walk: (browser: SupportedBrowser) => Promise<FlowSummary>;
+    signal?: AbortSignal;
+    onEvent?: (event: FlowEvent) => void;
+}): Promise<FlowRunResult>;

package/dist/flows/run/per-browser.js

@@ -0,0 +1,46 @@
+/**
+ * The browsers a flow runs in, one run each: the union of its nodes' browsers (`nodeBrowsers`, a Test node's
+ * the project's and a Group node's its group's), in the order the flow's nodes first name them. `only` keeps
+ * those of its browsers, in the flow's order; one no node uses is ignored, and none left is an error. A flow
+ * without Test or Group nodes runs once, in the first of `only`, else the first of `projectBrowsers`.
+ */
+export function flowBrowsers(nodeBrowsers, flow, projectBrowsers, only) {
+    const union = [
+        ...new Set(flow.nodes.flatMap((n) => nodeBrowsers[n.id] ?? [])),
+    ];
+    if (union.length === 0)
+        return [only?.[0] ?? projectBrowsers[0]];
+    if (!only)
+        return union;
+    const kept = union.filter((b) => only.includes(b));
+    if (kept.length === 0)
+        throw new Error(`runFlowInProject(): this flow runs in none of ${only.join(", ")}`);
+    return kept;
+}
+/**
+ * Walks the flow once per browser, one after the other, then sends `flow-done`. The runs are independent: a
+ * failed one (an `onFailure: "stop"` included) ends that browser's run only. An abort stops them all: the runs
+ * left are not started. The result is cancelled only when a run was cut short or a browser was not started.
+ */
+export async function runPerBrowser(input) {
+    const runs = [];
+    for (const browser of input.browsers) {
+        if (input.signal?.aborted)
+            break;
+        const summary = await input.walk(browser);
+        runs.push({ browser, summary });
+        if (summary.status === "cancelled")
+            break;
+    }
+    // An abort that came after every run finished cuts nothing short
+    const cutShort = runs.length < input.browsers.length ||
+        runs.some((r) => r.summary.status === "cancelled");
+    const status = cutShort
+        ? "cancelled"
+        : runs.some((r) => r.summary.status === "failed")
+            ? "failed"
+            : "passed";
+    const result = { status, runs };
+    input.onEvent?.({ type: "flow-done", ...result });
+    return result;
+}

package/dist/flows/run/project-facts.d.ts

@@ -0,0 +1,13 @@
+import { type FlowFacts } from "../core/index.js";
+import type { ResolvedGroup } from "../../runner/groups.js";
+/** What `flowFacts` needs of a project's test, as the runner registers it */
+interface TestIO {
+    id: string;
+    /** The inputs the test declares, with their defaults */
+    inputs?: Record<string, string>;
+    /** The outputs the test declares */
+    outputs?: string[];
+}
+/** The facts a flow is checked and wired with: each test's declared inputs and outputs, and each group's tests */
+export declare function flowFacts(tests: readonly TestIO[], groups: readonly Pick<ResolvedGroup, "name" | "testIds">[]): FlowFacts;
+export {};

package/dist/flows/run/project-facts.js

@@ -0,0 +1,12 @@
+import { flowFactsFrom } from "../core/index.js";
+/** The facts a flow is checked and wired with: each test's declared inputs and outputs, and each group's tests */
+export function flowFacts(tests, groups) {
+    return flowFactsFrom(tests.map((t) => ({
+        id: t.id,
+        inputs: Object.entries(t.inputs ?? {}).map(([name, value]) => ({
+            name,
+            default: value,
+        })),
+        ...(t.outputs && { outputs: t.outputs }),
+    })), groups);
+}

package/dist/flows/run/project-options.d.ts

@@ -3,6 +3,7 @@ import type { PoolOptions, WorkerPool } from "../../runner/worker-pool.js";
 import type { runTests } from "../../runner/run.js";
 import type { FlowFile, FlowProblem } from "../core/index.js";
 import type { FlowEvent } from "./events.js";
+import type { SupportedBrowser } from "../../types/browser.js";
 /** The flow has errors; nothing was run */
 export declare class FlowCheckError extends Error {
     readonly problems: FlowProblem[];
@@ -20,10 +21,16 @@ export interface RunFlowInProjectOptions extends ProjectOptions {
     /** `"fail"` (default): a flow with a node that can't run is refused. `"skip"`: those nodes are skipped. */
     unsupported?: "fail" | "skip";
     port?: number;
+    /**
+     * Run the flow in these browsers only, in the flow's order (a browser no node uses is ignored, none left is an
+     * error). Unset runs it once in each browser its nodes use (see `flowBrowsers`); `[one]` runs it once
+     */
+    browsers?: SupportedBrowser[];
     /**
      * The folder for the tests' named screenshots, instead of `<project>/result` (see `runTests`). Each node writes to
-     * `nodes/<node id>/` inside it, so a test that runs in two nodes keeps both sets; screenshot paths in a node's
-     * results are relative to that folder. Relative to the project folder
+     * `<browser>/nodes/<node id>/` inside it (`nodeFolder`), so a test that runs in two nodes or two browsers keeps
+     * every set; screenshot paths in a node's test events start with that folder: they are relative to `outputDir`,
+     * with `/` separators. Relative to the project folder
      */
     outputDir?: string;
     /**

package/dist/flows/run/project.d.ts

@@ -1,7 +1,7 @@
 import { type FlowFile, type FlowProblem } from "../core/index.js";
 import { type ResolvedGroup } from "../../runner/groups.js";
 import type { SamuraiTestConfig } from "../../types/config.js";
-import type { FlowSummary, NodeTest } from "./events.js";
+import type { FlowRunResult, NodeTest } from "./events.js";
 import { FlowCheckError, type FlowRunOptions, type RunFlowInProjectOptions } from "./project-options.js";
 import type { SupportedBrowser } from "../../types/browser.js";
 export { FlowCheckError };
@@ -15,15 +15,19 @@ interface ProjectTest {
     name: string;
     /** The spec file relative to `srcDir`, with `/` separators */
     relative: string;
+    /** The inputs the test declares, with their defaults */
+    inputs?: Record<string, string>;
+    /** The outputs the test declares */
+    outputs?: string[];
 }
-/** The tests, and the browsers, of each Test and Group node of a flow; a Test node uses the project's browsers */
-export declare function nodeTestsOf(flow: FlowFile, tests: Pick<ProjectTest, "id" | "file" | "name">[], groups: Pick<ResolvedGroup, "name" | "testIds" | "browsers">[]): {
+/** The tests, and the browsers, of each Test and Group node of a flow: a Test node's are the project's, a Group node's its group's */
+export declare function nodeTestsOf(flow: FlowFile, tests: Pick<ProjectTest, "id" | "file" | "name">[], groups: Pick<ResolvedGroup, "name" | "testIds" | "browsers">[], projectBrowsers: SupportedBrowser[]): {
     nodeTests: Record<string, NodeTest[]>;
     nodeBrowsers: Record<string, SupportedBrowser[]>;
 };
 /**
  * Checks a flow against the project without running it: its tests, groups and environment
- * variables, and which kinds can run. Returns the flow (with keys) and every problem, warnings included.
+ * variables, which kinds can run, and where each Test and Group node's inputs come from. Returns the flow (with keys) and every problem, warnings included.
  */
 export declare function checkFlowInProject(options: Pick<RunFlowInProjectOptions, "flow" | "flowId" | "projectDir" | "config" | "dataDir" | "environment" | "unsupported">): Promise<{
     flow: FlowFile;
@@ -31,8 +35,9 @@ export declare function checkFlowInProject(options: Pick<RunFlowInProjectOptions
 }>;
 /**
  * Checks and runs a flow of a project: loads its config, lists its tests and groups, refuses to start
- * when `checkFlow` finds errors (`FlowCheckError`), then walks the flow; each Test and Group node runs
- * its tests through `runTests`, one after the other, or on one shared worker pool when `workers` is above 1.
- * One at a time per process.
+ * when `checkFlow` finds errors (`FlowCheckError`), then walks the flow once per browser (see `flowBrowsers`),
+ * one browser after the other, each run with its own variables and results. Each Test and Group node runs its
+ * tests through `runTests`, one after the other, or on one shared worker pool when `workers` is above 1.
+ * Resolves to every run's summary; the last event is `flow-done`. One at a time per process.
  */
-export declare function runFlowInProject(options: RunFlowInProjectOptions): Promise<FlowSummary>;
+export declare function runFlowInProject(options: RunFlowInProjectOptions): Promise<FlowRunResult>;

package/dist/flows/run/project.js

@@ -14,8 +14,9 @@ import TestRunner from "../../runner/test-runner.js";
 import { WorkerPool } from "../../runner/worker-pool.js";
 import { processWorkerFactory } from "../../runner/worker-process.js";
 import { readFlow } from "./files.js";
-import { nodeFolder } from "./node-folder.js";
-import { itemsOf, runOnPool } from "./node-pool.js";
+import { flowFacts } from "./project-facts.js";
+import { nodeRunner } from "./node-runner.js";
+import { flowBrowsers, runPerBrowser } from "./per-browser.js";
 import { FlowCheckError, } from "./project-options.js";
 import { projectSteps } from "../steps/set.js";
 import { HANDLERS } from "./handlers/index.js";
@@ -34,8 +35,8 @@ export function chooseEnvironment(config, flow, option) {
         return flow.envDefault;
     return config.defaultEnvironment ?? names[0] ?? "default";
 }
-/** The tests, and the browsers, of each Test and Group node of a flow; a Test node uses the project's browsers */
-export function nodeTestsOf(flow, tests, groups) {
+/** The tests, and the browsers, of each Test and Group node of a flow: a Test node's are the project's, a Group node's its group's */
+export function nodeTestsOf(flow, tests, groups, projectBrowsers) {
     const byId = new Map(tests.map((t) => [t.id, t]));
     const nodeTests = {};
     const nodeBrowsers = {};
@@ -52,6 +53,8 @@ export function nodeTestsOf(flow, tests, groups) {
             continue;
         if (group)
             nodeBrowsers[node.id] = group.browsers;
+        if (node.kind === "test")
+            nodeBrowsers[node.id] = projectBrowsers;
         nodeTests[node.id] = ids.flatMap((id) => {
             const t = byId.get(id);
             return t ? [{ file: t.file, name: t.name }] : [];
@@ -92,10 +95,13 @@ async function prepare(options) {
             file: t.file,
             name: t.name,
             relative: toPosix(path.relative(srcDir, t.file)),
+            ...(t.inputs && { inputs: t.inputs }),
+            ...(t.outputs && { outputs: t.outputs }),
         }));
         const groups = resolveGroups(config, tests.map((t) => ({ file: t.relative, name: t.name })), realDir, srcDir);
         return { tests, groups };
     });
+    const facts = flowFacts(tests, groups);
     const problems = checkFlow(flow, {
         tests: tests.map((t) => t.id),
         groups: groups.map((g) => g.name),
@@ -106,6 +112,7 @@ async function prepare(options) {
         ]),
         unsupported,
         nodes: steps.nodes,
+        facts,
     });
     return {
         projectDir,
@@ -117,23 +124,27 @@ async function prepare(options) {
         environment,
         tests,
         groups,
+        facts,
         problems,
     };
 }
 /**
  * Checks a flow against the project without running it: its tests, groups and environment
- * variables, and which kinds can run. Returns the flow (with keys) and every problem, warnings included.
+ * variables, which kinds can run, and where each Test and Group node's inputs come from. Returns the flow (with keys) and every problem, warnings included.
  */
 export async function checkFlowInProject(options) {
     const { flow, problems } = await prepare(options);
     return { flow, problems };
 }
 async function walkFlowInProject(options) {
-    const { projectDir, flow, unsupported, config, steps, name, environment, tests, groups, problems, } = await prepare(options);
+    const { projectDir, flow, unsupported, config, steps, name, environment, tests, groups, facts, problems, } = await prepare(options);
     const errors = problems.filter((p) => p.level === "error");
     if (errors.length)
         throw new FlowCheckError(errors);
-    const { nodeTests, nodeBrowsers } = nodeTestsOf(flow, tests, groups);
+    const projectBrowsers = browsersFor({ project: config.browsers });
+    const { nodeTests, nodeBrowsers } = nodeTestsOf(flow, tests, groups, projectBrowsers);
+    // Before anything starts: a list of browsers this flow doesn't use is refused
+    const browsers = flowBrowsers(nodeBrowsers, flow, projectBrowsers, options.browsers);
     const run = options.testRunner ?? runTests;
     // An injected runner (tests) stays in this process unless the workers are asked for
     const asked = options.workers !== undefined ||
@@ -183,50 +194,35 @@ async function walkFlowInProject(options) {
             },
         })
         : undefined;
+    const walk = (browser) => runFlow({
+        flow,
+        browser,
+        nodeTests,
+        nodeBrowsers,
+        environment,
+        facts,
+        ...(options.signal && { signal: options.signal }),
+        ...(options.onEvent && { onEvent: options.onEvent }),
+        ...(options.sleep && { sleep: options.sleep }),
+        unsupported,
+        handlers: { ...HANDLERS, ...steps.handlers },
+        nodes: steps.nodes,
+        runTests: nodeRunner({
+            projectDir,
+            config,
+            options,
+            ...(hasEnvironment(config, name) && { environment: name }),
+            retries,
+            run,
+            ...(pool && { pool }),
+        }, browser),
+    });
     try {
-        return await runFlow({
-            flow,
-            nodeTests,
-            nodeBrowsers,
-            environment,
+        return await runPerBrowser({
+            browsers,
+            walk,
             ...(options.signal && { signal: options.signal }),
             ...(options.onEvent && { onEvent: options.onEvent }),
-            ...(options.sleep && { sleep: options.sleep }),
-            unsupported,
-            handlers: { ...HANDLERS, ...steps.handlers },
-            nodes: steps.nodes,
-            runTests: async ({ nodeId, tests, onEvent, signal, browsers }) => {
-                // Each node gets a folder of its own: the same test in two nodes would overwrite its screenshots
-                const outputDir = options.outputDir !== undefined
-                    ? path.join(options.outputDir, ...nodeFolder(nodeId).split("/"))
-                    : undefined;
-                if (pool)
-                    return runOnPool(pool, itemsOf(tests, browsers ?? browsersFor({ project: config.browsers }), outputDir), onEvent, signal);
-                const summary = await run({
-                    projectDir,
-                    config,
-                    ...(options.dataDir !== undefined && { dataDir: options.dataDir }),
-                    // The environment the expressions see, whenever the project defines it
-                    ...(hasEnvironment(config, name) ? { environment: name } : {}),
-                    ...(options.headless !== undefined && { headless: options.headless }),
-                    ...(options.timeout !== undefined && { timeout: options.timeout }),
-                    ...(options.expectTimeout !== undefined && {
-                        expectTimeout: options.expectTimeout,
-                    }),
-                    ...(options.port !== undefined && { port: options.port }),
-                    ...(retries > 0 && { retries }),
-                    ...(browsers && { browsers }),
-                    files: [...new Set(tests.map((t) => t.file))],
-                    testNames: tests.map((t) => t.name),
-                    reportPath: false,
-                    ...(outputDir !== undefined && { outputDir }),
-                    signal,
-                    onEvent,
-                });
-                if (signal.aborted)
-                    return "cancelled";
-                return summary.status === "success" ? "passed" : "failed";
-            },
         });
     }
     finally {
@@ -235,9 +231,10 @@ async function walkFlowInProject(options) {
 }
 /**
  * Checks and runs a flow of a project: loads its config, lists its tests and groups, refuses to start
- * when `checkFlow` finds errors (`FlowCheckError`), then walks the flow; each Test and Group node runs
- * its tests through `runTests`, one after the other, or on one shared worker pool when `workers` is above 1.
- * One at a time per process.
+ * when `checkFlow` finds errors (`FlowCheckError`), then walks the flow once per browser (see `flowBrowsers`),
+ * one browser after the other, each run with its own variables and results. Each Test and Group node runs its
+ * tests through `runTests`, one after the other, or on one shared worker pool when `workers` is above 1.
+ * Resolves to every run's summary; the last event is `flow-done`. One at a time per process.
  */
 export async function runFlowInProject(options) {
     // One log for the whole run, across the project sessions it opens one after the other

package/dist/flows/run/report.d.ts

@@ -1,5 +1,5 @@
 import type { TestResult } from "../../types/test.js";
-import type { FlowEvent, FlowSummary, NodeResult } from "./events.js";
+import type { FlowBrowserRun, FlowEvent, FlowRunResult } from "./events.js";
 /** One test a Test or Group node ran, as the runner reported it */
 export type FlowTestResult = {
     nodeId: string;
@@ -9,14 +9,14 @@ export interface FlowReport {
     flow: string;
     name: string;
     environment: string;
-    status: FlowSummary["status"];
+    /** Across the browsers: see `FlowRunResult` */
+    status: FlowRunResult["status"];
     startedAt: string;
     durationMs: number;
-    nodes: Record<string, NodeResult>;
-    vars: Record<string, unknown>;
+    /** Every test of every run; each names its browser */
     tests: FlowTestResult[];
-    /** The flow couldn't be walked at all */
-    error?: string;
+    /** One entry per browser the flow ran in, in order: its nodes, variables and error */
+    runs: FlowBrowserRun[];
 }
 /** Follows a run's events and builds its report once it ends (or `finish` is given what is known) */
 export declare class FlowReportBuilder {
@@ -31,7 +31,7 @@ export declare class FlowReportBuilder {
     });
     handle(event: FlowEvent): void;
     private collect;
-    finish(summary: FlowSummary, environment?: string): FlowReport;
+    finish(result: FlowRunResult, environment?: string): FlowReport;
 }
 /** Writes `<projectDir>/result/flows/<id>.json` with the registered secrets masked, as `report.json` is. Returns the path */
 export declare function writeFlowReport(projectDir: string, report: FlowReport): Promise<string>;