Observation and reuse

An image's composition interface may remain valid for the provider's lifetime. A cached result remains valid only while its inputs are unchanged.

Following a change through the scene

Move the overlay in the lab and the composed output needs to change. The upstream filter has the same input it had before, so recomputing it would do unnecessary work. Change the source image instead and that filter must be observed again.

The image graph owns those relationships. Its revisions and input dependencies determine whether an observation can be reused. The data transfer layer doesn't need to understand what an overlay is to transfer the resulting pixels.

The Godot checks measure transfers and plan builds during this update, then validate the pixels separately.

Reusing facts with a known lifetime

A prepared Representation is immutable while available, so two references to the same record can take an identity fast path. Independently published descriptions still agree through their canonical bytes.

A Cursor has a similarly local guarantee. Its token provider offers stable observations by logical index, while the wrapper owns its position. Caching the token at that position saves repeated calls without introducing shared mutable progress. Moving the Cursor invalidates the local observation; copying it forks the position.

An arbitrary Abstract answer needs its own stability promise. A consumer cannot infer that promise from the fact that binding succeeded or that a previous call returned the same answer.

When the work takes time

A provider may need to cross a process boundary or wait for another system, but an Unknown answer doesn't tell us how to schedule that work or promise that the provider will eventually determine it.

The base operations are synchronous. A higher-level contract can add callbacks, polling or cancellation, and a host can adapt the call into its own async runtime. That contract must also specify who retains the request and its inputs while work is outstanding.