@w6w/ui 0.2.0 → 0.2.54

package/dist/components/ExecutionLogPanel.d.ts

@@ -1,6 +1,14 @@
 import { ReactNode } from 'react';
 import { StepMeta } from '../provider.tsx';
-import { StepStatus } from './StepStatusPill.tsx';
+import { SkipReason, StepStatus } from './StepStatusPill.tsx';
+/** What a step is: the app and action it uses, and whether it is a trigger (`uses.trigger`). */
+export interface ExecutionLogNode {
+    app: string;
+    action: string;
+    trigger?: boolean;
+    appName?: string;
+    actionName?: string;
+}
 /**
  * A step's or run's failure, already normalised by the HOST from the workflow
  * spec's `StepError` (`code`/`message`/`phase`/`retryable`). The panel never
@@ -43,6 +51,12 @@ export interface ExecutionLogStep {
     /** Human-readable step name. Falls back to `id` when omitted. */
     label?: string;
     status: StepStatus;
+    /**
+     * Why a `skipped` step did not run (`StepExecution.skipReason`). `not_on_path` rows leave the
+     * list for the "other paths" footer; the rest show a short reason beside the Skipped pill.
+     * Absent (a run recorded before reasons existed) ⇒ a plain Skipped row, as before.
+     */
+    skipReason?: SkipReason;
     /** ISO-8601 timestamp the step started, once it has. */
     startedAt?: string;
     /** ISO-8601 timestamp the step finished, once it has. */
@@ -51,20 +65,64 @@ export interface ExecutionLogStep {
     input?: unknown;
     /** The step's output, once it has one. */
     output?: unknown;
+    /** Captured console output (also present when a script throws). */
+    logs?: string[];
     /**
      * What ran (`StepExecution.meta`): app, version, action and connection id. Shown as a
      * Metadata block after Output. Absent or `null` ⇒ no block at all (R-12: no filler).
      */
     meta?: StepMeta | null;
+    /**
+     * What this step IS, from the workflow definition — shown on the row itself so a run reads as
+     * "Trigger · Cohost · Order Placed" rather than a bare node id. `appName`/`actionName` are the
+     * host's display names for a registered app; a built-in `@w6w/*` node is named here from its
+     * own definition, and anything unnamed falls back to the raw id. Absent ⇒ the row shows its
+     * label alone, as before.
+     */
+    node?: ExecutionLogNode;
     /**
      * Why the step failed (`StepExecution.error`, "present on failed"). Rendered
      * below the row's box and outside its lazy `<details>` body, so the reason
      * reads without expanding the row.
      */
     error?: ExecutionLogError;
+    /** For each only (I4): the per-iteration body-step records, index ascending. */
+    iterations?: ExecutionLogIteration[];
+    /** Distinct iteration indices the run recorded (may exceed `iterations.length`). */
+    iterationsTotal?: number;
+    /** How many of those iterations failed. */
+    iterationsFailed?: number;
+    /** `true` when `iterations` holds fewer than `iterationsTotal`. */
+    iterationsTruncated?: boolean;
+    /**
+     * The step's state writes (`stateWrites`, the run's state log rows for this step), in write
+     * order: `state.<path>: old → new`, or a warning when `warning` is set (a `StateWarningCode`).
+     * `item` is the For each item a hoisted body write came from. Absent, `null` or `[]` ⇒ no rows.
+     */
+    stateWrites?: Array<{
+        path: string[];
+        item?: number;
+        old?: unknown;
+        new?: unknown;
+        warning?: string;
+    }> | null;
+    /**
+     * The run's state tree after this step, shown as "State after this step" in the State block.
+     * Absent or `null` ⇒ not shown; `{}` shows only alongside writes.
+     */
+    stateAfter?: Record<string, unknown> | null;
+}
+/** One For each iteration: its status and the body-step records, in execution order. */
+export interface ExecutionLogIteration {
+    /** 0-based; the same number as `foreach.index` in that iteration's expressions. */
+    index: number;
+    status: "succeeded" | "failed" | "running";
+    /** The body step that failed, when one did. */
+    failedNodeId?: string;
+    steps: ExecutionLogStep[];
 }
 export interface ExecutionLogPanelProps {
-    /** The run's steps, rendered in exactly this order — never re-sorted. */
+    /** Rendered earliest first by start time (finish time as fallback), then untimed steps. */
     steps: ExecutionLogStep[];
     /** Shown instead of the list when `steps` is empty. */
     emptyLabel?: ReactNode;
@@ -88,7 +146,7 @@ export interface ExecutionLogPanelProps {
     stepErrors?: ExecutionLogRecordedError[];
 }
 /**
- * Read-only log of a workflow run's steps, in the order given: each row is
+ * Read-only log of a workflow run's steps, in ascending execution time: each row is
  * the step's status pill, its timing, and its resolved input/output.
  *
  * A pure display leaf — no data fetching, no polling, no layout media

package/dist/components/ExpressionEditorModal.d.ts

@@ -24,19 +24,42 @@ export interface ExpressionEditorModalProps {
     options: ExpressionOptions;
     /** Field name shown in the modal title. */
     fieldLabel?: string;
-    /** Expression mode's commit. Not used in `mode="json-binding"` (see `onBind`). */
+    /** Expression mode's commit. Not used in `mode="json-binding"` (see `onSaveJson`). */
     onSave?: (next: ExprValue | string) => void;
     onClose: () => void;
     /**
-     * `"json-binding"`: pick ONE upstream step output for a whole `json`/`group`
-     * param. The rail shows only the Workflow state slot, each step gets an
-     * "Entire output" leaf, and a click calls `onBind({ $: ref })` (the plain
-     * one-key object, never an `ExprValue`) and closes. No chips editor, no
-     * Save, no template/Result panes. Absent ⇒ expression mode, unchanged.
+     * `"json-binding"`: the value of a whole `json`/`group` param, composed as JSON. The rail
+     * shows Previous steps (each step's "Entire output", its fields and, for an app step, its
+     * Metadata), Inputs and Variables — no Secrets or Documents. A click on a source into an empty
+     * draft (or one holding only a reference) binds it: `onSaveJson("{{ ref }}")` and close. Into a
+     * draft being composed it ADDS the reference (`addRefToDraft`, `json-compose.ts`): at the caret
+     * where a value or property fits, else as a new property/element at the end — never replacing
+     * the draft. Save calls `onSaveJson` with the parsed JSON.
+     * Absent ⇒ expression mode, unchanged.
      */
     mode?: "json-binding";
-    onBind?: (next: {
-        $: string;
-    }) => void;
+    /** json-binding mode: the field's current value, seeding the compose pane. */
+    jsonValue?: unknown;
+    /** json-binding mode: Save from the compose pane, with the parsed JSON. */
+    onSaveJson?: (next: unknown) => void;
+    /**
+     * json-binding mode only: the field takes one whole value (`ActionParam.whole`). A source click
+     * into an empty draft, or one parsing to exactly `[]` / `{}`, binds the bare ref. Any other
+     * draft composes as usual.
+     */
+    whole?: boolean;
+    /**
+     * json-binding mode only: a workflow's starting state (`Workflow.initialState`), evaluated once
+     * at run start. The rail has no Previous steps or State section (the state is blank then) and
+     * no Secrets (a secret never enters state), but does list Documents. A toggle above it picks
+     * what a source click inserts: its reference (default), or its current sample value as a
+     * literal. A click always composes into the object, never binds the whole field. An empty
+     * draft saves `undefined`; Save is refused while `jsonProblem` names a problem.
+     */
+    startingState?: boolean;
+    /** Starting-state mode: why the draft text cannot be saved (`null` when it can). */
+    jsonProblem?: (text: string) => string | null;
+    /** The modal's title, in place of "Edit JSON value" / "Edit expression". */
+    title?: string;
 }
-export declare function ExpressionEditorModal({ value, masked, multiline, options, fieldLabel, onSave, onClose, mode, onBind, }: ExpressionEditorModalProps): import("react").JSX.Element;
+export declare function ExpressionEditorModal({ value, masked, multiline, options, fieldLabel, onSave, onClose, mode, jsonValue, onSaveJson, whole: wholeField, startingState: startingStateProp, jsonProblem, title, }: ExpressionEditorModalProps): import("react").JSX.Element;

package/dist/components/ExpressionOptions.d.ts

@@ -5,7 +5,18 @@ import { SecretValue } from '../types.ts';
  * sources — a step cannot reference its own output.
  */
 export declare function excludeSelfStep(steps: ExpressionStepSource[], selfId: string | null | undefined): ExpressionStepSource[];
-/** An upstream step whose output this field can reference (`steps.<id>.output`). */
+/** One pickable output field of a step / trigger event, as the rail lists it. */
+export interface ExpressionFieldSource {
+    key: string;
+    label?: string;
+    path?: boolean;
+    /**
+     * `true` for a key the app DECLARES but the step's real (fresh/persisted) shape lacks:
+     * offered muted, "declared by the app".
+     */
+    declaredOnly?: true;
+}
+/** An upstream step whose output this field can reference (`nodes.<id>.output`). */
 export interface ExpressionStepSource {
     /** Step id — the key under `steps` in the run scope. */
     id: string;
@@ -15,7 +26,7 @@ export interface ExpressionStepSource {
      * The step's output field keys, when any are known (a manual trigger's
      * configured `fields`, a built-in node's static output, or an app action's
      * shape — see `outputsFrom`). Each entry feeds exactly one ref —
-     * `steps.<id>.output.<key>` — which is the canonical form the engine resolves
+     * `nodes.<id>.output.<key>` — which is the canonical form the engine resolves (`steps.<id>…` is its compat alias)
      * (`RunScope.steps`; `core/rfcs/workflow.md` §"Expressions", `core/rfcs/node-types.md`
      * "Executing a trigger node yields the run's start payload … which downstream
      * nodes read as `steps.<triggerId>.output`").
@@ -27,18 +38,14 @@ export interface ExpressionStepSource {
      * **Omitted** (not `[]`) when the step declares no outputs, so a consumer can
      * tell "nothing declared" from "declared none" without a special case.
      */
-    outputs?: {
-        key: string;
-        label?: string;
-        path?: boolean;
-    }[];
+    outputs?: ExpressionFieldSource[];
     /**
-     * Where `outputs` came from, for an app-action step: the action's declared
-     * `output`, its `sample`, or the step's last test run (`output-shape.ts`).
+     * Where `outputs` came from, for an app-action step: a fresh test output, the persisted
+     * test shape, the action's declared `output`, or its `sample` (`output-shape.ts`).
      * An entry with `path: true` is a dot path into nested output (`start.utc`),
      * checked segment by segment; without it the key is one literal key.
      */
-    outputsFrom?: "declared" | "sample" | "test";
+    outputsFrom?: "fresh" | "persisted" | "declared" | "sample";
     /**
      * `true` when the step is an app action that declares no output shape and has
      * no test run yet — the picker tells the author to run a test to see fields.
@@ -46,12 +53,35 @@ export interface ExpressionStepSource {
     needsTest?: boolean;
     /**
      * `true` for an EXTERNAL app-action step only (R-7): the picker then offers a fixed
-     * Metadata group (`steps.<id>.meta.app|version|action|connectionId`). **Omitted, not
-     * `false`**, for triggers and every `@w6w/*` node. Carries no metadata VALUE: the group
-     * is just labels, and the value exists only at run time.
+     * Metadata group (`nodes.<id>.meta.app|version|action|connectionId`). **Omitted, not
+     * `false`**, for triggers and every `@w6w/*` node. Carries no metadata VALUE: the static
+     * values come from {@link ExpressionOptions.nodeMeta}.
      */
     hasMeta?: boolean;
 }
+/**
+ * One field of the merged workflow STATE a step reads (`state-shape.ts`), offered as
+ * `state.<key>` in the picker's "State" section. `paths` says whether every entry path into the
+ * step sets it (`all`) or only some (`some` — e.g. one of two converging triggers writes it).
+ */
+export interface ExpressionStateField extends ExpressionFieldSource {
+    paths: "all" | "some";
+}
+/**
+ * The For each a step sits in the body of: offered as the rail's "Loop" group (Current item,
+ * Index, one row per item field). Present only for a loop-body step.
+ */
+export interface ExpressionLoopSource {
+    foreachId: string;
+    /** Element [0] of the For each's resolved `items`. OMITTED (key absent) when unresolvable. */
+    itemSample?: unknown;
+    /** `inferOutputFields(itemSample)`. OMITTED when none. */
+    itemOutputs?: {
+        key: string;
+        label?: string;
+        path?: boolean;
+    }[];
+}
 /**
  * A document contributing pickable refs (`documents.<key>`, and one
  * `documents.<key>.<field>` per top-level field when it qualifies).
@@ -97,6 +127,12 @@ export interface ExpressionDocumentSource {
 /** Known variable/secret names offered in an ExpressionInput's insert menu. */
 export interface ExpressionOptions {
     vars?: string[];
+    /**
+     * Account-level constants (`const.<name>`): read-only, set by an
+     * administrator, ordinary data (not secret). Offered as insertable chips
+     * only — there is deliberately no create callback.
+     */
+    constants?: string[];
     secrets?: string[];
     /**
      * Function/run input keys in scope (`inputs.<name>`). Present when the field
@@ -113,15 +149,65 @@ export interface ExpressionOptions {
     documents?: ExpressionDocumentSource[];
     /**
      * The workflow state leading to this step: upstream steps whose output is in
-     * scope (`steps.<id>.output`). Present only in a workflow context; omitted for
+     * scope (`nodes.<id>.output`). Present only in a workflow context; omitted for
      * a standalone field.
      */
     steps?: ExpressionStepSource[];
+    /** The enclosing For each, when the field belongs to a loop-body step (`foreach.item` / `foreach.index`). */
+    loop?: ExpressionLoopSource;
+    /**
+     * The merged workflow state this step reads (starting data, variables and upstream writers;
+     * `state-shape.ts`). The picker lists it as the "State" section, only when non-empty.
+     */
+    stateShape?: {
+        fields: ExpressionStateField[];
+    };
     /** Whether a trigger event is in scope (`trigger.event`). */
     hasTrigger?: boolean;
+    /**
+     * The trigger event's fields, offered as `trigger.event.<key>` under the `trigger.event`
+     * chip: the payload the entry trigger last ran with, else an app trigger's declared event
+     * fields. Omitted when none are known.
+     */
+    eventOutputs?: ExpressionFieldSource[];
+    /**
+     * Where {@link eventOutputs} came from: a test this session (`fresh`), the server's remembered
+     * sample (`persisted`), the trigger's declared `output`, or its `sample`.
+     */
+    eventOutputsFrom?: ExpressionStepSource["outputsFrom"];
+    /**
+     * Which tier each value in {@link sampleValues} came from, keyed by the same full ref:
+     * a fresh test output, the persisted test (`from last test`) or the app's declared
+     * `sample` (`example from the app`). A ref absent here is not a step/event value.
+     */
+    valueSources?: Record<string, "fresh" | "persisted" | "sample">;
+    /**
+     * Every node's configuration keys, read as `nodes.<id>.config.<key>` on any run whether or not
+     * the node runs — its literal settings, and a webhook trigger's `url`. Offered as the rail's
+     * "Node settings" group, for every node, not only upstream ones. Workflow context only.
+     */
+    nodeConfigs?: {
+        id: string;
+        keys: string[];
+    }[];
+    /**
+     * Each node's configuration VALUES, keyed by node id — what a run reads at
+     * `nodes.<id>.meta.config` (`nodeConfigOf`): authored literal params (never a secret, never a
+     * binding) plus a webhook trigger's `url` from its subscription. The Test tab and the Result
+     * preview resolve config refs against it. Workflow context only.
+     */
+    nodeConfig?: Record<string, Record<string, unknown>>;
+    /**
+     * Each node's static metadata VALUES, keyed by node id — what a run reads at
+     * `nodes.<id>.meta.<key>` whether or not the node ran (`nodeMetaOf`): `app`, `action`,
+     * `connectionId`, the `version` the canvas labels it with, and a webhook trigger's
+     * `subscriptionId` / `url`. Offered as Metadata leaves
+     * in the picker and resolved by the previews. Workflow context only.
+     */
+    nodeMeta?: Record<string, Record<string, unknown>>;
     /**
      * Design-time sample values the Result preview substitutes for known refs,
-     * keyed by FULL ref (`"vars.from_email"`, `"documents.test"`). Seeded by the
+     * keyed by FULL ref (`"var.from_email"`, `"documents.test"`). Seeded by the
      * host from the project's real vars/documents so the preview shows actual
      * values instead of the raw `{{ ref }}` template. Optional — a user-typed
      * Sample value still overrides, and unknown refs keep the raw fallback.

package/dist/components/HtmlPreview.d.ts

@@ -0,0 +1,7 @@
+/** Vendor HTML is hostile. NEVER dangerouslySetInnerHTML it; this is the only render path. */
+export declare const HTML_PREVIEW_CSP = "default-src 'none'; style-src 'unsafe-inline'; img-src data:; base-uri 'none'; form-action 'none'";
+/** The CSP meta is FIRST so it is parsed into <head> before any payload byte. */
+export declare function htmlPreviewSrcDoc(html: string): string;
+export declare function HtmlPreview({ html }: {
+    html: string;
+}): import("react").JSX.Element;

package/dist/components/JsonTree.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A read-only, dependency-free tree for a parsed JSON value.
+ *
+ * Deliberately NOT exported from `src/index.ts` (`T0.1.1` pin 2): the public
+ * way to show a result is `ResultViewer`, which owns the format decision and
+ * the toolbar. `JsonTree` is the piece `ResultViewer` composes for
+ * `format: "json"`, so it stays private until a consumer needs a bare tree.
+ *
+ * Two properties everything here is built around:
+ *
+ *  - **Nothing is injected.** Every key, every scalar and every brace reaches
+ *    the DOM as a React text child — there is no `dangerouslySetInnerHTML`
+ *    anywhere in this file. A property key such as `"<img onerror=…>"` is just
+ *    text, which is the whole point: the value came from a vendor API.
+ *  - **Collapsing is a native `<details>`.** The children are always rendered
+ *    and the browser hides them, so collapsed text stays in the DOM: it is
+ *    selectable, findable by the browser's find-in-page, and readable by a
+ *    test. Re-rendering the subtree "only when open" would silently make the
+ *    collapsed content unreachable.
+ */
+export interface JsonTreeProps {
+    /** Any value; objects and arrays become collapsible nodes, the rest leaves. */
+    value: unknown;
+    /**
+     * How many levels start open. A node at depth `d` (root `d = 0`) is open iff
+     * `d < expandDepth`, so the default `2` opens the root and its children —
+     * enough to see the shape of a response without scrolling. `Infinity` opens
+     * everything; `1` leaves only the root open.
+     */
+    expandDepth?: number;
+}
+export declare function JsonTree({ value, expandDepth }: JsonTreeProps): import("react").JSX.Element;

package/dist/components/ResolvedParams.d.ts

@@ -15,6 +15,11 @@ export interface ResolvedParamsProps {
      * the trigger arm, and two side by side is a defect, not a feature).
      */
     view?: "props" | "code";
+    /**
+     * Param keys the host sends as SOURCE TEXT, never resolved (`@w6w/script`'s `code`, the
+     * engine's `LITERAL_PARAMS`): shown verbatim, so a `{{ }}` in them never reads as a value.
+     */
+    literalKeys?: readonly string[];
 }
 /**
  * Read-only sibling of `ParamsForm`: for every configured param, shows the
@@ -28,4 +33,4 @@ export interface ResolvedParamsProps {
  * the static chip vocabulary (`varLabel`, `.w6w-expr-chip-*`) rather than
  * `expression-dom.ts`'s DOM-painting, which is for the editable field.
  */
-export declare function ResolvedParams({ params, values, testStartState, view, }: ResolvedParamsProps): import("react").JSX.Element;
+export declare function ResolvedParams({ params, values, testStartState, view, literalKeys, }: ResolvedParamsProps): import("react").JSX.Element;

package/dist/components/ResultViewer.d.ts

@@ -0,0 +1,46 @@
+export interface ResultViewerProps {
+    /** The result as the host received it: an already-parsed value, or a raw
+     *  response body string. The format is sniffed from this ROOT value only
+     *  (`detectResultFormat`); string leaves inside a JSON tree stay text. */
+    value: unknown;
+    /** Keep an already-parsed payload as JSON, including strings; default sniffs the format. */
+    format?: "auto" | "json";
+    /** Height cap of the scrolling body, in px. Default 320. */
+    maxHeight?: number;
+    /** Extra class on the root, for spacing in the consuming pane. */
+    className?: string;
+}
+/**
+ * Read-only display of one result value, chosen by its format:
+ *
+ * | format     | body                                                       |
+ * | ---------- | ---------------------------------------------------------- |
+ * | `json`     | a collapsible `JsonTree`, with Expand all / Collapse all    |
+ * | `xml`      | source (`CodeBlock`, `markup`, when small enough)           |
+ * | `html`     | `HtmlPreview` — an empty-sandbox iframe — or source         |
+ * | `markdown` | `Markdown` — or source                                      |
+ * | `text`     | a plain `<pre>`                                             |
+ *
+ * Read-only means read-only: nothing here takes an `onChange`, and the one
+ * interactive affordance besides the collapsers and the Rendered/Source
+ * toggle is `Copyable`'s button, overlaying the top-right corner and revealed
+ * on hover (`w6w-copyable--hover`).
+ *
+ * **Vendor HTML never touches this document.** The `html` format renders only
+ * through `HtmlPreview` — an `<iframe sandbox="">` whose `srcdoc` opens with a
+ * restrictive CSP meta as its first element — so a hostile payload cannot run
+ * script and cannot reach this page's origin or its data. Nothing in this
+ * component is ever passed to `dangerouslySetInnerHTML`. Accepted residual: a
+ * reader's CLICK on a link inside the preview navigates the frame itself (a
+ * page load in a sandboxed, scriptless, cookie-less document) — nothing more.
+ * Above `RESULT_RENDER_MAX_CHARS` even that path is skipped: an oversized
+ * document is shown as source, with a note saying so. Source views are handed
+ * to `renderSource`, which drops Prism above `RESULT_HIGHLIGHT_MAX_CHARS`.
+ *
+ * The copy button always writes `resultCopyText(detected)` — pretty-printed
+ * JSON for a tree, the raw string for every other format — so what lands on
+ * the clipboard is what the reader means by "the result", not the on-screen
+ * rendering. If that computation throws (circular value, `BigInt`), the view
+ * still renders and the button writes a best-effort string instead.
+ */
+export declare function ResultViewer(props: ResultViewerProps): import("react").JSX.Element;

package/dist/components/ScriptBindingsNotice.d.ts

@@ -0,0 +1,31 @@
+export interface ScriptConversion {
+    /** What the open-time conversion did, until Undo. */
+    converted: number;
+    undo: () => void;
+}
+/**
+ * A Run script's `{{ }}` markers, converted when the step opens. The host never substitutes
+ * inside code (see `script-bindings.ts`), so a marker there is literal text at run time. When
+ * the step opens, each convertible marker is rewritten to the code read it names
+ * (`$.get(root, ...keys)` in JavaScript/TypeScript); {@link ScriptBindingsNotice} says so,
+ * with Undo. Runs once per mount of the step editor, so after Undo the code stays as it was
+ * until the step is opened again. Read-only (or not a script), nothing is rewritten.
+ */
+export declare function useScriptConversion({ enabled, values, onChange, }: {
+    /** A writable `@w6w/script` step. */
+    enabled: boolean;
+    /** The step's `with`: `code`, `language`, `input`. */
+    values: Record<string, unknown>;
+    onChange: (next: Record<string, unknown>) => void;
+}): ScriptConversion | null;
+/**
+ * The quiet line under a Run script's Configure tab: "Converted 2 references to code reads ·
+ * Undo" after the open-time conversion, and, for any marker still in the code, that it stays
+ * literal text. Renders nothing otherwise.
+ */
+export declare function ScriptBindingsNotice({ values, conversion, readOnly, }: {
+    /** The step's `with`: `code`, `language`. */
+    values: Record<string, unknown>;
+    conversion: ScriptConversion | null;
+    readOnly?: boolean;
+}): import("react").JSX.Element | null;

package/dist/components/ScriptCodeField.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { ScriptLanguage } from '../script-bindings.ts';
+import { ActionParam } from '../types.ts';
+/** Script picker and node chips insert literal-key reads for every script language. */
+export declare function ScriptCodeField({ param, value, language, label, req, readOnly, onChange, }: {
+    param: ActionParam;
+    value: string;
+    language: ScriptLanguage;
+    label: string;
+    req: ReactNode;
+    readOnly?: boolean;
+    onChange: (next: string) => void;
+}): import("react").JSX.Element;

package/dist/components/StepStatusPill.d.ts

@@ -8,6 +8,13 @@ import { ReactNode } from 'react';
  * the same precedent `HealthStatusPill`'s `HealthPillState` establishes.
  */
 export type StepStatus = "pending" | "running" | "succeeded" | "failed" | "skipped";
+/**
+ * Why a `skipped` step did not run — the engine's `NodeExecution.skipReason`, again a thin
+ * LOCAL literal. `not_on_path`: the step is not downstream of the fired trigger (or outside a
+ * run-from-node scope), so it was never part of the run; the other three are real skips. A
+ * record from before the engine stamped reasons has none.
+ */
+export type SkipReason = "not_on_path" | "condition" | "stopped" | "disabled";
 /**
  * The five states a whole EXECUTION (an invocation, an endpoint call, a
  * workflow run) can be in — the run-level sibling of `StepStatus`, and again a

package/dist/components/expression-authoring.d.ts

@@ -0,0 +1,13 @@
+import { ExprPart } from '../types.ts';
+import { ExpressionOptions } from './ExpressionOptions.tsx';
+/** Compile an entire condition, including picker chips followed by typed operators. Plain
+ * text/templates stay unchanged. The persisted value uses the existing JSONLogic wire format. */
+export declare function compileAuthoredParts(original: ExprPart[], options: ExpressionOptions): {
+    parts: ExprPart[];
+    error: string | null;
+};
+/** Sample fields include those inside comparisons, not just standalone reference chips. */
+export declare function authoredReferences(parts: ExprPart[]): string[];
+/** Evaluate supported conditions with the same evaluator as workflow execution. Other legacy
+ * expression forms keep their existing template preview. Explicit samples preserve JSON types. */
+export declare function previewAuthoredParts(parts: ExprPart[], seeds?: Record<string, unknown>, overrides?: Record<string, string>): string;

package/dist/components/expression-dom.d.ts

@@ -3,14 +3,14 @@ import { ExprPart } from '../types.ts';
  * The name a source or chip DISPLAYS. Never the ref it SAVES.
  *
  * A saved ref is always canonical and engine-resolvable — the run scope offers
- * exactly `vars.* · steps.<id>.output.* · steps.<id>.meta.* · trigger.* · secrets.* · documents.* ·
+ * exactly `var.* · steps.<id>.output.* · steps.<id>.meta.* · trigger.* · secrets.* · documents.* · const.* ·
  * inputs.* · foreach.* · output.*` (`core/rfcs/workflow.md` §Expressions, built
  * in `w6w-workflow/packages/engine/src/run.ts`). Those read long in a field, so
  * the label drops the root the chip's sigil and colour already imply:
  *
  * | ref                         | label          |
  * |-----------------------------|----------------|
- * | `vars.from_email`           | `from_email`   |
+ * | `var.from_email`            | `from_email`   |
  * | `steps.gate_1.output`       | `gate_1`       |
  * | `steps.gate_1.output.email` | `gate_1.email` |
  * | `steps.gate_1.meta.version` | `gate_1 meta · version` |
@@ -41,6 +41,21 @@ export declare function isRefSafeKey(key: string): boolean;
  * {@link isRefSafeKey} on its own.
  */
 export declare function isRefSafePath(path: string): boolean;
+/**
+ * Lay a step's flat output fields out as a tree for the picker: each row shows only its OWN
+ * name, nested under the nearest listed ancestor. `event`, `event.tz`, `event.start.utc` read as
+ * `event` › `tz`, `start.utc` — the step id and the shared prefix are what truncated every row to
+ * the same `eventbrite_to_cohost_1.event.…`. A literal key (no `path`) is one name at depth 0.
+ * Display only: the ref is still built from the verbatim `key`.
+ */
+export declare function outputFieldTree<F extends {
+    key: string;
+    path?: boolean;
+}>(fields: F[]): {
+    field: F;
+    depth: number;
+    name: string;
+}[];
 /**
  * Build the non-editable inline chip (tag) DOM node for a part.
  *

package/dist/components/expression-template.d.ts

@@ -19,13 +19,23 @@ import { ExprPart, ExprValue, SecretValue } from '../types.ts';
  */
 export { parseTemplate, serializeTemplate };
 /**
- * Serialize parts to the leanest faithful VALUE: prune empty text, collapse a
- * lone text segment to a plain string (backward-compat), else an `ExprValue`.
- * Shared by the inline field and the expression editor modal.
+ * Serialize parts to the value that is saved: the `{{ }}` template STRING — exactly what the
+ * author sees (core Workflow RFC amendment, 2026-10-29). Text parts are source text, kept
+ * verbatim (an escaped `\{{ var.x }}` stays escaped). The one exception is a `render` part,
+ * which has no `{{ }}` spelling by design (RFC, *The `render` part kind*): a value holding one
+ * is saved as an `ExprValue` envelope. Shared by the inline field and the expression editor
+ * modal.
  */
 export declare function partsToValue(parts: ExprPart[]): ExprValue | string;
 /** Every root name, for tests that pin the derived set without reaching into the type. */
 export declare const RUN_SCOPE_ROOT_NAMES: readonly string[];
+/**
+ * THE alias rule for the state tree: `state`, `var` and `vars` are one object. For a ref whose
+ * root is one of them (followed by `.` or end of string) this gives the lookup spellings in order:
+ * the ref exactly as written, then `state.<rest>`, `var.<rest>`, `vars.<rest>` (deduplicated).
+ * Any other root gives only the ref itself (`steps`/`nodes` are NOT aliased here).
+ */
+export declare function stateAliasSpellings(ref: string): string[];
 /**
  * Root-anchored parse (CONDUCTOR AMENDMENT 2026-08-14): builds every marker in
  * `s` via `parseTemplate` (never a second `{{ }}` scanner), then requires:
@@ -49,6 +59,18 @@ export declare const RUN_SCOPE_ROOT_NAMES: readonly string[];
  * vendor placeholders with no root of their own).
  */
 export declare function parseRootAnchoredTemplate(s: string): ExprPart[];
+/**
+ * True when `v` holds a reference the run resolves — an `ExprValue` envelope, or a string with
+ * at least one live marker of ours. Since the editor saves template STRINGS, this (not
+ * `isExprValue`) is the test for "this field is an expression".
+ */
+export declare function holdsExpression(v: unknown): boolean;
+/**
+ * Parse a string the way the engine resolves a `with` string (`parseResolvableTemplate`):
+ * parts with escapes consumed, or `null` when the engine would pass it through untouched (no
+ * marker of ours, or one marker that is not ours). For previews.
+ */
+export declare function parseResolvableText(s: string): ExprPart[] | null;
 /**
  * Parse an incoming value into editable parts (+ any sealed secret to display).
  * The inverse of {@link partsToValue} for the editable forms; a sealed

package/dist/components/icons.d.ts

@@ -4,7 +4,7 @@ import { ReactNode } from 'react';
  * never for the studio component that happened to draw it, so a caller asks for
  * `icon="history"` rather than `icon="history-icon-tsx"`.
  */
-export type IconName = "edit" | "edit-2" | "delete" | "copy" | "check" | "close" | "history" | "info" | "clock" | "json" | "code" | "sync" | "cloud-download" | "eye" | "play" | "stop" | "warning" | "file-text" | "settings" | "github" | "user" | "users" | "logout" | "id-card" | "dashboard" | "pulse" | "workflow" | "globe" | "lambda" | "sliders" | "file" | "plug" | "grid" | "folder" | "git-branch" | "coin" | "building" | "server" | "price-tag" | "lang-node" | "terminal" | "lang-python" | "lang-curl" | "sun" | "moon" | "circle-half" | "layout" | "run" | "trash" | "maximize" | "form" | "braces" | "settings-2";
+export type IconName = "edit" | "edit-2" | "delete" | "copy" | "check" | "close" | "history" | "info" | "clock" | "json" | "code" | "sync" | "cloud-download" | "eye" | "play" | "stop" | "warning" | "file-text" | "settings" | "github" | "user" | "bot" | "users" | "logout" | "id-card" | "dashboard" | "pulse" | "workflow" | "globe" | "lambda" | "sliders" | "file" | "plug" | "grid" | "folder" | "git-branch" | "coin" | "building" | "server" | "price-tag" | "lang-node" | "terminal" | "lang-python" | "lang-curl" | "sun" | "moon" | "circle-half" | "layout" | "run" | "pause" | "ban" | "trash" | "maximize" | "form" | "braces" | "settings-2" | "sticky-note" | "frame" | "bold" | "grip" | "chevron-down" | "database";
 /**
  * Which attributes the shared `<svg>` root carries — i.e. how the glyph is
  * painted. The sources are not uniform, and forcing them into one shape would