BPMN 2.0 Process Projection

EdgeNode compiles graph execution plans into standardized Business Process Model and Notation (BPMN 2.0) models. Rather than requiring manual layout drafting, the platform derives start and end events, tasks, exclusive gateways, message triggers, and swimlanes directly from underlying database entities: artifact streams, state transition cycles, priority transactions, and execution pipelines.

Conceptual Overview

A Plan in EdgeNode models a collection of Streams. Each stream represents the end-to-end lifecycle of a specific artifact (such as a requirement, design, code, prototype, part, or assembly) flowing through operational states.

Domain Meaning	BPMN 2.0 Output	Visual Notation
Lifecycle of one artifact	Process Path	Sequential flow path
Initial artifact entry	Start Event	Thin circle (○)
Final artifact departure	End Event	Thick circle (◉)
State transformation step	Task / Activity	Rounded rectangle `[origin → target]`
Handoff between steps	Sequence Flow	Solid directional arrow (→)
Selection across valid branches	Exclusive Gateway (XOR)	Diamond with 'X' (◇)
Cross-stream triggering event	Message / Trigger Flow	Dashed connector to Start Event
Role executing the cycle	Swimlane	Horizontal participant lane

Core Projection Mechanics

Stream lifecycle mapping showing start event, task sequence, and end event — Figure 1.0: End-to-end stream lifecycle mapping from entry sentinels to exit events.

1. Streams as Process Units

Every stream models an artifact's end-to-end path. EdgeNode enforces data integrity at the database layer through partial unique indexes, ensuring every stream contains exactly one entry boundary and one exit boundary:

"One stream equals one coherent path through the diagram: $\bigcirc \rightarrow \text{[task]} \rightarrow \dots \rightarrow \bigoplus$ ." — EdgeNode Architectural Specification

2. State-Driven Cycle Classification

A cycle represents an atomic step of work that transforms an artifact from origin state to target state:

Entry Sentinel (origin_state = '(entry)'): Rendered as a Start Event (thin-bordered circle). Represents an instantaneous event with zero processing duration.
Exit Sentinel (target_state = '(exit)'): Rendered as an End Event (thick-bordered circle). Marks the completion of the artifact flow.
Operational Cycle: Rendered as a standard BPMN Task (rounded rectangle). Displays the transformation badge [origin → target] and the associated artifact type.

Path Continuity and Gateway Derivation

In EdgeNode, gateways are not manually placed nodes; they are derived by the renderer from state continuity and priority fan-out.

The State Integrity Rule

A sequence flow connects two consecutive cycles $c_i$ and $c_j$ if and only if the output state of $c_i$ matches the input state of $c_j$ :

\text{ValidFlow}(c_i, c_j) \iff c_i.\text{target\_state} = c_j.\text{origin\_state}

State continuity is realized either through same-level transaction links (transactions) or by descending into child nodes (parent). If states do not align, no flow arrow is drawn.

Priority-Based Exclusive Gateways

When an output state produces multiple valid, state-continuous transitions, the priority attribute on outgoing transactions determines execution paths:

Priority 1: The Primary / Happy Path (rendered along the main horizontal flow axis).
Priority 2, 3, ...: The Alternative / Rework Paths (branching off the main trajectory).

💡 Derivation Principle

An Exclusive Gateway (◇ with X) is generated whenever a state has multiple state-consistent continuations distinguished by priority. Priority alone does not create a gateway; it requires state continuity plus a fan-out of priorities.

Inter-Stream Triggers and Swimlane Responsibilities

Cross-Stream Triggers

Streams maintain isolated scopes and never share sequence flows directly. Inter-stream coordination is governed by plan pipelines:

When a cycle in a specific stream reaches it's pipeline state, it initiates execution of another stream within a single plan. The renderer projects this dependency as a dashed trigger connector directed to the Start Event of the target stream.

Swimlanes via RACI Governance

Swimlanes reflect organizational execution ownership:

Each operational cycle defines a responsible referencing the roles table (RACI Responsible).
The renderer maps each distinct role to a horizontal swimlane.
When a stream transitions between cycles owned by different roles, sequence flow vectors move vertically across lanes while maintaining left-to-right temporal progression.