@w6w/ui 0.2.11 → 0.2.54

package/dist/CodeEditor.d.ts

@@ -1,10 +1,11 @@
+import { EditorView } from '@codemirror/view';
 import { ThemeMode } from './types.ts';
 /**
  * A CodeMirror *editing* mode for `<CodeEditor>` — a distinct concept from the
  * Prism *display-highlighting* grammar name a sibling module exports for
  * rendered snippets. Deliberately its own type, not shared with that one.
  */
-export type ScriptLanguage = "javascript" | "python";
+export type ScriptLanguage = "javascript" | "typescript" | "python";
 export interface CodeEditorProps {
     value: string;
     onChange: (value: string) => void;
@@ -30,6 +31,8 @@ export interface CodeEditorProps {
     language?: ScriptLanguage;
     /** Accessible label for the editor. */
     "aria-label"?: string;
+    /** Called with the CodeMirror view once it exists — for inserting at the caret. */
+    onCreateEditor?: (view: EditorView) => void;
 }
 /**
  * Plain-text-by-default code editor built on CodeMirror 6 — the same surface as

package/dist/ConditionEditor.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The standard expression textbox on either side of each comparison row, the rows joined by
+ * one combinator (all of / any of / exactly one of). A condition the rows cannot express
+ * (a nested group, another operator) opens in the code view.
+ */
+export declare function ConditionEditor({ values, onChange, readOnly, purpose, }: {
+    values: Record<string, unknown>;
+    onChange: (values: Record<string, unknown>) => void;
+    readOnly?: boolean;
+    purpose?: "if" | "stop" | "router";
+}): import("react").JSX.Element;

package/dist/JsonEditor.d.ts

@@ -1,3 +1,4 @@
+import { EditorView } from '@codemirror/view';
 import { ReactNode } from 'react';
 import { ThemeMode } from './types.ts';
 export interface JsonEditorProps {
@@ -26,6 +27,17 @@ export interface JsonEditorProps {
      * `minHeight` and `maxHeight` — an inline JSON/group field wants this.
      */
     height?: string;
+    /**
+     * Receives the CodeMirror view once it exists — for a host that inserts text at the caret
+     * (the JSON compose pane of `ExpressionEditorModal`).
+     */
+    onCreateEditor?: (view: EditorView) => void;
+    /** Fired when the editor loses focus. */
+    onBlur?: () => void;
+    /** Fired when the editor gains focus. */
+    onFocus?: () => void;
+    /** Show JSON syntax diagnostics. Defaults to true; forms can defer them until blur. */
+    showDiagnostics?: boolean;
     /** Read-only mode — useful for previewing a stored definition. */
     readOnly?: boolean;
     /**

package/dist/ParamCustomization.d.ts

@@ -0,0 +1,5 @@
+export declare function ParamCustomization({ values, onChange, readOnly, }: {
+    values: Record<string, unknown>;
+    onChange: (values: Record<string, unknown>) => void;
+    readOnly?: boolean;
+}): import("react").JSX.Element;

package/dist/ParamsForm.d.ts

@@ -42,11 +42,17 @@ export interface ParamsFormProps {
  * tidy. Widget is chosen by `param.type` — same field-driven approach as
  * `AuthFieldsForm`, extended with `text` (textarea) and `json` (JsonEditor).
  *
- * Values are collected into a plain object suitable for a step's `with`. For
- * expression bindings (`{ $: "steps.x.output.y" }`) authors drop to the JSON
- * view; this form deals in literals.
+ * Values are collected into a plain object suitable for a step's `with`. A field
+ * bound to a reference holds a `{{ }}` template string (`"{{ nodes.x.output.y }}"`).
  */
 export declare function ParamsForm({ params, values, onChange, readOnly, dynamic }: ParamsFormProps): import("react").JSX.Element;
+/** Entries one picker request asks for: a page, never the whole store. */
+export declare const STORE_KEY_PAGE = 25;
+/** One muted line under an entry's key: its value, shortened, and when it last changed. */
+export declare function storeEntryDetail(entry: {
+    value?: unknown;
+    updatedAt?: string;
+}): string;
 /**
  * One typed key/value entry in a `vars` param. `type` is a real value type only:
  * `expression` is a binding *mode* (see {@link FxField}/`ExprValue`), not a value
@@ -60,3 +66,5 @@ export interface DataVar {
     type: "string" | "number" | "boolean" | "json";
     value: unknown;
 }
+/** Rows for a literal object or the existing typed-row format; bindings stay in JSON mode. */
+export declare function dataVarRows(value: unknown, previous?: DataVar[]): DataVar[] | null;

package/dist/RouterEditor.d.ts

@@ -0,0 +1,5 @@
+export declare function RouterEditor({ values, onChange, readOnly, }: {
+    values: Record<string, unknown>;
+    onChange: (values: Record<string, unknown>) => void;
+    readOnly?: boolean;
+}): import("react").JSX.Element;

package/dist/StepBuilderModal.d.ts

@@ -1,15 +1,21 @@
 import { NodeConfig } from './NodeConfigForm.tsx';
-import { ExpressionStepSource } from './components/ExpressionOptions.tsx';
+import { ExpressionLoopSource, ExpressionStepSource } from './components/ExpressionOptions.tsx';
 import { InternalNodeDef } from './flow-types.ts';
-import { StepStartState } from './provider.tsx';
-import { ActionParam, AppSummary, FunctionSummary, ThemeMode, WorkflowDetail, WorkflowSummary } from './types.ts';
-/** The step the builder emits — the editor assigns the final `id`. `NodeConfig`
- * carries the base settings (retry / onError / notes) set on the Config view. */
+import { StepStartState, W6WApi } from './provider.tsx';
+import { ActionDef, ActionParam, AppSummary, FunctionSummary, ThemeMode, WorkflowDetail, WorkflowSummary } from './types.ts';
+/** The step the builder emits — the editor assigns the final `id` unless `id` carries a
+ * name the user chose in the add flow. `NodeConfig` carries the base settings (retry /
+ * onError / notes) set on the Config view. */
 export interface BuiltStep extends NodeConfig {
+    /** The node name chosen in the add flow; on `onDraftChange` it renames the minted node. */
+    id?: string;
     uses: {
         app: string;
         action: string;
         connection?: string | null;
+        connectionRef?: string;
+        /** Marks an app TRIGGER node (`action` is the trigger key); the engine/server read it. */
+        trigger?: true;
     };
     with?: Record<string, unknown>;
 }
@@ -30,6 +36,12 @@ export interface StepBuilderModalProps {
      * Endpoints pickers) keep the original one-shot "Add node" behavior.
      */
     onDraftChange?: (id: string, step: BuiltStep) => void;
+    /**
+     * The graph's current node ids. With `onDraftChange`, the add flow shows the minted node's
+     * name with the same rename control the step editor has, validated against these (unique,
+     * no dot), and applies it on Done — so the node is created with that name.
+     */
+    stepIds?: string[];
     theme?: ThemeMode;
     /**
      * Hide the GRAPH-ONLY tabs — Triggers / Controls / Utilities / Data, the
@@ -56,9 +68,10 @@ export interface StepBuilderModalProps {
      * Which homepage tab opens first. Defaults to `"connected"` — F-2.0's
      * homepage. A caller re-opening the picker for an already-bound target
      * passes that target's own family, so "Change" lands where the current
-     * value lives instead of making the author re-find the tab.
+     * value lives instead of making the author re-find the tab. The canvas's
+     * right-click "Add trigger" opens on `"triggers"`.
      */
-    initialTab?: "connected" | "functions" | "workflows";
+    initialTab?: "connected" | "functions" | "workflows" | "triggers";
     /** Modal heading. Defaults to "Add a node". */
     title?: string;
     /**
@@ -81,6 +94,11 @@ export interface StepBuilderModalProps {
      * which have no graph to draw ancestors from.
      */
     upstreamSteps?: ExpressionStepSource[];
+    /**
+     * The For each whose body the new step lands in (`stepBuilderLoop`, same decision as its
+     * rail). Seeds the Test tab's `state.foreach` with the sample item and index 0; not editable here.
+     */
+    loop?: ExpressionLoopSource;
     /**
      * Pre-select an app when the modal opens. When provided along with
      * initialAction/initialConnection/initialWith, the modal opens directly
@@ -138,6 +156,12 @@ export interface StepBuilderModalProps {
      * so the only outcome is an infinite loop. Absent ⇒ nothing is excluded.
      */
     excludeCallableIds?: readonly string[];
+    /**
+     * Fired once an app trigger or webhook picked on the Triggers tab is committed (needs
+     * `onDraftChange`), with the new node's id: the host closes this modal and
+     * opens that node in its own step editor, as it does for any node.
+     */
+    onOpenStep?: (id: string) => void;
 }
 /** The four representations of the Configure tab: form, full-step JSON,
  * params-only JSON, node settings. */
@@ -152,12 +176,13 @@ export type ConfigView = "props" | "code" | "params-code" | "config";
  * deliberately no second toggle component: one glyph set, one styling, one
  * pressed-state behaviour, however many views a host offers.
  */
-export declare function ConfigViewToggle({ view, onChange, disabled, views, }: {
+export declare function ConfigViewToggle({ view, onChange, disabled, views, customized, }: {
     view: ConfigView;
     onChange: (v: ConfigView) => void;
     disabled?: boolean;
     /** Which views to offer, in order. Defaults to all four. */
     views?: ConfigView[];
+    customized?: boolean;
 }): import("react").JSX.Element;
 /**
  * Guided "add a step" flow. A sidebar toggles between **Apps** (pick app →
@@ -167,21 +192,27 @@ export declare function ConfigViewToggle({ view, onChange, disabled, views, }: {
  *
  * Data + IO come from `useW6WApi()`, so mount it under `<W6WUIProvider>`.
  */
-export declare function StepBuilderModal({ onClose, onAdd, onDraftChange, theme, appsOnly, callables, initialTab, title, workflowId, stepId, upstreamSteps, initialApp, initialAction, initialConnection, initialWith, appsFilter, appsIds, connectionOnly, onConnected, excludeCallableIds, }: StepBuilderModalProps): import("react").JSX.Element;
+export declare function StepBuilderModal({ onClose, onAdd, onDraftChange, theme, appsOnly, callables, initialTab, title, workflowId, stepId, upstreamSteps, loop, initialApp, initialAction, initialConnection, initialWith, appsFilter, appsIds, connectionOnly, onConnected, excludeCallableIds, onOpenStep, stepIds, }: StepBuilderModalProps): import("react").JSX.Element;
 /**
  * Config form for a chosen internal node — its schema rendered through the same
  * `ParamsForm` as app actions, seeded with the node's defaults. Emits the built
  * step on Add.
  */
-export declare function ControlStepConfig({ node, onAdd, onClose, onDraftChange, workflowId, upstreamSteps, }: {
+export declare function ControlStepConfig({ node: initialNode, onAdd, onClose, onDone, onDraftChange, onOpenStep, workflowId, upstreamSteps, loop, }: {
     node: InternalNodeDef;
     onAdd: (s: BuiltStep) => string | undefined | void;
     onClose: () => void;
+    /** Done, once the node is added — applies the add flow's name, then closes. Else `onClose`. */
+    onDone?: () => void;
     /** See {@link StepBuilderModalProps.onDraftChange}. */
     onDraftChange?: (id: string, step: BuiltStep) => void;
+    /** Open the full webhook editor, including its URL and listener, as soon as it is added. */
+    onOpenStep?: (id: string) => void;
     workflowId?: string;
     /** The new step's known graph ancestors — see {@link StepBuilderModalProps.upstreamSteps}. */
     upstreamSteps?: ExpressionStepSource[];
+    /** See {@link StepBuilderModalProps.loop}. */
+    loop?: ExpressionLoopSource;
 }): import("react").JSX.Element;
 export declare function triggerFieldsOf(wf: WorkflowDetail): ActionParam[];
 /**
@@ -196,15 +227,25 @@ export declare function triggerFieldsOf(wf: WorkflowDetail): ActionParam[];
  * `NodeConfigForm` is reached once the `@w6w/call` step already lives on a
  * canvas, not at add-time.
  */
-export declare function CallableStepConfig({ family, targetId, targetLabel, onAdd, onClose, onDraftChange, }: {
+export declare function CallableStepConfig({ family, targetId, targetLabel, onAdd, onClose, onDone, onDraftChange, }: {
     family: "function" | "workflow";
     targetId: string;
     targetLabel: string;
     onAdd: (s: BuiltStep) => string | undefined | void;
     onClose: () => void;
+    /** Done, once the node is added — applies the add flow's name, then closes. Else `onClose`. */
+    onDone?: () => void;
     /** See {@link StepBuilderModalProps.onDraftChange}. */
     onDraftChange?: (id: string, step: BuiltStep) => void;
 }): import("react").JSX.Element;
+/**
+ * The starting `with` for a freshly picked action: every param whose `default` is
+ * an expression (e.g. `"{{ const.account_id }}"`). A plain default is only shown
+ * as a placeholder value and never stored, so an expression default would render
+ * as literal text and never reach the engine — seeding it makes it a live,
+ * saved binding the user can still clear or replace.
+ */
+export declare function expressionDefaults(params: ActionParam[]): Record<string, unknown>;
 /**
  * Whether every required param has a usable value — gates the inline "Test run".
  * A required array (e.g. a `vars` table) may be empty (see the Data node); other
@@ -297,6 +338,8 @@ interface ReadyToUse {
     state: "loading" | "error" | "empty" | "ready";
     error?: string;
     apps: AppSummary[];
+    /** Full connected-id scope for server search, including apps not loaded yet. */
+    appIds?: string[];
     fns: FunctionSummary[];
     wfs: WorkflowSummary[];
     /** More connected-app ids remain unresolved — draw an explicit "load more" affordance. */
@@ -344,17 +387,42 @@ export declare function clampMinutes(raw: string, min: number): number;
  *
  * Exported for tests only (not re-exported from the package index).
  */
-export declare function useReadyToUse(callables: readonly ("function" | "workflow")[], appsFilter?: (app: AppSummary) => boolean, excludeIds?: readonly string[], appsIds?: readonly string[]): ReadyToUse;
+export declare function useReadyToUse(callables: readonly ("function" | "workflow")[], appsFilter?: (app: AppSummary) => boolean, excludeIds?: readonly string[], appsIds?: readonly string[], 
+/** `resolveInline`: ignore a connection row's inline `app` meta and resolve every id through
+ *  `listAppsByIds` — for a caller that needs fields the inline meta lacks (`triggerCount`). */
+opts?: {
+    resolveInline?: boolean;
+}): ReadyToUse;
 /** A copy of `items` without any entry whose `id` equals one of `ids` (id
  *  equality only — never name or position). No `ids` ⇒ an unchanged copy. */
 export declare function withoutIds<T extends {
     id: string;
 }>(items: readonly T[], ids?: readonly string[]): T[];
-export declare function AppStepConfig({ appId, app, onAdd, onClose, onDraftChange, onChangeApp, theme, workflowId, stepId, upstreamSteps, initialAction, initialConnection, initialWith, }: {
+/** An app's triggers as action-shaped defs ({ key, title, description, params }), so
+ *  the action pickers and param forms take them as they are. No API member => none. */
+export declare function getTriggerDefs(api: W6WApi, appId: string): Promise<ActionDef[]>;
+/** An app trigger's Test tab: it runs when the app reports the event, not by hand. */
+export declare function AppTriggerTestNote({ title, app }: {
+    title: string;
+    app: string;
+}): import("react").JSX.Element;
+export declare function AppStepConfig({ kind, onOpenStep, appId, app, onAdd, onClose, onDone, onDraftChange, onChangeApp, theme, workflowId, stepId, upstreamSteps, loop, initialAction, initialConnection, initialWith, }: {
+    /**
+     * What the Setup tab picks: one of the app's actions, or (`"trigger"`, the
+     * Triggers tab) one of its triggers. Same account step, same picker, same
+     * add-on-pick; a trigger node carries `uses.trigger: true` and lists
+     * `api.getAppTriggers`. Its Test tab only says when it runs: there is no
+     * action to invoke by hand.
+     */
+    kind?: "action" | "trigger";
+    /** See {@link StepBuilderModalProps.onOpenStep}. */
+    onOpenStep?: (id: string) => void;
     appId: string;
     app?: AppSummary;
     onAdd: (s: BuiltStep) => string | undefined | void;
     onClose: () => void;
+    /** Done, once the node is added — applies the add flow's name, then closes. Else `onClose`. */
+    onDone?: () => void;
     /** See {@link StepBuilderModalProps.onDraftChange}. */
     onDraftChange?: (id: string, step: BuiltStep) => void;
     onChangeApp?: () => void;
@@ -363,6 +431,8 @@ export declare function AppStepConfig({ appId, app, onAdd, onClose, onDraftChang
     stepId?: string;
     /** The new step's known graph ancestors — see {@link StepBuilderModalProps.upstreamSteps}. */
     upstreamSteps?: ExpressionStepSource[];
+    /** See {@link StepBuilderModalProps.loop}. */
+    loop?: ExpressionLoopSource;
     /** Pre-selected action key, opens directly to Configure tab when provided with initialWith */
     initialAction?: string;
     /** Pre-selected connection id */

package/dist/StepNameEditor.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A node's name (its step id) with a pencil to rename it — the one control both the step
+ * editor and the add flow show. `onCommit` validates and applies a changed name, returning
+ * why it was refused (shown inline, the input stays open) or `null`. Enter / blur commit,
+ * Escape reverts.
+ */
+export declare function StepNameEditor({ value, onCommit, readOnly, }: {
+    value: string;
+    onCommit: (id: string) => string | null;
+    readOnly?: boolean;
+}): import("react").JSX.Element;

package/dist/StopEditor.d.ts

@@ -0,0 +1,5 @@
+export declare function StopEditor({ values, onChange, readOnly, }: {
+    values: Record<string, unknown>;
+    onChange: (values: Record<string, unknown>) => void;
+    readOnly?: boolean;
+}): import("react").JSX.Element;

package/dist/TriggerFillForm.d.ts

@@ -1,4 +1,6 @@
 import { StepTestPersist } from './StepBuilderModal.tsx';
+/** How long an edited sample payload sits before it is remembered (it is flushed on close too). */
+export declare const EDIT_SAVE_DEBOUNCE_MS = 600;
 /**
  * The Test-tab widget for a manual/webhook trigger. A trigger's configured
  * `fields` ARE the run's starting state, so testing it means **filling those
@@ -37,8 +39,14 @@ import { StepTestPersist } from './StepBuilderModal.tsx';
  * `packages/studio/src/lib/workflow-live-run.ts`): it fetches the manual
  * trigger's latest `step_tests` row and sends its `with` verbatim as `input`.
  * This form is not in that path; it only writes the fixture that call reads.
+ *
+ * **Listen for test event.** With `listen` supplied (a `@w6w/webhook` trigger inside a workflow),
+ * the primary action is {@link WebhookListenPanel}: the real request a caller sends becomes the
+ * payload. **Use as test data** runs exactly this form's Test path with the captured request as
+ * the values, so it lands as the trigger's output and saved test like a typed payload would. The
+ * manual payload box stays, folded below as the secondary option.
  */
-export declare function TriggerFillForm({ app, action, fields, persist, }: {
+export declare function TriggerFillForm({ app, action, fields, persist, listen, }: {
     app: string;
     action: string;
     /** The trigger's `fields` param value (an array of field definitions). */
@@ -49,4 +57,9 @@ export declare function TriggerFillForm({ app, action, fields, persist, }: {
      * a fixture by and this form neither reads nor writes one.
      */
     persist?: StepTestPersist;
+    /** Offer "Listen for test event" (webhook triggers in a saved workflow). */
+    listen?: {
+        stepWith: Record<string, unknown> | undefined;
+        readOnly?: boolean;
+    };
 }): import("react").JSX.Element;

package/dist/WebhookListenPanel.d.ts

@@ -0,0 +1,28 @@
+import { SubscriptionSummary, WebhookListenSession } from './types.ts';
+/** The captured call a webhook trigger emits as its output. */
+export type CapturedWebhookRequest = NonNullable<WebhookListenSession["request"]>;
+/**
+ * The `@w6w/webhook` subscription that feeds `stepId`: the one bound to that node, else the
+ * workflow's first webhook subscription (one not bound to any node — the URL panel's own pick).
+ */
+export declare function pickWebhookSubscription(subs: SubscriptionSummary[], stepId: string): SubscriptionSummary | null;
+/** Headers for display: secret-looking values masked. */
+export declare function displayHeaders(headers: Record<string, string>): Record<string, string>;
+/**
+ * "Listen for test event" — the webhook trigger's primary Test action. Opens a short-lived listen
+ * session on the node's webhook subscription, so the receive URL captures the next request even
+ * while the workflow is unpublished (the caller gets a test acknowledgement and no run starts),
+ * and long-polls it. A captured request is shown — method, time, query, headers (secret-looking
+ * ones masked), pretty body — and **Use as test data** hands it to `onUse`, which makes it this
+ * trigger's output and saved test.
+ */
+export declare function WebhookListenPanel({ workflowId, stepId, stepWith, readOnly, onUse, using, }: {
+    workflowId: string;
+    stepId: string;
+    /** The node's current config — the params a newly created subscription starts from. */
+    stepWith: Record<string, unknown> | undefined;
+    readOnly?: boolean;
+    onUse: (request: CapturedWebhookRequest) => void;
+    /** `onUse`'s save is in flight. */
+    using?: boolean;
+}): import("react").JSX.Element | null;

package/dist/WorkflowConnections.d.ts

@@ -0,0 +1,29 @@
+import { RefObject } from 'react';
+import { FlowStep } from './flow-types.ts';
+import { ConnectionSummary } from './types.ts';
+import { FlowConnections } from './workflow-connections.ts';
+export declare const WorkflowConnectionsContext: import('react').Context<{
+    nodes: FlowStep[];
+    readOnly?: boolean;
+    connections: FlowConnections;
+    setConnections: (connections: FlowConnections) => void;
+} | null>;
+export declare function useWorkflowConnections(): {
+    nodes: FlowStep[];
+    readOnly?: boolean;
+    connections: FlowConnections;
+    setConnections: (connections: FlowConnections) => void;
+} | null;
+/** One account menu for both adding and editing workflow nodes. */
+export declare function WorkflowConnectionPicker({ step, conns, failed, readOnly, open, onOpenChange, anchorRef, onChangeConnection, onChangeConnectionRef, onConnectionCreated, }: {
+    step: FlowStep;
+    conns: ConnectionSummary[] | null;
+    failed?: boolean;
+    readOnly?: boolean;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    anchorRef: RefObject<HTMLElement | null>;
+    onChangeConnection: (id: string) => void;
+    onChangeConnectionRef: (ref: string) => void;
+    onConnectionCreated: () => void;
+}): import("react").JSX.Element;

package/dist/WorkflowFlowEditor.d.ts

@@ -1,13 +1,25 @@
-import { ExpressionOptions, ExpressionStepSource } from './components/ExpressionOptions.tsx';
+import { ExpressionLoopSource, ExpressionOptions, ExpressionStepSource } from './components/ExpressionOptions.tsx';
 import { FlowStep, FlowWorkflow } from './flow-types.ts';
+import { StepStartState } from './provider.tsx';
 import { RunState } from './run-visuals.ts';
 import { StepProblem, StepProblems } from './step-problems.ts';
 import { AppSummary } from './types.ts';
+/** What kind of change an `onChange` reports — see `WorkflowFlowEditorProps.onChange`. */
+export interface FlowChangeMeta {
+    viewportOnly?: true;
+}
 export interface WorkflowFlowEditorProps {
     /** The workflow being edited. The editor re-derives layout when this changes identity. */
     value: FlowWorkflow;
-    /** Fired whenever the user changes the graph — new nodes, edges, or step edits. */
-    onChange: (next: FlowWorkflow) => void;
+    /**
+     * Fired whenever the user changes the graph — new nodes, edges, or step edits.
+     *
+     * `meta.viewportOnly` is `true` when the change is the author's pan/zoom being
+     * written to `settings.viewport` and nothing else. A host that drops the shown
+     * run on an edit (so the run paint stops describing a workflow that changed)
+     * keeps it for these: moving the camera changes nothing that ran.
+     */
+    onChange: (next: FlowWorkflow, meta?: FlowChangeMeta) => void;
     /** Disable all interactions — pans/zooms are still enabled. */
     readOnly?: boolean;
     /** Height of the editor viewport. Defaults to 480px. */
@@ -65,7 +77,7 @@ export interface WorkflowFlowEditorProps {
      * connection no longer exists gets an error ring + tooltip. Omitted ⇒ the
      * canvas renders exactly as today. The host owns detection; this editor never
      * infers a problem itself. Repaints live (same `value.id`) and is never
-     * persisted: `flowToWorkflow` never reads `data.stepProblem`.
+     * persisted: `flowToWorkflow` never reads `data.stepProblems`.
      */
     stepProblems?: StepProblems;
     /**
@@ -95,6 +107,31 @@ export interface WorkflowFlowEditorProps {
      * `onChange` and never overwrites the stored viewport.
      */
     fitViewKey?: string | number | boolean;
+    /**
+     * Run from a node: ▶ runs THAT node and then continues through every node downstream of it,
+     * following the edges the way a real run does, and stops BEFORE each paused node
+     * (`ui.paused`). The host enqueues it as a real run (`POST /workflows/:id/nodes/:nodeId/run`
+     * with `continue: true`) and shows it like any run — `runState` + its run log.
+     *
+     * Called from the ▶ collect form's Run button with:
+     * - `stopAt` — every paused node except the start node itself;
+     * - `state` — the upstream outputs the form seeded (saved step tests / the last run), the same
+     *   start state a single-node run is given;
+     * - `input` — the filled values, only when the start node is a trigger.
+     *
+     * Omitted ⇒ ▶ test-runs the single node exactly as before (and flow-control nodes have no ▶).
+     * A rejected promise is shown in the run modal.
+     */
+    onRunFromNode?: (nodeId: string, req: RunFromNodeRequest) => Promise<void> | void;
+}
+/** What {@link WorkflowFlowEditorProps.onRunFromNode} is called with. */
+export interface RunFromNodeRequest {
+    /** Paused node ids the run must stop before (never the start node). */
+    stopAt: string[];
+    /** Upstream outputs seeded from saved step tests / the last run; absent when none. */
+    state?: StepStartState;
+    /** The trigger's filled values — present only when the start node is a trigger. */
+    input?: Record<string, unknown>;
 }
 /** Which view the step edit modal opens in: the tabbed form, raw JSON, or node settings. */
 type EditView = "props" | "json" | "settings";
@@ -109,22 +146,41 @@ type EditView = "props" | "json" | "settings";
  *   - Selecting a node reveals a toolbar above it: Edit / Duplicate / Delete.
  *   - Edit opens a modal with a Form ⇄ JSON toggle for that step.
  *   - Every meaningful change fires `onChange` with an updated Workflow.
+ *   - Ctrl/Cmd+Z undoes graph edits; Ctrl/Cmd+Shift+Z (or Ctrl+Y) redoes them.
+ *     History is local to the open workflow and excludes tests, samples and viewport changes.
  */
 export declare function WorkflowFlowEditor(props: WorkflowFlowEditorProps): import("react").JSX.Element;
-export declare function StepEditModal({ workflowId, step: initialStep, upstreamSteps, onChange, onClose, readOnly, initialView, fanOutCount, onTestRun, stepProblem, }: {
+/**
+ * The state the Test tab PREVIEWS its resolved params against: the seeded `testStartState`
+ * (what the test will actually send) with, for each upstream `nodes.<id>.output` and the
+ * `trigger.event` that the seeds do not carry, the value the editor already previews in the ƒx
+ * Result (`sampleValues`: a persisted test's kept value or the app's declared `sample`). A seeded
+ * output always wins. Only the PREVIEW reads this; the invoke is still sent `testStartState`.
+ */
+export declare function previewStartState(state: StepStartState | undefined, sampleValues: Record<string, unknown> | undefined): StepStartState | undefined;
+export declare function StepEditModal(props: StepEditModalProps): import("react").JSX.Element;
+interface StepEditModalProps {
     workflowId: string;
     step: FlowStep;
+    /** Refresh authored fields after undo/redo without remounting the Test tab. */
+    restoreVersion?: number;
     /** Graph ancestors of this step (from `upstreamStateSources`); the incoming-state picker seeds from their saved tests. */
     upstreamSteps: ExpressionStepSource[];
+    /** The enclosing For each when this step is in its body: seeds `state.foreach` on Test. */
+    loop?: ExpressionLoopSource;
     onChange: (next: FlowStep) => void;
     onClose: () => void;
     readOnly?: boolean;
     initialView?: EditView;
     /** Most outgoing edges this node has in one lane; "Run next nodes" needs >= 2. */
     fanOutCount?: number;
+    /** This step's own output field keys, offered by "Write to state" › Pick fields (free text still accepted). */
+    stateOutputFields?: string[];
     /** Fired the instant the footer Test button is clicked, before the test runs (T1.1.1). */
     onTestRun?: () => void;
-    /** Host-supplied problem for this step; a dangling connection locks Configure/Test. */
-    stepProblem?: StepProblem;
-}): import("react").JSX.Element;
+    /** Host-supplied problems for this step; a dangling connection locks Configure/Test, a fixable one gets a button. */
+    stepProblems?: StepProblem[];
+    /** The graph's other node ids — a rename onto one of them is refused with a message. */
+    otherStepIds?: string[];
+}
 export {};