Aperture™ Runtime Reconstruction Architecture
From Governed Computation to an Inspectable Longitudinal Record
SubstrateX Aperture™ is a Runtime Evidence Observatory. Its reconstruction architecture is the implemented bridge between controlled computation and the evidence surfaces through which longitudinal computational behavior can be examined.
The Runtime Blackbox and Runtime Reconstruction perform different functions.
The Blackbox governs computation. Runtime Reconstruction constructs the inspectable longitudinal record.
The Blackbox controls whether a qualified source may enter computation, which execution path is used, when the run reaches an evidence-bearing state, and whether an evidence record can be issued. Runtime Reconstruction begins from the structures produced through that controlled boundary. It aligns observations, coordinates, events, measurements, regimes, and markers into a common runtime object that can be replayed, investigated, challenged, and preserved.
This is not an attempt to reproduce an inaccessible internal computation. Aperture does not reconstruct hidden model state, private reasoning, consciousness, intention, or an unobserved causal mechanism. It constructs an ordered representation of the behavior supported by the supplied operational record and the declared computational methods applied to it.
The result is a source-bound account of development across time.
The Reconstruction Boundary
Reconstruction begins only after source qualification and controlled computation have established the material from which a runtime can lawfully be formed.
The architectural sequence is:
Qualified source record
↓
Role-preserving canonical events
↓
Observable measurements and registered detectors
↓
Coordinate and event normalization
↓
Canonical runtime spine and runtime event ledger
↓
Regime and temporal reconstruction
↓
Worldline and replay-frame construction
↓
Governing evidence run, investigation, and preservation
Each stage inherits the authority limits of the stage before it. A later visualization cannot repair missing source evidence. A replay frame cannot promote a candidate marker into a confirmed event. An instrument cannot move a temporal anchor. An operator-facing summary cannot create a stronger claim than the governing evidence run supports.
This inheritance rule is one of the central implementations of Evidence-Governed Computation™ within Aperture.
One Runtime, Several Coordinated Objects
The reconstruction architecture separates several related objects that conventional dashboards often collapse into a single visualization.
Canonical runtime spine
Holds the ordered frame structure, coordinates, events, roles, regimes, measurements, markers, and evidence references for the reconstructed run.
Runtime Event Ledger
Registers evidence-bearing events and their type, coordinate, source, basis, and relationship to the governing run.
Runtime Playback Frames
Provide a cursor-addressable replay sequence derived from the canonical spine.
Worldline Projection
Makes the reconstructed trajectory visible without becoming an independent evidence source.
Temporal Authority
Governs event ordering, marker status, interval admissibility, and the distinction between weakening, candidate formation, confirmed boundary crossing, observable failure, and recovery.
Reconstruction Surface
Brings these objects into one investigative environment while remaining subordinate to the governing evidence run.
These objects are coordinated, but they are not interchangeable. The runtime spine is not the worldline. The worldline is not the evidence authority. Playback is not a new analysis. The reconstruction surface does not become authoritative merely because it displays authoritative material.
The Canonical Runtime Spine
The canonical runtime spine is the structural center of reconstruction.
It converts a collection of computed series and source-linked observations into an ordered frame sequence. Each frame can carry:
a frame index;
a canonical turn;
an original source turn, when supplied;
a declared primary coordinate;
role and source references;
registered measurements;
regime state;
event and marker references;
temporal readings;
continuity, drift, pressure, stability, and recovery-related values where computable;
a bounded source preview or content reference; and
the evidence basis used to construct the frame.
The spine therefore serves as more than a time series. It is the common coordinate structure through which source records, computed measurements, temporal events, worldline positions, and downstream evidence surfaces remain aligned.
Its governing rule is:
A reconstructed feature must resolve to the same runtime identity and coordinate system as the evidence from which it was formed.
If a surface cannot resolve a value to the governing spine or another declared authority object, it must report the value as unavailable, unresolved, or not computable. It may not silently construct a substitute.
Coordinate Reconciliation
Operational records rarely arrive with one universal time coordinate. A transcript may supply ordered turns. An incident record may contain timestamps. A workflow may contain event numbers. A normalized runtime may introduce its own frame sequence.
Aperture preserves these differences through three principal coordinates.
Frame Index
Identifies a position inside the reconstructed playback sequence.
Canonical Turn
Identifies the normalized order established during canonicalization.
Source Turn
Preserves the original source coordinate when one was supplied and qualified.
The architecture records which coordinate is primary for each frame and event. A valid source coordinate remains primary when available. When the source does not supply one, Aperture may use canonical order while preserving the absence of the source coordinate.
It does not collapse the three systems into one ambiguous turn number.
This matters because temporal claims depend on order. A warning, boundary event, failure marker, or recovery event cannot be compared lawfully unless the coordinates used for the comparison are known and compatible.
When coordinates disagree, Aperture is designed to expose the disagreement rather than conceal it through visual alignment.
The Runtime Event Ledger
The runtime event ledger records the events through which the reconstruction can be inspected and challenged.
An event may include:
a stable event identity;
event type and severity;
frame, canonical, and source coordinates;
a label and evidence basis;
the registered source from which it was resolved;
associated measurements or markers; and
an inspection path back to the relevant evidence.
The ledger distinguishes among different event origins. Source-observed events, operator-supplied markers, computed transitions, candidate boundaries, confirmed boundaries, observable failures, and recovery events do not receive the same status merely because they appear on the same timeline.
This prevents a common analytical error: treating every visible marker as though it possessed identical evidentiary authority.
The ledger also gives replay, investigation, synthesis, and preservation a common event vocabulary. Those surfaces may organize or filter registered events. They may not rewrite their identity, coordinate, or authority.
Regime Reconstruction
Longitudinal behavior is not represented as a collection of isolated scores. Aperture reconstructs how the runtime occupied and moved among registered behavioral regimes.
Regime reconstruction binds a state to each qualified frame and examines whether the evidence supports persistence, transition, collapse, recovery, or another registered condition. Versioned transition rules and hysteresis prevent a momentary fluctuation from being automatically presented as a sustained regime change.
The reconstruction can therefore distinguish:
a local variation from a persistent transition;
rising pressure from a confirmed boundary crossing;
a candidate event from an established event;
visible failure from instability without a supplied failure marker; and
temporary improvement from supported recovery or re-entry.
Regime labels describe the organization of the observed runtime under declared rules. They do not establish why the system behaved as it did, what an actor intended, or what inaccessible internal state existed.
Unified Temporal Authority
Temporal reconstruction is governed by explicit anchors rather than inferred from the visual position of a chart marker.
Aperture distinguishes several event classes:
t_aw — an admissible weakening or warning anchor;
t_candidate — candidate boundary formation;
t* — confirmed Basin Exit;
tf — externally observable failure, when supplied or otherwise lawfully established from the record; and
recovery or re-entry — a supported return event after instability or exit.
These anchors are not synonyms.
Candidate boundary evidence is not automatically promoted to Basin Exit. A confirmed Basin Exit requires the applicable persistence and hysteresis conditions. Observable failure remains distinct from the preceding runtime transition. Recovery must be supported by evidence after the relevant disruption; it cannot be inferred from a favorable final frame alone.
Formal lead-time is admissible only when the required anchors exist on a compatible coordinate system and occur in a valid order:
Δt = tf − t*
If t* is confirmed but tf is not supplied, Aperture may report an open inspection window or post-exit watch. It must not report formal lead-time. If candidate formation exists without a confirmed t*, the event remains candidate evidence. If coordinates conflict, the interval remains unresolved.
A missing anchor is never converted into a zero-valued event merely to complete a timeline.
This separation prevents retrospective visual proximity from being presented as prospective warning capability.
Worldline Formation
The worldline is generated from the canonical runtime spine. It makes change across the runtime visible by projecting registered frame values into a navigable trajectory.
Its geometry may express relationships among dimensions such as stability, drift, pressure, continuity, Basin proximity, role fragmentation, or recovery support. The visible position of a frame remains a projection of registered evidence; it is not an additional measurement created by the display.
The architecture therefore enforces several boundaries:
the worldline cannot create a new event;
visual geometry cannot move a formal temporal anchor;
animation cannot fill missing evidence;
display compaction cannot remove evidence from the governing record;
a color or spatial transition cannot establish a stronger regime claim; and
alternative visual layouts must resolve to the same underlying frames and evidence identity.
This allows presentation to adapt to screen size, runtime scale, and investigative purpose without allowing the reconstruction itself to drift.
Replay-Frame Construction
Runtime replay is built from the ordered spine rather than from an independent animation state.
Each playback position can resolve:
the current frame and its coordinates;
the corresponding source reference;
the active regime;
registered measurements;
events and markers at that position;
the preceding and subsequent runtime relationship; and
the evidence basis available for inspection.
Moving the replay cursor does not recompute the run or generate a new interpretation. It changes the operator's position within the same reconstructed evidence object.
This distinction is essential. A conventional playback can become a persuasive animation detached from the source. Aperture's replay is designed as an evidence-return mechanism: the operator can move from the visible runtime state back to the frame, event, coordinate, and source material that support it.
The replay must therefore remain synchronized with the governing runtime spine. Duplicate or stale frame stores cannot become competing authorities.
Source-Linked Reconstruction
Every reconstruction must preserve a path back toward origin.
Aperture carries source identity, canonical identity, run identity, frame references, event basis, and content references through the reconstruction. This enables a visible finding to be traced through the following chain:
Visible feature
↓
Worldline or reconstruction frame
↓
Canonical runtime spine
↓
Registered event or measurement
↓
Canonical source position
↓
Supplied operational record
The return path is as important as the forward computation. Without it, a reconstruction may be visually coherent but evidentially weak.
Deterministic Core and Variable Issuance Metadata
The reconstruction contains a deterministic computational core and a separate issuance envelope.
The deterministic core is governed by the qualified source, canonicalization rules, method versions, registered measurements, detector rules, and reconstruction contracts. When these inputs remain fixed, the same source should resolve to the same canonical ordering, frame relationships, registered events, regime sequence, and reconstruction identity.
Some surrounding metadata may legitimately vary. Issuance time, operator-declared context, optional disclosure fields, interface state, and preservation time do not belong to the deterministic computational core.
The architecture must therefore distinguish:
what was recomputed from fixed evidence and methods;
what was supplied by an operator;
what was generated as issuance or preservation metadata; and
what remains absent.
This prevents a timestamp difference from being mistaken for a computational mismatch and prevents variable context from silently altering the underlying reconstruction.
Missingness and Reconstruction Failure States
Evidence-Governed Computation requires the system to preserve failure and uncertainty states instead of completing the record cosmetically.
No Qualified Source
Remain in an awaiting state; do not construct telemetry or a runtime spine.
Insufficient Telemetry-Bearing Observations
Report the run as not computable under the applicable method.
Source Coordinate Absent
Preserve the absence and use canonical order only where declared.
Coordinate Disagreement
Expose the conflict and withhold dependent temporal intervals.
Candidate Boundary Only
Preserve candidate status; do not issue confirmed Basin Exit.
Confirmed t* without tf
Report the supported watch or inspection window; do not compute formal Δt.
No Replayable Frame Sequence
Withhold the worldline and replay rather than generate a decorative substitute.
Missing Source Basis for a Finding
Mark the finding unsupported, unavailable, or outside the claim boundary.
These are not interface inconveniences. They are evidence states.
Reconstruction Consumers
Once formed, the reconstruction supports several downstream Aperture capabilities:
Evidence State examines evidentiary validity, coverage, and claim boundaries;
Claim Lineage traces how supported statements arise from the record;
Runtime Map presents regime occupancy and behavioral terrain;
Formation Timeline examines temporal development;
Failure Boundary inspects weakening, candidate formation, Basin Exit, failure, and recovery;
Role Topology examines role-bearing relationships preserved through ingestion;
the Instrumentation Stack issues bounded projections over the same governing run;
Guided Investigation organizes human inspection; and
preservation retains the reconstruction and its lineage for later replay, comparison, and challenge.
These are consumers of the reconstruction. They are not independent reconstruction authorities.
Architectural Invariants
The Runtime Reconstruction Architecture is governed by a small set of non-negotiable invariants.
One governing runtime identity. Every frame, event, worldline point, replay position, and downstream projection resolves to the same evidence run.
Origin remains recoverable. Reconstructed features retain a path back to their source and computational basis.
Coordinates remain explicit. Frame, canonical, and source coordinates are never silently conflated.
Markers retain their status. Weakening, candidate formation, confirmed Basin Exit, observable failure, and recovery remain distinct.
Missing evidence remains missing. The interface cannot complete an incomplete record.
Visuals do not create authority. Geometry, animation, emphasis, and layout remain projections.
Replay does not recompute. Playback navigates the issued reconstruction rather than generating a new one.
Downstream systems are read-bound. Instruments, investigations, summaries, and operational lenses cannot mutate the spine or its evidence.
Formal intervals require admissible anchors. No lead-time claim is issued without the required ordered events.
Preservation retains lineage. An exported reconstruction carries the identities, methods, uncertainty states, and claim boundaries required for future inspection.
Relationship to the Instrumentation Reconstruction Page
The Instrumentation section explains how the reconstructed runtime becomes the common object examined through multiple bounded instrument projections. This Engineering page establishes the architecture that makes that relationship possible.
The distinction is:
Runtime Reconstruction in Instrumentation explains the observatory, the shared object of measurement, and how instruments participate in investigation.
Runtime Reconstruction Architecture in Engineering explains how the canonical spine, coordinates, ledger, temporal authority, worldline, and replayable record are constructed and kept coherent.
The two pages describe different layers of the same system. One concerns scientific and investigative use. The other concerns computational formation and evidentiary control.
The Governing Definition
SubstrateX Aperture™ Runtime Reconstruction Architecture is the evidence-governed computational system that aligns qualified source records, canonical events, measurements, coordinates, regimes, temporal anchors, and replay frames into one inspectable longitudinal runtime.
Its purpose is not to generate a persuasive story about what occurred. Its purpose is to construct an ordered record whose visible structure can be traced, replayed, measured, challenged, and preserved without exceeding the authority of the supplied evidence.
The Blackbox determines whether computation may proceed and when an evidence-bearing run exists. Runtime Reconstruction gives that run its inspectable longitudinal structure. Runtime Evidence Authority governs the identity, claim limits, and preservation posture of the resulting record.
Together, these layers make Aperture's central capability executable:
Operational records become source-bound Runtime Evidence through controlled computation, deterministic reconstruction, governed measurement, and preservation-ready lineage.