Double buffering (fiber.alternate, ReactInternalTypes.js:174; createWorkInProgress, ReactFiber.js:327-355) plus the scheduler's interruptible lanes mean a committed value and one or more in-flight values are simultaneously live. Any external-read primitive must pick committed-vs-in-flight semantics or accept tearing.

Impact: This is entangled with time-slicing, Suspense, transitions, and Offscreen. Exposing uncontrolled reads would forfeit the guarantee that React decides when reads happen — the precondition for all concurrent features.

This is the irreversible decision. The reason there is no out-bound read is the same reason concurrent rendering is safe: React owns read timing. A primitive that read in-flight state could not be walked back without breaking concurrency guarantees that the whole ecosystem now depends on.

useSyncExternalStore (ReactFiberHooks.js:1633) is React's expand-contract bridge for external state: snapshot read each render + checkIfSnapshotChanged forcing a sync re-render on tearing (1846-1850). react-cache was an earlier external-held experiment in the same spirit. The evolution path is not 'expose fiber state' but 'keep state outside and make the doorway richer.'

Impact: Investing here delivers external readability with zero risk to concurrency, because React still controls every read.

→ Treat useSyncExternalStore as the canonical external-state boundary. Future readability features (selectors, derived snapshots, transition-aware reads) belong on this seam — it is reversible (expand-contract) where a fiber-read API is not.

Today every read funnels through ReactSharedInternals.H, set only inside renderWithHooks and nulled at finishRenderingHooks (ReactFiberHooks.js:511,656,664). For an external read primitive to exist, the fiber would need a render-independent read path that does not depend on the dispatcher slot being live.

Impact: A render-independent read path is the minimum architectural surface required; without it 'read state outside render' is structurally a thrown error.

→ First safe step: do NOT add a raw fiber-read API. Instead expose committed-tree snapshot reads built on the existing useSyncExternalStore consistency machinery, and never surface in-flight work-in-progress state. This keeps React the owner of when reads happen.

Hooks are addressed by call order, not by key (ReactFiberHooks.js:194-200, 263-266). There is no name to read state by. An external primitive needs stable, keyed identity — which the positional linked-list model cannot provide without changing the hook model itself.

Impact: Retrofitting keys onto positional hooks would be an epic, breaking change to the most-used API in the library.

→ Don't retrofit hooks. The addressable-state path already exists: useSyncExternalStore gives external stores their own keyed identity. Formalize and enrich the external-store boundary rather than making fiber internals addressable.

An external state-read primitive requires breaking three invariants at once: (1) the render-only dispatcher gate, (2) positional hook identity, and (3) React's ownership of read timing under concurrency. The first two are hard; the third is the one that cannot be unwound without forfeiting time-slicing safety.

Ranked by reversibility: identity (irreversible API change, but local), gate (large, additive), concurrency ownership (the load-bearing wall). Because (3) is exactly what makes Suspense/transitions/Offscreen possible, the rational evolution is to keep state outside the tree and enrich useSyncExternalStore — which is precisely what React has done.