@onlineapps/cookbook-core 2.1.7 → 2.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/cookbook-core",
-  "version": "2.1.7",
+  "version": "2.1.8",
   "description": "Core cookbook parsing and validation - lightweight foundation for workflow definitions",
   "main": "src/index.js",
   "scripts": {

package/schemas/cookbook.schema.json

@@ -1,5 +1,6 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
+  "$comment": "COOKBOOK V2 FORMAT - V1 IS BANNED! steps MUST be object keyed by step_id, NOT array!",
   "type": "object",
   "required": ["steps", "version"],
   "additionalProperties": true,
@@ -10,8 +11,8 @@
     },
     "version": {
       "type": "string",
-      "pattern": "^\\d+\\.\\d+\\.\\d+$",
-      "description": "Semantic version of the cookbook schema"
+      "pattern": "^2\\.\\d+\\.\\d+$",
+      "description": "Semantic version - MUST be 2.x.x (V1 is banned)"
     },
     "description": {
       "type": "string"
@@ -34,50 +35,25 @@
     },
     "metadata": {
       "type": "object",
-      "properties": {
-        "tags": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        },
-        "priority": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 10
-        },
-        "deprecated": {
-          "type": "boolean"
-        },
-        "deprecationMessage": {
-          "type": "string"
-        },
-        "author": {
-          "type": "string"
-        },
-        "created": {
-          "type": "string",
-          "format": "date-time"
-        },
-        "modified": {
-          "type": "string",
-          "format": "date-time"
-        }
-      },
       "additionalProperties": true
     },
     "steps": {
-      "type": "array",
-      "minItems": 1,
-      "items": {
+      "type": "object",
+      "minProperties": 1,
+      "additionalProperties": {
         "$ref": "#/definitions/Step"
-      }
+      },
+      "description": "V2: Object keyed by step_id (NOT array!)"
+    },
+    "delivery": {
+      "type": "object",
+      "description": "Delivery configuration for workflow results"
     }
   },
   "definitions": {
     "Step": {
       "type": "object",
-      "required": ["id", "type"],
+      "required": ["step_id", "type"],
       "oneOf": [
         { "$ref": "#/definitions/TaskStep" },
         { "$ref": "#/definitions/ForeachStep" },
@@ -90,12 +66,14 @@
     },
     "TaskStep": {
       "type": "object",
-      "required": ["id", "type", "service"],
+      "required": ["step_id", "type", "service"],
       "additionalProperties": true,
       "properties": {
-        "id": {
+        "step_id": {
           "type": "string",
-          "minLength": 1
+          "minLength": 1,
+          "pattern": "^[a-zA-Z0-9_]+$",
+          "description": "V2: step_id (snake_case, must match object key)"
         },
         "type": {
           "type": "string",
@@ -109,14 +87,6 @@
           "type": "string",
           "minLength": 1
         },
-        "action": {
-          "type": "string",
-          "enum": ["GET", "POST", "PUT", "DELETE", "PATCH"]
-        },
-        "endpoint": {
-          "type": "string",
-          "minLength": 1
-        },
         "operation": {
           "type": "string",
           "minLength": 1,
@@ -124,20 +94,15 @@
         },
         "input": {
           "type": "object",
-          "additionalProperties": true,
-          "description": "Optional input mapping - supports all JSON types"
+          "additionalProperties": true
         },
         "output": {
           "type": "object",
-          "additionalProperties": true,
-          "description": "Optional output mapping - supports all JSON types"
+          "additionalProperties": true
         },
         "depends_on": {
           "type": "array",
-          "items": {
-            "type": "string",
-            "minLength": 1
-          }
+          "items": { "type": "string" }
         },
         "retry": {
           "$ref": "#/definitions/Retry"
@@ -150,130 +115,91 @@
           "$ref": "#/definitions/ErrorHandler"
         },
         "condition": {
-          "type": "string",
-          "description": "JSONPath expression that must evaluate to true for step to execute"
+          "type": "string"
+        },
+        "expect": {
+          "type": "object",
+          "description": "Expected output for testing"
         }
-      },
-      "condition": {
-        "type": "string",
-        "description": "JSONPath expression for conditional execution"
-      },
-      "timeoutMs": {
-        "type": "integer",
-        "minimum": 1,
-        "description": "Timeout for entire foreach loop"
-      },
-      "on_error": {
-        "$ref": "#/definitions/ErrorHandler"
       }
     },
     "ForeachStep": {
       "type": "object",
-      "required": ["id", "type", "iterator", "body"],
+      "required": ["step_id", "type", "iterator", "body"],
       "additionalProperties": true,
       "properties": {
-        "id": {
+        "step_id": {
           "type": "string",
-          "minLength": 1
+          "minLength": 1,
+          "pattern": "^[a-zA-Z0-9_]+$"
         },
         "type": {
           "type": "string",
           "const": "foreach"
         },
-        "name": {
-          "type": "string",
-          "minLength": 1
-        },
         "iterator": {
           "type": "string",
           "minLength": 1
         },
         "body": {
-          "type": "array",
-          "minItems": 1,
-          "items": {
+          "type": "object",
+          "minProperties": 1,
+          "additionalProperties": {
             "$ref": "#/definitions/Step"
           }
-        },
-        "output": {
-          "type": "object",
-          "additionalProperties": true,
-          "description": "Optional output collection mapping"
         }
       }
     },
     "ForkJoinStep": {
       "type": "object",
-      "required": ["id", "type", "branches", "join"],
+      "required": ["step_id", "type", "branches", "join"],
       "additionalProperties": true,
       "properties": {
-        "id": {
+        "step_id": {
           "type": "string",
-          "minLength": 1
+          "minLength": 1,
+          "pattern": "^[a-zA-Z0-9_]+$"
         },
         "type": {
           "type": "string",
           "const": "fork_join"
         },
-        "name": {
-          "type": "string",
-          "minLength": 1
-        },
         "branches": {
-          "type": "array",
-          "minItems": 1,
-          "items": {
+          "type": "object",
+          "minProperties": 1,
+          "additionalProperties": {
             "$ref": "#/definitions/Step"
           }
         },
         "join": {
           "type": "object",
           "required": ["strategy"],
-          "additionalProperties": false,
           "properties": {
             "strategy": {
               "type": "string",
-              "enum": ["merge", "first", "last", "all", "custom"],
-              "description": "How to combine branch results"
+              "enum": ["merge", "first", "last", "all", "custom"]
             },
             "output": {
-              "type": "object",
-              "additionalProperties": true,
-              "description": "Optional output mapping for joined results"
+              "type": "object"
             }
           }
         }
-      },
-      "condition": {
-        "type": "string",
-        "description": "JSONPath expression for conditional execution"
-      },
-      "timeoutMs": {
-        "type": "integer",
-        "minimum": 1,
-        "description": "Timeout for all branches"
-      },
-      "on_error": {
-        "$ref": "#/definitions/ErrorHandler"
       }
     },
     "SwitchStep": {
       "type": "object",
-      "required": ["id", "type", "expression", "cases", "default"],
+      "required": ["step_id", "type", "expression", "cases"],
       "additionalProperties": true,
       "properties": {
-        "id": {
+        "step_id": {
           "type": "string",
-          "minLength": 1
+          "minLength": 1,
+          "pattern": "^[a-zA-Z0-9_]+$"
         },
         "type": {
           "type": "string",
           "const": "switch"
         },
-        "name": {
-          "type": "string",
-          "minLength": 1
-        },
         "expression": {
           "type": "string",
           "minLength": 1
@@ -287,138 +213,82 @@
         },
         "default": {
           "$ref": "#/definitions/Step"
-        },
-        "depends_on": {
-          "type": "array",
-          "items": {
-            "type": "string",
-            "minLength": 1
-          }
-        },
-        "condition": {
-          "type": "string",
-          "description": "JSONPath expression for conditional execution"
-        },
-        "on_error": {
-          "$ref": "#/definitions/ErrorHandler"
         }
       }
     },
     "SubWorkflowStep": {
       "type": "object",
-      "required": ["id", "type", "steps"],
+      "required": ["step_id", "type", "steps"],
       "additionalProperties": true,
       "properties": {
-        "id": {
+        "step_id": {
           "type": "string",
-          "minLength": 1
+          "minLength": 1,
+          "pattern": "^[a-zA-Z0-9_]+$"
         },
         "type": {
           "type": "string",
           "const": "sub_workflow"
         },
-        "name": {
-          "type": "string",
-          "minLength": 1
-        },
         "input": {
-          "type": "object",
-          "additionalProperties": true,
-          "description": "Optional input for sub-workflow - supports all JSON types"
+          "type": "object"
         },
         "steps": {
-          "type": "array",
-          "minItems": 1,
-          "items": {
+          "type": "object",
+          "minProperties": 1,
+          "additionalProperties": {
             "$ref": "#/definitions/Step"
           }
-        },
-        "condition": {
-          "type": "string",
-          "description": "JSONPath expression for conditional execution"
-        },
-        "timeoutMs": {
-          "type": "integer",
-          "minimum": 1,
-          "description": "Timeout for entire sub-workflow"
-        },
-        "on_error": {
-          "$ref": "#/definitions/ErrorHandler"
         }
       }
     },
     "WaitStep": {
       "type": "object",
-      "required": ["id", "type", "durationMs"],
+      "required": ["step_id", "type", "durationMs"],
       "additionalProperties": true,
       "properties": {
-        "id": {
+        "step_id": {
           "type": "string",
-          "minLength": 1
+          "minLength": 1,
+          "pattern": "^[a-zA-Z0-9_]+$"
         },
         "type": {
           "type": "string",
           "const": "wait"
         },
-        "name": {
-          "type": "string",
-          "minLength": 1
-        },
         "durationMs": {
           "type": "integer",
           "minimum": 0
-        },
-        "condition": {
-          "type": "string",
-          "description": "JSONPath expression for conditional execution"
         }
       }
     },
     "DispatchStep": {
       "type": "object",
-      "required": ["id", "type", "method", "target"],
+      "required": ["step_id", "type", "method", "target"],
       "additionalProperties": true,
       "properties": {
-        "id": {
+        "step_id": {
           "type": "string",
-          "minLength": 1
+          "minLength": 1,
+          "pattern": "^[a-zA-Z0-9_]+$"
         },
         "type": {
           "type": "string",
           "const": "dispatch"
         },
-        "name": {
-          "type": "string",
-          "minLength": 1
-        },
         "method": {
           "type": "string",
-          "enum": ["webhook", "http", "grpc", "kafka", "sqs", "custom"],
-          "description": "Dispatch method to use"
+          "enum": ["webhook", "http", "grpc", "kafka", "sqs", "custom"]
         },
         "target": {
           "type": "string",
           "format": "uri"
         },
         "input": {
-          "type": "object",
-          "additionalProperties": true,
-          "description": "Optional dispatch payload - supports all JSON types"
+          "type": "object"
         },
         "retry": {
           "$ref": "#/definitions/Retry"
-        },
-        "condition": {
-          "type": "string",
-          "description": "JSONPath expression for conditional execution"
-        },
-        "timeoutMs": {
-          "type": "integer",
-          "minimum": 1,
-          "description": "Timeout for dispatch operation"
-        },
-        "on_error": {
-          "$ref": "#/definitions/ErrorHandler"
         }
       }
     },
@@ -438,45 +308,38 @@
         "backoffMultiplier": {
           "type": "number",
           "minimum": 1.0,
-          "maximum": 5.0,
-          "description": "Exponential backoff multiplier"
+          "maximum": 5.0
         }
       }
     },
     "ErrorHandler": {
       "type": "object",
+      "required": ["strategy"],
       "additionalProperties": false,
       "properties": {
         "strategy": {
           "type": "string",
-          "enum": ["retry", "fail", "continue", "compensate", "fallback"],
-          "description": "How to handle errors"
+          "enum": ["retry", "fail", "continue", "compensate", "fallback"]
         },
         "retries": {
           "type": "integer",
           "minimum": 0,
-          "maximum": 10,
-          "description": "Number of retries before applying strategy"
+          "maximum": 10
         },
         "retryDelayMs": {
           "type": "integer",
-          "minimum": 0,
-          "description": "Delay between retries"
+          "minimum": 0
         },
         "fallbackStep": {
-          "type": "string",
-          "description": "Step ID to execute as fallback"
+          "type": "string"
         },
         "compensationStep": {
-          "type": "string",
-          "description": "Step ID to execute for compensation/rollback"
+          "type": "string"
         },
         "errorOutput": {
-          "type": "string",
-          "description": "JSONPath to store error details"
+          "type": "string"
         }
-      },
-      "required": ["strategy"]
+      }
     }
   }
-}
+}

package/src/parser/cookbookValidatorV2.js

@@ -29,19 +29,18 @@ class CookbookValidationError extends Error {
 }
 
 /**
- * Load schema file with version detection
+ * Load V2 schema - V1 IS BANNED, only one schema exists
  */
 function loadSchema(version = '2.0') {
-  const schemaMap = {
-    '1.0': 'cookbook.schema.json',       // Legacy v1.0 schema
-    '2.0': 'cookbook.v2.schema.json'     // New v2.0 schema with snake_case
-  };
+  // V1 is BANNED - reject immediately
+  if (version.startsWith('1.')) {
+    throw new CookbookValidationError('V1 FORMAT BANNED! Use version 2.x.x');
+  }
 
-  const filename = schemaMap[version.split('.')[0] + '.0'] || schemaMap['2.0'];
-  const schemaPath = path.join(__dirname, '../../schemas', filename);
+  const schemaPath = path.join(__dirname, '../../schemas/cookbook.schema.json');
 
   if (!fs.existsSync(schemaPath)) {
-    throw new CookbookValidationError(`Schema file not found: ${filename}`);
+    throw new CookbookValidationError('Schema file not found: cookbook.schema.json');
   }
 
   return JSON.parse(fs.readFileSync(schemaPath, 'utf-8'));
@@ -249,53 +248,48 @@ function validateSemantics(cookbook, version) {
       stepIds.add(stepId);
     }
 
-    // Check nested steps
-    if (step.steps) {
-      step.steps.forEach((nested, idx) =>
-        checkStep(nested, `${path}.steps[${idx}]`)
+    // Check nested steps - V2: all nested steps are objects keyed by step_id
+    if (step.steps && typeof step.steps === 'object') {
+      Object.entries(step.steps).forEach(([nestedKey, nested]) =>
+        checkStep(nested, `${path}.steps.${nestedKey}`)
       );
     }
-    if (step.body) {
-      step.body.forEach((nested, idx) =>
-        checkStep(nested, `${path}.body[${idx}]`)
+    if (step.body && typeof step.body === 'object') {
+      Object.entries(step.body).forEach(([nestedKey, nested]) =>
+        checkStep(nested, `${path}.body.${nestedKey}`)
       );
     }
-    if (step.branches) {
-      step.branches.forEach((branch, idx) => {
-        if (branch.steps) {
-          branch.steps.forEach((nested, jdx) =>
-            checkStep(nested, `${path}.branches[${idx}].steps[${jdx}]`)
-          );
-        }
+    if (step.branches && typeof step.branches === 'object') {
+      Object.entries(step.branches).forEach(([branchKey, branch]) => {
+        checkStep(branch, `${path}.branches.${branchKey}`);
       });
     }
     if (step.cases) {
       Object.keys(step.cases).forEach(caseKey => {
         const caseVal = step.cases[caseKey];
-        if (caseVal.steps) {
-          caseVal.steps.forEach((nested, idx) =>
-            checkStep(nested, `${path}.cases.${caseKey}.steps[${idx}]`)
-          );
-        }
+        checkStep(caseVal, `${path}.cases.${caseKey}`);
       });
     }
   }
 
-  // Check all steps
+  // Check all steps - V2: steps is an OBJECT keyed by step_id, NOT an array
   if (cookbook.steps) {
-    cookbook.steps.forEach((step, idx) =>
-      checkStep(step, `steps[${idx}]`)
+    if (Array.isArray(cookbook.steps)) {
+      throw new CookbookValidationError('V1 FORMAT BANNED! steps must be an object keyed by step_id, not an array');
+    }
+    Object.entries(cookbook.steps).forEach(([stepKey, step]) =>
+      checkStep(step, `steps.${stepKey}`)
     );
   }
 
   // Check dependencies exist
   if (version === '2.0' && cookbook.steps) {
-    cookbook.steps.forEach((step, idx) => {
+    Object.entries(cookbook.steps).forEach(([stepKey, step]) => {
       if (step.depends_on) {
         step.depends_on.forEach(dep => {
           if (!stepIds.has(dep)) {
             throw new CookbookValidationError(
-              `Step ${idx} depends on non-existent step_id '${dep}'`
+              `Step '${stepKey}' depends on non-existent step_id '${dep}'`
             );
           }
         });

package/schemas/cookbook.v2.schema.json

@@ -1,728 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "https://onlineapps.com/schemas/cookbook/v2.1.0/cookbook.schema.json",
-  "title": "Cookbook Workflow Schema v2.1",
-  "description": "Schema for defining workflow orchestration with snake_case convention",
-  "type": "object",
-  "required": ["version", "steps"],
-  "additionalProperties": false,
-  "properties": {
-    "version": {
-      "type": "string",
-      "pattern": "^2\\.\\d+\\.\\d+$",
-      "description": "Schema version (must start with 2.x.x)"
-    },
-    "name": {
-      "type": "string",
-      "description": "Human-readable workflow name"
-    },
-    "description": {
-      "type": "string",
-      "description": "Workflow description"
-    },
-    "config": {
-      "$ref": "#/definitions/Config",
-      "description": "Global configuration and defaults"
-    },
-    "api_input": {
-      "type": "object",
-      "description": "Expected input parameters for the workflow",
-      "additionalProperties": true
-    },
-    "steps": {
-      "type": "array",
-      "minItems": 1,
-      "items": {
-        "$ref": "#/definitions/Step"
-      },
-      "description": "Array of workflow steps"
-    },
-    "delivery": {
-      "$ref": "#/definitions/DeliveryConfig",
-      "description": "Delivery strategy and destinations for workflow output"
-    }
-  },
-  "definitions": {
-    "Config": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "default_timeout_ms": {
-          "type": "integer",
-          "minimum": 1,
-          "description": "Default timeout for all steps in milliseconds"
-        },
-        "default_retry": {
-          "$ref": "#/definitions/RetryConfig",
-          "description": "Default retry configuration for all steps"
-        }
-      }
-    },
-    "Step": {
-      "type": "object",
-      "required": ["step_id", "type"],
-      "oneOf": [
-        { "$ref": "#/definitions/TaskStep" },
-        { "$ref": "#/definitions/ForeachStep" },
-        { "$ref": "#/definitions/ForkJoinStep" },
-        { "$ref": "#/definitions/SwitchStep" },
-        { "$ref": "#/definitions/SubWorkflowStep" },
-        { "$ref": "#/definitions/WaitStep" },
-        { "$ref": "#/definitions/DispatchStep" }
-      ]
-    },
-    "TaskStep": {
-      "type": "object",
-      "required": ["step_id", "type", "service", "operation"],
-      "additionalProperties": false,
-      "properties": {
-        "step_id": {
-          "type": "string",
-          "pattern": "^[a-zA-Z0-9_]+$",
-          "description": "Unique identifier for the step"
-        },
-        "type": {
-          "const": "task",
-          "description": "Step type"
-        },
-        "name": {
-          "type": "string",
-          "description": "Human-readable step name"
-        },
-        "service": {
-          "type": "string",
-          "pattern": "^[a-z0-9-]+$",
-          "description": "Target microservice name"
-        },
-        "operation": {
-          "type": "string",
-          "description": "Operation ID from OpenAPI spec (required for task steps)"
-        },
-        "input": {
-          "type": "object",
-          "additionalProperties": true,
-          "description": "Input parameters for the operation"
-        },
-        "output": {
-          "type": "object",
-          "additionalProperties": true,
-          "description": "Output mapping to workflow context"
-        },
-        "timeout_ms": {
-          "type": "integer",
-          "minimum": 1,
-          "description": "Timeout in milliseconds (overrides default)"
-        },
-        "retry": {
-          "$ref": "#/definitions/RetryConfig",
-          "description": "Retry configuration (overrides default)"
-        },
-        "on_error": {
-          "$ref": "#/definitions/ErrorHandler",
-          "description": "Error handling configuration"
-        },
-        "compensate": {
-          "$ref": "#/definitions/CompensationStep",
-          "description": "Rollback/compensation configuration"
-        },
-        "depends_on": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "description": "Array of step_ids this step depends on"
-        }
-      }
-    },
-    "ForeachStep": {
-      "type": "object",
-      "required": ["step_id", "type", "iterator", "steps"],
-      "additionalProperties": false,
-      "properties": {
-        "step_id": {
-          "type": "string",
-          "pattern": "^[a-zA-Z0-9_]+$"
-        },
-        "type": {
-          "const": "foreach"
-        },
-        "name": {
-          "type": "string"
-        },
-        "iterator": {
-          "type": "string",
-          "pattern": "^\\$\\{.+\\}$",
-          "description": "Reference to array to iterate over"
-        },
-        "steps": {
-          "type": "array",
-          "minItems": 1,
-          "items": {
-            "$ref": "#/definitions/Step"
-          },
-          "description": "Steps to execute for each item"
-        },
-        "output": {
-          "type": "object",
-          "additionalProperties": true,
-          "description": "How to aggregate results"
-        },
-        "max_concurrency": {
-          "type": "integer",
-          "minimum": 1,
-          "description": "Maximum parallel executions"
-        },
-        "on_error": {
-          "$ref": "#/definitions/ErrorHandler"
-        },
-        "depends_on": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        }
-      }
-    },
-    "ForkJoinStep": {
-      "type": "object",
-      "required": ["step_id", "type", "branches", "join"],
-      "additionalProperties": false,
-      "properties": {
-        "step_id": {
-          "type": "string",
-          "pattern": "^[a-zA-Z0-9_]+$"
-        },
-        "type": {
-          "const": "fork_join"
-        },
-        "name": {
-          "type": "string"
-        },
-        "branches": {
-          "type": "array",
-          "minItems": 2,
-          "items": {
-            "type": "object",
-            "required": ["branch_id", "steps"],
-            "properties": {
-              "branch_id": {
-                "type": "string"
-              },
-              "steps": {
-                "type": "array",
-                "minItems": 1,
-                "items": {
-                  "$ref": "#/definitions/Step"
-                }
-              }
-            }
-          },
-          "description": "Parallel branches to execute"
-        },
-        "join": {
-          "type": "object",
-          "required": ["strategy"],
-          "properties": {
-            "strategy": {
-              "enum": ["all", "first", "race", "merge"],
-              "description": "How to join branch results"
-            },
-            "timeout_ms": {
-              "type": "integer",
-              "minimum": 1
-            }
-          }
-        },
-        "output": {
-          "type": "object",
-          "additionalProperties": true
-        },
-        "on_error": {
-          "$ref": "#/definitions/ErrorHandler"
-        },
-        "depends_on": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        }
-      }
-    },
-    "SwitchStep": {
-      "type": "object",
-      "required": ["step_id", "type", "expression", "cases", "default"],
-      "additionalProperties": false,
-      "properties": {
-        "step_id": {
-          "type": "string",
-          "pattern": "^[a-zA-Z0-9_]+$"
-        },
-        "type": {
-          "const": "switch"
-        },
-        "name": {
-          "type": "string"
-        },
-        "expression": {
-          "type": "string",
-          "pattern": "^\\$\\{.+\\}$",
-          "description": "Expression to evaluate for switch"
-        },
-        "cases": {
-          "type": "object",
-          "additionalProperties": {
-            "type": "object",
-            "required": ["steps"],
-            "properties": {
-              "steps": {
-                "type": "array",
-                "minItems": 1,
-                "items": {
-                  "$ref": "#/definitions/Step"
-                }
-              }
-            }
-          },
-          "description": "Case branches"
-        },
-        "default": {
-          "type": "object",
-          "required": ["steps"],
-          "properties": {
-            "steps": {
-              "type": "array",
-              "minItems": 1,
-              "items": {
-                "$ref": "#/definitions/Step"
-              }
-            }
-          },
-          "description": "Default branch (required)"
-        },
-        "on_error": {
-          "$ref": "#/definitions/ErrorHandler"
-        },
-        "depends_on": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        }
-      }
-    },
-    "SubWorkflowStep": {
-      "type": "object",
-      "required": ["step_id", "type", "workflow_id"],
-      "additionalProperties": false,
-      "properties": {
-        "step_id": {
-          "type": "string",
-          "pattern": "^[a-zA-Z0-9_]+$"
-        },
-        "type": {
-          "const": "sub_workflow"
-        },
-        "name": {
-          "type": "string"
-        },
-        "workflow_id": {
-          "type": "string",
-          "description": "ID of workflow to execute"
-        },
-        "parameters": {
-          "type": "object",
-          "additionalProperties": true,
-          "description": "Parameters to pass to sub-workflow"
-        },
-        "output": {
-          "type": "object",
-          "additionalProperties": true
-        },
-        "timeout_ms": {
-          "type": "integer",
-          "minimum": 1
-        },
-        "on_error": {
-          "$ref": "#/definitions/ErrorHandler"
-        },
-        "depends_on": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        }
-      }
-    },
-    "WaitStep": {
-      "type": "object",
-      "required": ["step_id", "type", "duration_ms"],
-      "additionalProperties": false,
-      "properties": {
-        "step_id": {
-          "type": "string",
-          "pattern": "^[a-zA-Z0-9_]+$"
-        },
-        "type": {
-          "const": "wait"
-        },
-        "name": {
-          "type": "string"
-        },
-        "duration_ms": {
-          "type": "integer",
-          "minimum": 1,
-          "description": "Wait duration in milliseconds"
-        },
-        "message": {
-          "type": "string",
-          "description": "Optional message explaining the wait"
-        },
-        "depends_on": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        }
-      }
-    },
-    "DispatchStep": {
-      "type": "object",
-      "required": ["step_id", "type", "method", "target"],
-      "additionalProperties": false,
-      "properties": {
-        "step_id": {
-          "type": "string",
-          "pattern": "^[a-zA-Z0-9_]+$"
-        },
-        "type": {
-          "const": "dispatch"
-        },
-        "name": {
-          "type": "string"
-        },
-        "method": {
-          "enum": ["webhook", "http", "grpc", "kafka", "sqs"],
-          "description": "Dispatch method"
-        },
-        "target": {
-          "type": "string",
-          "description": "Target URL or address"
-        },
-        "input": {
-          "type": "object",
-          "additionalProperties": true
-        },
-        "headers": {
-          "type": "object",
-          "additionalProperties": {
-            "type": "string"
-          }
-        },
-        "timeout_ms": {
-          "type": "integer",
-          "minimum": 1
-        },
-        "retry": {
-          "$ref": "#/definitions/RetryConfig"
-        },
-        "on_error": {
-          "$ref": "#/definitions/ErrorHandler"
-        },
-        "depends_on": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        }
-      }
-    },
-    "RetryConfig": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "max_attempts": {
-          "type": "integer",
-          "minimum": 1,
-          "description": "Maximum retry attempts"
-        },
-        "delay_ms": {
-          "type": "integer",
-          "minimum": 0,
-          "description": "Delay between retries in milliseconds"
-        },
-        "backoff": {
-          "enum": ["linear", "exponential"],
-          "description": "Backoff strategy"
-        },
-        "max_delay_ms": {
-          "type": "integer",
-          "minimum": 1,
-          "description": "Maximum delay for exponential backoff"
-        }
-      }
-    },
-    "ErrorHandler": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "strategy": {
-          "enum": ["retry", "fail", "continue", "compensate"],
-          "description": "Error handling strategy"
-        },
-        "retry": {
-          "$ref": "#/definitions/RetryConfig"
-        },
-        "catch": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "required": ["error_type", "handler_step"],
-            "properties": {
-              "error_type": {
-                "type": "string",
-                "description": "Type of error to catch"
-              },
-              "handler_step": {
-                "type": "string",
-                "description": "Step to execute on this error"
-              }
-            }
-          },
-          "description": "Specific error handlers"
-        },
-        "finally": {
-          "type": "string",
-          "description": "Step to always execute"
-        }
-      }
-    },
-    "CompensationStep": {
-      "type": "object",
-      "required": ["step_id", "service", "operation"],
-      "additionalProperties": false,
-      "properties": {
-        "step_id": {
-          "type": "string",
-          "pattern": "^[a-zA-Z0-9_]+$",
-          "description": "ID for compensation step"
-        },
-        "service": {
-          "type": "string",
-          "pattern": "^[a-z0-9-]+$"
-        },
-        "operation": {
-          "type": "string"
-        },
-        "input": {
-          "type": "object",
-          "additionalProperties": true
-        }
-      }
-    },
-    "DeliveryConfig": {
-      "type": "object",
-      "required": ["handler"],
-      "additionalProperties": false,
-      "properties": {
-        "handler": {
-          "enum": ["dispatcher", "service_step", "none"],
-          "description": "Delivery handler selection"
-        },
-        "allow_skip": {
-          "type": "boolean",
-          "default": false,
-          "description": "Allow dispatcher to skip delivery without failing workflow"
-        },
-        "delivery_step": {
-          "type": "string",
-          "pattern": "^[a-zA-Z0-9_]+$",
-          "description": "Step ID that performs delivery when handler=service_step"
-        },
-        "destinations": {
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/DeliveryDestination"
-          },
-          "default": []
-        },
-        "output": {
-          "$ref": "#/definitions/DeliveryOutput"
-        }
-      },
-      "allOf": [
-        {
-          "if": {
-            "properties": {
-              "handler": { "const": "dispatcher" }
-            }
-          },
-          "then": {
-            "required": ["destinations", "output"],
-            "properties": {
-              "destinations": {
-                "minItems": 1
-              }
-            }
-          }
-        },
-        {
-          "if": {
-            "properties": {
-              "handler": { "const": "service_step" }
-            }
-          },
-          "then": {
-            "required": ["delivery_step", "output"]
-          }
-        }
-      ]
-    },
-    "DeliveryDestination": {
-      "type": "object",
-      "required": ["type"],
-      "properties": {
-        "type": {
-          "enum": ["webhook", "websocket", "public_url"],
-          "description": "Delivery channel type"
-        },
-        "name": {
-          "type": "string",
-          "pattern": "^[a-zA-Z0-9._-]+$",
-          "description": "Optional identifier for monitoring"
-        },
-        "enabled": {
-          "type": "boolean",
-          "default": true
-        },
-        "retry": {
-          "$ref": "#/definitions/RetryConfig"
-        }
-      },
-      "allOf": [
-        {
-          "if": {
-            "properties": {
-              "type": { "const": "webhook" }
-            }
-          },
-          "then": {
-            "$ref": "#/definitions/DeliveryWebhookOptions"
-          }
-        },
-        {
-          "if": {
-            "properties": {
-              "type": { "const": "websocket" }
-            }
-          },
-          "then": {
-            "$ref": "#/definitions/DeliveryWebsocketOptions"
-          }
-        },
-        {
-          "if": {
-            "properties": {
-              "type": { "const": "public_url" }
-            }
-          },
-          "then": {
-            "$ref": "#/definitions/DeliveryPublicUrlOptions"
-          }
-        }
-      ]
-    },
-    "DeliveryWebhookOptions": {
-      "type": "object",
-      "required": ["url", "method"],
-      "properties": {
-        "url": {
-          "type": "string",
-          "format": "uri",
-          "description": "Target webhook URL"
-        },
-        "method": {
-          "type": "string",
-          "enum": ["GET", "POST", "PUT", "PATCH", "DELETE"]
-        },
-        "headers": {
-          "type": "object",
-          "additionalProperties": {
-            "type": "string"
-          }
-        },
-        "body_template": {
-          "type": ["object", "array"],
-          "description": "Optional custom payload template"
-        },
-        "timeout_ms": {
-          "type": "integer",
-          "minimum": 100,
-          "description": "Request timeout"
-        }
-      }
-    },
-    "DeliveryWebsocketOptions": {
-      "type": "object",
-      "properties": {
-        "client_id": {
-          "type": "string",
-          "description": "Client session identifier"
-        },
-        "tenant_id": {
-          "type": "string",
-          "description": "Tenant/topic identifier"
-        },
-        "events": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        }
-      },
-      "anyOf": [
-        { "required": ["client_id"] },
-        { "required": ["tenant_id"] }
-      ]
-    },
-    "DeliveryPublicUrlOptions": {
-      "type": "object",
-      "required": ["path"],
-      "properties": {
-        "path": {
-          "type": "string",
-          "pattern": "^[a-zA-Z0-9._\\-/\\${}]+$",
-          "description": "Storage key / relative path"
-        },
-        "ttl_seconds": {
-          "type": "integer",
-          "minimum": 60,
-          "description": "Time to live for generated URL"
-        },
-        "access": {
-          "type": "string",
-          "enum": ["public", "signed"],
-          "default": "signed"
-        },
-        "max_downloads": {
-          "type": "integer",
-          "minimum": 1
-        }
-      }
-    },
-    "DeliveryOutput": {
-      "type": "object",
-      "propertyNames": {
-        "pattern": "^[a-zA-Z0-9_]+$"
-      },
-      "additionalProperties": {
-        "type": [
-          "string",
-          "number",
-          "boolean",
-          "object",
-          "array"
-        ]
-      }
-    }
-  }
-}