docs/process/README.md

# Processes in Corezoid

## Overview

A **Process** in Corezoid is the primary structure for orchestrating automated data handling,
integrations, and routing. It serves as the highest-level entity that unites one or more **Nodes**
into a coherent workflow. While each Node performs a specific function (such as checking conditions,
calling external APIs, or transforming data), the Process itself defines the overall sequence and
logic that connects those Nodes toward a common objective.

## Structure and Components

### Core Components

1. **Start Node** (Required)

   - Entry point for all tasks
   - Exactly one Start node is allowed per Process
   - Receives tasks via API calls, manual entry, or from other Processes

2. **Processing Nodes** (Optional)

   - Various node types that perform specific operations
   - Can include Condition, Code, API Call, and other node types
   - Arranged in a logical flow to process task data

3. **End Nodes** (Recommended)
   - Terminate the processing flow
   - Can have multiple End nodes for different outcomes
   - Mark tasks as completed with success or error status

### Process Schema

A typical Process follows this structure:

```
START NODE → PROCESSING NODES → END NODE(S)
```

With branching logic:

```
                 ┌→ PROCESSING PATH A → END NODE A
START NODE → CONDITION NODE
                 └→ PROCESSING PATH B → END NODE B
```

## Operational Mechanics

Data enters a Process through the single **Start** node. As it flows forward, each Node may validate
parameters, call external services, or update values. The Process terminates when the data reaches
one or more **End** nodes, completing its lifecycle. Conditional or branching Nodes can introduce
multiple paths, but all ultimately resolve in an End node, ensuring no infinite loops.

## Usage Context

Processes facilitate varied operational scenarios, such as:

- **Microservice coordination**: Multiple APIs and services operate together in an event-driven
  pipeline.
- **Transaction routing**: Structured validation and updates in finance or e-commerce flows.
- **Data transformation**: Aggregating, parsing, or enriching data with external systems or internal
  rules.
- **Workflow automation**: Orchestrating complex business processes with multiple steps and decision
  points.
- **Integration hub**: Connecting disparate systems and services through a centralized process flow.

## Key Features

- **Single Start Node Constraint**: Exactly one Start node is allowed. Additional Start nodes cause
  a validation error.
- **Container for Logic**: A Process centralizes control of data progression, integrating distinct
  actions performed by Nodes.
- **Flexible Data Path**: Nodes can branch or merge flows as needed, yet all paths converge in an
  End node to prevent loops.
- **Version Control**: Processes can be versioned, allowing for safe updates and rollbacks.
- **Reusability**: Processes can be called by other processes, enabling modular design.

## Process Lifecycle

1. **Creation**: Define the process structure with nodes and connections
2. **Configuration**: Set up node parameters and logic
3. **Validation**: Ensure the process structure is valid
4. **Deployment**: Commit changes to make the process active
5. **Execution**: Process tasks as they arrive
6. **Monitoring**: Track process performance and task status
7. **Maintenance**: Update the process as requirements change

## Best Practices

- Design processes with clear entry and exit points
- Implement comprehensive error handling
- Document the purpose of each process and its key nodes
- Use descriptive node titles that indicate their function
- Test processes thoroughly before deployment
- Monitor process performance and error rates
- Consider breaking complex processes into smaller, reusable sub-processes

## Examples

For JSON examples of processes, see the individual process files below:

- [Process with Input Parameters](process-with-parameters.md) - Example of a process with various
  input parameter types and validation rules
- [Process Output Parameters](process-output-parameters.md) - Documentation for defining output
  parameters in processes with Reply to Process nodes

## Guides

- [Process Development Guide](process-development-guide.md) - Comprehensive guide for planning,
  implementing, testing, and maintaining processes
- [Converting Algorithms to Effective Processes](algorithm-to-process-guide.md) - Step-by-step guide
  for implementing algorithms as Corezoid processes
- [Node Positioning Best Practices](node-positioning-best-practices.md) - Guidelines for positioning
  and arranging nodes in process diagrams
- [Node Size Reference](node-size-reference.md) - Measured dimensions and sizing rules for every
  Corezoid node renderer
- [Error Handling Strategies](error-handling.md) - Comprehensive approaches to handling errors in
  processes
- [Process Lifecycle and Object Moves](process-lifecycle-and-move.md) - Verified pause/resume
  behavior and safe process/folder reparenting

## Related Documentation

- [Process JSON Validation](process-json-validation.md) - Validation requirements for process JSON
  files
- [Nodes Overview](../nodes/README.md) - Documentation for all node types
- [Tasks Overview](../tasks/README.md) - Information about task structure and handling