// Anti-pattern: Single workflow doing everything
// Customer onboarding with 47 nodes, 12 branches, 8 error handlers
// Result: Impossible to test, debug, or modify without breaking something

// Symptoms you've hit the ceiling:
// - Adding a new step requires scrolling through 5 screens
// - Changing one branch breaks three unrelated branches
// - Onboarding new developers takes 3+ weeks
// - "Don't touch that workflow, it works somehow"

// Workflow A modifies data that Workflow B depends on
// Workflow C calls Workflow D which updates the same records
// Workflow E fails silently because Workflow F changed its output format

// Result: Changes require understanding the entire system
// Risk: Any modification can cascade unpredictably
// Reality: Development velocity grinds to a halt

// How do you test a workflow with:
// - 15 external API dependencies
// - 8 different execution paths
// - State that persists across multiple executions
// - Time-based triggers with external conditions

// Answer: Most teams don't. They test in production.
// Consequence: 73% of production incidents are caused by untested changes

// Problem: You need to retry a failed operation with modified parameters
// DAG constraint: Can't loop back to the same node
// Workaround: Complex branching that duplicates logic

// Result: "Spaghetti workflows" where logic is duplicated
// across multiple branches to simulate iteration

// Each node has its own output data
// Passing state between nodes requires explicit wiring
// Complex workflows become "wiring diagrams" where data flow
// obscures business logic

// Example: A workflow with 20 nodes might have
// 60+ data connections, each requiring maintenance

// Business rule embedded in IF node expression:
{{ $json.order.total > 1000 && $json.customer.tier === 'premium' && $json.items.length > 5 && !$json.flags.rush_order }}

// Question: Where is "premium customer with large orders get free shipping" documented?
// Answer: It's not. It's buried in node configuration.
// Consequence: Business logic becomes tribal knowledge

// Good: Each workflow does ONE thing well
// Workflow: validate-customer-data
// Responsibility: Validate and normalize customer input
// Inputs: Raw customer data
// Outputs: Validated customer object or validation errors

// Bad: Workflow tries to do everything
// Workflow: customer-onboarding-complete
// Attempts: validation + CRM creation + email sending + 
//           Slack notification + analytics tracking + document generation
// Result: 47 nodes, impossible to test, changes are risky

// Contract for customer-validation workflow

// Input Schema:
{
  "customer": {
    "email": "string (required, valid email)",
    "name": "string (required, min 2 chars)",
    "company": "string (optional)",
    "phone": "string (optional, valid format)"
  },
  "context": {
    "source": "string (web|api|import)",
    "timestamp": "ISO 8601 datetime"
  }
}

// Output Schema (Success):
{
  "status": "valid",
  "customer": {
    "id": "generated-uuid",
    "email": "[email protected]",
    "name": "Normalized Name",
    // ... normalized fields
  },
  "validation": {
    "passed": ["email", "name"],
    "warnings": ["phone format adjusted"]
  }
}

// Output Schema (Failure):
{
  "status": "invalid",
  "errors": [
    { "field": "email", "code": "INVALID_FORMAT", "message": "..." }
  ],
  "suggestions": ["..."]
}

// Orchestrator workflow: customer-onboarding-orchestrator
// Does NOT contain business logic
// ONLY coordinates other workflows

// Step 1: Validate input
// Calls: workflow-validate-customer-data
// On success: proceed to step 2
// On failure: return validation errors

// Step 2: Check duplicates
// Calls: workflow-check-duplicate-customer
// On duplicate found: merge or alert
// On new customer: proceed to step 3

// Step 3: Create CRM record
// Calls: workflow-create-crm-record
// On success: proceed to step 4
// On failure: rollback, alert admin

// Step 4: Send welcome sequence
// Calls: workflow-trigger-welcome-email
// Async: don't wait for completion

// Step 5: Notify team
// Calls: workflow-send-slack-notification
// Async: fire and forget

// Each sub-workflow is independently testable
// Orchestrator logic is visible at a glance
// New steps can be added without touching existing code

// Parent Workflow: order-processing-orchestrator

// Node: Validate Order Input
// Type: Execute Workflow
// Workflow ID: validate-order-data
// Passes: {{ $json }}

// Node: Check Inventory
// Type: Execute Workflow  
// Workflow ID: check-inventory-availability
// Passes: {{ $json.order.items }}
// Waits for: Validation to complete

// Node: Calculate Shipping
// Type: Execute Workflow
// Workflow ID: calculate-shipping-rates
// Passes: {{ $json.order }}
// Waits for: Inventory check

// Node: Process Payment
// Type: Execute Workflow
// Workflow ID: process-payment-gateway
// Passes: {{ $json.order.total }}
// Waits for: Shipping calculation

// Node: Send Confirmations
// Type: Execute Workflow
// Workflow ID: send-order-confirmations
// Passes: {{ $json.order }}
// Async: true (don't wait)

// Calling workflow (parent):
// Set node before Execute Workflow:
{
  "orderId": "{{ $json.id }}",
  "customerEmail": "{{ $json.customer.email }}",
  "items": "{{ $json.items }}",
  "metadata": {
    "source": "web",
    "sessionId": "{{ $json.sessionId }}",
    "timestamp": "{{ $now }}"
  }
}

// Called workflow (child) receives this as input
// Access via: {{ $json.orderId }}, {{ $json.customerEmail }}, etc.

// Child workflow returns:
// Last node's output becomes parent's input for next node
// Or explicitly set with Code node:
return {
  json: {
    status: "success",
    processedAt: $now,
    result: processedData
  }
};

// Parent workflow error handling pattern:

// Node: Execute Workflow (process-payment)
// On Error: Continue
// Error Output → Node: Handle Payment Failure

// Handle Payment Failure node (Code):
const error = items[0].json.error;

// Determine failure type
if (error.message.includes('insufficient_funds')) {
  return {
    json: {
      action: 'send_payment_retry_email',
      priority: 'high',
      customer: $('Execute Workflow').item.json.customerEmail
    }
  };
} else if (error.message.includes('card_declined')) {
  return {
    json: {
      action: 'notify_customer_service',
      priority: 'urgent',
      reason: 'card_issue'
    }
  };
} else {
  return {
    json: {
      action: 'alert_technical_team',
      priority: 'critical',
      error: error.message
    }
  };
}

// Workflow: utility-format-phone-number
// Purpose: Normalize phone numbers to E.164 format
// Inputs: { "phone": "string", "country": "string (optional)" }
// Outputs: { "formatted": "string", "valid": "boolean" }

// Code node implementation:
const phoneUtil = require('google-libphonenumber').PhoneNumberUtil.getInstance();
const PNT = require('google-libphonenumber').PhoneNumberType;

const phone = $json.phone;
const country = $json.country || 'US';

try {
  const number = phoneUtil.parse(phone, country);
  const isValid = phoneUtil.isValidNumber(number);
  
  if (isValid) {
    return {
      json: {
        formatted: phoneUtil.format(number, PhoneNumberFormat.E164),
        valid: true,
        type: phoneUtil.getNumberType(number)
      }
    };
  }
} catch (e) {
  // Invalid number
}

return {
  json: {
    formatted: null,
    valid: false,
    error: 'Invalid phone number format'
  }
};

// Workflow: utility-error-handler
// Creates consistent error responses across all workflows

// Inputs: { "error": "Error object", "context": "..." }

// Code node:
const error = $json.error;
const context = $json.context;

const standardizedError = {
  error: {
    code: error.code || 'UNKNOWN_ERROR',
    message: error.message || 'An unexpected error occurred',
    timestamp: new Date().toISOString(),
    workflowId: $workflow.id,
    executionId: $execution.id,
    context: context
  },
  retryable: isRetryableError(error),
  nextSteps: suggestRecoveryActions(error)
};

function isRetryableError(err) {
  const retryableCodes = [
    'RATE_LIMITED',
    'TIMEOUT',
    'NETWORK_ERROR',
    'SERVICE_UNAVAILABLE'
  ];
  return retryableCodes.includes(err.code);
}

function suggestRecoveryActions(err) {
  // Return actionable next steps based on error type
  // ...
}

return { json: standardizedError };

// Instead of nested IF nodes, use structured decision tables

// Workflow: calculate-discount
// Uses: Code node with decision table

const decisionTable = [
  // Customer Tier, Order Value, Season, Discount %
  { tier: 'bronze',  minValue: 0,    maxValue: 100,  season: 'regular', discount: 0 },
  { tier: 'bronze',  minValue: 100,  maxValue: 500,  season: 'regular', discount: 5 },
  { tier: 'bronze',  minValue: 500,  maxValue: Infinity, season: 'regular', discount: 10 },
  { tier: 'silver',  minValue: 0,    maxValue: 100,  season: 'regular', discount: 5 },
  { tier: 'silver',  minValue: 100,  maxValue: 500,  season: 'regular', discount: 10 },
  { tier: 'silver',  minValue: 500,  maxValue: Infinity, season: 'regular', discount: 15 },
  { tier: 'gold',    minValue: 0,    maxValue: 100,  season: 'regular', discount: 10 },
  { tier: 'gold',    minValue: 100,  maxValue: 500,  season: 'regular', discount: 15 },
  { tier: 'gold',    minValue: 500,  maxValue: Infinity, season: 'regular', discount: 20 },
  { tier: 'any',     minValue: 1000, maxValue: Infinity, season: 'holiday', discount: 25 },
];

const order = $json.order;
const customer = $json.customer;

const applicableRules = decisionTable.filter(rule => {
  const tierMatch = rule.tier === 'any' || rule.tier === customer.tier;
  const valueMatch = order.total >= rule.minValue && order.total < rule.maxValue;
  const seasonMatch = rule.season === 'any' || rule.season === order.season;
  return tierMatch && valueMatch && seasonMatch;
});

// Apply highest discount
const maxDiscount = Math.max(...applicableRules.map(r => r.discount));

return {
  json: {
    originalTotal: order.total,
    discountPercent: maxDiscount,
    discountAmount: order.total * (maxDiscount / 100),
    finalTotal: order.total * (1 - maxDiscount / 100),
    appliedRules: applicableRules
  }
};

// For complex processes with multiple states and transitions
// Workflow: order-state-machine

const validTransitions = {
  'pending': ['confirmed', 'cancelled'],
  'confirmed': ['processing', 'cancelled'],
  'processing': ['shipped', 'backordered'],
  'shipped': ['delivered', 'lost'],
  'delivered': ['completed', 'returned'],
  'backordered': ['processing', 'cancelled'],
  'cancelled': [],
  'completed': [],
  'returned': ['refunded'],
  'refunded': [],
  'lost': ['refunded', 'replaced']
};

const stateActions = {
  'pending': {
    onEnter: ['validateInventory', 'checkFraud'],
    onExit: ['clearHold'],
    timeout: { hours: 24, action: 'autoCancel' }
  },
  'confirmed': {
    onEnter: ['reserveInventory', 'processPayment'],
    onExit: ['releaseInventoryIfFailed']
  },
  'processing': {
    onEnter: ['createPickingList', 'notifyWarehouse'],
    timeout: { hours: 48, action: 'escalate' }
  }
  // ... more states
};

// Current state and requested transition
const currentState = $json.currentState;
const requestedState = $json.requestedState;

// Validate transition
const allowed = validTransitions[currentState]?.includes(requestedState);

if (!allowed) {
  return {
    json: {
      success: false,
      error: `Invalid transition from ${currentState} to ${requestedState}`,
      validTransitions: validTransitions[currentState] || []
    }
  };
}

// Execute state actions
const actions = stateActions[requestedState]?.onEnter || [];

return {
  json: {
    success: true,
    previousState: currentState,
    newState: requestedState,
    actions: actions,
    timestamp: $now
  }
};

// Declarative business rules that non-developers can understand

const rules = [
  {
    name: 'High Value Order Alert',
    condition: (data) => data.order.total > 10000,
    action: 'notify_manager',
    priority: 1
  },
  {
    name: 'VIP Customer Fast Track',
    condition: (data) => data.customer.tier === 'vip' && data.order.items.length < 10,
    action: 'priority_processing',
    priority: 2
  },
  {
    name: 'International Order Check',
    condition: (data) => data.order.shipping.country !== 'US',
    action: 'customs_review',
    priority: 3
  },
  {
    name: 'Subscription Discount',
    condition: (data) => data.customer.subscriptionActive && data.order.type === 'subscription',
    action: 'apply_subscription_discount',
    priority: 4
  }
];

// Evaluate all rules
const orderData = $json;
const matchedRules = rules
  .filter(rule => rule.condition(orderData))
  .sort((a, b) => a.priority - b.priority);

// Execute actions in priority order
const actions = matchedRules.map(rule => ({
  action: rule.action,
  rule: rule.name,
  priority: rule.priority
}));

return {
  json: {
    orderId: orderData.order.id,
    matchedRules: matchedRules.length,
    actions: actions,
    requiresApproval: actions.some(a => ['notify_manager', 'customs_review'].includes(a.action))
  }
};

// Select processing strategy based on order characteristics

const strategies = {
  'digital': {
    processor: 'processDigitalOrder',
    fulfillment: 'immediateDelivery',
    payment: 'chargeImmediately'
  },
  'physical': {
    processor: 'processPhysicalOrder',
    fulfillment: 'warehousePicking',
    payment: 'chargeOnShip'
  },
  'subscription': {
    processor: 'processSubscription',
    fulfillment: 'scheduleRecurring',
    payment: 'setupRecurringBilling'
  },
  'mixed': {
    processor: 'processMixedOrder',
    fulfillment: 'splitFulfillment',
    payment: 'chargeInStages'
  }
};

function determineStrategy(order) {
  const hasDigital = order.items.some(i => i.type === 'digital');
  const hasPhysical = order.items.some(i => i.type === 'physical');
  const isSubscription = order.type === 'subscription';
  
  if (isSubscription) return 'subscription';
  if (hasDigital && hasPhysical) return 'mixed';
  if (hasDigital) return 'digital';
  return 'physical';
}

const order = $json.order;
const strategy = determineStrategy(order);
const config = strategies[strategy];

return {
  json: {
    orderId: order.id,
    strategy: strategy,
    config: config,
    // Output determines which sub-workflow to call
    nextWorkflow: `process-order-${strategy}`
  }
};

// Process order through multiple handlers until one handles it

const handlers = [
  {
    name: 'Fraud Check',
    canHandle: (order) => order.total > 5000 || order.flags?.risky,
    handle: (order) => ({ action: 'hold_for_review', reason: 'fraud_check' })
  },
  {
    name: 'Inventory Check',
    canHandle: (order) => order.items.some(i => i.stock < i.quantity),
    handle: (order) => ({ action: 'backorder', reason: 'insufficient_stock' })
  },
  {
    name: 'Customs Check',
    canHandle: (order) => order.shipping.country !== order.warehouse.country,
    handle: (order) => ({ action: 'customs_hold', reason: 'international_shipment' })
  },
  {
    name: 'Standard Processing',
    canHandle: () => true, // Default handler
    handle: (order) => ({ action: 'process_normally', reason: 'standard_flow' })
  }
];

const order = $json.order;

// Find first handler that can process this order
const handler = handlers.find(h => h.canHandle(order));
const result = handler.handle(order);

return {
  json: {
    orderId: order.id,
    handler: handler.name,
    result: result,
    canProceed: result.action !== 'hold_for_review'
  }
};

// Workflow: expense-approval-process

// Step 1: Receive expense submission
// Input: { expense: {...}, submitter: {...} }

// Step 2: Auto-approval for small amounts
// Code node:
const expense = $json.expense;
const autoApproveLimit = 100; // $100

if (expense.amount <= autoApproveLimit && expense.category !== 'travel') {
  return {
    json: {
      status: 'auto_approved',
      approvedAt: $now,
      approvedBy: 'system',
      nextStep: 'process_payment'
    }
  };
}

// Step 3: Route to appropriate approver based on amount
let approverLevel;
if (expense.amount <= 500) approverLevel = 'manager';
else if (expense.amount <= 2000) approverLevel = 'director';
else approverLevel = 'vp';

// Step 4: Create approval task in project management tool
// Using HTTP node to create task in Asana/Monday/etc.

// Step 5: Wait for approval (using Wait node)
// Webhook trigger for approval response

// Step 6: Process based on approval decision
// On approval: process_payment workflow
// On rejection: notify_submitter workflow

// Workflow: customer-support-triage

const ticket = $json.ticket;
const customer = $json.customer;

// Scoring system for auto vs manual handling
const riskScore = calculateRiskScore(ticket, customer);

function calculateRiskScore(ticket, customer) {
  let score = 0;
  
  // Urgency factors
  if (ticket.priority === 'urgent') score += 30;
  if (ticket.tags.includes('billing')) score += 20;
  if (ticket.tags.includes('security')) score += 40;
  
  // Customer factors
  if (customer.tier === 'enterprise') score += 25;
  if (customer.lifetimeValue > 50000) score += 15;
  
  // Content analysis
  if (ticket.sentiment === 'angry') score += 20;
  if (ticket.previousTickets > 3) score += 10;
  
  return score;
}

// Decision routing
if (riskScore < 30) {
  // Low risk: Automated response
  return {
    json: {
      action: 'auto_respond',
      template: 'standard_response',
      score: riskScore
    }
  };
} else if (riskScore < 60) {
  // Medium risk: Queue for human review within 4 hours
  return {
    json: {
      action: 'queue_for_agent',
      priority: 'normal',
      sla: '4_hours',
      score: riskScore
    }
  };
} else {
  // High risk: Immediate human attention
  return {
    json: {
      action: 'immediate_escalation',
      priority: 'critical',
      notify: ['support_manager', 'customer_success'],
      score: riskScore,
      reason: 'High-value customer or sensitive issue'
    }
  };
}

// Workflow: content-moderation-pipeline

const content = $json.content;

// Step 1: AI pre-screening
const aiScore = await callModerationAPI(content);

// Step 2: Routing based on confidence
if (aiScore.confidence > 0.95 && aiScore.category === 'safe') {
  // High confidence safe: Auto-approve
  return { json: { action: 'auto_approve', confidence: aiScore.confidence } };
} else if (aiScore.confidence > 0.9 && aiScore.category === 'violating') {
  // High confidence violation: Auto-reject
  return { json: { action: 'auto_reject', confidence: aiScore.confidence, reason: aiScore.reason } };
} else {
  // Uncertain: Queue for human review
  // Create review task with AI context
  const reviewTask = {
    contentId: content.id,
    aiPrediction: aiScore.category,
    aiConfidence: aiScore.confidence,
    flags: aiScore.flags,
    suggestedAction: aiScore.suggestedAction,
    reviewUrl: `https://moderation.example.com/review/${content.id}`,
    sla: '24_hours'
  };
  
  // Send to review queue (Redis, database, or task queue)
  await sendToReviewQueue(reviewTask);
  
  return {
    json: {
      action: 'queued_for_review',
      queuePosition: await getQueuePosition(),
      estimatedReviewTime: await getEstimatedTime(),
      contentId: content.id
    }
  };
}

// Workflow: send-approval-request

const request = $json.request;

// Build comprehensive context for approver
const approvalContext = {
  // What needs approval
  requestType: request.type,
  title: request.title,
  description: request.description,
  amount: request.amount,
  currency: request.currency,
  
  // Why it matters
  businessJustification: request.justification,
  expectedRoi: request.roi,
  riskLevel: request.risk,
  
  // Who is involved
  requester: {
    name: request.requester.name,
    department: request.requester.department,
    history: request.requester.approvalHistory
  },
  
  // Historical context
  similarRequests: await getSimilarRequests(request),
  departmentBudget: await getDepartmentBudget(request.requester.department),
  remainingBudget: await getRemainingBudget(request.requester.department),
  
  // AI recommendation (if applicable)
  aiRecommendation: request.aiAnalysis?.recommendation,
  aiConfidence: request.aiAnalysis?.confidence,
  aiRationale: request.aiAnalysis?.rationale,
  
  // Quick actions
  actions: [
    { label: 'Approve', value: 'approve', color: 'green' },
    { label: 'Reject', value: 'reject', color: 'red' },
    { label: 'Request Info', value: 'info', color: 'blue' },
    { label: 'Escalate', value: 'escalate', color: 'yellow' }
  ],
  
  // Response mechanism
  respondUrl: `https://approvals.example.com/respond/${request.id}`,
  expiresAt: new Date(Date.now() + 48 * 60 * 60 * 1000).toISOString()
};

// Send via Slack with rich formatting
// or Email with clear CTAs
// or Microsoft Teams with adaptive cards

return {
  json: {
    sent: true,
    notificationType: 'slack',
    context: approvalContext,
    expiresAt: approvalContext.expiresAt
  }
};

// Workflow: daily-expense-batch-review

// Runs daily at 9 AM
// Gathers all pending expenses and creates batch review

const pendingExpenses = await getPendingExpenses();

// Group by department for efficient review
const byDepartment = pendingExpenses.reduce((acc, exp) => {
  const dept = exp.department;
  if (!acc[dept]) acc[dept] = [];
  acc[dept].push(exp);
  return acc;
}, {});

// Create batch review for each department head
for (const [department, expenses] of Object.entries(byDepartment)) {
  const totalAmount = expenses.reduce((sum, e) => sum + e.amount, 0);
  const departmentHead = await getDepartmentHead(department);
  
  const batchReview = {
    batchId: `batch-${$now}-${department}`,
    department: department,
    reviewer: departmentHead,
    summary: {
      totalExpenses: expenses.length,
      totalAmount: totalAmount,
      averageAmount: totalAmount / expenses.length,
      categories: groupByCategory(expenses),
      highestExpense: Math.max(...expenses.map(e => e.amount)),
      flaggedExpenses: expenses.filter(e => e.flags?.length > 0)
    },
    expenses: expenses.map(e => ({
      id: e.id,
      amount: e.amount,
      category: e.category,
      submitter: e.submitter,
      description: e.description,
      flags: e.flags,
      daysPending: daysSince(e.submittedAt)
    })),
    actions: {
      approveAll: { url: `...`, label: 'Approve All' },
      reviewIndividual: { url: `...`, label: 'Review Each' },
      rejectAll: { url: `...`, label: 'Reject All' }
    }
  };
  
  await sendBatchReviewNotification(departmentHead, batchReview);
}

return {
  json: {
    batchesCreated: Object.keys(byDepartment).length,
    totalExpenses: pendingExpenses.length,
    totalAmount: pendingExpenses.reduce((sum, e) => sum + e.amount, 0)
  }
};

// Workflow: long-running-document-processing

const documentId = $json.documentId;

// Step 1: Load checkpoint if exists
const checkpoint = await loadCheckpoint(documentId);

if (checkpoint) {
  // Resume from checkpoint
  $json.resumeFrom = checkpoint.step;
  $json.partialResults = checkpoint.results;
}

// Step 2: Process in stages with checkpoints
const stages = [
  { name: 'extract_text', function: extractText },
  { name: 'classify_document', function: classifyDocument },
  { name: 'extract_entities', function: extractEntities },
  { name: 'validate_data', function: validateData },
  { name: 'store_results', function: storeResults }
];

const startIndex = checkpoint ? stages.findIndex(s => s.name === checkpoint.step) : 0;

for (let i = startIndex; i < stages.length; i++) {
  const stage = stages[i];
  
  try {
    const result = await stage.function($json);
    
    // Save checkpoint after each stage
    await saveCheckpoint(documentId, {
      step: stage.name,
      results: result,
      completedAt: $now
    });
    
  } catch (error) {
    // Save failed state for recovery
    await saveCheckpoint(documentId, {
      step: stage.name,
      error: error.message,
      failedAt: $now,
      retryCount: (checkpoint?.retryCount || 0) + 1
    });
    
    throw error; // Let n8n handle retry/error workflow
  }
}

// Step 3: Clean up checkpoint on success
await deleteCheckpoint(documentId);

// Workflow: order-saga-orchestrator
// Coordinates multiple services with compensating actions

const order = $json.order;
const sagaId = generateUUID();

const sagaSteps = [
  {
    name: 'reserve_inventory',
    execute: async () => await reserveInventory(order.items),
    compensate: async () => await releaseInventory(order.items)
  },
  {
    name: 'process_payment',
    execute: async () => await chargePayment(order.payment),
    compensate: async () => await refundPayment(order.payment)
  },
  {
    name: 'create_shipment',
    execute: async () => await createShippingLabel(order),
    compensate: async () => await cancelShippingLabel(order)
  },
  {
    name: 'send_confirmation',
    execute: async () => await sendEmail(order.customer.email, 'confirmation'),
    compensate: null // Email can't be unsent, but it's not critical
  }
];

const completedSteps = [];

for (const step of sagaSteps) {
  try {
    const result = await step.execute();
    completedSteps.push({ name: step.name, result });
    
    // Log progress
    await logSagaProgress(sagaId, step.name, 'completed');
    
  } catch (error) {
    // Log failure
    await logSagaProgress(sagaId, step.name, 'failed', error);
    
    // Compensate completed steps in reverse order
    for (const completed of completedSteps.reverse()) {
      const stepDef = sagaSteps.find(s => s.name === completed.name);
      if (stepDef.compensate) {
        try {
          await stepDef.compensate();
          await logSagaProgress(sagaId, completed.name, 'compensated');
        } catch (compError) {
          await logSagaProgress(sagaId, completed.name, 'compensation_failed', compError);
          // Alert for manual intervention
          await alertManualIntervention(sagaId, completed.name, compError);
        }
      }
    }
    
    return {
      json: {
        success: false,
        sagaId: sagaId,
        failedAt: step.name,
        error: error.message,
        compensationStatus: 'attempted'
      }
    };
  }
}

return {
  json: {
    success: true,
    sagaId: sagaId,
    completedSteps: completedSteps.map(s => s.name),
    orderStatus: 'confirmed'
  }
};

// Workflow: api-call-with-circuit-breaker

const serviceName = $json.service;
const circuitState = await getCircuitState(serviceName);

// Check circuit state
if (circuitState.status === 'OPEN') {
  // Circuit is open - fail fast
  const timeSinceOpened = Date.now() - circuitState.openedAt;
  const timeout = circuitState.timeoutMs || 60000;
  
  if (timeSinceOpened < timeout) {
    return {
      json: {
        success: false,
        error: 'Circuit breaker is OPEN',
        retryAfter: new Date(circuitState.openedAt + timeout).toISOString(),
        circuitState: circuitState
      }
    };
  } else {
    // Try half-open state
    await setCircuitState(serviceName, 'HALF_OPEN');
  }
}

// Make the API call
try {
  const response = await makeAPICall($json);
  
  // Success - record it
  await recordSuccess(serviceName);
  
  // If was half-open, close the circuit
  if (circuitState.status === 'HALF_OPEN') {
    await setCircuitState(serviceName, 'CLOSED', { consecutiveSuccesses: 0 });
  }
  
  return { json: { success: true, data: response } };
  
} catch (error) {
  // Record failure
  await recordFailure(serviceName);
  
  const consecutiveFailures = await getConsecutiveFailures(serviceName);
  const threshold = circuitState.failureThreshold || 5;
  
  if (consecutiveFailures >= threshold) {
    // Open the circuit
    await setCircuitState(serviceName, 'OPEN', {
      openedAt: Date.now(),
      reason: error.message,
      consecutiveFailures: consecutiveFailures
    });
  }
  
  return {
    json: {
      success: false,
      error: error.message,
      circuitState: await getCircuitState(serviceName)
    }
  };
}

// Workflow: resilient-api-call

const operation = $json.operation;
const maxRetries = operation.maxRetries || 3;
const baseDelay = operation.baseDelayMs || 1000;

for (let attempt = 0; attempt <= maxRetries; attempt++) {
  try {
    const result = await executeOperation(operation);
    
    // Log success after retry
    if (attempt > 0) {
      await logEvent('operation_succeeded_after_retry', {
        operation: operation.name,
        attempts: attempt + 1
      });
    }
    
    return {
      json: {
        success: true,
        attempts: attempt + 1,
        result: result
      }
    };
    
  } catch (error) {
    const isLastAttempt = attempt === maxRetries;
    const isRetryable = isRetryableError(error);
    
    if (isLastAttempt || !isRetryable) {
      // Give up
      return {
        json: {
          success: false,
          attempts: attempt + 1,
          error: error.message,
          retryable: false
        }
      };
    }
    
    // Calculate delay with exponential backoff and jitter
    const delay = Math.min(
      baseDelay * Math.pow(2, attempt) + Math.random() * 1000,
      30000 // Max 30 seconds
    );
    
    await logEvent('retry_scheduled', {
      operation: operation.name,
      attempt: attempt + 1,
      nextAttemptDelay: delay,
      error: error.message
    });
    
    // Wait before retry
    await sleep(delay);
  }
}

function isRetryableError(error) {
  const retryableCodes = [
    'ECONNRESET',
    'ETIMEDOUT',
    'ENOTFOUND',
    'ECONNREFUSED',
    '503',
    '502',
    '504',
    '429'
  ];
  
  return retryableCodes.some(code => 
    error.code?.includes(code) || 
    error.message?.includes(code) ||
    error.statusCode?.toString() === code
  );
}

// Workflow: process-with-dlq

const message = $json.message;
const processingStartTime = Date.now();
const timeoutMs = 30000;

try {
  // Set up timeout
  const timeoutPromise = new Promise((_, reject) => 
    setTimeout(() => reject(new Error('Processing timeout')), timeoutMs)
  );
  
  // Race between processing and timeout
  const result = await Promise.race([
    processMessage(message),
    timeoutPromise
  ]);
  
  return {
    json: {
      success: true,
      processingTime: Date.now() - processingStartTime,
      result: result
    }
  };
  
} catch (error) {
  // Send to Dead Letter Queue for later analysis
  const deadLetter = {
    originalMessage: message,
    error: {
      message: error.message,
      stack: error.stack,
      code: error.code
    },
    context: {
      workflowId: $workflow.id,
      executionId: $execution.id,
      timestamp: $now,
      attemptCount: message.attemptCount || 1
    },
    metadata: {
      source: message.source,
      receivedAt: message.receivedAt,
      processingTime: Date.now() - processingStartTime
    }
  };
  
  await sendToDeadLetterQueue(deadLetter);
  
  // Alert if this is happening frequently
  const dlqMetrics = await getDLQMetrics(timeWindow = '1h');
  if (dlqMetrics.count > dlqMetrics.threshold) {
    await alertOperationsTeam({
      alert: 'DLQ_THRESHOLD_EXCEEDED',
      count: dlqMetrics.count,
      threshold: dlqMetrics.threshold,
      recentErrors: dlqMetrics.recentErrors
    });
  }
  
  return {
    json: {
      success: false,
      sentToDLQ: true,
      error: error.message
    }
  };
}

// Workflow: batch-processor

const items = $json.items;
const batchSize = $json.batchSize || 100;
const results = [];

// Process in batches
for (let i = 0; i < items.length; i += batchSize) {
  const batch = items.slice(i, i + batchSize);
  const batchNumber = Math.floor(i / batchSize) + 1;
  const totalBatches = Math.ceil(items.length / batchSize);
  
  // Process batch
  const batchResults = await Promise.all(
    batch.map(item => processItem(item))
  );
  
  results.push(...batchResults);
  
  // Log progress
  await logProgress({
    batch: batchNumber,
    totalBatches: totalBatches,
    processed: results.length,
    total: items.length,
    percentComplete: Math.round((results.length / items.length) * 100)
  });
  
  // Brief pause between batches to prevent rate limiting
  if (i + batchSize < items.length) {
    await sleep(100);
  }
}

return {
  json: {
    success: true,
    totalProcessed: results.length,
    successful: results.filter(r => r.success).length,
    failed: results.filter(r => !r.success).length,
    results: results
  }
};

// Workflow: enqueue-for-async-processing

const request = $json.request;

// Don't process synchronously - enqueue for background processing
const job = {
  id: generateUUID(),
  type: request.type,
  payload: request.payload,
  priority: request.priority || 'normal',
  submittedAt: $now,
  estimatedDuration: estimateDuration(request),
  dependencies: request.dependencies || []
};

// Add to processing queue
await enqueueJob(job);

// Return immediately with job ID
return {
  json: {
    accepted: true,
    jobId: job.id,
    status: 'queued',
    estimatedStartTime: await getEstimatedStartTime(job),
    statusUrl: `https://api.example.com/jobs/${job.id}/status`
  }
};

// Separate workflow: async-job-processor
// Triggered by queue, processes jobs in background
// Updates status that can be polled via statusUrl

// Workflow: stream-large-dataset

const query = $json.query;
const pageSize = 1000;
let page = 0;
let hasMore = true;
let totalProcessed = 0;

// Open output stream (e.g., to file, S3, or webhook)
const outputStream = await createOutputStream($json.destination);

while (hasMore) {
  // Fetch page
  const pageData = await fetchPage(query, page, pageSize);
  
  if (pageData.length === 0) {
    hasMore = false;
    break;
  }
  
  // Transform page
  const transformed = pageData.map(transformRecord);
  
  // Write to stream (don't hold in memory)
  await outputStream.write(transformed);
  
  totalProcessed += pageData.length;
  page++;
  
  // Log progress
  if (page % 10 === 0) {
    await logProgress({
      page: page,
      totalProcessed: totalProcessed,
      memoryUsage: process.memoryUsage()
    });
  }
  
  // Check if we've hit a limit
  if ($json.maxRecords && totalProcessed >= $json.maxRecords) {
    hasMore = false;
  }
}

// Close stream
await outputStream.close();

return {
  json: {
    success: true,
    totalRecords: totalProcessed,
    pagesProcessed: page,
    destination: $json.destination
  }
};

// Workflow: rotate-api-credentials

const service = $json.service;
const rotationPolicy = await getRotationPolicy(service);

// Check if rotation is needed
const lastRotation = await getLastRotation(service);
const daysSinceRotation = daysBetween(lastRotation, $now);

if (daysSinceRotation < rotationPolicy.days) {
  return {
    json: {
      rotated: false,
      reason: 'Rotation not yet due',
      nextRotation: addDays(lastRotation, rotationPolicy.days)
    }
  };
}

// Perform rotation
const newCredentials = await generateNewCredentials(service);

// Update in credential store (gradual rollout)
await updateCredentialStore(service, {
  primary: newCredentials,
  secondary: await getCurrentCredentials(service), // Keep old as backup
  rotationTime: $now
});

// Notify dependent systems
await notifyCredentialRotation(service, {
  rotationTime: $now,
  affectedWorkflows: await getWorkflowsUsingCredential(service)
});

// Schedule old credential expiration
await scheduleCredentialExpiration(service, {
  expireAt: addHours($now, rotationPolicy.gracePeriodHours)
});

return {
  json: {
    rotated: true,
    service: service,
    rotationTime: $now,
    expiresAt: addHours($now, rotationPolicy.gracePeriodHours)
  }
};

// Workflow: process-with-full-audit

const operation = $json.operation;
const auditId = generateUUID();

// Pre-operation audit log
await createAuditRecord({
  id: auditId,
  operation: operation.type,
  status: 'started',
  actor: $json.user,
  timestamp: $now,
  input: sanitizeForAudit($json),
  ip: $json.requestIp,
  userAgent: $json.userAgent
});

try {
  const result = await executeOperation(operation);
  
  // Success audit log
  await updateAuditRecord(auditId, {
    status: 'completed',
    completedAt: $now,
    output: sanitizeForAudit(result),
    duration: Date.now() - new Date($now).getTime()
  });
  
  return { json: { success: true, auditId: auditId, result: result } };
  
} catch (error) {
  // Failure audit log
  await updateAuditRecord(auditId, {
    status: 'failed',
    failedAt: $now,
    error: sanitizeForAudit(error.message),
    stackTrace: sanitizeForAudit(error.stack)
  });
  
  throw error;
}

function sanitizeForAudit(data) {
  // Remove PII and sensitive data before logging
  const sensitiveFields = ['password', 'ssn', 'creditCard', 'apiKey'];
  const sanitized = { ...data };
  
  for (const field of sensitiveFields) {
    if (sanitized[field]) {
      sanitized[field] = '[REDACTED]';
    }
  }
  
  return sanitized;
}

// Workflow: test-harness-for-subworkflows

const testCases = [
  {
    name: 'Valid customer - standard tier',
    input: { customer: { tier: 'standard', email: '[email protected]' } },
    expected: { status: 'success', tier: 'standard' }
  },
  {
    name: 'Invalid email format',
    input: { customer: { tier: 'standard', email: 'invalid' } },
    expected: { status: 'error', errorCode: 'INVALID_EMAIL' }
  },
  {
    name: 'Missing required field',
    input: { customer: { tier: 'standard' } },
    expected: { status: 'error', errorCode: 'MISSING_EMAIL' }
  }
];

const results = [];

for (const testCase of testCases) {
  try {
    // Execute workflow under test
    const actual = await executeWorkflow('workflow-under-test', testCase.input);
    
    // Compare with expected
    const passed = matchesExpected(actual, testCase.expected);
    
    results.push({
      name: testCase.name,
      passed: passed,
      expected: testCase.expected,
      actual: actual,
      duration: actual.duration
    });
    
  } catch (error) {
    results.push({
      name: testCase.name,
      passed: false,
      error: error.message
    });
  }
}

// Generate test report
const report = {
  total: results.length,
  passed: results.filter(r => r.passed).length,
  failed: results.filter(r => !r.passed).length,
  results: results,
  coverage: calculateCoverage(results)
};

await sendTestReport(report);

return { json: report };