Cell class abstract interface Getting Started Core 16 Operators Demo:aircraft Demo:hotel Core

A reactive node: holds state (or relays signals), validates every incoming change against a policy, and broadcasts accepted changes to whatever else is listening.

Internally, a Cell's behavior is split into four independent, swappable pieces — a Receptor (how it transforms an incoming Pulse), a TestCell (what it's allowed to accept), a Context (what tier/domain it belongs to), and Synapses (who it notifies on change). You don't construct any of these directly for ordinary use — they all have working defaults, and the static operators below hide them entirely.

Where to start

First 16 operators: Almost everything is built from one of these. They will cover most of your daily reactive programming needs. They're ordered from most essential to more advanced.

These are ordered for a learning path: get data in → hold state → react in the UI → shape streams → go async → combine sources.

• Cell.ingress — How intent/events enter the graph
• Cell.state — Retained app state you read and update
• Cell.observe — Side effects: UI, logging, wiring widgets
• Cell.derive — Pure view-models / projections from state
• Cell.hub — Routing signals to specific handlers
• Cell.open — Module boundaries for manual control
• Cell.distinct — Skip redundant updates and rebuilds
• Cell.valve — Flow control: only allow pulses when a condition is met
• Cell.throttle/Cell.debounce — Timing control: input rate-limiting
• Cell.asyncMap — HTTP/DB work (latestOnly / exhaust)
• Cell.fromFuture/Cell.fromStream — Bridge Futures and Streams into Cell
• Cell.synthesis — merge multiple sources into one consensus
• Cell.sanitized — Data sanitization / validation
• Cell.switchMap - Selected user / tab / locale → active upstream
• Cell.transaction — Multi-cell atomic updates (money, stock, forms)
• Cell.txApply — batch multiple apply() into a single commit.

Each works with zero knowledge of Receptor, TestCell, Context, or Synapses — all optional, all defaulted. They represent the Standard Entry Point, allowing you to build complex reactive systems by connecting simple building blocks. While you focus on your logic, the framework automatically manages the input (Ingress), logic (Transformation), and notifications (Egress), handling all security checks and verification steps in the background.

Identity

A cell obtained via deputy or unmodifiable is a proxy, not a copy — it shares its principal's underlying state. cell == cell.deputy() is true; they're interchangeable in Sets and Maps. What differs is what each is permitted to do (validate), never what data it holds.

Going further

Cell.governed and Cell.fromNucleus expose full control over lifecycle, security tier, and concurrency. Reach for these only when the operators above are genuinely insufficient — e.g. building infrastructure nodes, not typical application state.

For a rich ecosystem of reactive primitives, see cell_flow—a complementary library providing 90+ instruction-layer Flow factories for complex stream orchestration, advanced filtering, and high-level data synchronization.

See Also:

• Pulse (the signal a cell processes).
• ValueCell (the concrete stateful type returned by Cell.state).
• HowTo: See guide/HowTo-Start.md for a comprehensive guide on getting started with the Cell architecture and reactive patterns.