@generacy-ai/workflow-engine 0.0.0-preview-20260304013206

package/dist/loader/schema.d.ts

@@ -0,0 +1,506 @@
+/**
+ * Zod validation schemas for workflow definitions.
+ */
+import { z } from 'zod';
+/**
+ * Input definition schema
+ */
+export declare const InputDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    default: z.ZodOptional<z.ZodUnknown>;
+    required: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    type: z.ZodOptional<z.ZodEnum<["string", "number", "boolean", "object", "array"]>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    required: boolean;
+    type?: "string" | "number" | "boolean" | "object" | "array" | undefined;
+    description?: string | undefined;
+    default?: unknown;
+}, {
+    name: string;
+    type?: "string" | "number" | "boolean" | "object" | "array" | undefined;
+    description?: string | undefined;
+    default?: unknown;
+    required?: boolean | undefined;
+}>;
+/**
+ * Retry configuration schema
+ */
+export declare const RetryConfigSchema: z.ZodObject<{
+    maxAttempts: z.ZodDefault<z.ZodNumber>;
+    delay: z.ZodDefault<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+    backoff: z.ZodDefault<z.ZodEnum<["constant", "linear", "exponential"]>>;
+    maxDelay: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+    jitter: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    maxAttempts: number;
+    delay: string | number;
+    backoff: "constant" | "linear" | "exponential";
+    maxDelay?: string | number | undefined;
+    jitter?: number | undefined;
+}, {
+    maxAttempts?: number | undefined;
+    delay?: string | number | undefined;
+    backoff?: "constant" | "linear" | "exponential" | undefined;
+    maxDelay?: string | number | undefined;
+    jitter?: number | undefined;
+}>;
+/**
+ * Step definition schema
+ */
+export declare const StepDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    action: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    uses: z.ZodOptional<z.ZodString>;
+    with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    command: z.ZodOptional<z.ZodString>;
+    script: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    continueOnError: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    condition: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    retry: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+        delay: z.ZodDefault<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+        backoff: z.ZodDefault<z.ZodEnum<["constant", "linear", "exponential"]>>;
+        maxDelay: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+        jitter: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxAttempts: number;
+        delay: string | number;
+        backoff: "constant" | "linear" | "exponential";
+        maxDelay?: string | number | undefined;
+        jitter?: number | undefined;
+    }, {
+        maxAttempts?: number | undefined;
+        delay?: string | number | undefined;
+        backoff?: "constant" | "linear" | "exponential" | undefined;
+        maxDelay?: string | number | undefined;
+        jitter?: number | undefined;
+    }>>;
+    gate: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    action: string;
+    name: string;
+    continueOnError: boolean;
+    env?: Record<string, string> | undefined;
+    timeout?: number | undefined;
+    command?: string | undefined;
+    with?: Record<string, unknown> | undefined;
+    uses?: string | undefined;
+    retry?: {
+        maxAttempts: number;
+        delay: string | number;
+        backoff: "constant" | "linear" | "exponential";
+        maxDelay?: string | number | undefined;
+        jitter?: number | undefined;
+    } | undefined;
+    script?: string | undefined;
+    condition?: string | undefined;
+    gate?: string | undefined;
+}, {
+    name: string;
+    env?: Record<string, string> | undefined;
+    timeout?: number | undefined;
+    command?: string | undefined;
+    with?: Record<string, unknown> | undefined;
+    uses?: string | undefined;
+    action?: string | undefined;
+    retry?: {
+        maxAttempts?: number | undefined;
+        delay?: string | number | undefined;
+        backoff?: "constant" | "linear" | "exponential" | undefined;
+        maxDelay?: string | number | undefined;
+        jitter?: number | undefined;
+    } | undefined;
+    script?: string | undefined;
+    continueOnError?: boolean | undefined;
+    condition?: string | undefined;
+    gate?: string | undefined;
+}>;
+/**
+ * Phase definition schema
+ */
+export declare const PhaseDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    steps: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        action: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        uses: z.ZodOptional<z.ZodString>;
+        with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        command: z.ZodOptional<z.ZodString>;
+        script: z.ZodOptional<z.ZodString>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+        continueOnError: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        condition: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodDefault<z.ZodNumber>;
+            delay: z.ZodDefault<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+            backoff: z.ZodDefault<z.ZodEnum<["constant", "linear", "exponential"]>>;
+            maxDelay: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+            jitter: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            maxAttempts: number;
+            delay: string | number;
+            backoff: "constant" | "linear" | "exponential";
+            maxDelay?: string | number | undefined;
+            jitter?: number | undefined;
+        }, {
+            maxAttempts?: number | undefined;
+            delay?: string | number | undefined;
+            backoff?: "constant" | "linear" | "exponential" | undefined;
+            maxDelay?: string | number | undefined;
+            jitter?: number | undefined;
+        }>>;
+        gate: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        action: string;
+        name: string;
+        continueOnError: boolean;
+        env?: Record<string, string> | undefined;
+        timeout?: number | undefined;
+        command?: string | undefined;
+        with?: Record<string, unknown> | undefined;
+        uses?: string | undefined;
+        retry?: {
+            maxAttempts: number;
+            delay: string | number;
+            backoff: "constant" | "linear" | "exponential";
+            maxDelay?: string | number | undefined;
+            jitter?: number | undefined;
+        } | undefined;
+        script?: string | undefined;
+        condition?: string | undefined;
+        gate?: string | undefined;
+    }, {
+        name: string;
+        env?: Record<string, string> | undefined;
+        timeout?: number | undefined;
+        command?: string | undefined;
+        with?: Record<string, unknown> | undefined;
+        uses?: string | undefined;
+        action?: string | undefined;
+        retry?: {
+            maxAttempts?: number | undefined;
+            delay?: string | number | undefined;
+            backoff?: "constant" | "linear" | "exponential" | undefined;
+            maxDelay?: string | number | undefined;
+            jitter?: number | undefined;
+        } | undefined;
+        script?: string | undefined;
+        continueOnError?: boolean | undefined;
+        condition?: string | undefined;
+        gate?: string | undefined;
+    }>, "many">;
+    condition: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    steps: {
+        action: string;
+        name: string;
+        continueOnError: boolean;
+        env?: Record<string, string> | undefined;
+        timeout?: number | undefined;
+        command?: string | undefined;
+        with?: Record<string, unknown> | undefined;
+        uses?: string | undefined;
+        retry?: {
+            maxAttempts: number;
+            delay: string | number;
+            backoff: "constant" | "linear" | "exponential";
+            maxDelay?: string | number | undefined;
+            jitter?: number | undefined;
+        } | undefined;
+        script?: string | undefined;
+        condition?: string | undefined;
+        gate?: string | undefined;
+    }[];
+    name: string;
+    condition?: string | undefined;
+}, {
+    steps: {
+        name: string;
+        env?: Record<string, string> | undefined;
+        timeout?: number | undefined;
+        command?: string | undefined;
+        with?: Record<string, unknown> | undefined;
+        uses?: string | undefined;
+        action?: string | undefined;
+        retry?: {
+            maxAttempts?: number | undefined;
+            delay?: string | number | undefined;
+            backoff?: "constant" | "linear" | "exponential" | undefined;
+            maxDelay?: string | number | undefined;
+            jitter?: number | undefined;
+        } | undefined;
+        script?: string | undefined;
+        continueOnError?: boolean | undefined;
+        condition?: string | undefined;
+        gate?: string | undefined;
+    }[];
+    name: string;
+    condition?: string | undefined;
+}>;
+/**
+ * Workflow definition schema
+ */
+export declare const WorkflowDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        required: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        type: z.ZodOptional<z.ZodEnum<["string", "number", "boolean", "object", "array"]>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        required: boolean;
+        type?: "string" | "number" | "boolean" | "object" | "array" | undefined;
+        description?: string | undefined;
+        default?: unknown;
+    }, {
+        name: string;
+        type?: "string" | "number" | "boolean" | "object" | "array" | undefined;
+        description?: string | undefined;
+        default?: unknown;
+        required?: boolean | undefined;
+    }>, "many">>;
+    phases: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        steps: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            action: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            uses: z.ZodOptional<z.ZodString>;
+            with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            command: z.ZodOptional<z.ZodString>;
+            script: z.ZodOptional<z.ZodString>;
+            timeout: z.ZodOptional<z.ZodNumber>;
+            continueOnError: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            condition: z.ZodOptional<z.ZodString>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxAttempts: z.ZodDefault<z.ZodNumber>;
+                delay: z.ZodDefault<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+                backoff: z.ZodDefault<z.ZodEnum<["constant", "linear", "exponential"]>>;
+                maxDelay: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+                jitter: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                maxAttempts: number;
+                delay: string | number;
+                backoff: "constant" | "linear" | "exponential";
+                maxDelay?: string | number | undefined;
+                jitter?: number | undefined;
+            }, {
+                maxAttempts?: number | undefined;
+                delay?: string | number | undefined;
+                backoff?: "constant" | "linear" | "exponential" | undefined;
+                maxDelay?: string | number | undefined;
+                jitter?: number | undefined;
+            }>>;
+            gate: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            action: string;
+            name: string;
+            continueOnError: boolean;
+            env?: Record<string, string> | undefined;
+            timeout?: number | undefined;
+            command?: string | undefined;
+            with?: Record<string, unknown> | undefined;
+            uses?: string | undefined;
+            retry?: {
+                maxAttempts: number;
+                delay: string | number;
+                backoff: "constant" | "linear" | "exponential";
+                maxDelay?: string | number | undefined;
+                jitter?: number | undefined;
+            } | undefined;
+            script?: string | undefined;
+            condition?: string | undefined;
+            gate?: string | undefined;
+        }, {
+            name: string;
+            env?: Record<string, string> | undefined;
+            timeout?: number | undefined;
+            command?: string | undefined;
+            with?: Record<string, unknown> | undefined;
+            uses?: string | undefined;
+            action?: string | undefined;
+            retry?: {
+                maxAttempts?: number | undefined;
+                delay?: string | number | undefined;
+                backoff?: "constant" | "linear" | "exponential" | undefined;
+                maxDelay?: string | number | undefined;
+                jitter?: number | undefined;
+            } | undefined;
+            script?: string | undefined;
+            continueOnError?: boolean | undefined;
+            condition?: string | undefined;
+            gate?: string | undefined;
+        }>, "many">;
+        condition: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        steps: {
+            action: string;
+            name: string;
+            continueOnError: boolean;
+            env?: Record<string, string> | undefined;
+            timeout?: number | undefined;
+            command?: string | undefined;
+            with?: Record<string, unknown> | undefined;
+            uses?: string | undefined;
+            retry?: {
+                maxAttempts: number;
+                delay: string | number;
+                backoff: "constant" | "linear" | "exponential";
+                maxDelay?: string | number | undefined;
+                jitter?: number | undefined;
+            } | undefined;
+            script?: string | undefined;
+            condition?: string | undefined;
+            gate?: string | undefined;
+        }[];
+        name: string;
+        condition?: string | undefined;
+    }, {
+        steps: {
+            name: string;
+            env?: Record<string, string> | undefined;
+            timeout?: number | undefined;
+            command?: string | undefined;
+            with?: Record<string, unknown> | undefined;
+            uses?: string | undefined;
+            action?: string | undefined;
+            retry?: {
+                maxAttempts?: number | undefined;
+                delay?: string | number | undefined;
+                backoff?: "constant" | "linear" | "exponential" | undefined;
+                maxDelay?: string | number | undefined;
+                jitter?: number | undefined;
+            } | undefined;
+            script?: string | undefined;
+            continueOnError?: boolean | undefined;
+            condition?: string | undefined;
+            gate?: string | undefined;
+        }[];
+        name: string;
+        condition?: string | undefined;
+    }>, "many">;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    retry: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+        delay: z.ZodDefault<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+        backoff: z.ZodDefault<z.ZodEnum<["constant", "linear", "exponential"]>>;
+        maxDelay: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+        jitter: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxAttempts: number;
+        delay: string | number;
+        backoff: "constant" | "linear" | "exponential";
+        maxDelay?: string | number | undefined;
+        jitter?: number | undefined;
+    }, {
+        maxAttempts?: number | undefined;
+        delay?: string | number | undefined;
+        backoff?: "constant" | "linear" | "exponential" | undefined;
+        maxDelay?: string | number | undefined;
+        jitter?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    phases: {
+        steps: {
+            action: string;
+            name: string;
+            continueOnError: boolean;
+            env?: Record<string, string> | undefined;
+            timeout?: number | undefined;
+            command?: string | undefined;
+            with?: Record<string, unknown> | undefined;
+            uses?: string | undefined;
+            retry?: {
+                maxAttempts: number;
+                delay: string | number;
+                backoff: "constant" | "linear" | "exponential";
+                maxDelay?: string | number | undefined;
+                jitter?: number | undefined;
+            } | undefined;
+            script?: string | undefined;
+            condition?: string | undefined;
+            gate?: string | undefined;
+        }[];
+        name: string;
+        condition?: string | undefined;
+    }[];
+    name: string;
+    version?: string | undefined;
+    env?: Record<string, string> | undefined;
+    timeout?: number | undefined;
+    inputs?: {
+        name: string;
+        required: boolean;
+        type?: "string" | "number" | "boolean" | "object" | "array" | undefined;
+        description?: string | undefined;
+        default?: unknown;
+    }[] | undefined;
+    description?: string | undefined;
+    retry?: {
+        maxAttempts: number;
+        delay: string | number;
+        backoff: "constant" | "linear" | "exponential";
+        maxDelay?: string | number | undefined;
+        jitter?: number | undefined;
+    } | undefined;
+}, {
+    phases: {
+        steps: {
+            name: string;
+            env?: Record<string, string> | undefined;
+            timeout?: number | undefined;
+            command?: string | undefined;
+            with?: Record<string, unknown> | undefined;
+            uses?: string | undefined;
+            action?: string | undefined;
+            retry?: {
+                maxAttempts?: number | undefined;
+                delay?: string | number | undefined;
+                backoff?: "constant" | "linear" | "exponential" | undefined;
+                maxDelay?: string | number | undefined;
+                jitter?: number | undefined;
+            } | undefined;
+            script?: string | undefined;
+            continueOnError?: boolean | undefined;
+            condition?: string | undefined;
+            gate?: string | undefined;
+        }[];
+        name: string;
+        condition?: string | undefined;
+    }[];
+    name: string;
+    version?: string | undefined;
+    env?: Record<string, string> | undefined;
+    timeout?: number | undefined;
+    inputs?: {
+        name: string;
+        type?: "string" | "number" | "boolean" | "object" | "array" | undefined;
+        description?: string | undefined;
+        default?: unknown;
+        required?: boolean | undefined;
+    }[] | undefined;
+    description?: string | undefined;
+    retry?: {
+        maxAttempts?: number | undefined;
+        delay?: string | number | undefined;
+        backoff?: "constant" | "linear" | "exponential" | undefined;
+        maxDelay?: string | number | undefined;
+        jitter?: number | undefined;
+    } | undefined;
+}>;
+export type InputDefinitionParsed = z.infer<typeof InputDefinitionSchema>;
+export type RetryConfigParsed = z.infer<typeof RetryConfigSchema>;
+export type StepDefinitionParsed = z.infer<typeof StepDefinitionSchema>;
+export type PhaseDefinitionParsed = z.infer<typeof PhaseDefinitionSchema>;
+export type WorkflowDefinitionParsed = z.infer<typeof WorkflowDefinitionSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/loader/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/loader/schema.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;EAMhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;EAM5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASnC,CAAC;AAGH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAC1E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAClE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACxE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAC1E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/loader/schema.js

@@ -0,0 +1,63 @@
+/**
+ * Zod validation schemas for workflow definitions.
+ */
+import { z } from 'zod';
+/**
+ * Input definition schema
+ */
+export const InputDefinitionSchema = z.object({
+    name: z.string().min(1),
+    description: z.string().optional(),
+    default: z.unknown().optional(),
+    required: z.boolean().optional().default(false),
+    type: z.enum(['string', 'number', 'boolean', 'object', 'array']).optional(),
+});
+/**
+ * Retry configuration schema
+ */
+export const RetryConfigSchema = z.object({
+    maxAttempts: z.number().int().min(1).default(1),
+    delay: z.union([z.number(), z.string()]).default(1000),
+    backoff: z.enum(['constant', 'linear', 'exponential']).default('exponential'),
+    maxDelay: z.union([z.number(), z.string()]).optional(),
+    jitter: z.number().min(0).max(1).optional(),
+});
+/**
+ * Step definition schema
+ */
+export const StepDefinitionSchema = z.object({
+    name: z.string().min(1),
+    action: z.string().optional().default('shell'),
+    uses: z.string().optional(),
+    with: z.record(z.unknown()).optional(),
+    command: z.string().optional(),
+    script: z.string().optional(),
+    timeout: z.number().optional(),
+    continueOnError: z.boolean().optional().default(false),
+    condition: z.string().optional(),
+    env: z.record(z.string()).optional(),
+    retry: RetryConfigSchema.optional(),
+    gate: z.string().optional(),
+});
+/**
+ * Phase definition schema
+ */
+export const PhaseDefinitionSchema = z.object({
+    name: z.string().min(1),
+    steps: z.array(StepDefinitionSchema).min(1),
+    condition: z.string().optional(),
+});
+/**
+ * Workflow definition schema
+ */
+export const WorkflowDefinitionSchema = z.object({
+    name: z.string().min(1),
+    description: z.string().optional(),
+    version: z.string().optional(),
+    inputs: z.array(InputDefinitionSchema).optional(),
+    phases: z.array(PhaseDefinitionSchema).min(1),
+    env: z.record(z.string()).optional(),
+    timeout: z.number().optional(),
+    retry: RetryConfigSchema.optional(),
+});
+//# sourceMappingURL=schema.js.map

package/dist/loader/schema.js.map

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

package/dist/loader/validator.d.ts

@@ -0,0 +1,33 @@
+import type { WorkflowDefinition } from '../types/workflow.js';
+/**
+ * Validation error with detailed information
+ */
+export declare class WorkflowValidationError extends Error {
+    readonly issues: Array<{
+        path: string;
+        message: string;
+        code: string;
+    }>;
+    constructor(message: string, issues: Array<{
+        path: string;
+        message: string;
+        code: string;
+    }>);
+}
+/**
+ * Validate a workflow definition object
+ * @param data Raw workflow data (parsed from YAML)
+ * @returns Validated WorkflowDefinition
+ * @throws WorkflowValidationError if validation fails
+ */
+export declare function validateWorkflow(data: unknown): WorkflowDefinition;
+/**
+ * Check if a workflow definition is valid without throwing
+ * @param data Raw workflow data
+ * @returns Object with valid flag and optional error
+ */
+export declare function isValidWorkflow(data: unknown): {
+    valid: boolean;
+    error?: WorkflowValidationError;
+};
+//# sourceMappingURL=validator.d.ts.map

package/dist/loader/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../src/loader/validator.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,SAAgB,MAAM,EAAE,KAAK,CAAC;QAC5B,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC,CAAC;gBAES,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CAK5F;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,kBAAkB,CAkElE;AA+BD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,uBAAuB,CAAA;CAAE,CAgBlG"}