@onlineapps/cookbook-core 2.1.5 → 2.1.7

package/package.json

@@ -1,11 +1,9 @@
 {
   "name": "@onlineapps/cookbook-core",
-  "version": "2.1.5",
+  "version": "2.1.7",
   "description": "Core cookbook parsing and validation - lightweight foundation for workflow definitions",
   "main": "src/index.js",
   "scripts": {
-    "prepublishOnly": "../../../scripts/pre-publish-compatibility-check.sh",
-    "postpublish": "../../../scripts/update-manifest-from-npm.sh && ../../../scripts/update-all-services.sh",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",

package/schemas/cookbook.schema.json

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

package/schemas/cookbook.v2.schema.json

@@ -0,0 +1,728 @@
+{
+  "$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"
+        ]
+      }
+    }
+  }
+}

package/src/parser/cookbookValidatorV2.js

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