@itmetsam/samurai-framework 0.3.0 → 0.4.0

package/dist/cli/flow-reporter.js

@@ -1,5 +1,6 @@
 import { nodeDef, } from "../flows/core/index.js";
 import { maskSecrets as maskText, } from "../flows/run/index.js";
+import { STEP_NODES } from "../flows/steps/index.js";
 const took = (ms) => ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(1)}s`;
 const SKIPPED_BY_SHAPE = new Set(["start", "end"]);
 /** Prints a flow run for a person: one line per node as it ends, then a count. Start and End are not listed. */
@@ -28,7 +29,7 @@ export class FlowReporter {
             label = nodeDef(node.kind).label;
         }
         catch {
-            label = node.kind;
+            label = STEP_NODES.find((d) => d.kind === node.kind)?.label ?? node.kind;
         }
         const base = node.title || label;
         const wrote = result.wrote ? Object.keys(result.wrote) : [];

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

@@ -1,4 +1,5 @@
 import { type FlowProblem } from "./nodes/index.js";
+import type { AnyNodeDefinition } from "./nodes/define.js";
 import type { FlowFile, FlowNodeModel } from "./schema.js";
 export type { FlowProblem } from "./nodes/index.js";
 export interface CheckOptions {
@@ -27,6 +28,8 @@ export interface CheckOptions {
      * The SAMURAI app passes the editor's titles (a Test node shows its test's name).
      */
     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[];
 }
 /**
  * Checks a flow before a run: the shape of the graph, keys, references that still
@@ -39,4 +42,4 @@ export declare function checkFlow(flow: FlowFile, options?: CheckOptions): FlowP
 export declare function expressionProblems(flow: FlowFile, environment: {
     name: string;
     variables: Record<string, unknown>;
-}): FlowProblem[];
+}, nodes?: readonly AnyNodeDefinition[]): FlowProblem[];

package/dist/flows/core/check.js

@@ -3,14 +3,15 @@ import { KEY_PATTERN } from "./keys.js";
 import { branchNames, dynamicOf, getPath, nodeDef, withDefaults, } from "./nodes/index.js";
 /** What the node is called in a message: its title, else its key, else its kind's label */
 const titleOf = (node, def) => node.title || node.key || def?.label || node.kind;
-const defOf = (kind) => {
-    try {
-        return nodeDef(kind);
-    }
-    catch {
-        return undefined;
-    }
-};
+const definitions = (nodes = []) => (kind) => nodes.find((d) => d.kind === kind) ??
+    (() => {
+        try {
+            return nodeDef(kind);
+        }
+        catch {
+            return undefined;
+        }
+    })();
 /** Node ids in the order a run reaches them: from Start, following edges */
 function reachableFrom(flow, startId) {
     const out = new Map();
@@ -36,6 +37,7 @@ function reachableFrom(flow, startId) {
  * its key, else its kind's label (the app names it by what the editor shows).
  */
 export function checkFlow(flow, options = {}) {
+    const defOf = definitions(options.nodes);
     const problems = [];
     const tests = options.tests ? new Set(options.tests) : undefined;
     const groups = options.groups ? new Set(options.groups) : undefined;
@@ -45,7 +47,7 @@ export function checkFlow(flow, options = {}) {
             problems.push({
                 level: "error",
                 nodeId: n.id,
-                message: `Unknown node kind: ${n.kind}`,
+                message: `Unknown step: ${n.kind}`,
             });
     const starts = flow.nodes.filter((n) => shapeOf(n) === "start");
     const ends = flow.nodes.filter((n) => shapeOf(n) === "end");
@@ -138,9 +140,9 @@ export function checkFlow(flow, options = {}) {
         else
             seen.set(n.key, n.id);
     }
-    problems.push(...emptyExpressions(flow));
+    problems.push(...emptyExpressions(flow, defOf));
     if (options.environment)
-        problems.push(...expressionProblems(flow, options.environment));
+        problems.push(...expressionProblems(flow, options.environment, options.nodes));
     const nodeCount = flow.nodes.filter((n) => {
         const s = shapeOf(n);
         return s !== "start" && s !== "end";
@@ -157,7 +159,7 @@ export function checkFlow(flow, options = {}) {
     return problems;
 }
 /** Every expression field left empty: it would stop the run at its node */
-function emptyExpressions(flow) {
+function emptyExpressions(flow, defOf) {
     return flow.nodes.flatMap((n) => {
         const def = defOf(n.kind);
         if (!def)
@@ -176,7 +178,8 @@ function emptyExpressions(flow) {
     });
 }
 /** Every expression field that doesn't check out, as "Label: message" */
-export function expressionProblems(flow, environment) {
+export function expressionProblems(flow, environment, nodes = []) {
+    const defOf = definitions(nodes);
     return flow.nodes.flatMap((n) => {
         const def = defOf(n.kind);
         if (!def)
@@ -187,7 +190,7 @@ export function expressionProblems(flow, environment) {
             const text = getPath(n, f.path);
             if (typeof text !== "string" || text.trim() === "")
                 return [];
-            const problem = problemOf(text, scopeAt(flow, n.id, environment));
+            const problem = problemOf(text, scopeAt(flow, n.id, environment, nodes));
             return problem
                 ? [
                     {

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

@@ -1,5 +1,7 @@
 import { type ExpressionError, type Parsed } from "./parse.js";
 export interface ExpressionScope {
+    /** Output names of the nodes that have them, by key */
+    outputs?: Record<string, readonly string[]>;
     /** The flow environment's name and its variable names */
     env: {
         name: string;

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

@@ -81,10 +81,10 @@ export function checkExpression(parsed, scope) {
                     message: `${name} is on another branch, so it has no result here`,
                     at,
                 };
-            if (field !== undefined &&
-                !NODE_FIELDS.includes(field))
+            const fields = [...NODE_FIELDS, ...(scope.outputs?.[name] ?? [])];
+            if (field !== undefined && !fields.includes(field))
                 return {
-                    message: `nodes.${name}.${field} doesn't exist. Use ${list(NODE_FIELDS)}`,
+                    message: `nodes.${name}.${field} doesn't exist. Use ${list(fields)}`,
                     at,
                 };
         }

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

@@ -6,7 +6,7 @@ export interface ExpressionContext {
         status: string;
         durationMs?: number;
         error?: string;
-    }>;
+    } & Record<string, unknown>>;
     run: {
         environment: string;
         trigger: string;

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

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

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

@@ -1,17 +1,25 @@
 import { ancestors, dominates, reachOrder } from "../graph.js";
-/** What an expression at `nodeId` may use */
-export function scopeAt(flow, nodeId, environment) {
+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 = []) {
+    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);
     const before = ancestors(flow, nodeId);
     const after = new Set(reachOrder(flow, nodeId));
     after.delete(nodeId);
     const vars = flow.nodes
-        .filter((n) => n.kind === "set-variable" &&
-        n.id !== nodeId &&
-        dominates(flow, n.id, nodeId))
-        .map((n) => n.config?.name)
+        .filter((n) => n.id !== nodeId && dominates(flow, n.id, nodeId))
+        .map((n) => {
+        const path = defOf(n.kind)?.writesVar;
+        return path ? getPath(n, path) : undefined;
+    })
         .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]] : [];
+    }));
     return {
         env: {
             name: environment.name,
@@ -21,5 +29,6 @@ export function scopeAt(flow, nodeId, environment) {
         before: keys(before),
         after: keys(after),
         all: keys(flow.nodes.map((n) => n.id)),
+        outputs,
     };
 }

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

@@ -8,9 +8,10 @@ export * from "./graph.js";
 export * from "./expression/index.js";
 export * from "./nodes/index.js";
 export * from "./check.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 = 1;
+export declare const FLOWS_API = 2;

package/dist/flows/core/index.js

@@ -8,9 +8,10 @@ export * from "./graph.js";
 export * from "./expression/index.js";
 export * from "./nodes/index.js";
 export * from "./check.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 = 1;
+export const FLOWS_API = 2;

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

@@ -110,6 +110,10 @@ export interface NodeCoreDefinition<K extends string = string, C = Record<string
     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>`) */
+    writesVar?: string;
     /** The node has an "on failure" choice */
     onFailure?: boolean;
     /** Pure: problems with this node alone. `node.config` has the field defaults filled in. */

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

@@ -9,70 +9,14 @@ declare const registered: readonly [import("./define.js").NodeCoreDefinition<"st
     readonly label: "Expression";
     readonly placeholder: "nodes.login.status == \"passed\"";
     readonly default: "";
-}]>>, import("./define.js").NodeCoreDefinition<"parallel", import("./define.js").ConfigOf<readonly []>>, import("./define.js").NodeCoreDefinition<"wait", import("./define.js").ConfigOf<readonly [{
-    readonly path: "title";
-    readonly type: "text";
-    readonly label: "Title";
-}, {
-    readonly path: "subtitle";
-    readonly type: "text";
-    readonly label: "Description";
-}, {
-    readonly path: "config.ms";
-    readonly type: "number";
-    readonly label: "Duration";
-    readonly unit: "ms";
-    readonly default: 1000;
-}]>>, import("./define.js").NodeCoreDefinition<"set-variable", import("./define.js").ConfigOf<readonly [{
-    readonly path: "config.name";
-    readonly type: "text";
-    readonly label: "Name";
-    readonly placeholder: "orderId";
-    readonly default: "";
-}, {
-    readonly path: "config.value";
-    readonly type: "expression";
-    readonly label: "Value";
-    readonly placeholder: "\"order-\" + run.environment";
-    readonly default: "";
-}]>>, import("./define.js").NodeCoreDefinition<"api", import("./define.js").ConfigOf<readonly [{
-    readonly path: "title";
-    readonly type: "text";
-    readonly label: "Title";
-}, {
-    readonly path: "subtitle";
-    readonly type: "text";
-    readonly label: "Description";
-}]>>, import("./define.js").NodeCoreDefinition<"database", import("./define.js").ConfigOf<readonly [{
-    readonly path: "title";
-    readonly type: "text";
-    readonly label: "Title";
-}, {
-    readonly path: "subtitle";
-    readonly type: "text";
-    readonly label: "Description";
-}]>>, import("./define.js").NodeCoreDefinition<"email", import("./define.js").ConfigOf<readonly [{
-    readonly path: "title";
-    readonly type: "text";
-    readonly label: "Title";
-}, {
-    readonly path: "subtitle";
-    readonly type: "text";
-    readonly label: "Description";
-}]>>, import("./define.js").NodeCoreDefinition<"script", import("./define.js").ConfigOf<readonly [{
-    readonly path: "title";
-    readonly type: "text";
-    readonly label: "Title";
-}, {
-    readonly path: "subtitle";
-    readonly type: "text";
-    readonly label: "Description";
-}]>>];
+}]>>, import("./define.js").NodeCoreDefinition<"parallel", import("./define.js").ConfigOf<readonly []>>];
 export type NodeKind = (typeof registered)[number]["kind"];
 export declare const NODES: readonly AnyNodeDefinition[];
 /** The definition of a kind; throws for an unknown one */
 export declare function nodeDef(kind: string): AnyNodeDefinition;
-/** How a run treats a node in the graph */
+/** The kinds core defines itself; every other kind is a step */
+export declare const CLOSED_KINDS: readonly string[];
+/** How a run treats a node in the graph: a kind core doesn't define is a step */
 export declare const shapeOf: (node: {
     kind: string;
 }) => import("./define.js").Shape;
@@ -97,11 +41,5 @@ export declare const branchOf: (node: {
 export declare const branchNames: (node: {
     kind: string;
 }) => string[];
-/**
- * Kinds defined in core that a run has no handler for yet (`flows/run` skips or refuses
- * them). The one list: `flows/run` uses it too, and the builder warns with it without
- * importing `flows/run`.
- */
-export declare const UNSUPPORTED_KINDS: readonly string[];
 export * from "./define.js";
 export * from "./path.js";

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

@@ -1,30 +1,11 @@
-import { api } from "./api.js";
 import { condition } from "./condition.js";
-import { database } from "./database.js";
-import { email } from "./email.js";
 import { end } from "./end.js";
 import { group } from "./group.js";
 import { parallel } from "./parallel.js";
-import { script } from "./script.js";
-import { setVariable } from "./set-variable.js";
 import { start } from "./start.js";
 import { test } from "./test.js";
-import { wait } from "./wait.js";
-// Library order
-const registered = [
-    start,
-    end,
-    test,
-    group,
-    condition,
-    parallel,
-    wait,
-    setVariable,
-    api,
-    database,
-    email,
-    script,
-];
+// Library order. Every other kind is a step (`flows/steps`).
+const registered = [start, end, test, group, condition, parallel];
 export const NODES = registered;
 /** The definition of a kind; throws for an unknown one */
 export function nodeDef(kind) {
@@ -33,14 +14,18 @@ export function nodeDef(kind) {
         throw new Error(`Unknown node kind: ${kind}`);
     return def;
 }
-/** How a run treats a node in the graph */
-export const shapeOf = (node) => nodeDef(node.kind).shape;
+/** The definition of a kind core registers; undefined for any other (a step) */
+const closedDef = (kind) => NODES.find((d) => d.kind === kind);
+/** The kinds core defines itself; every other kind is a step */
+export const CLOSED_KINDS = NODES.map((d) => d.kind);
+/** How a run treats a node in the graph: a kind core doesn't define is a step */
+export const shapeOf = (node) => closedDef(node.kind)?.shape ?? "step";
 /** The branch names a dynamic list gives its branches: branch-0, branch-1, ... */
 export const dynamicName = (index) => `branch-${index}`;
 /** The dynamic branch settings of a `branches` node; undefined for a fixed list and any other shape */
 export const dynamicOf = (node) => {
-    const def = nodeDef(node.kind);
-    return def.shape === "branches" &&
+    const def = closedDef(node.kind);
+    return def?.shape === "branches" &&
         def.branches &&
         !Array.isArray(def.branches)
         ? def.branches
@@ -51,8 +36,8 @@ export const dynamicOf = (node) => {
  * `min` empty ones for a dynamic list. Empty for any other shape.
  */
 export const branchesOf = (node) => {
-    const def = nodeDef(node.kind);
-    if (def.shape !== "branches" || !def.branches)
+    const def = closedDef(node.kind);
+    if (!def || def.shape !== "branches" || !def.branches)
         return [];
     if (Array.isArray(def.branches))
         return def.branches;
@@ -66,16 +51,5 @@ export const branchOf = (node, handle) => dynamicOf(node)
     : branchesOf(node).find((b) => b.name === handle);
 /** The names of the branches `branchesOf` lists */
 export const branchNames = (node) => branchesOf(node).map((b) => b.name);
-/**
- * Kinds defined in core that a run has no handler for yet (`flows/run` skips or refuses
- * them). The one list: `flows/run` uses it too, and the builder warns with it without
- * importing `flows/run`.
- */
-export const UNSUPPORTED_KINDS = [
-    "api",
-    "database",
-    "email",
-    "script",
-];
 export * from "./define.js";
 export * from "./path.js";

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

@@ -0,0 +1,42 @@
+import type { Field, FlowProblem, NodeCoreDefinition } from "./nodes/define.js";
+import type { FlowNodeModel } from "./schema.js";
+/** Rules a step field carries: checked live in the builder and again by checkFlow */
+export interface FieldRules {
+    required?: boolean;
+    /** `number` fields */
+    min?: number;
+    max?: number;
+    /** `text` fields: a regular expression the value must match */
+    pattern?: string;
+    /** Said instead of the default when `pattern` doesn't match */
+    patternMessage?: string;
+}
+export type StepField = Field & FieldRules;
+export type StepSection = "control" | "integrations";
+export interface StepOutput {
+    name: string;
+    label?: string;
+}
+/** A step as data: what the app's catalog holds. No functions. */
+export interface StepInfo {
+    /** Stored in flow files as the node's `kind` */
+    kind: string;
+    label: string;
+    /** A design-system icon name */
+    icon: string;
+    section: StepSection;
+    /** `config.*` fields; Title and Description are added by `stepNodeOf` */
+    fields: readonly StepField[];
+    /** The line under the title: `{config.x}` is replaced with the field's value */
+    summary?: string;
+    outputs?: readonly StepOutput[];
+    /** The path of the field holding a variable name the step writes */
+    writesVar?: string;
+}
+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[];
+/** 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) */
+export declare function stepNodeOf(info: StepInfo, validate?: NodeCoreDefinition["validate"]): NodeCoreDefinition;

package/dist/flows/core/steps.js

@@ -0,0 +1,47 @@
+import { getPath } from "./nodes/path.js";
+export const STEP_KIND = /^[a-z][a-z0-9-]*$/;
+/** A node's own result fields: an output can't take these names */
+export const RESERVED_OUTPUTS = ["status", "durationMs", "error"];
+const TITLE_FIELDS = [
+    { path: "title", type: "text", label: "Title" },
+    { path: "subtitle", type: "text", label: "Description" },
+];
+const empty = (value) => value === undefined || (typeof value === "string" && value.trim() === "");
+/** Problems with `node`'s values against the fields' rules, as "Label: message" */
+export function fieldProblems(fields, node, label) {
+    const problems = [];
+    const add = (message) => problems.push({ level: "error", nodeId: node.id, message: `${label}: ${message}` });
+    for (const f of fields) {
+        const name = f.label ?? f.path;
+        const value = getPath(node, f.path);
+        if (f.required && empty(value)) {
+            add(`${name} is required.`);
+            continue;
+        }
+        if (typeof value === "number") {
+            if (f.min !== undefined && value < f.min)
+                add(`${name} must be at least ${f.min}.`);
+            if (f.max !== undefined && value > f.max)
+                add(`${name} must be at most ${f.max}.`);
+        }
+        if (f.pattern && typeof value === "string" && value !== "" && !new RegExp(f.pattern).test(value))
+            add(f.patternMessage ?? `${name} doesn't match ${f.pattern}.`);
+    }
+    return problems;
+}
+/** The definition core's walker and checkFlow use for a step; `validate` is the step's own (engine only) */
+export function stepNodeOf(info, validate) {
+    return {
+        kind: info.kind,
+        label: info.label,
+        shape: "step",
+        fields: [...TITLE_FIELDS, ...info.fields],
+        onFailure: true,
+        results: (info.outputs ?? []).map((o) => o.name),
+        ...(info.writesVar !== undefined && { writesVar: info.writesVar }),
+        validate: (node, ctx) => [
+            ...fieldProblems(info.fields, node, ctx.label),
+            ...(validate?.(node, ctx) ?? []),
+        ],
+    };
+}

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

@@ -8,8 +8,10 @@ export interface NodeResult {
     note?: string;
     /** Condition: the branch taken */
     branch?: string;
-    /** Set variable: what it wrote */
+    /** What the node wrote to vars */
     wrote?: Record<string, unknown>;
+    /** A step's outputs, readable later as `nodes.<key>.<name>` */
+    outputs?: Record<string, unknown>;
 }
 /** One test of a node: absolute file and full name */
 export interface NodeTest {

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

@@ -1,6 +1,4 @@
 import type { Handler } from "./support.js";
 export type { Handler, HandlerRun, Outcome } from "./support.js";
-/** The kinds a run can execute, by kind */
+/** The kinds a run can execute, by kind: the closed ones and every built-in step */
 export declare const HANDLERS: Readonly<Record<string, Handler>>;
-/** Kinds that exist in `flows/core` and have no handler yet (core's one list) */
-export declare const UNSUPPORTED: readonly string[];

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

@@ -1,13 +1,11 @@
-import { UNSUPPORTED_KINDS } from "../../core/index.js";
+import { STEP_HANDLERS } from "../../steps/catalog.js";
 import { condition } from "./condition.js";
 import { end } from "./end.js";
 import { group } from "./group.js";
 import { parallel } from "./parallel.js";
-import { setVariable } from "./set-variable.js";
 import { start } from "./start.js";
 import { test } from "./test.js";
-import { wait } from "./wait.js";
-/** The kinds a run can execute, by kind */
+/** The kinds a run can execute, by kind: the closed ones and every built-in step */
 export const HANDLERS = {
     start,
     end,
@@ -15,8 +13,5 @@ export const HANDLERS = {
     group,
     condition,
     parallel,
-    wait,
-    "set-variable": setVariable,
+    ...STEP_HANDLERS,
 };
-/** Kinds that exist in `flows/core` and have no handler yet (core's one list) */
-export const UNSUPPORTED = UNSUPPORTED_KINDS;

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

@@ -1,4 +1,4 @@
-import { type ExpressionContext, type FlowFile, type FlowNodeModel } from "../../core/index.js";
+import { type AnyNodeDefinition, type ExpressionContext, type FlowFile, type FlowNodeModel } from "../../core/index.js";
 import type { RunEvent } from "../../../runner/reporter.js";
 import type { NodeResult, NodeTest } from "../events.js";
 /** What a handler can use of the run */
@@ -14,6 +14,9 @@ export interface HandlerRun {
     runTests: (tests: NodeTest[], onEvent: (e: RunEvent) => void) => 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 */
+    nodes: readonly AnyNodeDefinition[];
+    log: (nodeId: string, level: "info" | "warn" | "error", text: string) => void;
 }
 /** What a handler decides; the walker adds timing */
 export type Outcome = Omit<NodeResult, "durationMs"> | "cancelled";

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

@@ -19,4 +19,4 @@ export async function runNodeTests(node, run, list) {
         : { status: "failed", error: "A test failed." };
 }
 /** 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))?.message;
+export const problemAt = (node, run, text) => checkExpression(parseExpression(text), scopeAt(run.flow, node.id, run.environment, run.nodes))?.message;

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

@@ -1,6 +1,6 @@
 /** Running flows: handlers, the walker, a project's flow files. Node only; see `flows/core` for the pure half. */
 export * from "./events.js";
-export { HANDLERS, UNSUPPORTED } from "./handlers/index.js";
+export { HANDLERS } from "./handlers/index.js";
 export type { Handler, HandlerRun, Outcome } from "./handlers/index.js";
 export { runFlow, type RunFlowOptions } from "./run.js";
 export { FLOW_SUFFIX, flowsDir, listFlows, readFlow, readFlowPath, readFlows, } from "./files.js";

package/dist/flows/run/index.js

@@ -1,6 +1,6 @@
 /** Running flows: handlers, the walker, a project's flow files. Node only; see `flows/core` for the pure half. */
 export * from "./events.js";
-export { HANDLERS, UNSUPPORTED } from "./handlers/index.js";
+export { HANDLERS } from "./handlers/index.js";
 export { runFlow } from "./run.js";
 export { FLOW_SUFFIX, flowsDir, listFlows, readFlow, readFlowPath, readFlows, } from "./files.js";
 export * from "./report.js";

package/dist/flows/run/project.js

@@ -6,6 +6,7 @@ import { withProject } from "../../runner/project.js";
 import { runTests } from "../../runner/run.js";
 import TestRunner from "../../runner/test-runner.js";
 import { readFlow } from "./files.js";
+import { STEP_NODES } from "../steps/catalog.js";
 import { HANDLERS } from "./handlers/index.js";
 import { runFlow } from "./run.js";
 /** The flow has errors; nothing was run */
@@ -78,6 +79,7 @@ async function prepare(options) {
         environment,
         handled: new Set(Object.keys(HANDLERS)),
         unsupported,
+        nodes: STEP_NODES,
     });
     return {
         projectDir,

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

@@ -30,7 +30,7 @@ export interface RunFlowOptions {
     unsupported?: "fail" | "skip";
     /** The handlers by kind. @default HANDLERS */
     handlers?: Readonly<Record<string, Handler>>;
-    /** Definitions of kinds beyond the ones `flows/core` registers (a handler needs one to be walked) */
+    /** Definitions of kinds core doesn't have. @default the built-in steps */
     nodes?: readonly AnyNodeDefinition[];
 }
 /**