@w6w/ui 0.2.11 → 0.2.55

package/dist/canvas-context-menu.d.ts

@@ -0,0 +1,27 @@
+/** A right-click's flow-space drop point plus the nodes its node actions apply to. */
+export interface CanvasMenuTarget {
+    /** Where an added node lands — the click converted to flow coordinates. */
+    flow: {
+        x: number;
+        y: number;
+    };
+    /** Node ids Duplicate / Delete act on. Empty on a bare-canvas right-click. */
+    nodeIds: string[];
+}
+export type CanvasMenuAction = "duplicate" | "delete" | "add-node" | "add-trigger";
+export interface CanvasMenuItem {
+    action: CanvasMenuAction;
+    label: string;
+    disabled: boolean;
+    danger?: boolean;
+    /** A divider is drawn above this item. */
+    separated?: boolean;
+}
+/**
+ * The nodes a right-click acts on. A node that is part of the current selection acts on
+ * the whole selection; any other node acts on itself alone (and becomes the selection).
+ * The bare canvas acts on whatever is selected.
+ */
+export declare function contextMenuTargets(selectedIds: readonly string[], nodeId?: string): string[];
+/** Duplicate + Delete when nodes are targeted, then Add node + Add trigger. All greyed when read-only. */
+export declare function canvasMenuItems(nodeIds: readonly string[], readOnly: boolean): CanvasMenuItem[];

package/dist/code.cjs

@@ -1,2 +1,2 @@
-"use client";"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./CodeBlock-CulfbnZD.cjs"),o=require("./Copyable-DA6eiU7w.cjs");exports.CodeBlock=e.CodeBlock;exports.Copyable=o.Copyable;
+"use client";"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./CodeBlock-CymlfyeA.cjs");exports.CodeBlock=e.CodeBlock;exports.Copyable=e.Copyable;
 //# sourceMappingURL=code.cjs.map

package/dist/code.mjs

@@ -1,8 +1,7 @@
 "use client";
-import { C as r } from "./CodeBlock-BqXDA35P.js";
-import { C as a } from "./Copyable-F4NTaG77.js";
+import { C as a, a as l } from "./CodeBlock-C-oIIYfC.js";
 export {
-  r as CodeBlock,
-  a as Copyable
+  a as CodeBlock,
+  l as Copyable
 };
 //# sourceMappingURL=code.mjs.map

package/dist/code.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"code.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}
+{"version":3,"file":"code.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/components/AnchoredFlyout.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode, RefObject } from 'react';
+/** Full-row flyout anchored inside the nearest dialog’s top layer. */
+export declare function AnchoredFlyout({ anchorRef, onClose, children, }: {
+    anchorRef: RefObject<HTMLElement | null>;
+    onClose: () => void;
+    children: ReactNode;
+}): import('react').ReactPortal | null;

package/dist/components/ColumnsEditor.d.ts

@@ -0,0 +1,27 @@
+import { TableColumn } from '../data-stores/data-store-view.ts';
+/**
+ * The `table` kind's column list: a controlled row editor (rows + `onChange(next)`; the column
+ * list itself is never copied).
+ *
+ * The **key column** select is the one piece of the schema a row cannot decide for itself: only a
+ * column that is `required` and typed `string` or `integer` may be a row's key, so the select
+ * offers only those rows. A column renamed, retyped or un-required out of that set resets the
+ * selection to `""` ("generated keys") rather than holding a key the server would reject.
+ *
+ * `columnErrors` is keyed by column NAME (what the host's error envelope names in
+ * `error.column`), so a 400 lands under the row that caused it.
+ *
+ * Each row also takes a **default**, typed as text and parsed with the column's type: empty or
+ * refused text leaves the column with no `default` key at all, a valid one stores the typed value
+ * (`7`, `true`), never the text.
+ */
+export interface ColumnsEditorProps {
+    columns: TableColumn[];
+    onChange: (next: TableColumn[]) => void;
+    /** The selected key column's name, or `""` for "generated keys". */
+    keyColumn: string;
+    onKeyColumnChange: (k: string) => void;
+    /** One message per column name, from the server's `error.column`. */
+    columnErrors: Record<string, string>;
+}
+export declare function ColumnsEditor(props: ColumnsEditorProps): import("react").JSX.Element;

package/dist/components/Combobox.d.ts

@@ -1,6 +1,8 @@
 export interface ComboboxOption {
     value: string;
     label: string;
+    /** A muted second line under the label (e.g. a value preview); never matched by the filter. */
+    detail?: string;
 }
 export interface ComboboxProps {
     options: ComboboxOption[];
@@ -22,10 +24,19 @@ export interface ComboboxProps {
      */
     listMaxHeight?: number;
     className?: string;
+    /**
+     * Called with the typed text on every edit — for a host that searches server-side and
+     * passes the results back as `options`. The local filter still narrows what is shown.
+     */
+    onInputChange?: (text: string) => void;
+    /** Shown in the open list when no option matches. Default "No matches". */
+    emptyText?: string;
+    /** A muted line at the foot of the open list (e.g. "More entries — type to narrow"). */
+    footer?: string;
 }
 /** Combobox is chosen when the list would take more than 60% of the viewport. */
 export declare function shouldUseCombobox(count: number, optionHeight: number, viewportHeight: number): boolean;
 /** Case-insensitive substring match on label and value. */
 export declare function filterOptions(options: ComboboxOption[], query: string): ComboboxOption[];
 export declare const DEFAULT_LIST_MAX_HEIGHT = 240;
-export declare function Combobox({ options, value, onChange, placeholder, disabled, "aria-label": ariaLabel, mode, forceSelection, optionHeight, listMaxHeight, className, }: ComboboxProps): import("react").JSX.Element;
+export declare function Combobox({ options, value, onChange, placeholder, disabled, "aria-label": ariaLabel, mode, forceSelection, optionHeight, listMaxHeight, className, onInputChange, emptyText, footer, }: ComboboxProps): import("react").JSX.Element;

package/dist/components/ConfirmModal.d.ts

@@ -8,6 +8,8 @@ export interface ConfirmModalProps {
     onClose: () => void;
     confirmLabel?: string;
     cancelLabel?: string;
+    /** Prevent dismissal and repeated submission while the action is running. */
+    pending?: boolean;
     /** Style the confirm button as destructive (default true — this dialog gates dangerous actions). */
     destructive?: boolean;
     /** Extra consequence copy under the message (e.g. a warning line) that a string cannot carry. */
@@ -30,4 +32,4 @@ export interface ConfirmModalProps {
  * Confirmations are `{pending}` state + a rendered sibling modal, never a blocking
  * call: a caller reachable from a keydown handler cannot swap in a boolean.
  */
-export declare function ConfirmModal({ title, message, onConfirm, onClose, confirmLabel, cancelLabel, destructive, children, }: ConfirmModalProps): import("react").JSX.Element;
+export declare function ConfirmModal({ title, message, onConfirm, onClose, confirmLabel, cancelLabel, destructive, pending, children, }: ConfirmModalProps): import("react").JSX.Element;

package/dist/components/CsvPanel.d.ts

@@ -0,0 +1,21 @@
+export interface CsvPanelProps {
+    /** What the panel is telling the operator, and whether it failed. `null` renders nothing. */
+    result: {
+        ok: boolean;
+        message: string;
+    } | null;
+    /** Disables Export while a request is in flight. */
+    busy?: boolean;
+    /** A file within {@link CSV_MAX_BYTES}. Reading and sending it are the host's. */
+    onImport: (file: File) => void;
+    /** A file the panel refused before handing it over (too large). */
+    onRefuse: (message: string) => void;
+    onExport: () => void;
+}
+/**
+ * CSV import and export for one table store: one file input, one Export button, one result line.
+ * Props-only. The panel owns the size check (a file over {@link CSV_MAX_BYTES} is refused here and
+ * never reaches `onImport`); it never parses the CSV, because the host is the authority on line
+ * and column.
+ */
+export declare function CsvPanel({ result, busy, onImport, onRefuse, onExport }: CsvPanelProps): import("react").JSX.Element;

package/dist/components/DataEntryEditor.d.ts

@@ -0,0 +1,38 @@
+export interface DataEntryEditorProps {
+    /** `kv` edits one input; `doc` edits JSON in a {@link JsonEditor}. */
+    kind: "kv" | "doc";
+    /** True for a not-yet-created entry: opens directly in edit mode with a key input. */
+    isNew: boolean;
+    /** The entry's key (existing mode heading). */
+    entryKey?: string;
+    /** The new entry's key (controlled). */
+    newKey?: string;
+    /** Concurrency token supplied by the host; never presented as document history. */
+    version?: number | null;
+    /** Existing mode: ISO expiry, shown when set. */
+    expiresAt?: string | null;
+    /** The value text (controlled). */
+    text: string;
+    /** A host-supplied value/save error. */
+    error?: string | null;
+    /** True after a stale `ifVersion`: shows the conflict copy and Reload, and disables Save. */
+    conflict?: boolean;
+    /** True while a save is in flight: disables Save. */
+    saving?: boolean;
+    /** Fired per edit of the value, with the new text. */
+    onTextChange: (text: string) => void;
+    /** Fired per edit of the new-entry key, with the new text. */
+    onKeyChange: (key: string) => void;
+    /** Opens the host's delete confirmation for an existing entry. */
+    onDelete?: () => void;
+    onSave: () => void;
+    onCancel: () => void;
+    /** Fired by the conflict prompt's Reload. */
+    onReload: () => void;
+}
+/**
+ * Existing entries open for viewing, then Edit enables changes inside the same modal.
+ * New entries start in edit mode. Drafts, `ifVersion` and mutations live in the host.
+ * Document validity is derived from the controlled text, including initial values and reloads.
+ */
+export declare function DataEntryEditor({ kind, isNew, entryKey, newKey, expiresAt, text, error, conflict, saving, onTextChange, onKeyChange, onDelete, onSave, onCancel, onReload, }: DataEntryEditorProps): import("react").JSX.Element;

package/dist/components/DataEntryList.d.ts

@@ -0,0 +1,33 @@
+import { ReactNode } from 'react';
+/** One row of a kv/doc store's entry list, as the host has already prepared it. */
+export interface DataEntryListRow {
+    key: string;
+    version: number;
+    /** The short text shown in the Value column. */
+    preview: string;
+}
+export interface DataEntryListProps {
+    rows: readonly DataEntryListRow[];
+    /** Shown instead of the table when there are no rows and the list is not `loading`. */
+    empty?: ReactNode;
+    /** When there are no rows, shows the loading text instead of `empty`. */
+    loading?: boolean;
+    /** Initial text of the key-prefix box. */
+    searchValue?: string;
+    /** Renders "Load more" when true. */
+    hasMore?: boolean;
+    /** Fired when a row is opened by mouse or its key button by keyboard. */
+    onOpen: (key: string) => void;
+    /** Fired with the prefix text when the search form is SUBMITTED (never per keystroke). */
+    onSearch: (text: string) => void;
+    /** Fired by the "New entry" button. */
+    onNew: () => void;
+    /** Fired by "Load more". */
+    onLoadMore: () => void;
+}
+/**
+ * A presentational list of a kv/doc store's entries: view-model rows in, callbacks out. It owns
+ * only the text of the search box; the query, the editor and the delete confirmation are the
+ * host's. Rows render through {@link DataTable}.
+ */
+export declare function DataEntryList({ rows, empty, loading, searchValue, hasMore, onOpen, onSearch, onNew, onLoadMore, }: DataEntryListProps): import("react").JSX.Element;

package/dist/components/DataStoreList.d.ts

@@ -0,0 +1,33 @@
+import { MouseEvent, ReactNode } from 'react';
+import { DataStore } from '../data-stores/data-store-view.ts';
+export interface DataStoreListProps {
+    stores: readonly DataStore[];
+    loading?: boolean;
+    error?: string | null;
+    /** Row click. The event is passed through untouched; the host may `preventDefault`. */
+    onOpen?: (id: string, event: MouseEvent<Element>) => void;
+    /** When set, each row is a real `<a href>`. */
+    getHref?: (id: string) => string;
+    /** Renders an Edit button per row. */
+    onEdit?: (store: DataStore) => void;
+    /** Renders an Archive button per row. Confirmation and the archive call are the host's. */
+    onArchive?: (store: DataStore) => void;
+    /** Disables every Archive button while an archive is in flight. */
+    busy?: boolean;
+    /** Size formatter; defaults to the package's `formatBytes` (`2.0 KiB`). */
+    formatSize?: (bytes: number) => string;
+    slots?: {
+        /** Heading block above the rows. */
+        header?: ReactNode;
+        /** Trailing action(s) next to the header (e.g. a "New store" button). */
+        actions?: ReactNode;
+        /** Shown when there are no stores and the list is not `loading`. */
+        empty?: ReactNode;
+    };
+}
+/**
+ * A presentational list of Data stores: rows in, callbacks out; it needs no provider. Rows render
+ * through {@link DataTable} (name, kind, entry count, size, last update, and an Edit/Archive column
+ * that is never a link).
+ */
+export declare function DataStoreList({ stores, loading, error, onOpen, getHref, onEdit, onArchive, busy, formatSize, slots, }: DataStoreListProps): import("react").JSX.Element;

package/dist/components/DataTableGrid.d.ts

@@ -0,0 +1,46 @@
+import { ReactNode } from 'react';
+import { TableColumn } from '../data-stores/data-store-view.ts';
+/** One grid row as the host has prepared it. `id` is the entry key; the new row is `isNew`. */
+export interface DataTableGridRow {
+    id: string;
+    /** True for the unsaved row: its key cell is editable and its `data-row` is `"new"`. */
+    isNew?: boolean;
+    /** Draft cell text by column name. */
+    cells: Record<string, string>;
+    /** The version the row was loaded at; `null` for a new row. */
+    version: number | null;
+    /** True when the draft differs from the loaded entry. */
+    dirty: boolean;
+    /** True after a stale `ifVersion`: shows the conflict copy and Reload, and disables Save. */
+    conflict?: boolean;
+    /** Per-cell error messages by column name, shown under their own cell. */
+    cellErrors?: Record<string, string>;
+}
+export interface DataTableGridProps {
+    columns: readonly TableColumn[];
+    /** The column whose cell is the row key (read-only on an existing row). */
+    keyColumn: string;
+    rows: readonly DataTableGridRow[];
+    /** A grid-level (not cell) error. */
+    error?: string | null;
+    loading?: boolean;
+    empty?: ReactNode;
+    /** Initial text of the key-prefix box. */
+    searchValue?: string;
+    hasMore?: boolean;
+    onCellChange: (rowId: string, column: string, text: string) => void;
+    onSave: (rowId: string) => void;
+    /** Fired immediately; confirmation is the host's. */
+    onDelete: (rowId: string) => void;
+    onReload: (rowId: string) => void;
+    onAddRow: () => void;
+    onLoadMore: () => void;
+    /** Fired with the prefix text when the search form is SUBMITTED (never per keystroke). */
+    onSearch: (text: string) => void;
+}
+/**
+ * A presentational editable grid for a table store: row view-models in, callbacks out. Drafts,
+ * dirty tracking, version handling and the delete confirmation are the host's. Rows render through
+ * {@link DataTable}.
+ */
+export declare function DataTableGrid({ columns, keyColumn, rows, error, loading, empty, searchValue, hasMore, onCellChange, onSave, onDelete, onReload, onAddRow, onLoadMore, onSearch, }: DataTableGridProps): import("react").JSX.Element;

package/dist/components/EventbriteTriggerPicker.d.ts

@@ -0,0 +1,7 @@
+import { EventbriteTriggerChoices } from '../eventbrite-trigger-selection.ts';
+/** The same event list the app's webhook registration uses, saved as activity/actions. */
+export declare function EventbriteTriggerPicker({ choices, onChange, readOnly, }: {
+    choices: EventbriteTriggerChoices;
+    onChange: (actions: string[]) => void;
+    readOnly?: boolean;
+}): import("react").JSX.Element;

package/dist/components/ExecutionDetail.d.ts

@@ -36,6 +36,9 @@ export interface ExecutionDetailValue {
     /** A workflow run's steps. `undefined` = not a step-bearing run (no section);
      * `[]` = it ran and no step did (the panel's own empty state). */
     steps?: ExecutionLogStep[];
+    /** The execution this one is a re-run of — shown as "Re-run of <id>".
+     * `null`/omitted ⇒ an ordinary execution, no line. */
+    rerunOf?: string | null;
 }
 export interface ExecutionDetailProps {
     /** The execution to show, or `null` when there is nothing to show yet. */
@@ -54,6 +57,19 @@ export interface ExecutionDetailProps {
     /** Supplied ⇒ the "Open in visual editor" button renders and calls this.
      * Omitted ⇒ no button (a function/endpoint run has no visual editor to open). */
     onOpenInEditor?: () => void;
+    /** Supplied ⇒ a "Back" control renders above everything else and calls this
+     * — for a host that shows this detail IN PLACE of the list it was opened
+     * from. Omitted ⇒ no control. Rendered in every branch, so a view whose
+     * fetch failed can still be left. */
+    onBack?: () => void;
+    /** Supplied ⇒ the "Re-run" button renders and calls this. Omitted ⇒ no button. */
+    onRerun?: () => void;
+    /** `true` while the host's re-run is in flight — the button is disabled and
+     * says so. */
+    rerunning?: boolean;
+    /** Supplied ⇒ the "Re-run of <id>" id is a link that calls this with that
+     * id, to open the original. Omitted ⇒ plain text. */
+    onOpenExecution?: (id: string) => void;
 }
 /**
  * Everything known about one past execution: which callable it was and how it
@@ -67,4 +83,4 @@ export interface ExecutionDetailProps {
  *
  * A pure display leaf — no fetching, no polling, no live-ticking timer.
  */
-export declare function ExecutionDetail({ execution, loading, errorMessage, onClose, onOpenInEditor, }: ExecutionDetailProps): import("react").JSX.Element;
+export declare function ExecutionDetail({ execution, loading, errorMessage, onClose, onOpenInEditor, onBack, onRerun, rerunning, onOpenExecution, }: ExecutionDetailProps): import("react").JSX.Element;

package/dist/components/ExecutionList.d.ts

@@ -19,6 +19,17 @@ export interface ExecutionListItem {
     /** Wall-clock duration once the run has finished; `null` while it is still
      * queued/running (rendered as `—`). */
     durationMs: number | null;
+    /** The execution this one is a re-run of — the row then carries a "Re-run"
+     * tag. `null`/omitted ⇒ an ordinary execution. */
+    rerunOf?: string | null;
+    /** How the run was started (`manual`, `schedule`, `webhook`, `event`, `replay`, or any other
+     *  value the host passes through). `null`/omitted ⇒ no trigger segment. */
+    trigger?: string | null;
+    /** The trigger node the run entered through, shown beside the trigger. */
+    triggerNodeId?: string | null;
+    /** The start of the run's input as JSON text, shown as a one-line snippet. `null`/omitted ⇒
+     *  no snippet. */
+    inputPreview?: string | null;
 }
 export interface ExecutionListProps {
     /** The page of past executions, rendered in exactly this order — never re-sorted. */
@@ -47,6 +58,13 @@ export interface ExecutionListProps {
     onPrev?: () => void;
     /** Supplied ⇒ the pager renders and `Next` calls this. */
     onNext?: () => void;
+    /** Supplied ⇒ every row gets a "Re-run" control beside it that reports the
+     * row's id here. Omitted ⇒ no control. */
+    onRerun?: (id: string) => void;
+    /** The row whose re-run is in flight — its control is disabled. While any
+     * re-run is in flight every row's control is disabled, so two can never
+     * overlap. `null`/omitted ⇒ none. */
+    rerunningId?: string | null;
 }
 /**
  * A paged list of past executions: one row per run, click-to-select, with a
@@ -57,4 +75,4 @@ export interface ExecutionListProps {
  * reports a page request; the host owns which page is loaded and which row is
  * selected.
  */
-export declare function ExecutionList({ items, selectedId, onSelect, showCallable, loading, emptyLabel, hasPrev, hasNext, onPrev, onNext, }: ExecutionListProps): import("react").JSX.Element;
+export declare function ExecutionList({ items, selectedId, onSelect, showCallable, loading, emptyLabel, hasPrev, hasNext, onPrev, onNext, onRerun, rerunningId, }: ExecutionListProps): import("react").JSX.Element;

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;