@xyne/workflow-sdk 3.2.37 → 3.2.38

package/dist/connectors/builtin/steps/loop.step.js

@@ -0,0 +1,73 @@
+/**
+ * LOOP step — iterate over an array and walk a body branch per item.
+ *
+ * BaseControlFlowStep with a single `body` branch. For each item in the
+ * source array, sets `ctx.workflow.steps[loopStepId].currentItem` and walks
+ * the body branch.
+ *
+ * Output: `{ results: unknown[], count: number }`
+ */
+import { z } from 'zod';
+import { BaseControlFlowStep, cloneScope } from '../../../steps/base-step.js';
+import { BuiltinStepType } from '../../../types/known-types.js';
+import { resolvePath } from '../../../engine/variable-resolver.js';
+// ─── Config ───
+export const LoopStepConfigSchema = z.object({
+    source: z.string().min(1).describe('Path to the array to iterate over (e.g. steps.fetch.output.items). Supports {{variable}} refs'),
+    body: z.array(z.object({ id: z.string(), type: z.string() }).passthrough()).describe('Steps to execute for each item in the array'),
+    maxIterations: z.number().int().positive().default(1000).describe('Maximum number of iterations as a safety limit'),
+});
+const LoopStepOutputSchema = z.object({
+    results: z.array(z.unknown()),
+    count: z.number(),
+});
+// ─── Step ───
+export class LoopStep extends BaseControlFlowStep {
+    type = BuiltinStepType.LOOP;
+    name = 'Loop';
+    description = 'Iterate over an array and execute steps for each item';
+    configSchema = LoopStepConfigSchema;
+    outputSchema = LoopStepOutputSchema;
+    category = 'control';
+    branchModel = 'iterate';
+    icon = 'repeat';
+    declaredOutputs = [
+        { key: 'body', label: 'For each item' },
+    ];
+    getBranches(config) {
+        return {
+            body: (config['body'] ?? []),
+        };
+    }
+    async execute(config, ctx) {
+        // Resolve the source array from context
+        const sourceValue = resolvePath(ctx.workflow, config.source);
+        if (!Array.isArray(sourceValue)) {
+            throw new Error(`LOOP source "${config.source}" did not resolve to an array (got ${typeof sourceValue})`);
+        }
+        const items = sourceValue;
+        const limit = Math.min(items.length, config.maxIterations);
+        const results = [];
+        for (let i = 0; i < limit; i++) {
+            const item = items[i];
+            // Each iteration runs in its own scope, keyed by node-path frame
+            // `loop_y:body#<i>`. The iteration index isolates body-step records and
+            // is the identity that lets a WAIT in iteration N resume the right
+            // iteration. `__loop` exposes the current item to body steps within the
+            // iteration scope (nested loops nest their own `__loop` in child scopes).
+            const iterScope = cloneScope(ctx.workflow);
+            iterScope.steps['__loop'] = {
+                type: 'LOOP',
+                output: {
+                    currentItem: item,
+                    currentIndex: i,
+                    totalItems: items.length,
+                },
+            };
+            await ctx.walkBranch(config.body, iterScope, 'body', i);
+            results.push(item);
+        }
+        return { results, count: results.length };
+    }
+}
+//# sourceMappingURL=loop.step.js.map

package/dist/connectors/builtin/steps/loop.step.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop.step.js","sourceRoot":"","sources":["../../../../src/connectors/builtin/steps/loop.step.ts"],"names":[],"mappings":"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"}

package/dist/connectors/builtin/steps/map.step.d.ts

@@ -0,0 +1,148 @@
+/**
+ * MAP step — iterate an array and run one `body` per item CONCURRENTLY.
+ *
+ * Like LOOP (resolves a source array, single `body`) but every item runs in
+ * parallel rather than sequentially — for cases where N dynamically-discovered
+ * items each need the same processing (e.g. validate the PAN of each of N
+ * owners). Each iteration runs in its own scope keyed by the node-path frame
+ * `map_x:item#<i>`, so a WAIT inside an iteration parks that iteration's own
+ * gate; multiple iterations can pause at once and resume independently — the
+ * same durable model PARALLEL uses (the executor's node-path records ARE the
+ * state; no saved state lives here).
+ *
+ * Output: `{ count, items: [{ index, item, steps }] }` — per-iteration step
+ * outputs, index-aligned with the source array (mirrors PARALLEL's
+ * `branches.<key>.steps`). Reference downstream as
+ * `…output.items.<i>.steps.<stepId>.output.<field>`.
+ */
+import { z } from 'zod';
+import { BaseControlFlowStep } from '../../../steps/base-step.js';
+import type { BranchStepOutputs, ControlFlowExecutionContext } from '../../../steps/base-step.js';
+import { BuiltinStepType } from '../../../types/known-types.js';
+import type { WorkflowStepConfig } from '../../../types/workflow-config.js';
+export declare const MapStepConfigSchema: z.ZodObject<{
+    source: z.ZodString;
+    body: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+}, "strip", z.ZodTypeAny, {
+    body: z.objectOutputType<{
+        id: z.ZodString;
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">[];
+    source: string;
+}, {
+    body: z.objectInputType<{
+        id: z.ZodString;
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">[];
+    source: string;
+}>;
+export type MapStepConfig = z.infer<typeof MapStepConfigSchema>;
+/** One iteration's result — its top-level step outputs (or an error). */
+export interface MapItemResult {
+    index: number;
+    item: unknown;
+    steps?: BranchStepOutputs;
+    error?: string;
+}
+export interface MapStepOutput extends Record<string, unknown> {
+    count: number;
+    items: MapItemResult[];
+}
+export declare class MapStep extends BaseControlFlowStep<typeof MapStepConfigSchema, MapStepOutput> {
+    readonly type = BuiltinStepType.MAP;
+    readonly name = "Map";
+    readonly description = "Map over an array, running steps for each item concurrently";
+    readonly configSchema: z.ZodObject<{
+        source: z.ZodString;
+        body: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            id: z.ZodString;
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            id: z.ZodString;
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        body: z.objectOutputType<{
+            id: z.ZodString;
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">[];
+        source: string;
+    }, {
+        body: z.objectInputType<{
+            id: z.ZodString;
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">[];
+        source: string;
+    }>;
+    readonly outputSchema: z.ZodObject<{
+        count: z.ZodNumber;
+        items: z.ZodArray<z.ZodObject<{
+            index: z.ZodNumber;
+            item: z.ZodUnknown;
+            steps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                output: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, "strip", z.ZodTypeAny, {
+                output: Record<string, unknown>;
+            }, {
+                output: Record<string, unknown>;
+            }>>>;
+            error: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            index: number;
+            steps?: Record<string, {
+                output: Record<string, unknown>;
+            }> | undefined;
+            error?: string | undefined;
+            item?: unknown;
+        }, {
+            index: number;
+            steps?: Record<string, {
+                output: Record<string, unknown>;
+            }> | undefined;
+            error?: string | undefined;
+            item?: unknown;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        items: {
+            index: number;
+            steps?: Record<string, {
+                output: Record<string, unknown>;
+            }> | undefined;
+            error?: string | undefined;
+            item?: unknown;
+        }[];
+        count: number;
+    }, {
+        items: {
+            index: number;
+            steps?: Record<string, {
+                output: Record<string, unknown>;
+            }> | undefined;
+            error?: string | undefined;
+            item?: unknown;
+        }[];
+        count: number;
+    }>;
+    readonly category: "control";
+    readonly branchModel: "map";
+    readonly icon = "layers";
+    readonly declaredOutputs: readonly [{
+        readonly key: "body";
+        readonly label: "For each item";
+    }];
+    getBranches(config: Record<string, unknown>): Record<string, WorkflowStepConfig[]>;
+    execute(config: MapStepConfig, ctx: ControlFlowExecutionContext): Promise<MapStepOutput>;
+}
+//# sourceMappingURL=map.step.d.ts.map

package/dist/connectors/builtin/steps/map.step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.step.d.ts","sourceRoot":"","sources":["../../../../src/connectors/builtin/steps/map.step.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,mBAAmB,EAAkC,MAAM,6BAA6B,CAAC;AAClG,OAAO,KAAK,EAAE,iBAAiB,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAC;AAClG,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAM5E,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;EAG9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAIhE,yEAAyE;AACzE,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,aAAc,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC5D,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,aAAa,EAAE,CAAC;CACxB;AAgBD,qBAAa,OAAQ,SAAQ,mBAAmB,CAC9C,OAAO,mBAAmB,EAC1B,aAAa,CACd;IACC,SAAkB,IAAI,uBAAuB;IAC7C,SAAkB,IAAI,SAAS;IAC/B,SAAkB,WAAW,iEAAiE;IAC9F,SAAkB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;OAAuB;IACrD,SAAkB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAAuB;IACrD,SAAkB,QAAQ,EAAG,SAAS,CAAU;IAChD,SAAkB,WAAW,EAAG,KAAK,CAAU;IAC/C,SAAkB,IAAI,YAAY;IAClC,SAAkB,eAAe;;;OAEtB;IAEF,WAAW,CAClB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAMxB,OAAO,CACpB,MAAM,EAAE,aAAa,EACrB,GAAG,EAAE,2BAA2B,GAC/B,OAAO,CAAC,aAAa,CAAC;CAoE1B"}

package/dist/connectors/builtin/steps/map.step.js

@@ -0,0 +1,111 @@
+/**
+ * MAP step — iterate an array and run one `body` per item CONCURRENTLY.
+ *
+ * Like LOOP (resolves a source array, single `body`) but every item runs in
+ * parallel rather than sequentially — for cases where N dynamically-discovered
+ * items each need the same processing (e.g. validate the PAN of each of N
+ * owners). Each iteration runs in its own scope keyed by the node-path frame
+ * `map_x:item#<i>`, so a WAIT inside an iteration parks that iteration's own
+ * gate; multiple iterations can pause at once and resume independently — the
+ * same durable model PARALLEL uses (the executor's node-path records ARE the
+ * state; no saved state lives here).
+ *
+ * Output: `{ count, items: [{ index, item, steps }] }` — per-iteration step
+ * outputs, index-aligned with the source array (mirrors PARALLEL's
+ * `branches.<key>.steps`). Reference downstream as
+ * `…output.items.<i>.steps.<stepId>.output.<field>`.
+ */
+import { z } from 'zod';
+import { BaseControlFlowStep, cloneScope, collectBranchSteps } from '../../../steps/base-step.js';
+import { BuiltinStepType } from '../../../types/known-types.js';
+import { resolvePath } from '../../../engine/variable-resolver.js';
+import { PauseStep } from '../../../engine/pause-step.js';
+// ─── Config ───
+export const MapStepConfigSchema = z.object({
+    source: z.string().min(1).describe('Path to the array to map over (e.g. steps.extract.output.owners). Supports {{variable}} refs'),
+    body: z.array(z.object({ id: z.string(), type: z.string() }).passthrough()).describe('Steps to execute for each item — all items run concurrently'),
+});
+const MapStepOutputSchema = z.object({
+    count: z.number(),
+    items: z.array(z.object({
+        index: z.number(),
+        item: z.unknown(),
+        steps: z.record(z.object({ output: z.record(z.unknown()) })).optional(),
+        error: z.string().optional(),
+    })),
+});
+// ─── Step ───
+export class MapStep extends BaseControlFlowStep {
+    type = BuiltinStepType.MAP;
+    name = 'Map';
+    description = 'Map over an array, running steps for each item concurrently';
+    configSchema = MapStepConfigSchema;
+    outputSchema = MapStepOutputSchema;
+    category = 'control';
+    branchModel = 'map';
+    icon = 'layers';
+    declaredOutputs = [
+        { key: 'body', label: 'For each item' },
+    ];
+    getBranches(config) {
+        return {
+            body: (config['body'] ?? []),
+        };
+    }
+    async execute(config, ctx) {
+        const sourceValue = resolvePath(ctx.workflow, config.source);
+        if (!Array.isArray(sourceValue)) {
+            throw new Error(`MAP source "${config.source}" did not resolve to an array (got ${typeof sourceValue})`);
+        }
+        const items = sourceValue;
+        const body = config.body;
+        // Run every iteration concurrently, each in its own scope keyed by node-path
+        // `map_x:item#<i>`. A paused iteration throws PauseStep; on resume the MAP
+        // re-enters and re-walks all iterations — completed ones memo-skip from
+        // their records, the parked one(s) resume. No saved state lives here.
+        const settled = await Promise.allSettled(items.map(async (item, i) => {
+            const iterScope = cloneScope(ctx.workflow);
+            iterScope.steps['__map'] = {
+                type: 'MAP',
+                output: { currentItem: item, currentIndex: i, totalItems: items.length },
+            };
+            await ctx.walkBranch(body, iterScope, 'item', i);
+            return { index: i, item, steps: collectBranchSteps(body, iterScope) };
+        }));
+        const results = [];
+        let pausedCount = 0;
+        let firstExternalRef;
+        for (let i = 0; i < settled.length; i++) {
+            const entry = settled[i];
+            if (entry.status === 'fulfilled') {
+                results.push(entry.value);
+            }
+            else if (PauseStep.is(entry.reason)) {
+                pausedCount++;
+                const pe = entry.reason;
+                if (firstExternalRef === undefined && pe.externalRef !== undefined) {
+                    firstExternalRef = pe.externalRef;
+                }
+            }
+            else {
+                results.push({
+                    index: i,
+                    item: items[i],
+                    error: entry.reason instanceof Error
+                        ? entry.reason.message
+                        : String(entry.reason),
+                });
+            }
+        }
+        // Any paused iteration parks the whole MAP; the executor records it as
+        // EXTERNAL_WAIT and re-enters on resume. Completed/failed iterations are
+        // durable in their per-item records — this throw discards the partial list.
+        if (pausedCount > 0) {
+            const reason = pausedCount === 1 ? 'item awaiting resume' : `${String(pausedCount)} items awaiting resume`;
+            throw new PauseStep(reason, firstExternalRef !== undefined ? { externalRef: firstExternalRef } : undefined);
+        }
+        results.sort((a, b) => a.index - b.index);
+        return { count: items.length, items: results };
+    }
+}
+//# sourceMappingURL=map.step.js.map

package/dist/connectors/builtin/steps/map.step.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.step.js","sourceRoot":"","sources":["../../../../src/connectors/builtin/steps/map.step.ts"],"names":[],"mappings":"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"}

package/dist/connectors/builtin/steps/parallel.step.d.ts

@@ -0,0 +1,246 @@
+/**
+ * PARALLEL step — fan-out N named branches concurrently and collect results.
+ *
+ * BaseControlFlowStep with N dynamic branches. Runs all in parallel via
+ * Promise.allSettled or Promise.race depending on `merge` mode.
+ *
+ * Each branch gets an isolated copy of the workflow context so concurrent
+ * writes to `context.steps` don't conflict. After completion, the last
+ * step's output from each branch is collected into the parallel step's output.
+ *
+ * ## Pause handling (allSettled)
+ *
+ * Each branch runs in its own scope and persists its steps under node-path keys
+ * (`parallel_x:<branch>#0/<stepId>`). When a branch parks, its `walkBranch`
+ * throws `PauseStep`; PARALLEL collects which branches paused and, if any did,
+ * throws a single `PauseStep` so the whole step parks. There is no internal
+ * saved state — the per-branch step records ARE the durable state. On resume
+ * the executor re-enters PARALLEL, re-runs every branch via `walkBranch`:
+ * completed branch steps memo-skip from their records, the parked one(s) resume
+ * from theirs. Multiple branches can be paused simultaneously; each `resume()`
+ * targets one branch's gate by node-path. When the last paused branch
+ * completes, PARALLEL merges everything and returns.
+ *
+ * ## Output
+ *
+ * Discriminated union on `mode` so consumers (including the UI)
+ * can switch on `mode` and get full type safety for each case:
+ *
+ *   allSettled: { mode: 'allSettled', branches: { [name]: { status, value?, reason? } } }
+ *   race:       { mode: 'race',       winner: string, result: { output } }
+ */
+import { z } from 'zod';
+import { BaseControlFlowStep } from '../../../steps/base-step.js';
+import type { ControlFlowExecutionContext, BranchStepOutputs } from '../../../steps/base-step.js';
+import { BuiltinStepType } from '../../../types/known-types.js';
+import type { WorkflowStepConfig } from '../../../types/workflow-config.js';
+export declare const ParallelStepConfigSchema: z.ZodObject<{
+    branches: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>, "many">>;
+    merge: z.ZodDefault<z.ZodEnum<["allSettled", "race"]>>;
+}, "strip", z.ZodTypeAny, {
+    branches: Record<string, z.objectOutputType<{
+        id: z.ZodString;
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">[]>;
+    merge: "allSettled" | "race";
+}, {
+    branches: Record<string, z.objectInputType<{
+        id: z.ZodString;
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">[]>;
+    merge?: "allSettled" | "race" | undefined;
+}>;
+export type ParallelStepConfig = z.infer<typeof ParallelStepConfigSchema>;
+/**
+ * Per-branch result — the branch's TOP-LEVEL steps map (keyed by step id, each
+ * `{ output }`, mirroring the main context's `steps.<id>.output`), or a failure.
+ * Referenced as `…output.branches.<key>.steps.<id>.output.<field>`.
+ */
+export type ParallelSettledBranchResult = {
+    status: 'fulfilled';
+    steps: BranchStepOutputs;
+} | {
+    status: 'rejected';
+    reason: string;
+};
+export interface ParallelAllSettledOutput extends Record<string, unknown> {
+    mode: 'allSettled';
+    branches: Record<string, ParallelSettledBranchResult>;
+}
+export interface ParallelRaceOutput extends Record<string, unknown> {
+    mode: 'race';
+    /** Which branch won. */
+    branch: string;
+    /** Only the winner is populated; uniform `branches` shape with all control flow. */
+    branches: Record<string, ParallelSettledBranchResult>;
+}
+export type ParallelStepOutput = ParallelAllSettledOutput | ParallelRaceOutput;
+export declare class ParallelStep extends BaseControlFlowStep<typeof ParallelStepConfigSchema, ParallelStepOutput> {
+    readonly type = BuiltinStepType.PARALLEL;
+    readonly name = "Parallel";
+    readonly description = "Run multiple branches concurrently and collect results";
+    readonly configSchema: z.ZodObject<{
+        branches: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            id: z.ZodString;
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            id: z.ZodString;
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>, "many">>;
+        merge: z.ZodDefault<z.ZodEnum<["allSettled", "race"]>>;
+    }, "strip", z.ZodTypeAny, {
+        branches: Record<string, z.objectOutputType<{
+            id: z.ZodString;
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">[]>;
+        merge: "allSettled" | "race";
+    }, {
+        branches: Record<string, z.objectInputType<{
+            id: z.ZodString;
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">[]>;
+        merge?: "allSettled" | "race" | undefined;
+    }>;
+    readonly outputSchema: z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+        mode: z.ZodLiteral<"allSettled">;
+        branches: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+            status: z.ZodLiteral<"fulfilled">;
+            steps: z.ZodRecord<z.ZodString, z.ZodObject<{
+                output: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, "strip", z.ZodTypeAny, {
+                output: Record<string, unknown>;
+            }, {
+                output: Record<string, unknown>;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            status: "fulfilled";
+            steps: Record<string, {
+                output: Record<string, unknown>;
+            }>;
+        }, {
+            status: "fulfilled";
+            steps: Record<string, {
+                output: Record<string, unknown>;
+            }>;
+        }>, z.ZodObject<{
+            status: z.ZodLiteral<"rejected">;
+            reason: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            status: "rejected";
+            reason: string;
+        }, {
+            status: "rejected";
+            reason: string;
+        }>]>>;
+    }, "strip", z.ZodTypeAny, {
+        branches: Record<string, {
+            status: "fulfilled";
+            steps: Record<string, {
+                output: Record<string, unknown>;
+            }>;
+        } | {
+            status: "rejected";
+            reason: string;
+        }>;
+        mode: "allSettled";
+    }, {
+        branches: Record<string, {
+            status: "fulfilled";
+            steps: Record<string, {
+                output: Record<string, unknown>;
+            }>;
+        } | {
+            status: "rejected";
+            reason: string;
+        }>;
+        mode: "allSettled";
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"race">;
+        branch: z.ZodString;
+        branches: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+            status: z.ZodLiteral<"fulfilled">;
+            steps: z.ZodRecord<z.ZodString, z.ZodObject<{
+                output: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, "strip", z.ZodTypeAny, {
+                output: Record<string, unknown>;
+            }, {
+                output: Record<string, unknown>;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            status: "fulfilled";
+            steps: Record<string, {
+                output: Record<string, unknown>;
+            }>;
+        }, {
+            status: "fulfilled";
+            steps: Record<string, {
+                output: Record<string, unknown>;
+            }>;
+        }>, z.ZodObject<{
+            status: z.ZodLiteral<"rejected">;
+            reason: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            status: "rejected";
+            reason: string;
+        }, {
+            status: "rejected";
+            reason: string;
+        }>]>>;
+    }, "strip", z.ZodTypeAny, {
+        branch: string;
+        branches: Record<string, {
+            status: "fulfilled";
+            steps: Record<string, {
+                output: Record<string, unknown>;
+            }>;
+        } | {
+            status: "rejected";
+            reason: string;
+        }>;
+        mode: "race";
+    }, {
+        branch: string;
+        branches: Record<string, {
+            status: "fulfilled";
+            steps: Record<string, {
+                output: Record<string, unknown>;
+            }>;
+        } | {
+            status: "rejected";
+            reason: string;
+        }>;
+        mode: "race";
+    }>]>;
+    readonly category: "control";
+    readonly icon = "columns";
+    /**
+     * Declared outputs are dynamic — one per branch key.
+     * Since branch keys are user-defined, we return empty here and let
+     * `getBranches()` handle discovery for validation.
+     */
+    readonly declaredOutputs: readonly [];
+    getBranches(config: Record<string, unknown>): Record<string, WorkflowStepConfig[]>;
+    /**
+     * Collapse the static `mode` discriminated union to the *configured* mode, so
+     * the variable picker sees a concrete object (not an `anyOf`) it can drill.
+     * Only the mode-dependent meta is declared here; the harness
+     * (`resolveOutputJsonSchemaOf`) splices the typed `branches` from `getBranches`.
+     */
+    resolveOutputJsonSchema(config: Record<string, unknown>): Record<string, unknown>;
+    execute(config: ParallelStepConfig, ctx: ControlFlowExecutionContext): Promise<ParallelStepOutput>;
+    private executeAllSettled;
+    private executeRace;
+}
+//# sourceMappingURL=parallel.step.d.ts.map

package/dist/connectors/builtin/steps/parallel.step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallel.step.d.ts","sourceRoot":"","sources":["../../../../src/connectors/builtin/steps/parallel.step.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,mBAAmB,EAAkC,MAAM,6BAA6B,CAAC;AAClG,OAAO,KAAK,EAAE,2BAA2B,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAClG,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAK5E,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;EAMnC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAI1E;;;;GAIG;AACH,MAAM,MAAM,2BAA2B,GACnC;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,iBAAiB,CAAA;CAAE,GACjD;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3C,MAAM,WAAW,wBAAyB,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACvE,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,2BAA2B,CAAC,CAAC;CACvD;AAED,MAAM,WAAW,kBAAmB,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,wBAAwB;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,oFAAoF;IACpF,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,2BAA2B,CAAC,CAAC;CACvD;AAED,MAAM,MAAM,kBAAkB,GAC1B,wBAAwB,GACxB,kBAAkB,CAAC;AA+BvB,qBAAa,YAAa,SAAQ,mBAAmB,CACnD,OAAO,wBAAwB,EAC/B,kBAAkB,CACnB;IACC,SAAkB,IAAI,4BAA4B;IAClD,SAAkB,IAAI,cAAc;IACpC,SAAkB,WAAW,4DAC8B;IAC3D,SAAkB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;OAA4B;IAC1D,SAAkB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA4B;IAC1D,SAAkB,QAAQ,EAAG,SAAS,CAAU;IAChD,SAAkB,IAAI,aAAa;IAEnC;;;;OAIG;IACH,SAAkB,eAAe,cAAe;IAEvC,WAAW,CAClB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAYvC;;;;;OAKG;IACM,uBAAuB,CAC9B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAOX,OAAO,CACpB,MAAM,EAAE,kBAAkB,EAC1B,GAAG,EAAE,2BAA2B,GAC/B,OAAO,CAAC,kBAAkB,CAAC;YAgBhB,iBAAiB;YAgEjB,WAAW;CAyB1B"}