┌─────────────────────────────────────────────────────────────┐
│                         FLOW                                │
│  (Directed Acyclic Graph - the container)                   │
│                                                             │
│   ┌─────────┐         ┌─────────┐         ┌─────────┐      │
│   │  NODE   │         │  NODE   │         │  NODE   │      │
│   │ ┌─────┐ │  EDGE   │ ┌─────┐ │  EDGE   │ ┌─────┐ │      │
│   │ │PORT │─┼────────▶│ │PORT │─┼────────▶│ │PORT │ │      │
│   │ └─────┘ │         │ └─────┘ │         │ └─────┘ │      │
│   └─────────┘         └─────────┘         └─────────┘      │
│                                                             │
└─────────────────────────────────────────────────────────────┘

// Add a node to the flow
flow.addNode(node: INode): Promise<INode>

// Connect two ports via edge
flow.connectPorts(sourceNodeId, sourcePortId, targetNodeId, targetPortId): Edge

// Subscribe to flow events
flow.onEvent(handler: (event: FlowEvent) => void): () => void

// Validate entire flow
flow.validate(): Promise<FlowValidationResult>

Idle → Ready → Executing → Completed
                    ↓
                  Error

enum NodeStatus {
  Idle = 'idle',           // Initial state
  Initialized = 'initialized',
  Ready = 'ready',         // Ready to execute
  Pending = 'pending',     // Waiting for dependencies
  Executing = 'executing', // Currently running
  Completed = 'completed', // Successfully finished
  Skipped = 'skipped',     // Skipped (condition not met)
  Error = 'error',         // Failed with error
  Disposed = 'disposed',   // Cleaned up
}

// Execute the node
node.execute(context: ExecutionContext): Promise<NodeExecutionResult>

// Get a port by ID
node.getPort(portId: string): IPort | undefined

// Validate configuration
node.validate(): Promise<NodeValidationResult>

// Reset to initial state
node.reset(): Promise<void>

interface NodeMetadata {
  type: string           // Node class name (required)
  title?: string         // Display name
  category?: NodeCategory // e.g., 'math', 'flow-control', 'ai'
  description?: string
  version?: number
  icon?: string
  tags?: string[]
  parentNodeId?: string  // If nested in group
  ui?: NodeUIMetadata    // Position, dimensions, etc.
}

type PortDirection = 'input' | 'output' | 'passthrough'

interface StringPortConfig {
  type: 'string'
  defaultValue?: string
  minLength?: number
  maxLength?: number
  pattern?: RegExp  // Validation regex
}

interface NumberPortConfig {
  type: 'number'
  defaultValue?: number
  min?: number
  max?: number
  step?: number
  integer?: boolean
}

interface ArrayPortConfig<Item> {
  type: 'array'
  itemConfig: IPortConfig  // Type of each item
  minLength?: number
  maxLength?: number
  isMutable?: boolean      // Can items be added/removed?
}

interface ObjectPortConfig<Schema> {
  type: 'object'
  schema: IObjectSchema    // Properties definition
  isSchemaMutable?: boolean
}

// Get/set port value
port.getValue(): T | undefined
port.setValue(value: T): void

// Validation
port.validate(): boolean

// Serialization
port.serialize(): JSONValue
port.deserialize(data: JSONValue): IPort

// Connection management
port.addConnection(nodeId: string, portId: string): void
port.removeConnection(nodeId: string, portId: string): void

enum EdgeStatus {
  Active = 'active',     // Connection working
  Inactive = 'inactive', // Disabled
  Error = 'error',       // Transfer failed
}

interface EdgeMetadata {
  label?: string              // Display label
  anchors?: EdgeAnchor[]      // Control points for custom paths
  version?: number            // For optimistic updates
}

interface EdgeAnchor {
  id: string
  x: number                   // Coordinate
  y: number
  index: number               // Order in path
}

class ExecutionContext {
  readonly executionId: string      // Unique run ID
  readonly rootExecutionId?: string // Root workflow ID
  readonly parentExecutionId?: string // Parent ID (for children)
  readonly flowId?: string
  readonly userId?: string
  readonly startTime: Date
  readonly abortController: AbortController
  readonly integrations: IntegrationContext  // AI, wallet, etc.
  readonly executionDepth: number  // Prevents infinite recursion (max 100)

  // Event emission (for event-driven execution)
  emitEvent(eventType: string, data: any, nodeId: string): void

  // Port resolution (for stream ports)
  resolvePort(nodeId: string, portId: string): void
  isPortResolved(nodeId: string, portId: string): boolean

  // Get integration data
  getIntegration<T>(type: string): T | undefined
}

class ExecutionEngine {
  constructor(flow: Flow, context: ExecutionContext, options?: ExecutionOptions)

  async execute(): Promise<void>

  // Control flow
  pause(): void
  resume(): void
  stop(reason?: string): void

  // Event handling
  onEvent(eventType: ExecutionEventEnum, callback): void
  onError(callback): void
}

interface ExecutionOptions {
  execution?: {
    maxConcurrency?: number    // Default: 50
    nodeTimeoutMs?: number     // Default: 3600000 (1 hour)
    flowTimeoutMs?: number     // Default: 10800000 (3 hours)
  }
  debug?: boolean              // Enable debugger
  breakpoints?: string[]       // Node IDs to break on
}

import { Node, Input, Output, PortString, PortNumber } from '@badaitech/chaingraph-types'

@Node({
  title: 'Add Numbers',
  category: 'math',
  description: 'Adds two numbers',
})
class AddNode extends BaseNode {
  @Input()
  @PortNumber({ defaultValue: 0 })
  a: number = 0

  @Input()
  @PortNumber({ defaultValue: 0 })
  b: number = 0

  @Output()
  @PortNumber()
  result: number = 0

  async execute(context: ExecutionContext): Promise<NodeExecutionResult> {
    this.result = this.a + this.b
    return {}
  }
}

1. Flow loads nodes and edges
2. ExecutionEngine resolves dependencies (topological sort)
3. Nodes execute in parallel where possible
4. Output port values transfer to connected input ports
5. Events stream in real-time
6. Flow completes or fails