Pools direct ByteBuffers for zero-allocation UDP I/O.

Provides a thread-safe, hot-path optimized regular buffer pool to minimize
garbage collection pressure during high-throughput packet processing.

Constructs and injects commands (DMX, RDM, State) into the node's flow loop.

Provides a functional API for queuing side effects and protocol actions
to be processed by the shell/logic graph.

Translates pure Art-Net protocol effects into actionable IO descriptors.

Decouples the logic-layer protocol machine from the shell-layer IO system
via open multimethod dispatch.

Flow graph construction for the Art-Net node runtime.

Assembles the core.async.flow graph connecting:
- udp-recv: Receives UDP packets
- failsafe: Timer ticks for failsafe DMX output
- logic:    Pure protocol state machine
- udp-send: Sends UDP packets

Part of the Imperative Shell: Orchestrates the reactive pipeline.

Node lifecycle management (Shell Layer).

Manages initialization, resource acquisition (channels, buffers),
and clean shutdown of the imperative shell components.
Delegates core domain logic to pure functions in the protocol layer.

Utilities for Art-Net network I/O, including address coercion and channel configuration.

Provides helpers for java.net.InetAddress and java.nio.channels.DatagramChannel
setup, isolated from protocol logic.

Art-Net 4 protocol policy enforcement.

Provides pure functions to validate compliance, specifically regarding
broadcast restrictions for certain opcodes.

Process handling UDP reception and packet decoding.

Implements a core.async flow loop that:
- Reads datagrams from the channel into pooled buffers
- Decodes Art-Net packets (discarding malformed ones)
- Emits valid packets to the flow graph

Process handling UDP transmission and action dispatch.

Implements a core.async flow loop that:
- Encodes and sends Art-Net packets (enforcing broadcast policy)
- Executes callback actions on virtual threads
- Manages delayed actions (e.g. reply dispatch)

State snapshot/application utilities for running Art-Net nodes.

Provides blocking access to remote node state via flow injection and
promise synchronization, and non-blocking state updates.

System lifecycle and runtime management/integration.

Integrates shell components and provides higher-level system operations
(lifecycle, effect execution). Delegates core I/O to shell modules.