Port-Address logic (Art-Net 4).

Art-Net 4 protocol constants, opcodes, and lookup tables.
Single source of truth for all protocol-level values derived from
the Art-Net 4 specification.

Central opcode dispatch for Art-Net packet encoding and decoding.
Routes to domain-specific handlers while maintaining the original
public API contract.

Common utilities shared across domain encode/decode modules.

Encode/decode for Config family packets: ArtInput, ArtAddress, ArtIpProg, ArtIpProgReply.

Encode/decode for Data family packets: ArtDataRequest, ArtDataReply.

Encode/decode for Diagnostic family packets: ArtDiagData, ArtCommand, ArtTrigger, ArtTimeCode.

Encode/decode for DMX family packets: ArtDmx, ArtNzs, ArtVlc, ArtSync.
These are the hot-path packets that use flyweight types for zero allocation.

Encode/decode for Firmware family packets: ArtFirmwareMaster, ArtFirmwareReply.

Encode/decode for Poll family packets: ArtPoll, ArtPollReply.

Encode/decode for RDM family packets: ArtRdm, ArtRdmSub, ArtTodRequest, ArtTodData, ArtTodControl.

Low-level buffer read/write primitives for Art-Net codec.
All functions operate on java.nio.ByteBuffer instances.

Flyweight packet types for zero-allocation hot paths.
ArtDmx and ArtNzs packets use these types to provide map-like
access without allocating intermediate data structures.

Helpers for ArtDataRequest/Reply configuration.

Provides pure functions for normalizing data configuration, utilized by
`impl.protocol.lifecycle`. Extracted to resolve dependency cycles.

Diagnostics logic (Art-Net 4).

ArtPoll/ArtPollReply handling (Art-Net 4).

Pure DMX merge and processing logic (Art-Net 4).

DMX logic helpers: sync, failsafe, merge (Art-Net 4).

Pure data constructors for Art-Net protocol effects.

Art-Net firmware upload coordination.

ArtInput paging and selection logic.

State lifecycle management: initialization and cap sync.

Pure Art-Net protocol state machine.

Manages Art-Net node state, including normalization, paging, and status bits.

Provides pure functions for configuring and transforming node state,
ensuring valid bitmasks and default values.

Helpers for ArtPoll discovery configuration and reply-on-change logic.

Provides pure functions for normalizing discovery settings and managing purely functional
reply-on-change subscriber state.

Implements Art-Net remote programming semantics for ArtAddress, ArtInput, and ArtIpProg.

Provides pure functions to transform node state based on remote programming commands,
including diagnostic acknowledgement generation.

Art-Net RDM/TOD helpers for the impl architecture. Maintains a
lightweight Table-of-Devices snapshot and subscriber registry so the logic
coordinator can focus on orchestration.

ArtRdm and ArtRdmSub transport validation and helpers per Art-Net 4 spec.

Art-Net 4 §ArtRdm:
- Transport all non-discovery RDM messages
- Unicast only (broadcast no longer allowed in Art-Net 4)
- Command field 0x00 = ArProcess (process RDM packet)
- Validate command class in RDM payload (byte 20)

Art-Net 4 §ArtRdmSub:
- Compressed sub-device data transfer
- Get (0x20): 0 data bytes
- Set (0x30): SubCount * 2 data bytes
- GetResponse (0x21): SubCount * 2 data bytes
- SetResponse (0x31): 0 data bytes

This module provides pure functions for:
- RDM command class validation
- ArtRdmSub packet validation
- Sub-device range and entry helpers
- Payload normalization for outbound commands

State schema and initialization (Art-Net 4).

ArtSync handling for Art-Net 4 protocol.

Per Art-Net 4 spec:
- ArtSync is used to synchronize DMX output across multiple universes
- ArtSync timeout is 4 seconds (nodes revert to immediate mode)
- ArtSync shall be ignored when merging multiple streams
- ArtSync shall be ignored if the sender doesn't match the most recent ArtDmx sender

Modes:
- :immediate - Output DMX frames as they arrive (default)
- :art-sync  - Buffer DMX frames until ArtSync is received

Timing utilities for deterministic testing.

ArtTrigger and ArtCommand processing per Art-Net 4 specification.

Art-Net 4 §ArtTrigger mandates:
- OEM filtering: Accept trigger if OEM = 0xFFFF or matches node's OEM
- Key types 0-3: KeyAscii, KeyMacro, KeySoft, KeyShow
- Key types 4-255: Undefined (pass to vendor callback if OEM != 0xFFFF)
- Payload (512 bytes): Interpretation depends on OEM/Key

This module provides pure functions for:
- Trigger debouncing with configurable rate limiting
- OEM-based target filtering
- Key/SubKey interpretation and acknowledgement generation
- Helper dispatch for registered trigger handlers

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.