@xyne/workflow-sdk 1.0.0

package/dist/steps/builtin/switch.step.d.ts

@@ -0,0 +1,200 @@
+/**
+ * SWITCH step — first-match-wins over an ordered list of conditional cases,
+ * with a guaranteed `default` fallback.
+ *
+ * Semantics (no fall-through):
+ *
+ *   for (const [i, c] of cases.entries())
+ *     if (evaluator.evaluate(c.condition, ctx.workflow)) {
+ *       walkBranch(c.steps, `case_${i}`)
+ *       return { branch: `case_${i}`, caseIndex: i, label: c.label ?? null }
+ *     }
+ *   walkBranch(default, 'default')
+ *   return { branch: 'default', caseIndex: null, label: null }
+ *
+ * Branch keys are positional (`case_0`, `case_1`, ..., `default`) so a
+ * paused execution's PausePath survives label edits.
+ */
+import { z } from 'zod';
+import { BaseControlFlowStep } from '../base-step.js';
+import type { ControlFlowExecutionContext } from '../base-step.js';
+import { BuiltinStepType } from '../../types/known-types.js';
+import type { WorkflowStepConfig } from '../../types/workflow-config.js';
+export declare const SwitchStepConfigSchema: z.ZodObject<{
+    cases: z.ZodArray<z.ZodObject<{
+        condition: z.ZodType<import("../../types/workflow-config.js").Condition, z.ZodTypeDef, import("../../types/workflow-config.js").Condition>;
+        label: z.ZodOptional<z.ZodString>;
+        steps: 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, {
+        steps: z.objectOutputType<{
+            id: z.ZodString;
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">[];
+        condition: import("../../types/workflow-config.js").Condition;
+        label?: string | undefined;
+    }, {
+        steps: z.objectInputType<{
+            id: z.ZodString;
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">[];
+        condition: import("../../types/workflow-config.js").Condition;
+        label?: string | undefined;
+    }>, "many">;
+    default: 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, {
+    default: z.objectOutputType<{
+        id: z.ZodString;
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">[];
+    cases: {
+        steps: z.objectOutputType<{
+            id: z.ZodString;
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">[];
+        condition: import("../../types/workflow-config.js").Condition;
+        label?: string | undefined;
+    }[];
+}, {
+    default: z.objectInputType<{
+        id: z.ZodString;
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">[];
+    cases: {
+        steps: z.objectInputType<{
+            id: z.ZodString;
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">[];
+        condition: import("../../types/workflow-config.js").Condition;
+        label?: string | undefined;
+    }[];
+}>;
+export type SwitchStepConfig = z.infer<typeof SwitchStepConfigSchema>;
+export interface SwitchStepOutput extends Record<string, unknown> {
+    /** Which branch executed. `'default'` when no case matched. `case_<i>` (i = caseIndex) otherwise. */
+    branch: string;
+    /** Index of the matched case, or `null` when `default` ran. */
+    caseIndex: number | null;
+    /** Label of the matched case, or `null` when `default` ran (or case had no label). */
+    label: string | null;
+}
+export declare class SwitchStep extends BaseControlFlowStep<typeof SwitchStepConfigSchema, SwitchStepOutput> {
+    readonly type = BuiltinStepType.SWITCH;
+    readonly name = "Switch";
+    readonly description = "Route to one of N branches; first matching case wins, otherwise default";
+    readonly configSchema: z.ZodObject<{
+        cases: z.ZodArray<z.ZodObject<{
+            condition: z.ZodType<import("../../types/workflow-config.js").Condition, z.ZodTypeDef, import("../../types/workflow-config.js").Condition>;
+            label: z.ZodOptional<z.ZodString>;
+            steps: 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, {
+            steps: z.objectOutputType<{
+                id: z.ZodString;
+                type: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">[];
+            condition: import("../../types/workflow-config.js").Condition;
+            label?: string | undefined;
+        }, {
+            steps: z.objectInputType<{
+                id: z.ZodString;
+                type: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">[];
+            condition: import("../../types/workflow-config.js").Condition;
+            label?: string | undefined;
+        }>, "many">;
+        default: 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, {
+        default: z.objectOutputType<{
+            id: z.ZodString;
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">[];
+        cases: {
+            steps: z.objectOutputType<{
+                id: z.ZodString;
+                type: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">[];
+            condition: import("../../types/workflow-config.js").Condition;
+            label?: string | undefined;
+        }[];
+    }, {
+        default: z.objectInputType<{
+            id: z.ZodString;
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">[];
+        cases: {
+            steps: z.objectInputType<{
+                id: z.ZodString;
+                type: z.ZodString;
+            }, z.ZodTypeAny, "passthrough">[];
+            condition: import("../../types/workflow-config.js").Condition;
+            label?: string | undefined;
+        }[];
+    }>;
+    readonly outputSchema: z.ZodObject<{
+        branch: z.ZodString;
+        caseIndex: z.ZodNullable<z.ZodNumber>;
+        label: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        branch: string;
+        label: string | null;
+        caseIndex: number | null;
+    }, {
+        branch: string;
+        label: string | null;
+        caseIndex: number | null;
+    }>;
+    readonly category: "control";
+    readonly icon = "switch";
+    readonly declaredOutputs: readonly [{
+        readonly key: "branch";
+        readonly label: "Matched branch key";
+    }, {
+        readonly key: "caseIndex";
+        readonly label: "Matched case index";
+    }, {
+        readonly key: "label";
+        readonly label: "Matched case label";
+    }];
+    /**
+     * Expose every branch (each case + default) so the config validator can
+     * walk forward references inside each one independently.
+     */
+    getBranches(config: Record<string, unknown>): Record<string, WorkflowStepConfig[]>;
+    execute(config: SwitchStepConfig, ctx: ControlFlowExecutionContext): Promise<SwitchStepOutput>;
+}
+//# sourceMappingURL=switch.step.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"switch.step.d.ts","sourceRoot":"","sources":["../../../src/steps/builtin/switch.step.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAgBzE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAItE,MAAM,WAAW,gBAAiB,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC/D,qGAAqG;IACrG,MAAM,EAAE,MAAM,CAAC;IACf,+DAA+D;IAC/D,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,sFAAsF;IACtF,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAaD,qBAAa,UAAW,SAAQ,mBAAmB,CACjD,OAAO,sBAAsB,EAC7B,gBAAgB,CACjB;IACC,SAAkB,IAAI,0BAA0B;IAChD,SAAkB,IAAI,YAAY;IAClC,SAAkB,WAAW,6EAA6E;IAC1G,SAAkB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAA0B;IACxD,SAAkB,YAAY;;;;;;;;;;;;OAA0B;IACxD,SAAkB,QAAQ,EAAG,SAAS,CAAU;IAChD,SAAkB,IAAI,YAAY;IAClC,SAAkB,eAAe;;;;;;;;;OAItB;IAEX;;;OAGG;IACM,WAAW,CAClB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAUxB,OAAO,CACpB,MAAM,EAAE,gBAAgB,EACxB,GAAG,EAAE,2BAA2B,GAC/B,OAAO,CAAC,gBAAgB,CAAC;CA+B7B"}

package/dist/steps/builtin/switch.step.js

@@ -0,0 +1,92 @@
+/**
+ * SWITCH step — first-match-wins over an ordered list of conditional cases,
+ * with a guaranteed `default` fallback.
+ *
+ * Semantics (no fall-through):
+ *
+ *   for (const [i, c] of cases.entries())
+ *     if (evaluator.evaluate(c.condition, ctx.workflow)) {
+ *       walkBranch(c.steps, `case_${i}`)
+ *       return { branch: `case_${i}`, caseIndex: i, label: c.label ?? null }
+ *     }
+ *   walkBranch(default, 'default')
+ *   return { branch: 'default', caseIndex: null, label: null }
+ *
+ * Branch keys are positional (`case_0`, `case_1`, ..., `default`) so a
+ * paused execution's PausePath survives label edits.
+ */
+import { z } from 'zod';
+import { BaseControlFlowStep } from '../base-step.js';
+import { BuiltinStepType } from '../../types/known-types.js';
+import { ConditionSchema } from '../../types/workflow-config.js';
+import { ConditionEvaluator } from '../../engine/condition-evaluator.js';
+// ─── Config ───
+const SwitchCaseSchema = z.object({
+    condition: ConditionSchema
+        .describe('Recursive condition tree (leaf or all/any composite). First case whose condition is true wins.'),
+    label: z.string().optional()
+        .describe('Optional UI label for this case. Not used for routing — branch keys are positional.'),
+    steps: z.array(z.object({ id: z.string(), type: z.string() }).passthrough()).describe('Steps to execute when this case wins.'),
+});
+export const SwitchStepConfigSchema = z.object({
+    cases: z.array(SwitchCaseSchema)
+        .describe('Ordered cases. Evaluated top-to-bottom; first match wins, no fall-through.'),
+    default: z.array(z.object({ id: z.string(), type: z.string() }).passthrough()).describe('Fallback branch. Runs when no case matches. Use `[]` to no-op the fallback.'),
+});
+const SwitchStepOutputSchema = z.object({
+    branch: z.string(),
+    caseIndex: z.number().int().nullable(),
+    label: z.string().nullable(),
+});
+// ─── Step ───
+const DEFAULT_BRANCH_KEY = 'default';
+const caseBranchKey = (i) => `case_${i}`;
+export class SwitchStep extends BaseControlFlowStep {
+    type = BuiltinStepType.SWITCH;
+    name = 'Switch';
+    description = 'Route to one of N branches; first matching case wins, otherwise default';
+    configSchema = SwitchStepConfigSchema;
+    outputSchema = SwitchStepOutputSchema;
+    category = 'control';
+    icon = 'switch';
+    declaredOutputs = [
+        { key: 'branch', label: 'Matched branch key' },
+        { key: 'caseIndex', label: 'Matched case index' },
+        { key: 'label', label: 'Matched case label' },
+    ];
+    /**
+     * Expose every branch (each case + default) so the config validator can
+     * walk forward references inside each one independently.
+     */
+    getBranches(config) {
+        const branches = {};
+        const cases = (config['cases'] ?? []);
+        for (let i = 0; i < cases.length; i++) {
+            branches[caseBranchKey(i)] = (cases[i]?.steps ?? []);
+        }
+        branches[DEFAULT_BRANCH_KEY] = (config['default'] ?? []);
+        return branches;
+    }
+    async execute(config, ctx) {
+        const evaluator = new ConditionEvaluator();
+        for (let i = 0; i < config.cases.length; i++) {
+            const entry = config.cases[i];
+            if (evaluator.evaluate(entry.condition, ctx.workflow)) {
+                const branchKey = caseBranchKey(i);
+                if (entry.steps.length > 0) {
+                    await ctx.walkBranch(entry.steps, ctx.workflow, branchKey);
+                }
+                return {
+                    branch: branchKey,
+                    caseIndex: i,
+                    label: entry.label ?? null,
+                };
+            }
+        }
+        if (config.default.length > 0) {
+            await ctx.walkBranch(config.default, ctx.workflow, DEFAULT_BRANCH_KEY);
+        }
+        return { branch: DEFAULT_BRANCH_KEY, caseIndex: null, label: null };
+    }
+}
+//# sourceMappingURL=switch.step.js.map

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

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

package/dist/steps/builtin/transform.step.d.ts

@@ -0,0 +1,247 @@
+/**
+ * TRANSFORM step — pure data manipulation.
+ *
+ * Applies a sequence of operations to the workflow context:
+ * - set: write a value at a dotted path
+ * - rename: move a value from one path to another
+ * - remove: delete a value at a dotted path
+ * - copy: copy a value from one path to another
+ *
+ * No services, no credentials — pure deterministic logic.
+ */
+import { z } from 'zod';
+import { BaseActionStep } from '../base-step.js';
+import type { StepExecutionContext } from '../base-step.js';
+import { BuiltinStepType } from '../../types/known-types.js';
+import type { StepCategory } from '../../types/categories.js';
+export declare const TransformOpSchema: z.ZodDiscriminatedUnion<"op", [z.ZodObject<{
+    op: z.ZodLiteral<"set">;
+    path: z.ZodString;
+    value: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+    op: "set";
+    path: string;
+    value?: unknown;
+}, {
+    op: "set";
+    path: string;
+    value?: unknown;
+}>, z.ZodObject<{
+    op: z.ZodLiteral<"rename">;
+    from: z.ZodString;
+    to: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    op: "rename";
+    from: string;
+    to: string;
+}, {
+    op: "rename";
+    from: string;
+    to: string;
+}>, z.ZodObject<{
+    op: z.ZodLiteral<"remove">;
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    op: "remove";
+    path: string;
+}, {
+    op: "remove";
+    path: string;
+}>, z.ZodObject<{
+    op: z.ZodLiteral<"copy">;
+    from: z.ZodString;
+    to: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    op: "copy";
+    from: string;
+    to: string;
+}, {
+    op: "copy";
+    from: string;
+    to: string;
+}>]>;
+export type TransformOp = z.infer<typeof TransformOpSchema>;
+export declare const TransformStepConfigSchema: z.ZodObject<{
+    operations: z.ZodArray<z.ZodDiscriminatedUnion<"op", [z.ZodObject<{
+        op: z.ZodLiteral<"set">;
+        path: z.ZodString;
+        value: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        op: "set";
+        path: string;
+        value?: unknown;
+    }, {
+        op: "set";
+        path: string;
+        value?: unknown;
+    }>, z.ZodObject<{
+        op: z.ZodLiteral<"rename">;
+        from: z.ZodString;
+        to: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        op: "rename";
+        from: string;
+        to: string;
+    }, {
+        op: "rename";
+        from: string;
+        to: string;
+    }>, z.ZodObject<{
+        op: z.ZodLiteral<"remove">;
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        op: "remove";
+        path: string;
+    }, {
+        op: "remove";
+        path: string;
+    }>, z.ZodObject<{
+        op: z.ZodLiteral<"copy">;
+        from: z.ZodString;
+        to: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        op: "copy";
+        from: string;
+        to: string;
+    }, {
+        op: "copy";
+        from: string;
+        to: string;
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    operations: ({
+        op: "set";
+        path: string;
+        value?: unknown;
+    } | {
+        op: "rename";
+        from: string;
+        to: string;
+    } | {
+        op: "remove";
+        path: string;
+    } | {
+        op: "copy";
+        from: string;
+        to: string;
+    })[];
+}, {
+    operations: ({
+        op: "set";
+        path: string;
+        value?: unknown;
+    } | {
+        op: "rename";
+        from: string;
+        to: string;
+    } | {
+        op: "remove";
+        path: string;
+    } | {
+        op: "copy";
+        from: string;
+        to: string;
+    })[];
+}>;
+export type TransformStepConfig = z.infer<typeof TransformStepConfigSchema>;
+export interface TransformStepOutput extends Record<string, unknown> {
+    applied: number;
+}
+export declare class TransformStep extends BaseActionStep<typeof TransformStepConfigSchema, TransformStepOutput> {
+    readonly type = BuiltinStepType.TRANSFORM;
+    readonly name = "Transform";
+    readonly description = "Apply data transformations to the workflow context";
+    readonly configSchema: z.ZodObject<{
+        operations: z.ZodArray<z.ZodDiscriminatedUnion<"op", [z.ZodObject<{
+            op: z.ZodLiteral<"set">;
+            path: z.ZodString;
+            value: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            op: "set";
+            path: string;
+            value?: unknown;
+        }, {
+            op: "set";
+            path: string;
+            value?: unknown;
+        }>, z.ZodObject<{
+            op: z.ZodLiteral<"rename">;
+            from: z.ZodString;
+            to: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            op: "rename";
+            from: string;
+            to: string;
+        }, {
+            op: "rename";
+            from: string;
+            to: string;
+        }>, z.ZodObject<{
+            op: z.ZodLiteral<"remove">;
+            path: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            op: "remove";
+            path: string;
+        }, {
+            op: "remove";
+            path: string;
+        }>, z.ZodObject<{
+            op: z.ZodLiteral<"copy">;
+            from: z.ZodString;
+            to: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            op: "copy";
+            from: string;
+            to: string;
+        }, {
+            op: "copy";
+            from: string;
+            to: string;
+        }>]>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        operations: ({
+            op: "set";
+            path: string;
+            value?: unknown;
+        } | {
+            op: "rename";
+            from: string;
+            to: string;
+        } | {
+            op: "remove";
+            path: string;
+        } | {
+            op: "copy";
+            from: string;
+            to: string;
+        })[];
+    }, {
+        operations: ({
+            op: "set";
+            path: string;
+            value?: unknown;
+        } | {
+            op: "rename";
+            from: string;
+            to: string;
+        } | {
+            op: "remove";
+            path: string;
+        } | {
+            op: "copy";
+            from: string;
+            to: string;
+        })[];
+    }>;
+    readonly outputSchema: z.ZodObject<{
+        applied: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        applied: number;
+    }, {
+        applied: number;
+    }>;
+    readonly category: StepCategory;
+    readonly icon = "filter";
+    execute(config: TransformStepConfig, ctx: StepExecutionContext): Promise<TransformStepOutput>;
+}
+//# sourceMappingURL=transform.step.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transform.step.d.ts","sourceRoot":"","sources":["../../../src/steps/builtin/transform.step.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AA4B9D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAK5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAI5E,MAAM,WAAW,mBAAoB,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAClE,OAAO,EAAE,MAAM,CAAC;CACjB;AA+DD,qBAAa,aAAc,SAAQ,cAAc,CAC/C,OAAO,yBAAyB,EAChC,mBAAmB,CACpB;IACC,SAAkB,IAAI,6BAA6B;IACnD,SAAkB,IAAI,eAAe;IACrC,SAAkB,WAAW,wDAAwD;IACrF,SAAkB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAA6B;IAC3D,SAAkB,YAAY;;;;;;OAA6B;IAC3D,SAAkB,QAAQ,EAAE,YAAY,CAAU;IAClD,SAAkB,IAAI,YAAY;IAEnB,OAAO,CACpB,MAAM,EAAE,mBAAmB,EAC3B,GAAG,EAAE,oBAAoB,GACxB,OAAO,CAAC,mBAAmB,CAAC;CAyChC"}

package/dist/steps/builtin/transform.step.js

@@ -0,0 +1,135 @@
+/**
+ * TRANSFORM step — pure data manipulation.
+ *
+ * Applies a sequence of operations to the workflow context:
+ * - set: write a value at a dotted path
+ * - rename: move a value from one path to another
+ * - remove: delete a value at a dotted path
+ * - copy: copy a value from one path to another
+ *
+ * No services, no credentials — pure deterministic logic.
+ */
+import { z } from 'zod';
+import { BaseActionStep } from '../base-step.js';
+import { BuiltinStepType } from '../../types/known-types.js';
+import { resolvePath } from '../../engine/variable-resolver.js';
+// ─── Config ───
+const SetOpSchema = z.object({
+    op: z.literal('set'),
+    path: z.string().min(1).describe('Dotted path where the value will be written'),
+    value: z.unknown().describe('Value to set at the path'),
+});
+const RenameOpSchema = z.object({
+    op: z.literal('rename'),
+    from: z.string().min(1).describe('Source dotted path'),
+    to: z.string().min(1).describe('Destination dotted path'),
+});
+const RemoveOpSchema = z.object({
+    op: z.literal('remove'),
+    path: z.string().min(1).describe('Dotted path to delete'),
+});
+const CopyOpSchema = z.object({
+    op: z.literal('copy'),
+    from: z.string().min(1).describe('Source dotted path'),
+    to: z.string().min(1).describe('Destination dotted path'),
+});
+export const TransformOpSchema = z.discriminatedUnion('op', [
+    SetOpSchema,
+    RenameOpSchema,
+    RemoveOpSchema,
+    CopyOpSchema,
+]);
+export const TransformStepConfigSchema = z.object({
+    operations: z.array(TransformOpSchema).min(1).describe('Sequence of data transformation operations to apply'),
+});
+const TransformStepOutputSchema = z.object({
+    applied: z.number(),
+});
+// ─── Helpers ───
+/**
+ * Set a value at a dotted path on a target object.
+ * Creates intermediate objects as needed.
+ */
+function setAtPath(target, path, value) {
+    const parts = path.split('.');
+    let current = target;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const key = parts[i];
+        if (current[key] === undefined ||
+            current[key] === null ||
+            typeof current[key] !== 'object') {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    current[parts[parts.length - 1]] = value;
+}
+/**
+ * Delete a value at a dotted path.
+ */
+function deleteAtPath(target, path) {
+    const parts = path.split('.');
+    let current = target;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const key = parts[i];
+        if (current[key] === undefined ||
+            current[key] === null ||
+            typeof current[key] !== 'object') {
+            return false;
+        }
+        current = current[key];
+    }
+    const lastKey = parts[parts.length - 1];
+    if (lastKey in current) {
+        delete current[lastKey];
+        return true;
+    }
+    return false;
+}
+// ─── Step ───
+export class TransformStep extends BaseActionStep {
+    type = BuiltinStepType.TRANSFORM;
+    name = 'Transform';
+    description = 'Apply data transformations to the workflow context';
+    configSchema = TransformStepConfigSchema;
+    outputSchema = TransformStepOutputSchema;
+    category = 'data';
+    icon = 'filter';
+    async execute(config, ctx) {
+        let applied = 0;
+        // Operate on the steps record
+        const data = ctx.workflow.steps;
+        for (const op of config.operations) {
+            switch (op.op) {
+                case 'set':
+                    setAtPath(data, op.path, op.value);
+                    applied++;
+                    break;
+                case 'rename': {
+                    const value = resolvePath(ctx.workflow, op.from);
+                    if (value !== undefined) {
+                        setAtPath(data, op.to, value);
+                        deleteAtPath(data, op.from);
+                        applied++;
+                    }
+                    break;
+                }
+                case 'remove':
+                    if (deleteAtPath(data, op.path)) {
+                        applied++;
+                    }
+                    break;
+                case 'copy': {
+                    const val = resolvePath(ctx.workflow, op.from);
+                    if (val !== undefined) {
+                        setAtPath(data, op.to, val);
+                        applied++;
+                    }
+                    break;
+                }
+            }
+        }
+        return { applied };
+    }
+}
+//# sourceMappingURL=transform.step.js.map