@itmetsam/samurai-framework 0.19.0 → 0.21.0

package/dist/flows/core/expression/scope.js

@@ -1,8 +1,13 @@
 import { ancestors, dominates, reachOrder } from "../graph.js";
 import { NODES } from "../nodes/index.js";
 import { getPath } from "../nodes/path.js";
-/** What an expression at `nodeId` may use; `nodes` adds definitions core doesn't have (steps) */
-export function scopeAt(flow, nodeId, environment, nodes = []) {
+import { declaredOutputs } from "../wiring.js";
+/**
+ * What an expression at `nodeId` may use. `options.nodes` adds definitions core
+ * doesn't have (steps); `options.facts` adds each keyed Test node's declared outputs.
+ */
+export function scopeAt(flow, nodeId, environment, options = {}) {
+    const { nodes = [], facts } = options;
     const defOf = (kind) => nodes.find((d) => d.kind === kind) ?? NODES.find((d) => d.kind === kind);
     const keyOf = (id) => flow.nodes.find((n) => n.id === id)?.key;
     const keys = (ids) => [...ids].map(keyOf).filter((k) => !!k);
@@ -17,8 +22,11 @@ export function scopeAt(flow, nodeId, environment, nodes = []) {
     })
         .filter((name) => typeof name === "string" && name !== "");
     const outputs = Object.fromEntries(flow.nodes.flatMap((n) => {
-        const results = defOf(n.kind)?.results;
-        return n.key && results?.length ? [[n.key, results]] : [];
+        const results = [
+            ...(defOf(n.kind)?.results ?? []),
+            ...declaredOutputs(n, facts),
+        ];
+        return n.key && results.length ? [[n.key, results]] : [];
     }));
     return {
         env: {

package/dist/flows/core/index.d.ts

@@ -8,10 +8,11 @@ export * from "./graph.js";
 export * from "./expression/index.js";
 export * from "./nodes/index.js";
 export * from "./check.js";
+export * from "./wiring.js";
 export * from "./steps.js";
 /**
  * Version of the contract between the SAMURAI app and this framework.
  * Increments whenever the app and the framework must agree on something new
  * (a node kind, a field, an event), so the app can tell when the framework is too old.
  */
-export declare const FLOWS_API = 2;
+export declare const FLOWS_API = 3;

package/dist/flows/core/index.js

@@ -8,10 +8,11 @@ export * from "./graph.js";
 export * from "./expression/index.js";
 export * from "./nodes/index.js";
 export * from "./check.js";
+export * from "./wiring.js";
 export * from "./steps.js";
 /**
  * Version of the contract between the SAMURAI app and this framework.
  * Increments whenever the app and the framework must agree on something new
  * (a node kind, a field, an event), so the app can tell when the framework is too old.
  */
-export const FLOWS_API = 2;
+export const FLOWS_API = 3;

package/dist/flows/core/nodes/condition.js

@@ -16,6 +16,5 @@ export const condition = defineNode({
             default: "",
         },
     ],
-    outputs: true,
     onFailure: true,
 });

package/dist/flows/core/nodes/define.d.ts

@@ -108,8 +108,6 @@ export interface NodeCoreDefinition<K extends string = string, C = Record<string
      */
     branches?: readonly Branch[] | DynamicBranches;
     fields: readonly Field[];
-    /** The node can write outputs (shared-context variables) */
-    outputs?: boolean;
     /** A step's output names: readable later as `nodes.<key>.<name>` */
     results?: readonly string[];
     /** The path of the field holding the name of a variable the node writes (`vars.<name>`) */

package/dist/flows/core/nodes/group.js

@@ -5,7 +5,6 @@ export const group = defineNode({
     label: "Group",
     shape: "step",
     fields: [{ path: "ref.group", type: "group", label: "Group" }],
-    outputs: true,
     validate: (node, ctx) => ctx.groups && !(node.ref?.group && ctx.groups.has(node.ref.group))
         ? [
             {

package/dist/flows/core/nodes/test.js

@@ -5,7 +5,6 @@ export const test = defineNode({
     label: "Test",
     shape: "step",
     fields: [],
-    outputs: true,
     validate: (node, ctx) => ctx.tests && !(node.ref?.testId && ctx.tests.has(node.ref.testId))
         ? [
             {

package/dist/flows/core/schema.d.ts

@@ -1,7 +1,11 @@
-export interface FlowNodeOutput {
-    /** Name of the shared-context variable the node writes */
-    name: string;
-}
+/** Where a Test or Group node's input comes from, when not wired by name. A Group node accepts only `{ useDefault: true }` */
+export type InputSource = {
+    expression: string;
+} | {
+    useDefault: true;
+};
+/** Whether `value` is an `InputSource`: `{ expression: string }` or `{ useDefault: true }` */
+export declare function isInputSource(value: unknown): value is InputSource;
 export interface FlowNodeModel {
     id: string;
     /** Short name expressions use: nodes.<key>. Lowercase letters, digits and _, unique in the flow */
@@ -15,7 +19,8 @@ export interface FlowNodeModel {
         testId?: string;
         group?: string;
     };
-    outputs?: FlowNodeOutput[];
+    /** test and group: per input name, an override or "use the default"; the rest is wired by name (see wiringAt) */
+    inputs?: Record<string, InputSource>;
     /** What to do when the node fails; "stop" ends the run there */
     onFailure: "stop" | "continue";
     /** Continue in the previous node's browser session (kept in the file; the framework opens a fresh browser per test today) */

package/dist/flows/core/schema.js

@@ -1,3 +1,10 @@
+/** Whether `value` is an `InputSource`: `{ expression: string }` or `{ useDefault: true }` */
+export function isInputSource(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const source = value;
+    return typeof source.expression === "string" || source.useDefault === true;
+}
 /** The flow file format version this framework writes and reads */
 export const FLOW_VERSION = 1;
 /** Steps, in order, that lift an older file to FLOW_VERSION. Empty while version 1 is the only one. */
@@ -29,5 +36,26 @@ export function readFlowFile(raw) {
         if (step)
             flow = step.migrate(flow);
     }
-    return { ...flow, version: FLOW_VERSION };
+    return {
+        ...flow,
+        nodes: flow.nodes.map(readNode),
+        version: FLOW_VERSION,
+    };
+}
+/**
+ * A node as the file holds it, without its hand-typed `outputs` (removed; tests declare their outputs now) and
+ * without `inputs` entries that aren't an `InputSource`
+ */
+function readNode(node) {
+    if (typeof node !== "object" || node === null)
+        return node;
+    const rest = { ...node };
+    delete rest.outputs;
+    if ("inputs" in rest) {
+        const inputs = rest.inputs;
+        delete rest.inputs;
+        if (typeof inputs === "object" && inputs !== null && !Array.isArray(inputs))
+            rest.inputs = Object.fromEntries(Object.entries(inputs).filter(([, source]) => isInputSource(source)));
+    }
+    return rest;
 }

package/dist/flows/core/steps.d.ts

@@ -36,6 +36,13 @@ export interface StepInfo {
 export declare const STEP_KIND: RegExp;
 /** A node's own result fields: an output can't take these names */
 export declare const RESERVED_OUTPUTS: readonly string[];
+/** The shape of an input or output name */
+export declare const IO_NAME: RegExp;
+/**
+ * Whether `name` can name a test's input or output: an identifier that isn't in `RESERVED_OUTPUTS` and isn't one
+ * of an object's special keys
+ */
+export declare const isIoName: (name: string) => boolean;
 /** Problems with `node`'s values against the fields' rules, as "Label: message" */
 export declare function fieldProblems(fields: readonly StepField[], node: FlowNodeModel, label: string): FlowProblem[];
 /** The definition core's walker and checkFlow use for a step; `validate` is the step's own (engine only) */

package/dist/flows/core/steps.js

@@ -6,6 +6,21 @@ export const RESERVED_OUTPUTS = [
     "durationMs",
     "error",
 ];
+/** The shape of an input or output name */
+export const IO_NAME = /^[A-Za-z_]\w*$/;
+/** Keys an object literal or a lookup treats specially: as a name they would set or read the prototype */
+const OBJECT_KEYS = [
+    "__proto__",
+    "constructor",
+    "prototype",
+];
+/**
+ * Whether `name` can name a test's input or output: an identifier that isn't in `RESERVED_OUTPUTS` and isn't one
+ * of an object's special keys
+ */
+export const isIoName = (name) => IO_NAME.test(name) &&
+    !RESERVED_OUTPUTS.includes(name) &&
+    !OBJECT_KEYS.includes(name);
 const TITLE_FIELDS = [
     { path: "title", type: "text", label: "Title" },
     { path: "subtitle", type: "text", label: "Description" },

package/dist/flows/core/wiring.d.ts

@@ -0,0 +1,72 @@
+import { type FlowFile, type FlowNodeModel } from "./schema.js";
+/**
+ * What a flow needs to know about the project's tests and groups to wire inputs:
+ * each test's declared inputs (with their defaults) and outputs, by test id, and
+ * each group's test ids, by group name. `checkFlowInProject` builds it from the
+ * project; the SAMURAI app builds it from `listTests` / `listGroups`.
+ */
+export interface FlowFacts {
+    tests: Record<string, {
+        inputs: {
+            name: string;
+            default: string;
+        }[];
+        outputs: string[];
+    }>;
+    groups: Record<string, string[]>;
+}
+/**
+ * The facts for a project's tests and groups, as `listTests` and `listGroups` give them: a test's `id`, its
+ * `inputs` and `outputs` (absent when it declares none) and a group's `name` and `testIds`. The lists are copied.
+ */
+export declare function flowFactsFrom(tests: readonly {
+    id: string;
+    inputs?: readonly {
+        name: string;
+        default: string;
+    }[];
+    outputs?: readonly string[];
+}[], groups: readonly {
+    name: string;
+    testIds: readonly string[];
+}[]): FlowFacts;
+/** Where one input of a node gets its value. Computed, never stored */
+export type InputWiring = {
+    from: "node";
+    nodeId: string;
+    output: string;
+} | {
+    from: "expression";
+    expression: string;
+} | {
+    from: "default";
+    value: string;
+} | {
+    from: "none";
+};
+/**
+ * Whether node `d` always ran before node `n`. Directly: `d` dominates `n`, or `d`
+ * sits on a Parallel branch that every path from the Parallel into the branch's end
+ * passes, and the Parallel's meet dominates `n`. Through nested Parallels: `d`
+ * always ran before some Parallel's meet, which always ran before `n`. A Parallel
+ * runs all its branches; a Condition runs one arm, so a node on one arm never
+ * always ran.
+ */
+export declare function alwaysBefore(flow: FlowFile, d: string, n: string): boolean;
+/**
+ * A Test or Group node's declared inputs, with their defaults. A group's inputs
+ * are the union of its tests' inputs; the first default wins. Empty without facts
+ * or for a test or group the facts don't know.
+ */
+export declare function declaredInputs(node: FlowNodeModel, facts: FlowFacts | undefined): Map<string, string>;
+/** The outputs a Test node declares; none for any other node */
+export declare const declaredOutputs: (node: FlowNodeModel, facts: FlowFacts | undefined) => readonly string[];
+/**
+ * Where each declared input of `nodeId` comes from, in this order: the node's
+ * override expression (Test nodes only), its "use the default", the closest Test
+ * node that always ran before it and declares an output of that name (of two in a
+ * row, the later one), else none.
+ */
+export declare function wiringAt(flow: FlowFile, nodeId: string, options?: {
+    facts?: FlowFacts;
+}): Record<string, InputWiring>;

package/dist/flows/core/wiring.js

@@ -0,0 +1,151 @@
+import { dominates, meetOf, reachOrder } from "./graph.js";
+import { isInputSource } from "./schema.js";
+/**
+ * The facts for a project's tests and groups, as `listTests` and `listGroups` give them: a test's `id`, its
+ * `inputs` and `outputs` (absent when it declares none) and a group's `name` and `testIds`. The lists are copied.
+ */
+export function flowFactsFrom(tests, groups) {
+    return {
+        tests: Object.fromEntries(tests.map((t) => [
+            t.id,
+            {
+                inputs: (t.inputs ?? []).map(({ name, default: value }) => ({
+                    name,
+                    default: value,
+                })),
+                outputs: [...(t.outputs ?? [])],
+            },
+        ])),
+        groups: Object.fromEntries(groups.map((g) => [g.name, [...g.testIds]])),
+    };
+}
+/**
+ * Whether node `d` always ran before node `n`. Directly: `d` dominates `n`, or `d`
+ * sits on a Parallel branch that every path from the Parallel into the branch's end
+ * passes, and the Parallel's meet dominates `n`. Through nested Parallels: `d`
+ * always ran before some Parallel's meet, which always ran before `n`. A Parallel
+ * runs all its branches; a Condition runs one arm, so a node on one arm never
+ * always ran.
+ */
+export function alwaysBefore(flow, d, n) {
+    return before(flow, parallelMeets(flow), d, n, new Set());
+}
+/** alwaysBefore over `meets`; `path` holds the meets on the current chain, so a looping flow still ends */
+function before(flow, meets, d, n, path) {
+    if (d === n)
+        return false;
+    if (directlyBefore(flow, d, n))
+        return true;
+    return meets.some((meet) => {
+        if (meet === n || path.has(meet) || !directlyBefore(flow, d, meet))
+            return false;
+        path.add(meet);
+        const ran = before(flow, meets, meet, n, path);
+        path.delete(meet);
+        return ran;
+    });
+}
+/** The meet of every Parallel in the flow */
+const parallelMeets = (flow) => flow.nodes
+    .filter((p) => p.kind === "parallel")
+    .map((p) => meetOf(flow, p.id))
+    .filter((m) => !!m);
+/** `d` dominates `n`, or `d` is on a Parallel branch every path into its meet passes, and the meet dominates `n` */
+function directlyBefore(flow, d, n) {
+    if (dominates(flow, d, n))
+        return d !== n;
+    return flow.nodes.some((p) => {
+        if (p.kind !== "parallel")
+            return false;
+        const meet = meetOf(flow, p.id);
+        if (!meet || !dominates(flow, meet, n))
+            return false;
+        return flow.edges.some((e) => e.source === p.id && passesBefore(flow, e.target, d, meet));
+    });
+}
+/** Whether every path from `from` to `meet` passes `d` (and one does) */
+function passesBefore(flow, from, d, meet) {
+    if (from === d)
+        return d !== meet;
+    if (!reachOrder(flow, from).includes(d))
+        return false;
+    const seen = new Set([d]);
+    const stack = [from];
+    while (stack.length) {
+        const id = stack.pop();
+        if (id === meet)
+            return false;
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        for (const e of flow.edges)
+            if (e.source === id)
+                stack.push(e.target);
+    }
+    return true;
+}
+/**
+ * A Test or Group node's declared inputs, with their defaults. A group's inputs
+ * are the union of its tests' inputs; the first default wins. Empty without facts
+ * or for a test or group the facts don't know.
+ */
+export function declaredInputs(node, facts) {
+    const inputs = new Map();
+    if (!facts)
+        return inputs;
+    const testIds = node.kind === "test"
+        ? [node.ref?.testId]
+        : node.kind === "group"
+            ? (facts.groups[node.ref?.group ?? ""] ?? [])
+            : [];
+    for (const id of testIds)
+        for (const input of (id && facts.tests[id]?.inputs) || [])
+            if (!inputs.has(input.name))
+                inputs.set(input.name, input.default);
+    return inputs;
+}
+/** The outputs a Test node declares; none for any other node */
+export const declaredOutputs = (node, facts) => (node.kind === "test" &&
+    node.ref?.testId &&
+    facts?.tests[node.ref.testId]?.outputs) ||
+    [];
+/**
+ * Where each declared input of `nodeId` comes from, in this order: the node's
+ * override expression (Test nodes only), its "use the default", the closest Test
+ * node that always ran before it and declares an output of that name (of two in a
+ * row, the later one), else none.
+ */
+export function wiringAt(flow, nodeId, options = {}) {
+    const node = flow.nodes.find((n) => n.id === nodeId);
+    if (!node)
+        return {};
+    const wiring = {};
+    let producers;
+    for (const [name, value] of declaredInputs(node, options.facts)) {
+        // A flow built in memory may hold anything here: only an InputSource is read
+        const entry = node.inputs?.[name];
+        const source = isInputSource(entry) ? entry : undefined;
+        if (source && "expression" in source && node.kind === "test")
+            wiring[name] = { from: "expression", expression: source.expression };
+        else if (source && "useDefault" in source)
+            wiring[name] = { from: "default", value };
+        else {
+            producers ??= flow.nodes.filter((p) => declaredOutputs(p, options.facts).length > 0 &&
+                alwaysBefore(flow, p.id, nodeId));
+            const from = closest(flow, producers.filter((p) => declaredOutputs(p, options.facts).includes(name)));
+            wiring[name] = from
+                ? { from: "node", nodeId: from.id, output: name }
+                : { from: "none" };
+        }
+    }
+    return wiring;
+}
+/** The candidate no other candidate always ran after; on a tie, the last a walk from Start meets */
+function closest(flow, candidates) {
+    const latest = candidates.filter((c) => !candidates.some((o) => o !== c && alwaysBefore(flow, c.id, o.id)));
+    if (latest.length <= 1)
+        return latest[0];
+    const start = flow.nodes.find((n) => n.kind === "start");
+    const order = start ? reachOrder(flow, start.id) : [];
+    return latest.sort((a, b) => order.indexOf(b.id) - order.indexOf(a.id))[0];
+}

package/dist/flows/run/branch-context.d.ts

@@ -1,14 +1,20 @@
 import type { ExpressionContext } from "../core/index.js";
-/** A branch of a Parallel node: its own copy of the variables and node outputs, and the variables as they were when it forked */
+/** The outputs each node saved in a run, by node id: what later nodes' inputs are wired from */
+export type OutputsById = Record<string, Record<string, unknown>>;
+/**
+ * A branch of a Parallel node: its own copy of the variables and node outputs (by key and by id), and the
+ * variables as they were when it forked
+ */
 export interface Fork {
     context: ExpressionContext;
+    outputsById: OutputsById;
     base: Record<string, unknown>;
 }
-export declare function forkContext(context: ExpressionContext): Fork;
+export declare function forkContext(context: ExpressionContext, outputsById: OutputsById): Fork;
 /**
- * Takes what the branches wrote into `into`: every node output, and every variable a branch changed. A variable
+ * Takes what the branches wrote into `into` and `intoOutputs`: every node output, and every variable a branch changed. A variable
  * two branches changed to different values is a clash and is not taken; the first clash is returned.
  */
-export declare function mergeForks(into: ExpressionContext, forks: readonly Fork[]): {
+export declare function mergeForks(into: ExpressionContext, intoOutputs: OutputsById, forks: readonly Fork[]): {
     clash?: string;
 };

package/dist/flows/run/branch-context.js

@@ -1,23 +1,25 @@
 import { isDeepStrictEqual } from "node:util";
-export function forkContext(context) {
+export function forkContext(context, outputsById) {
     return {
         context: {
             ...context,
             vars: { ...context.vars },
             nodes: { ...context.nodes },
         },
+        outputsById: { ...outputsById },
         base: { ...context.vars },
     };
 }
 /**
- * Takes what the branches wrote into `into`: every node output, and every variable a branch changed. A variable
+ * Takes what the branches wrote into `into` and `intoOutputs`: every node output, and every variable a branch changed. A variable
  * two branches changed to different values is a clash and is not taken; the first clash is returned.
  */
-export function mergeForks(into, forks) {
+export function mergeForks(into, intoOutputs, forks) {
     const changed = new Map();
     const clashes = new Set();
-    for (const { context, base } of forks) {
+    for (const { context, outputsById, base } of forks) {
         Object.assign(into.nodes, context.nodes);
+        Object.assign(intoOutputs, outputsById);
         for (const [name, value] of Object.entries(context.vars)) {
             if (name in base && isDeepStrictEqual(base[name], value))
                 continue;

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

@@ -1,4 +1,5 @@
 import type { RunEvent } from "../../runner/reporter.js";
+import type { SupportedBrowser } from "../../types/browser.js";
 export type NodeStatus = "passed" | "failed" | "skipped" | "not-run";
 export interface NodeResult {
     status: NodeStatus;
@@ -10,32 +11,46 @@ export interface NodeResult {
     branch?: string;
     /** What the node wrote to vars */
     wrote?: Record<string, unknown>;
-    /** A step's outputs, readable later as `nodes.<key>.<name>` */
+    /** A step's outputs, or the outputs a Test node's test saved; readable later as `nodes.<key>.<name>` */
     outputs?: Record<string, unknown>;
+    /** A Test or Group node: the input values it sent to its tests; absent when it sent none */
+    inputs?: Record<string, string>;
 }
 /** One test of a node: absolute file and full name */
 export interface NodeTest {
     file: string;
     name: string;
 }
+/**
+ * What a flow run reports. A flow runs once per browser: every event but the last carries the browser of its run,
+ * `flow-start` and `flow-end` come once per browser, and `flow-done` closes the whole thing.
+ */
 export type FlowEvent = {
     type: "flow-start";
+    browser: SupportedBrowser;
     environment: string;
 } | {
     type: "node-start";
+    browser: SupportedBrowser;
     nodeId: string;
 } | {
     type: "node-end";
+    browser: SupportedBrowser;
     nodeId: string;
     result: NodeResult;
 } | {
     type: "test";
+    browser: SupportedBrowser;
     nodeId: string;
     event: RunEvent;
 } | {
     type: "flow-end";
+    browser: SupportedBrowser;
     summary: FlowSummary;
-};
+} | ({
+    type: "flow-done";
+} & FlowRunResult);
+/** How one browser's walk of a flow ended */
 export interface FlowSummary {
     status: "passed" | "failed" | "cancelled";
     nodes: Record<string, NodeResult>;
@@ -43,3 +58,16 @@ export interface FlowSummary {
     /** The flow couldn't be walked at all */
     error?: string;
 }
+/** One browser's run of a flow */
+export interface FlowBrowserRun {
+    browser: SupportedBrowser;
+    summary: FlowSummary;
+}
+/**
+ * How a flow run ended, across its browsers: `cancelled` when it was aborted, else `failed` when any run failed,
+ * else `passed`. `runs` holds the runs that started, in the order they ran; an abort leaves the rest out
+ */
+export interface FlowRunResult {
+    status: "passed" | "failed" | "cancelled";
+    runs: FlowBrowserRun[];
+}

package/dist/flows/run/handlers/group.js

@@ -1,7 +1,11 @@
-import { runNodeTests } from "./support.js";
+import { runWiredTests } from "../node-inputs.js";
+import { notInBrowser } from "./support.js";
 export const group = async (node, run) => {
+    const skipped = notInBrowser(node, run);
+    if (skipped)
+        return skipped;
     const list = run.nodeTests[node.id] ?? [];
     if (list.length === 0)
         return { status: "passed", note: "This group has no tests." };
-    return runNodeTests(node, run, list);
+    return runWiredTests(node, run, list);
 };

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

@@ -2,7 +2,12 @@ import { type FlowNodeModel } from "../../core/index.js";
 import type { NodeTest } from "../events.js";
 import type { HandlerRun, Outcome } from "./types.js";
 export declare const fail: (e: unknown) => Outcome;
-/** Runs `list` for the node and turns the result into an outcome */
-export declare function runNodeTests(node: FlowNodeModel, run: HandlerRun, list: NodeTest[]): Promise<Outcome>;
+/** A Test or Group node whose browsers lack the run's is skipped with a note */
+export declare const notInBrowser: (node: FlowNodeModel, run: HandlerRun) => Outcome | undefined;
+/**
+ * Runs `list` for the node with `inputs` and turns the result into an outcome: the inputs it sent (when any) and,
+ * for a Test node that passed, the outputs its test saved (a retried test's last attempt)
+ */
+export declare function runNodeTests(node: FlowNodeModel, run: HandlerRun, list: NodeTest[], inputs?: Record<string, string>): Promise<Outcome>;
 /** The checker's problem with an expression, as the builder would show it: a bypassed check fails the node the same way */
 export declare const problemAt: (node: FlowNodeModel, run: HandlerRun, text: string) => string | undefined;

package/dist/flows/run/handlers/support.js

@@ -3,20 +3,49 @@ export const fail = (e) => ({
     status: "failed",
     error: e.message,
 });
-/** Runs `list` for the node and turns the result into an outcome */
-export async function runNodeTests(node, run, list) {
+/** A Test or Group node whose browsers lack the run's is skipped with a note */
+export const notInBrowser = (node, run) => run.nodeBrowsers?.[node.id]?.includes(run.browser) === false
+    ? { status: "skipped", note: `not run in ${run.browser}` }
+    : undefined;
+/**
+ * Runs `list` for the node with `inputs` and turns the result into an outcome: the inputs it sent (when any) and,
+ * for a Test node that passed, the outputs its test saved (a retried test's last attempt)
+ */
+export async function runNodeTests(node, run, list, inputs = {}) {
+    const sent = Object.keys(inputs).length > 0 ? inputs : undefined;
+    let saved;
     let result;
     try {
-        result = await run.runTests(node.id, list, (e) => run.onTestEvent(node.id, e), run.nodeBrowsers?.[node.id]);
+        result = await run.runTests(node.id, list, (e) => {
+            if (e.type === "test-end")
+                saved = "outputs" in e.result ? e.result.outputs : undefined;
+            run.onTestEvent(node.id, e);
+        }, sent);
     }
     catch (e) {
-        return fail(e);
+        return {
+            status: "failed",
+            error: e.message,
+            ...(sent && { inputs: sent }),
+        };
     }
     if (result === "cancelled")
         return "cancelled";
+    const outputs = node.kind === "test" ? saved : undefined;
     return result === "passed"
-        ? { status: "passed" }
-        : { status: "failed", error: "A test failed." };
+        ? {
+            status: "passed",
+            ...(sent && { inputs: sent }),
+            ...(outputs && { outputs }),
+        }
+        : {
+            status: "failed",
+            error: "A test failed.",
+            ...(sent && { inputs: sent }),
+        };
 }
 /** The checker's problem with an expression, as the builder would show it: a bypassed check fails the node the same way */
-export const problemAt = (node, run, text) => checkExpression(parseExpression(text), scopeAt(run.flow, node.id, run.environment, run.nodes))?.message;
+export const problemAt = (node, run, text) => checkExpression(parseExpression(text), scopeAt(run.flow, node.id, run.environment, {
+    nodes: run.nodes,
+    ...(run.facts && { facts: run.facts }),
+}))?.message;

package/dist/flows/run/handlers/test.js

@@ -1,7 +1,11 @@
-import { runNodeTests } from "./support.js";
+import { runWiredTests } from "../node-inputs.js";
+import { notInBrowser } from "./support.js";
 export const test = async (node, run) => {
+    const skipped = notInBrowser(node, run);
+    if (skipped)
+        return skipped;
     const list = run.nodeTests[node.id];
     if (!list || list.length === 0)
         return { status: "failed", error: "This test was deleted or moved." };
-    return runNodeTests(node, run, list);
+    return runWiredTests(node, run, list);
 };