Skip to content

03 Context and Scope

Alex Flom edited this page May 15, 2026 · 8 revisions

Context and Scope

The system specified by this wiki is Prism. Prism is realized by the three crates uor-foundation, prism, and prism-verify. At Level 1 of the C4 model, Prism is one logical entity; its decomposition into these three crates is a Level 2 concern (section 5).

Prism interacts with three external actors. No fourth actor exists in the system context.

Level 1 System Context

Business Context

The business context specifies the actors that exchange information with Prism, and what information is exchanged.

Actor Role Information sent to Prism Information received from Prism
Application author A person or team that authors a Rust crate importing prism (which re-exports uor-foundation's type-declaration vocabulary; the author has only one crate to import) and distributes the resulting executable. ConstrainedTypeShape declarations; Grounding impls; selection of HostTypes, HostBounds, the AxisTuple (per ADR-030; the third substitution-axis position bound by + Hasher per ADR-036, with HashAxis from the prism-crypto standard-library sub-crate per ADR-031 as the canonical first member), and optionally the ResolverTuple (per ADR-036; the fourth model-declaration substrate parameter defaulting to NullResolverTuple, declared via the resolver! SDK macro and carrying application-provided per-value content for resolver-bound ψ-Term variants per ADR-035 when the model’s verb bodies emit any); runtime input bytes that the executable will process. Sealed pipeline outputs (Validated, Grounded, Certified, Triad, Derivation, FreeRank, Datum); Trace values; typed impossibility witnesses when the input does not admit a Grounded<T>.
Application user A person who runs the application author’s executable on local hardware. May be the same person as the application author; may be distinct. Trace values produced by the application author’s executable; the matching Hasher selection identifier (received out-of-band, alongside the trace). Certified<GroundingCertificate> values re-derived from the trace, or typed ReplayError values when re-derivation does not succeed.
Rust toolchain The cargo plus rustc ecosystem that compiles Rust source to executable form. The application author’s Rust source, including the prism-importing crate; the application user’s verification source, including the crate that calls into prism-verify. Compiled WASM or native executables.

The application author publishes the executable to a distribution channel of their choosing. The application user obtains the executable from that channel. Prism is silent on the channel: it MAY be a release page, a package registry, a peer-to-peer network, a signed Git repository, removable media, or any other mechanism that conveys a binary from author to user. Prism does not interact with the channel; the channel does not appear as an actor in the system context.

Technical Context

The technical context specifies the channels through which the actors exchange information with Prism, and the form of the information at each channel.

Channel Endpoints Form
prism API Application author’s source code → prism types, traits, and re-exports Rust source code, statically type-checked at compile time. The author’s crate is the endpoint. Failure to satisfy the surface prism exposes MUST cause rustc to reject the author’s crate.
prism → uor-foundation API prism → uor-foundation types, traits, and mint primitives Rust source code, statically type-checked at compile time. Failure of uor-foundation to satisfy the bounds prism declares MUST cause rustc to reject prism.
Pipeline runtime Application author’s compiled code → prism::pipeline::run Native function call. Inputs are sealed values constructed via the principal data path. Outputs are sealed Grounded<T> values plus Trace values.
prism → uor-foundation mint primitives prism::pipeline → uor-foundation::mint_* public functions Compile-time-resolved direct call from the pipeline into the mint-primitive surface. The architectural commitment (ADR-016) reserves prism's pipeline as the only sanctioned caller.
prism-verify API Application user’s source code → prism-verify types and functions Rust source code, statically type-checked at compile time. The verification surface accepts a Trace and a Hasher and returns either Certified<GroundingCertificate> or ReplayError. Implementation lives in prism's replay component; prism-verify is a façade re-exporting it.
Toolchain delegation Application author’s source / application user’s source → Rust toolchain Rust source code (*.rs files, Cargo.toml manifests). The toolchain produces compiled artifacts (WASM or native executables, library crates as compilation dependencies). Prism does not specify the toolchain invocation; this is the application author’s and application user’s responsibility.
Trace conveyance Application author’s executable → application user Trace values, in the wire format specified normatively in section 8 (Cross-cutting Concepts). The Hasher identifier is conveyed out-of-band alongside the trace; the wire format of the trace does not embed the hasher.

Cross-boundary Properties

Five properties hold at every boundary listed above. These restate the constraints in section 2 in terms of the boundary they apply to.

  • Sealing. Across the prism API and prism → uor-foundation API channels, no caller can construct a sealed certified type by any path other than prism::pipeline::run (which calls uor-foundation's mint primitives for the four UOR-domain types) or certify_from_trace (re-exported through prism-verify). (Constraint TC-02, TC-03.)

  • Compile-time UORassembly enforcement. Across the prism API and prism → uor-foundation API channels, the Rust toolchain rejects source code that violates the UORassembly contract. (Constraint TC-04.)

  • Zero-cost runtime. On the Pipeline runtime channel, no Prism runtime layer mediates the function call. (Constraint TC-01.)

  • Replay equivalence. Across the Verification API channel, the verifier never invokes the author’s deciders or any hash function. The trace and matching Hasher are sufficient. (Constraint TC-05.)

  • No author infrastructure. Across the Trace conveyance channel and the application’s runtime, no service operated by the application author is required for the application to function or for the user to verify its outputs. (Constraint TC-06.)

Clone this wiki locally