Package-level declarations

Runtime capability for a pure, single-input derived observation. The source and transformation are immutable and caller-owned; runtimes evaluate committed inputs on their owner thread. Implementations must also implement ordinary StateSource.subscribe with its complete lifetime contract.

Caller-owned observable value whose reads and writes require its construction execution owner. This is the physical construction thread unless a runtime explicitly creates it in a serial ownership scope. Equal assignments do not invalidate observers; changed assignments invalidate every observing screen. Screen evaluation and guarded equality reject mutation before changing the value. A throwing equality comparison preserves the previous value and propagates the original failure. Create this value outside screen evaluation so rebuilding a screen does not reset it.

Read-only view of an observable value owned by its construction thread. Reading during screen evaluation records a dependency of that screen. Implementations reject access during a guarded equality comparison or from another thread. The caller owns the value and its lifetime independently of observing screens.

Runtime-owned dependency set for one owner-confined screen evaluator. Successful evaluation replaces dependencies; failed evaluation retains them until terminal cleanup. Closing releases every dependency without closing the caller-owned state and is idempotent.

Identifies one observation in the ordered history of a state source.

Carries a source observation and its publication revision.

An externally owned source of revisioned state snapshots.

The atomic result of subscribing to a StateSource.

Creates a lazy, caller-owned projection of this source, supporting nullable values and chained projections. Construction does not subscribe or evaluate transform. Keep the returned identity when consumers share a projection. The transformation must be deterministic, side-effect-free, and return normally; ordinary subscriptions may transform on any notifying thread. Ordinary subscriptions preserve every revision, including equal results. Retained UI consumers instead share the upstream subscription, transform a frame-committed input, and suppress dependent UI work when the transformed result is equal by ==. No source history or global cache is retained. Heavy work and I/O belong outside the transformation.

Creates a caller-owned observable value under the current execution owner. Retain it outside screen evaluation; equal assignments leave observing screens clean.