@w6w/ui 0.2.11 → 0.2.55

package/dist/step-preview-state.d.ts

@@ -1,8 +1,10 @@
 import { Edge } from '@xyflow/react';
-import { ExpressionStepSource } from './components/ExpressionOptions.tsx';
+import { ExpressionFieldSource, ExpressionLoopSource, ExpressionStepSource } from './components/ExpressionOptions.tsx';
 import { StepNode } from './flow-utils.ts';
-import { ActionShapeDef } from './output-shape.ts';
+import { ActionShapeDef, OutputShapeSource } from './output-shape.ts';
 import { StepMeta, StepStartState, StepTest } from './provider.tsx';
+import { SubscriptionSummary } from './types.ts';
+import { FlowConnections } from './workflow-connections.ts';
 /**
  * What the editor knows about upstream steps' output SHAPES beyond the static
  * `internalNodeDef(...).output` — both optional, so a caller without them gets
@@ -15,8 +17,20 @@ export interface StepShapeContext {
      * no "run a test" claim it might have to retract a moment later.
      */
     actionDef?: (app: string, action: string) => ActionShapeDef | undefined;
-    /** Each step's latest saved test-run output, by step id. */
+    /**
+     * An app TRIGGER's definition (its declared `output` / `sample`), same "undefined = not
+     * loaded, no claim" semantics as `actionDef`. Feeds `trigger.event.<key>`.
+     */
+    triggerDef?: (app: string, trigger: string) => ActionShapeDef | undefined;
+    /** Each step's FRESH test-run output (this session), by step id. */
     testOutputs?: Record<string, unknown>;
+    /**
+     * Each step's PERSISTED test output (server-side `node_samples`), by step id. A SEPARATE
+     * input from `testOutputs` so the tiers stay visible; fresh beats persisted.
+     */
+    persistedOutputs?: Record<string, unknown>;
+    /** Each For each's saved Test sample (`foreachTestSample`), by step id — the item-shape fallback. */
+    loopSamples?: Record<string, unknown[]>;
 }
 /** A graph ancestor carrying a saved step-test, offered as a one-click seed. */
 export interface SeedSource {
@@ -35,7 +49,41 @@ export interface SeedSource {
 interface PendingConnect {
     nodeId: string;
     handleType: "source" | "target";
+    /** The lane the drag came off (WFE's `pendingConnect` carries it). */
+    lane?: "success" | "error" | "each";
 }
+/**
+ * Every node id that is a graph ancestor of `rootId` — walks `edges` backward. Exported for
+ * `state-shape.ts` (which imports this module, never the reverse).
+ */
+export declare function ancestorIds(rootId: string, edges: Edge[]): Set<string>;
+/**
+ * The array a For each's `items` resolves to at design time, or `undefined`.
+ * A whole-value ref (`{{ nodes.x.output.tickets }}` / `{ "$": … }`) resolves through
+ * `resolve-params.ts` against the saved test outputs; a literal array is returned as-is;
+ * anything else (a non-array result, a multipart template, a missing ref) is `undefined`.
+ */
+export declare function resolveLoopItems(items: unknown, testOutputs: Record<string, unknown>): unknown[] | undefined;
+/**
+ * {@link resolveLoopItems} against a whole Test start state (`startStateFromSeeds`), so a
+ * For each's own Test resolves `items` exactly as the other steps' Test previews do — a
+ * `trigger.event` ref included.
+ */
+export declare function resolveLoopItemsInState(items: unknown, state: StepStartState | undefined): unknown[] | undefined;
+/** How many items a For each's saved Test keeps: enough for the shape, never the whole list. */
+export declare const FOREACH_TEST_SAMPLE_MAX = 10;
+/**
+ * The step-test fixture a For each's Test saves. Nothing runs, so no run is recorded and
+ * `lastRunOutput` stays empty — the For each's real output is its BODY's results, and an
+ * after-loop step must not preview (or be seeded with) the input list as that. The sample
+ * rides in the fixture's `with` instead: the resolved `items` (capped) and the full count.
+ */
+export declare function foreachTestFixture(items: unknown[], input: Record<string, unknown>): {
+    input: Record<string, unknown>;
+    with: Record<string, unknown>;
+};
+/** The sample a For each's saved Test carries (`foreachTestFixture`), or `undefined`. */
+export declare function foreachTestSample(test: StepTest | null | undefined): unknown[] | undefined;
 /**
  * The workflow state a given step can reference: the outputs of every step
  * that runs before it (its graph ancestors) plus whether a trigger precedes
@@ -77,9 +125,19 @@ interface PendingConnect {
  *
  * With no specific step (shouldn't happen for a field edit) every node is offered.
  */
-export declare function upstreamStateSources(editingId: string | null, nodes: StepNode[], edges: Edge[], shapes?: StepShapeContext): {
+export declare function upstreamStateSources(editingId: string | null, nodes: StepNode[], edges: Edge[], shapes?: StepShapeContext, draftId?: string | null): {
     steps: ExpressionStepSource[];
     hasTrigger: boolean;
+    /** Present iff the anchor step is a loop-body member. */
+    loop?: ExpressionLoopSource;
+    /**
+     * Saved tests the projection reads beyond `steps`: an after-loop For each's last body step,
+     * and the enclosing For each itself (its Test's item sample).
+     */
+    extraSampleIds?: string[];
+    /** An app trigger ancestor's declared `trigger.event.<key>` fields. */
+    eventOutputs?: ExpressionFieldSource[];
+    eventOutputsFrom?: OutputShapeSource;
 };
 /**
  * The new add-step wizard's graph ancestors, derived from `pendingConnect` —
@@ -98,6 +156,8 @@ export declare function upstreamStateSources(editingId: string | null, nodes: St
  * {@link upstreamStateSources} uses.
  */
 export declare function stepBuilderUpstreamSteps(pendingConnect: PendingConnect | null, nodes: StepNode[], edges: Edge[], shapes?: StepShapeContext): ExpressionStepSource[];
+/** The `loop` source for the add-step builder's new step — the same decision as its rail. */
+export declare function stepBuilderLoop(pendingConnect: PendingConnect | null, nodes: StepNode[], edges: Edge[], shapes?: StepShapeContext): ExpressionLoopSource | undefined;
 /**
  * Gather each graph ancestor's latest saved step-test so the incoming-state
  * control can offer it as a seed. **One implementation**, called by every
@@ -133,11 +193,100 @@ export declare function fetchSeedSources(listStepTests: (stepId: string) => Prom
  * ⚠️ Single-step scope only. A full run (`POST /workflows/:id/run`) builds its
  * own scope and is not affected by this.
  */
-export declare function startStateFromSeeds(seeds: SeedSource[]): StepStartState | undefined;
+export declare function startStateFromSeeds(seeds: SeedSource[], loop?: {
+    item?: unknown;
+    index?: number;
+}): StepStartState | undefined;
+/** The default `{ item, index }` a loop-body Test is seeded with: the sample item, index 0. */
+export declare function loopSeedFromSource(loop: ExpressionLoopSource | undefined): {
+    item?: unknown;
+    index?: number;
+} | undefined;
+/** The editable "Current item" text a loop's sample item starts as (`""` when there is none). */
+export declare function loopItemText(loop: ExpressionLoopSource | undefined): string;
+/**
+ * Parse the loop seed control's two fields. A blank item means "no item"; a blank index means 0.
+ * Invalid item JSON, or an index that is not a non-negative integer, is an ERROR — the caller
+ * refuses the run rather than falling back to the sample.
+ */
+export declare function parseLoopSeed(itemText: string, indexText: string): {
+    ok: true;
+    value: {
+        item?: unknown;
+        index: number;
+    };
+} | {
+    ok: false;
+    error: string;
+};
 /**
- * Sample values for a step's `steps.<id>.meta.*` refs, from a saved fixture's
+ * Sample values for a step's `nodes.<id>.meta.*` refs (and the `steps.` alias), from a saved fixture's
  * `lastRunMeta`. Reads the four named fields only; absent meta yields nothing
  * (a version or connection is never derived from anywhere else).
  */
 export declare function stepMetaSampleValues(stepId: string, meta: StepMeta | null | undefined): Record<string, unknown>;
+/**
+ * The flat `sampleValues` the expression editor's Result preview reads: each upstream step's
+ * last test output on the very refs the picker inserts (`nodes.<id>.output`, `.output.<key>`,
+ * each offered nested path), mirrored under `steps.` (the compat alias), plus metadata and,
+ * for a loop-body step, `foreach.item` / `foreach.item.<key>` / `foreach.index` (= 0, the
+ * sample element's position). Lives here (not in WFE) so a render test can drive it.
+ */
+export declare function upstreamSampleValues(steps: ExpressionStepSource[], testOutputs: Record<string, unknown>, testMetas: Record<string, StepMeta>, loop?: ExpressionLoopSource, tiers?: SampleTiers): Record<string, unknown>;
+/**
+ * The lower tiers of preview values, beside the fresh `testOutputs`: the PERSISTED test
+ * outputs and the app's declared `sample`s (by step id; `event` is an app trigger's sample,
+ * read as `trigger.event`). Precedence per ref: fresh > persisted > sample.
+ */
+export interface SampleTiers {
+    persisted?: Record<string, unknown>;
+    samples?: Record<string, unknown>;
+    event?: unknown;
+}
+/** Which tier each value in {@link upstreamSampleValues} came from, keyed by the same ref. */
+export declare function upstreamSampleValueSources(steps: ExpressionStepSource[], testOutputs: Record<string, unknown>, testMetas: Record<string, StepMeta>, loop?: ExpressionLoopSource, tiers?: SampleTiers): Record<string, "fresh" | "persisted" | "sample">;
+/**
+ * The declared `sample` of each app step (by id) and of an app trigger (as the event
+ * sample), read through `shapes.actionDef` / `triggerDef`. An `output`-only definition
+ * contributes nothing: no placeholders are fabricated.
+ */
+export declare function declaredSamples(nodes: StepNode[], shapes: StepShapeContext): {
+    samples: Record<string, unknown>;
+    event?: unknown;
+};
+/**
+ * Each node's configuration keys for the picker's "Node settings" group — what the engine lays
+ * at `nodes.<id>.config` (`nodeConfigOf`): the step's literal `with` keys (never a secret, never a
+ * binding), plus `url` for a webhook trigger node (the host adds it from the node's subscription).
+ * A node with none is left out.
+ */
+export declare function nodeConfigSources(nodes: StepNode[]): {
+    id: string;
+    keys: string[];
+}[];
+/**
+ * Each node's configuration VALUES — the client's `nodeConfigOf`: the step's static `with`
+ * (sealed secrets and bindings dropped, so nothing sealed ever reaches a preview) with a webhook
+ * trigger node's `url` laid over it from the workflow's subscriptions, picked as the server's
+ * `hostNodeConfig` picks it (the one bound to the node, else for a `@w6w/webhook` node the newest
+ * webhook subscription). A node with nothing to configure is absent.
+ */
+export declare function nodeConfigValues(nodes: StepNode[], subs: readonly SubscriptionSummary[]): Record<string, Record<string, unknown>>;
+/**
+ * Each node's static metadata VALUES — the client's `nodeMetaOf`: `app`, `action` and
+ * `connectionId` (the node's own connection, else `null`) from the definition, plus a webhook
+ * trigger node's `subscriptionId` and `url` from its subscription ({@link subscriptionFor}), and
+ * `version` from `apps` — the same summary the canvas labels the node with (`<id> - v<version>`),
+ * i.e. the version it will dispatch. Readable at `nodes.<id>.meta.<key>` whether or not the node
+ * ran; a run's reported meta overrides it. An app with no known version has no `version` (the
+ * previews then say "resolved at run"). A node with no app is absent.
+ */
+export declare function nodeMetaValues(nodes: StepNode[], subs: readonly SubscriptionSummary[], apps?: ReadonlyMap<string, {
+    version?: string;
+}>, connections?: FlowConnections): Record<string, Record<string, unknown>>;
+/**
+ * {@link nodeMetaValues} as the flat `sampleValues` the Result preview reads, on the refs the
+ * picker inserts (`nodes.<id>.meta.<key>`, mirrored under `steps.`).
+ */
+export declare function nodeMetaSampleValues(meta: Record<string, Record<string, unknown>>): Record<string, unknown>;
 export {};

package/dist/step-problems.d.ts

@@ -1,34 +1,64 @@
-/**
- * Host-supplied per-step problems painted on the canvas. Pure — no React or
- * @xyflow imports. The host owns detection; ui never infers a problem itself.
- */
-export interface StepProblem {
+import { LoopInvalid } from './flow-loop.ts';
+/** A one-click fix: pure data, applied by `applyStepProblemFix` on the author's click. */
+export type StepProblemFix = {
+    kind: "unwrap_items";
+    label: "Unwrap Items";
+} | {
+    kind: "use_current_item";
+    foreachId: string;
+    label: "Use Current item";
+};
+export type StepProblem = {
     code: "unknown_connection";
     connection: string;
+} | {
+    code: "foreach_wrapped_items";
+    fix: StepProblemFix;
+} | {
+    code: "foreach_body_refs_output";
+    foreachId: string;
+    refs: string[];
+    fix: StepProblemFix;
+} | {
+    code: "loop_body_invalid";
+    reason: LoopInvalid;
+}
+/** Writes a state path that a step running at the same time (`with`) also writes (`findStateWriteProblems`). */
+ | {
+    code: "state_parallel_write";
+    path: string[];
+    with: string[];
 }
-/** Keyed by step id. */
-export type StepProblems = Record<string, StepProblem>;
+/** The saved workflow still lacks setup (unbound alias, empty store, missing var/secret/constant); `items` name what. */
+ | {
+    code: "setup_incomplete";
+    items: string[];
+};
+/** Keyed by step id; a step carries every problem it has (D-B1). */
+export type StepProblems = Record<string, StepProblem[]>;
 interface ProblemNode {
     id: string;
     data: {
-        stepProblem?: StepProblem;
+        stepProblems?: StepProblem[];
     };
 }
 /**
- * Stamp `data.stepProblem` from `problems`, clearing it for steps no longer in
- * the map. Returns the SAME node object when nothing changed.
+ * Stamp `data.stepProblems` from `problems`, clearing it for steps no longer in
+ * the map (or mapped to `[]`). Returns the SAME node object when the incoming
+ * list deep-equals the stamped one.
  */
 export declare function applyStepProblems<N extends ProblemNode>(nodes: N[], problems: StepProblems | undefined): N[];
 export declare function stepProblemTooltip(p: StepProblem): string;
-/** True while the step still points at the connection the host reports missing. */
+/** True while the step still points at a connection the host reports missing (any entry). */
 export declare function isConnectionBlocked(step: {
     uses: {
         connection?: string | null;
     };
-}, problem: StepProblem | undefined): boolean;
+}, problems: StepProblem[] | undefined): boolean;
 /** The Setup tab's Connection button label — exactly five outcomes. */
 export declare function connectionButtonLabel(connection: string | undefined | null, conns: {
     id: string;
     displayName?: string;
+    builtIn?: boolean;
 }[] | null, failed: boolean): string;
 export {};

package/dist/test-inputs.d.ts

@@ -0,0 +1,25 @@
+import { ActionParam } from './types.ts';
+/** One remembered input (`GET /workflows/:id/test-inputs` → `testInputs[]`). */
+export interface NodeTestInput {
+    nodeId: string;
+    input: Record<string, unknown>;
+    /** ISO timestamp of the write. */
+    updatedAt: string;
+}
+/**
+ * The remembered input of `nodeId`: `undefined` when the node has no row (the
+ * caller may fall back to an older source, e.g. the latest step-test fixture),
+ * `{}` when it was CLEARED (stay on the declared defaults), else the values.
+ */
+export declare function findTestInput(rows: readonly NodeTestInput[] | undefined, nodeId: string): Record<string, unknown> | undefined;
+/**
+ * What may be remembered of `values`: a literal typed into a `secret` param is
+ * DROPPED (it must never be persisted in plain text — the operator re-enters
+ * it), a binding to a secret is kept as the expression, and a sealed envelope
+ * is dropped anywhere at the top level (the server strips nested ones too).
+ */
+export declare function rememberableInput(values: Record<string, unknown>, params?: readonly ActionParam[]): Record<string, unknown>;
+/** Track `save` until it settles (it never rejects into the tracker). Returns `save`. */
+export declare function trackTestInputSave<T>(save: Promise<T>): Promise<T>;
+/** Resolves once every remembered-input save issued so far has settled (never rejects). */
+export declare function testInputSavesSettled(): Promise<void>;

package/dist/trigger-registration.d.ts

@@ -0,0 +1,28 @@
+import { SubscriptionSummary } from './types.ts';
+export type RegistrationTone = "ok" | "pending" | "danger" | "muted";
+export interface RegistrationDisplay {
+    label: string;
+    tone: RegistrationTone;
+    /** `lastError.message`, only for a failed subscription that carries one. */
+    error: string | null;
+    /** Always set: a distinct "never fired" text when `lastFireAt` is null/absent/unparseable. */
+    lastFire: string;
+    /** True iff the subscription is `failed` AND the host can retry. */
+    retryVisible: boolean;
+}
+export declare const NEVER_FIRED = "Never fired";
+/** UTC, minute precision, so the text is stable across locales and test hosts. */
+export declare function formatLastFire(iso: string | null | undefined): string;
+/** Null when the summary has no known status (older server): the node shows no badge. */
+export declare function registrationDisplay(sub: SubscriptionSummary | undefined, canRetry: boolean): RegistrationDisplay | null;
+/** nodeId -> subscription for the node-bound ones (a null `nodeId` is workflow-level). */
+export declare function subscriptionsByNode(subs: readonly SubscriptionSummary[]): Map<string, SubscriptionSummary>;
+/**
+ * The app trigger nodes of a workflow value. Total over a value that has no `nodes` yet
+ * (embed mounts pass a partial value): an absent list is no trigger nodes.
+ */
+export declare function appTriggerNodesOf<N extends {
+    uses?: {
+        trigger?: boolean;
+    };
+}>(nodes: readonly N[] | null | undefined): N[];

package/dist/types.d.ts

@@ -1,8 +1,4 @@
-/**
- * Wire types the components consume. These mirror the shapes the w6w server
- * returns over HTTP. They are intentionally a local copy so consumers who
- * don't use `@w6w/types` (partners, non-TypeScript backends) don't need it.
- */
+import { ParamWhen } from '@w6w/expr';
 /** Summary of a registered app as returned by GET /apps. */
 export interface AppSummary {
     id: string;
@@ -33,6 +29,8 @@ export interface AppSummary {
      * `packages/server/packages/api/wire-summary.ts`'s `zeroCredential`).
      */
     zeroCredential?: boolean;
+    /** Number of triggers the app declares (wire already carries it). */
+    triggerCount?: number;
 }
 /** One trigger an app declares, as returned by GET /apps/:id/triggers. */
 export interface TriggerSummary {
@@ -43,9 +41,15 @@ export interface TriggerSummary {
     description?: string;
     requiresAuth?: boolean;
     /** `"poll"` triggers are fetched on an interval; absent or `"webhook"` receive pushes. */
-    type?: "webhook" | "poll";
+    type?: "webhook" | "poll" | "protocol";
     /** Host floor for a poll trigger's interval, in milliseconds. */
     minIntervalMs?: number;
+    /** The trigger's declared parameters (the route returns the full declaration). */
+    params?: readonly unknown[];
+    /** The event's declared fields (an `OutputField[]`) — keys for `trigger.event.<key>`. */
+    output?: unknown;
+    /** A representative event payload the app declares (never fabricated). */
+    sample?: unknown;
 }
 /** A Subscription (rfcs/trigger.md) as returned by the console subscription routes. */
 export interface SubscriptionSummary {
@@ -56,15 +60,43 @@ export interface SubscriptionSummary {
     connectionId: string | null;
     /** Present only for `appId === "@w6w/webhook"` — the server's own computed receive URL. */
     webhookUrl?: string;
-    type?: "webhook" | "poll";
-    status?: string;
+    type?: "webhook" | "poll" | "protocol";
+    status?: SubscriptionStatus;
     /** Poll interval in milliseconds; null for webhook subscriptions. */
     intervalMs?: number | null;
     lastError?: {
         code: string;
         message: string;
     } | null;
+    /** The workflow trigger node this subscription is bound to; null for a workflow-level one. */
+    nodeId?: string | null;
+    /** When registration with the app succeeded; null until it has. */
+    registeredAt?: string | null;
+    /** When the subscription last fired; null/absent when it never has. */
+    lastFireAt?: string | null;
+}
+/**
+ * A "Listen for test event" session on a `@w6w/webhook` subscription
+ * (`POST /subscriptions/:id/listen`). `request` is the captured, credential-masked call —
+ * exactly what a real run's webhook trigger emits as its output.
+ */
+export interface WebhookListenSession {
+    id: string;
+    subscriptionId: string;
+    nodeId: string | null;
+    expiresAt: string;
+    status: "waiting" | "captured" | "expired";
+    request?: {
+        method: string;
+        path: string;
+        query: Record<string, string>;
+        headers: Record<string, string>;
+        body: unknown;
+    };
+    receivedAt?: string;
 }
+/** Registration state of a Subscription (rfcs/trigger-protocol.md §Lifecycle). */
+export type SubscriptionStatus = "pending" | "registered" | "failed" | "paused" | "destroying";
 /** One field on an Auth method's connection form. Drives the input widgets. */
 export interface AuthField {
     key: string;
@@ -94,6 +126,8 @@ export interface ActionParam {
     required?: boolean;
     default?: unknown;
     hint?: string;
+    /** Render hint; multiselect supports "checkboxes" or the default chip picker. */
+    ui?: string;
     /** Placeholder text for the input (e.g. the trailing prompt on a multiselect). */
     placeholder?: string;
     /**
@@ -102,6 +136,18 @@ export interface ActionParam {
      * params (they always show).
      */
     advanced?: boolean;
+    /**
+     * The field holds ONE value or expression, never a composed container: in the JSON-binding
+     * editor, picking a reference into an empty draft (or a bare `[]` / `{}`) stores the bare
+     * whole-value ref `"{{ ref }}"`, not `[ref]`. A literal still can be typed.
+     */
+    whole?: boolean;
+    /**
+     * The param is declared on the action but never rendered by any param form, and never gates
+     * the required check. Its stored value is preserved untouched (e.g. a canvas-owned `body`).
+     * Not the entry-level `InternalNodeDef.hidden` (a palette hide).
+     */
+    hidden?: boolean;
     /**
      * Lay this param out on a shared row with adjacent params carrying the same
      * `row` id — e.g. a username/password pair side by side.
@@ -122,6 +168,12 @@ export interface ActionParam {
      * (e.g. Basic-auth fields shown only when `auth` is `"basic"`).
      */
     showIf?: ParamCondition;
+    /**
+     * Conditional overlay: the first entry whose `if` holds overlays
+     * label/hint/required/ui/options onto this param (see `effectiveParam` in
+     * `@w6w/expr`). Mirrors `@w6w/types`' `Param.when`.
+     */
+    when?: ParamWhen<ParamOption[] | DynamicOptions>[];
     /**
      * Constrained choices. Renders as a single-select dropdown for `select` (or any
      * param with options), and as a multi-select pill picker for `multiselect`.
@@ -148,6 +200,14 @@ export interface ActionParam {
     layout?: "row" | "stack";
     /** `section: "collapsible"` only — start collapsed (default `true`). */
     collapsed?: boolean;
+    /** `section: "collapsible"` only — start open when any child already holds a value. */
+    openWhenSet?: boolean;
+    /**
+     * `type: "code"` only — a Run script's code, which reads run data from its `state` / `vars` /
+     * `consts` globals: its insert actions write code reads, never `{{ }}` (the host does not
+     * substitute in code).
+     */
+    scriptReads?: boolean;
 }
 /** A single choice for a param rendered as a dropdown. */
 export interface ParamOption {
@@ -221,6 +281,8 @@ export interface ParamConfig {
     multiline?: boolean;
     /** With options: accept a value not in the list (Combobox `forceSelection` off). */
     allowCustom?: boolean;
+    /** Multiselect storage format. Defaults to an array; CSV preserves string-based API inputs. */
+    valueFormat?: "array" | "csv";
 }
 /** Summary of an action an app exposes, as returned by GET /apps/:id. */
 export interface ActionDef {

package/dist/use-app-action-defs.d.ts

@@ -1,7 +1,15 @@
 import { PortsLookup } from './flow-types.ts';
 import { StepNode } from './flow-utils.ts';
 import { W6WApi } from './provider.tsx';
-import { ActionDef } from './types.ts';
+import { ActionDef, TriggerSummary } from './types.ts';
 export declare function useAppActionDefs(api: W6WApi, nodes: StepNode[]): Record<string, ActionDef[]>;
+/**
+ * The trigger definitions of every app a workflow's APP-TRIGGER nodes (`uses.trigger === true`)
+ * use, so the editor can offer `trigger.event.<field>` from a trigger's declared `output` /
+ * `sample` without a run. Same shape as {@link useAppActionDefs}: fetched once per app id
+ * (`getAppTriggers`, optional on the api — absent means no claim), keyed on the sorted set of
+ * app ids, best-effort, a failed fetch retried by a later change.
+ */
+export declare function useAppTriggerDefs(api: W6WApi, nodes: StepNode[]): Record<string, TriggerSummary[]>;
 /** Build a `PortsLookup` over the fetched catalog defs (`useAppActionDefs`' result). */
 export declare function portsLookupFromDefs(defs: Record<string, ActionDef[]>): PortsLookup;

package/dist/use-test-input.d.ts

@@ -0,0 +1,18 @@
+import { ActionParam } from './types.ts';
+export interface RememberedTestInput {
+    /** `true` once the read settled (or there was nothing to read). */
+    loaded: boolean;
+    /** `false` when the host has no `loadTestInputs` — fall back to the older source. */
+    supported: boolean;
+    /** `undefined` = no row; `{}` = cleared; else the values last used. */
+    input: Record<string, unknown> | undefined;
+    /** Remember `values` (secret literals dropped). Best-effort: never throws. */
+    save: (values: Record<string, unknown>, params?: readonly ActionParam[]) => void;
+    /** Forget the values (stored as `{}`, so no older source refills the form). */
+    clear: () => void;
+}
+export declare function useRememberedTestInput(workflowId: string | undefined, nodeId: string | undefined): RememberedTestInput;
+/** The small muted note under a prefilled form: "last used values · Clear". */
+export declare function LastUsedNote({ onClear }: {
+    onClear: () => void;
+}): import("react").JSX.Element;

package/dist/workflow-connections.d.ts

@@ -0,0 +1,78 @@
+import { FlowStep, FlowWorkflow } from './flow-types.ts';
+import { AppSummary, AuthDef, ConnectionSummary } from './types.ts';
+export type FlowConnections = Record<string, {
+    app: string;
+    connection: string | null;
+}>;
+export type ConnectionResourceEdit = {
+    type: "add";
+    name: string;
+    app: string;
+    connection: string;
+} | {
+    type: "update";
+    ref: string;
+    name: string;
+    connection: string;
+    nodeIds?: string[];
+} | {
+    type: "replace";
+    ref: string;
+    connection: string;
+} | {
+    type: "rename";
+    ref: string;
+    name: string;
+} | {
+    type: "remove";
+    ref: string;
+} | {
+    type: "assign";
+    ref: string;
+    nodeIds: string[];
+};
+export interface WorkflowConnectionResources {
+    workflowId: string;
+    nodes: Pick<FlowStep, "id" | "uses">[];
+    connections: FlowConnections;
+    /** App identity already resolved for the canvas; reuse it in the connections rail. */
+    apps?: ReadonlyMap<string, AppSummary>;
+    readOnly?: boolean;
+    /** Select and reveal a consuming node on the canvas. Available in read-only views too. */
+    focusNode?: (nodeId: string) => void;
+    /** Temporary canvas emphasis, without changing selection or the saved workflow. */
+    highlightNode?: (nodeId: string | null) => void;
+    /** Stable callback against the current canvas, including edits made since the panel opened. */
+    edit: (edit: ConnectionResourceEdit) => void;
+}
+/** Edit references and their consumers together, so one undo restores the whole change. */
+export declare function editConnectionResources(nodes: FlowStep[], connections: FlowConnections, edit: ConnectionResourceEdit): {
+    nodes: FlowStep[];
+    connections: FlowConnections;
+};
+/** Missing/foreign bindings stay unresolved in the editor; the server rejects invalid references. */
+export declare function connectionIdFor(step: FlowStep, connections?: FlowConnections): string | undefined;
+/** A workflow-owned name, independent of the first node or the account's display name. */
+export declare function nextWorkflowConnectionName(appId: string, connections: FlowConnections): string;
+/** Lift old inline IDs on the next editor save. Independent bindings remain independent. */
+export declare function centralizeConnections<T extends Pick<FlowWorkflow, "connections" | "nodes">>(workflow: T): T;
+/** Drop only unreferenced aliases when serializing the complete workflow. */
+export declare function pruneUnusedConnections<T extends Pick<FlowWorkflow, "connections" | "nodes">>(workflow: T): T;
+export declare function withConnectionRef(step: FlowStep, connectionRef: string): FlowStep;
+/** An ordinary account selection affects this node only, detaching it from a shared entry. */
+export declare function selectNodeConnection(step: FlowStep, connection: string | undefined, nodes: FlowStep[], connections: FlowConnections): {
+    step: FlowStep;
+    connections: FlowConnections;
+};
+export declare function connectionSourceNodes(step: FlowStep, nodes: FlowStep[], connections: FlowConnections): FlowStep[];
+/** Accounts used anywhere in the workflow, including independently stored bindings. */
+export declare function connectionUsers(app: string, connection: string | undefined, nodes: FlowStep[], connections: FlowConnections): FlowStep[];
+/** An explicit initial selection wins; otherwise inherit the last added configured node. */
+export declare function defaultConnectionFor(step: FlowStep, choices: ConnectionSummary[], nodes: FlowStep[], connections: FlowConnections, initialConnection?: string): {
+    connection?: string;
+    connectionRef?: string;
+};
+/** The server's zero-credential sentinel is a real picker choice, without creating a row. */
+export declare function withDefaultConnection(appId: string, auths: AuthDef[], choices: ConnectionSummary[]): ConnectionSummary[];
+/** Change every binding used by the displayed account's consumers, retaining reference keys. */
+export declare function replaceWorkflowConnection(app: string, before: string, after: string, nodes: FlowStep[], connections: FlowConnections): FlowConnections;