Make gameplay failures reproducible

Stonefall: return to the same moment.

This native engine capture shows a Machina-fractured stone gateway under impact. Restoring the checkpoint and repeating the input reproduces the collapse; changing the launch direction produces a different outcome.

We checked restoration both before impact and while debris was moving, then verified the recorded playback. All checked states matched on this build and machine.

The geometry is fractured in advance. This scene uses project-specific checkpoint support for its collider caches; it does not establish support for every physics scene or identical results across devices.

Observe the running game coherently.

One observation brings together build and content identity, tick, state hash, screen and UI information, resources, recent commands, changes, events and script errors. A rendered capture can accompany the observation from the same frame.

Headless player sessions can step gameplay without a GPU. Offscreen rendering adds images through the real renderer. Rust sessions, the CLI, a JSON-RPC protocol and an MCP adapter expose operations for tests, developer tools and AI agents. Controls can be addressed through paths or semantic IDs.

Automation is a development/test surface. Release player variants exclude the agent protocol and command history. Device support and rendering availability depend on the host.

Record the inputs a replay needs.

A recording contains frame input and timing, host events, and taped external readings such as wall time, entropy and user-storage results. Background content and navigation results are delivered at their recorded points during replay.

Strict replay compares build, package and content identity before proceeding. State hashes and per-section checkpoint digests locate a divergence at recorded sample points and name the differing sections. Detailed state recording can add a structured diff; a lenient mode permits deliberate replay against changed inputs after a fix.

Editor Play recordings embed the pre-Play scene document, including unsaved edits. Development and Test players have a configurable flight recorder. A failed scenario step emits a bundle containing its recording, last observation, history, failure details and a capture when rendering is enabled.

Exactness targets the same build and platform and the state covered by the hash. A divergence that appears and heals between hash points can go unseen; every-tick hashing narrows that interval. Pixel identity across GPUs and cross-platform physics determinism are not guaranteed.

Restore execution state with declared coverage.

Execution checkpoints extend a game save with registered subsystem state. A section declares fingerprint, capture, restore, version and dependency behavior. Tests restore and continue physics, runtime spawns, animation, script state, timers, edited mesh-instance sets, runtime render textures and material parameters, navigation paths, ground-motor orders and vector art mid-transition. Streamed-out entities and their saved state are held by the world-streaming section. Checkpoints use persistent entity identities and canonical section encoding; example-scene tests compare capture → restore → capture digests in deterministic and realtime sessions.

Undeclared state refuses capture by name. In-flight work can defer capture until a suitable boundary. Compatibility checks compare build, package, content and simulation identity before teardown. Tests check that an incompatible checkpoint leaves the running scene unchanged. This makes missing coverage and incompatible inputs visible to the caller.

Coverage is incomplete. Edited voxel volumes and fragments, voxel streaming residency, Story playback, joints, some Machina state and other unsupported runtime state still refuse checkpoints. Vector text inputs currently restore their displayed text but lose the localization key until set again. Editor Play's existing save-based checkpoint slot is a separate workflow. The Session::replay_from API restores a checkpoint from mid-recording and verifies the remaining frames. Streamed replay supports pause, forward skip and restart, described below. A clickable timeline, arbitrary backward seeking and a checkpoint-backed rolling recording window remain unfinished.

Open a recording as an interactive session.

A native game can render offscreen and stream its frames to a browser over WebRTC. The same session can expose the agent protocol, so a person watches the game while an agent inspects its structured state. This is a native streamed session; the browser is the viewer and input surface.

# Run from the engine checkout; use your project and recording paths.
cargo xtask stream PROJECT --replay RECORDING --endpoint /absolute/path/to/session-agent.json
# Connect an MCP client to that same session.
cargo xtask mcp --endpoint /absolute/path/to/session-agent.json

Replay feeds each recorded frame at its recorded timing and checks the recorded state samples. A divergence stops playback and reports its tick. The control-link page offers Pause/Play, +5 seconds and Restart. Taking control ends replay and continues the game live from its current state; live input and external readings resume.

Restart restores the starting checkpoint and virtual wall time when supported, preserving the session and agent connection. If the start cannot be checkpointed, restart reopens the session. The separate Session::replay_from API can restore a supplied checkpoint and verify the subsequent recorded frames.

A launch provides separate view and control links, with up to four viewers. View links permit watching; control links additionally permit input and playback controls. Only one controller owns input at a time, including agent connections. Taking or releasing control clears held buttons, keys and touches.

Current streaming is for local and LAN development. Audio, internet session infrastructure, a clickable timeline, arbitrary backward seeking and automatic recording of a fork with its parent-run identity remain unfinished. Forward skip simulates the intervening frames. Streaming does not expand checkpoint coverage or replay determinism.

The October 21 website capture exercised pause, inspection and live continuation in the lifecycle example. A separate vector recording matched from the start (480 frames, six hash and six digest comparisons), but its streamed restart diverged at recorded tick 60. Restart needs further validation for that scene.

Documented verification includes Chrome playback and input, viewer/control permission checks, and headless tests of replay-to-live continuation and restarting with matching hashes. Latency distributions and broad browser/device acceptance remain to be measured.

Check behavior against explicit contracts.

The workspace architecture is generated from a shared model and checked for drift. That documentation check is distinct from behavioral contract tests and composition builds.