@itmetsam/samurai-framework 0.20.0 → 0.21.1

package/dist/flows/core/check-io.js

@@ -0,0 +1,84 @@
+import { problemOf, scopeAt } from "./expression/index.js";
+import { meetOf, reachOrder } from "./graph.js";
+import { isInputSource } from "./schema.js";
+import { declaredInputs, declaredOutputs, wiringAt, } from "./wiring.js";
+/**
+ * Problems with inputs and outputs: an input with no source, an override expression
+ * that doesn't check out, an entry for an input the test doesn't declare, a Group
+ * node with an expression, and two branches of one Parallel saving the same output.
+ */
+export function ioProblems(flow, check) {
+    return [
+        ...flow.nodes.flatMap((n) => n.kind === "test" || n.kind === "group"
+            ? inputProblems(flow, n, check)
+            : []),
+        ...flow.nodes
+            .filter((n) => n.kind === "parallel")
+            .flatMap((p) => branchClashes(flow, p, check)),
+    ];
+}
+function inputProblems(flow, node, check) {
+    const known = node.kind === "test"
+        ? !!node.ref?.testId && !!check.facts.tests[node.ref.testId]
+        : !!node.ref?.group && !!check.facts.groups[node.ref.group];
+    if (!known)
+        return [];
+    const problems = [];
+    const at = (level, message) => problems.push({ level, nodeId: node.id, message });
+    const declared = declaredInputs(node, check.facts);
+    const groupSet = new Set();
+    for (const [name, source] of Object.entries(node.inputs ?? {})) {
+        if (!declared.has(name))
+            at("warning", `input "${name}" is not used by this ${node.kind === "group" ? "node" : "test"}`);
+        else if (!isInputSource(source) || !("expression" in source))
+            continue;
+        else if (node.kind === "group")
+            groupSet.add(name);
+        else if (check.environment) {
+            const problem = problemOf(source.expression, scopeAt(flow, node.id, check.environment, {
+                nodes: check.nodes,
+                facts: check.facts,
+            }));
+            if (problem)
+                at("error", `${check.titleOf(node)}: input "${name}": ${problem.message}`);
+        }
+    }
+    if (groupSet.size)
+        at("error", `${check.titleOf(node)}: Group nodes can't set inputs (${[...groupSet].map((x) => `"${x}"`).join(", ")})`);
+    for (const [name, wiring] of Object.entries(wiringAt(flow, node.id, { facts: check.facts })))
+        if (wiring.from === "none" && !groupSet.has(name))
+            at("error", `${check.titleOf(node)}: input "${name}" has no source. Save it as an output in an earlier test, set an expression, or use the default`);
+    return problems;
+}
+/**
+ * `<parallel title>: branches both save "x"`, once per output name two branches
+ * save. A node two branches both reach before the meet counts for the first only.
+ */
+function branchClashes(flow, parallel, check) {
+    const meet = meetOf(flow, parallel.id);
+    const beyond = new Set(meet ? reachOrder(flow, meet) : []);
+    const savedBy = new Map();
+    const counted = new Set();
+    for (const e of flow.edges.filter((x) => x.source === parallel.id)) {
+        const names = new Set(reachOrder(flow, e.target)
+            .filter((id) => {
+            if (beyond.has(id) || counted.has(id))
+                return false;
+            counted.add(id);
+            return true;
+        })
+            .flatMap((id) => {
+            const n = flow.nodes.find((x) => x.id === id);
+            return n ? declaredOutputs(n, check.facts) : [];
+        }));
+        for (const name of names)
+            savedBy.set(name, (savedBy.get(name) ?? 0) + 1);
+    }
+    return [...savedBy]
+        .filter(([, count]) => count > 1)
+        .map(([name]) => ({
+        level: "error",
+        nodeId: parallel.id,
+        message: `${check.titleOf(parallel)}: branches both save "${name}"`,
+    }));
+}

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

@@ -1,6 +1,7 @@
 import { type FlowProblem } from "./nodes/index.js";
 import type { AnyNodeDefinition } from "./nodes/define.js";
 import type { FlowFile, FlowNodeModel } from "./schema.js";
+import type { FlowFacts } from "./wiring.js";
 export type { FlowProblem } from "./nodes/index.js";
 export interface CheckOptions {
     /** The test ids that exist. When given, a Test node whose test is gone is an error. */
@@ -30,6 +31,12 @@ export interface CheckOptions {
     titles?: (node: FlowNodeModel) => string | undefined;
     /** Definitions of kinds core doesn't have (steps). A node of a kind in neither is "Unknown step". */
     nodes?: readonly AnyNodeDefinition[];
+    /**
+     * The project's tests' inputs and outputs and its groups' tests. When given, every
+     * Test and Group node's inputs are checked (a source for each, override expressions,
+     * unused entries) and so are a Parallel's branches (two saving one output name).
+     */
+    facts?: FlowFacts;
 }
 /**
  * Checks a flow before a run: the shape of the graph, keys, references that still
@@ -38,8 +45,15 @@ export interface CheckOptions {
  * its key, else its kind's label (the app names it by what the editor shows).
  */
 export declare function checkFlow(flow: FlowFile, options?: CheckOptions): FlowProblem[];
-/** Every expression field that doesn't check out, as "Label: message" */
+/**
+ * Every expression field that doesn't check out, as "Label: message". `options.nodes`
+ * adds definitions core doesn't have (steps); `options.facts` lets expressions read
+ * a keyed Test node's declared outputs (`nodes.<key>.<output>`).
+ */
 export declare function expressionProblems(flow: FlowFile, environment: {
     name: string;
     variables: Record<string, unknown>;
-}, nodes?: readonly AnyNodeDefinition[]): FlowProblem[];
+}, options?: {
+    nodes?: readonly AnyNodeDefinition[];
+    facts?: FlowFacts;
+}): FlowProblem[];

package/dist/flows/core/check.js

@@ -1,3 +1,4 @@
+import { ioProblems } from "./check-io.js";
 import { problemOf, scopeAt } from "./expression/index.js";
 import { KEY_PATTERN } from "./keys.js";
 import { branchNames, dynamicOf, getPath, nodeDef, withDefaults, } from "./nodes/index.js";
@@ -142,7 +143,17 @@ export function checkFlow(flow, options = {}) {
     }
     problems.push(...emptyExpressions(flow, defOf));
     if (options.environment)
-        problems.push(...expressionProblems(flow, options.environment, options.nodes));
+        problems.push(...expressionProblems(flow, options.environment, {
+            nodes: options.nodes,
+            facts: options.facts,
+        }));
+    if (options.facts)
+        problems.push(...ioProblems(flow, {
+            facts: options.facts,
+            environment: options.environment,
+            nodes: options.nodes,
+            titleOf: (n) => options.titles?.(n) ?? titleOf(n, defOf(n.kind)),
+        }));
     const nodeCount = flow.nodes.filter((n) => {
         const s = shapeOf(n);
         return s !== "start" && s !== "end";
@@ -177,8 +188,13 @@ function emptyExpressions(flow, defOf) {
         }));
     });
 }
-/** Every expression field that doesn't check out, as "Label: message" */
-export function expressionProblems(flow, environment, nodes = []) {
+/**
+ * Every expression field that doesn't check out, as "Label: message". `options.nodes`
+ * adds definitions core doesn't have (steps); `options.facts` lets expressions read
+ * a keyed Test node's declared outputs (`nodes.<key>.<output>`).
+ */
+export function expressionProblems(flow, environment, options = {}) {
+    const { nodes = [], facts } = options;
     const defOf = definitions(nodes);
     return flow.nodes.flatMap((n) => {
         const def = defOf(n.kind);
@@ -190,7 +206,7 @@ export function expressionProblems(flow, environment, nodes = []) {
             const text = getPath(n, f.path);
             if (typeof text !== "string" || text.trim() === "")
                 return [];
-            const problem = problemOf(text, scopeAt(flow, n.id, environment, nodes));
+            const problem = problemOf(text, scopeAt(flow, n.id, environment, { nodes, facts }));
             return problem
                 ? [
                     {

package/dist/flows/core/expression/scope.d.ts

@@ -1,8 +1,15 @@
 import type { AnyNodeDefinition } from "../nodes/define.js";
 import type { FlowFile } from "../schema.js";
+import { type FlowFacts } from "../wiring.js";
 import type { ExpressionScope } from "./check.js";
-/** What an expression at `nodeId` may use; `nodes` adds definitions core doesn't have (steps) */
+/**
+ * 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 declare function scopeAt(flow: FlowFile, nodeId: string, environment: {
     name: string;
     variables: Record<string, unknown>;
-}, nodes?: readonly AnyNodeDefinition[]): ExpressionScope;
+}, options?: {
+    nodes?: readonly AnyNodeDefinition[];
+    facts?: FlowFacts;
+}): ExpressionScope;

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;
 };