fix(headless): wait for memcard bootstrap IO progress
Intrepid/Prometeu/Runtime/pipeline/head There was a failure building this commit

Coordinate bounded native publication progress during frame advance while preserving watchdogs, guest budgets and resource ownership. Add controlled and packaged reopen regressions, clarify the runtime specs, and retain qualification evidence.
This commit is contained in:
2026-11-10 23:26:40 +00:00
parent 49d7fca0b7
commit c3589be1ad
34 changed files with 5904 additions and 5 deletions
@@ -371,6 +371,21 @@ and an explicit player policy through `boot_with_memcard_choice`. Its boot loop
waits for actual worker progress with a bounded watchdog timeout; frame execution
remains independent of real-time pacing.
During a headless frame advance, a successful bootstrap hook may still depend on
its native presentation publication. Only while that dependency blocks the active
VM and the corresponding IO remains queued or running, the host owner waits on
the shared lane's progress signal, outside firmware/VM ticks. Each requested wait
is at most 5 ms. Polling preserves the request's original 500 ms cancellation and
1 s stop/escalation deadlines. A single additional 2 s owner deadline starts on
first entry to this wait within an advance and never resets on wake or reentry.
It does not extend the native deadlines. Native media action stops the advance
with exact progress; if the dependency outlives the owner deadline without a
terminal boundary, it returns a native `memcard_error` for `advance` with reason
`restart_required` and the current media state. Neither outcome confirms IO
cessation or releases worker-owned buffers, media or locks. An ordinary gameplay
commit that does not block the VM does not activate this wait. Pure IO polling
and waiting do not advance guest counters or input and do not pace game frames.
Before guest boot, firmware presents persistent, fresh-memory-only and (when
available) existing-save-memory-only choices. Choosing no card does not bypass
snapshot reservation. Leaving a resident game with dirty RAM requires an explicit
@@ -326,6 +326,17 @@ wall-clock timeout.
the number of firmware ticks spent advancing one logical frame. Its limit is
tooling policy, not a guest cycle budget, runtime fault, or wall-clock
performance requirement.
- If a successful memcard bootstrap still blocks the active VM on its queued or
running native publication, the headless owner coordinates lane progress outside
machine ticks, in requested waits of at most 5 ms. The same advance retains its
request and a single 2 s outer deadline from first wait admission; wakes/reentry
do not reset it. Native 500 ms cancellation and 1 s escalation remain authoritative.
A native action-required boundary takes precedence; unresolved IO at the outer
deadline returns a memcard `restart_required` host error with a native snapshot.
Every return pauses execution and clears the host's step request. IO-only polls
and waits do not add guest ticks/frames, enlarge the 100,000 firmware-tick
watchdog, rerun bootstrap, or synchronize unrelated gameplay commits. Waiting
does not establish IO cessation or permit release of worker-owned resources.
- `capture_frame()` returns an owned clone of the canonical frame paired with
the latest successful advance. The explicit `{logical_frame_index, FrameId}`
pair is authoritative; no numeric equality or fixed offset is implied.
@@ -320,6 +320,22 @@ as a game frame. Idle IO polling leaves guest counters/input unchanged. Reconcil
accepts no replacement path, validates expected identity before changes, preserves
RAM/continuation/original retained results and does not rerun initialization.
When successful bootstrap remains blocked by its pending native publication, the
owner coordinates lane progress within the same advance, outside machine ticks,
with requested waits of at most 5 ms. This does not apply to an unrelated gameplay
commit. Native deadlines remain 500 ms for cancellation and 1 s for stop/escalation,
measured from the original request admission. One additional 2 s deadline from
first wait entry in an `advance_frame` does not reset on wake/reentry or extend
those deadlines. Existing native action-required/fault boundaries take precedence.
If the dependency remains pending at the outer deadline without such a boundary,
the advance returns `stop:host_error`, exact known `completed` progress, and
`error.code:memcard_error` with `details.operation:advance`,
`details.reason:restart_required` and `details.state` holding the native snapshot.
The guest finishes paused with the host step request cleared. This preserves
worker ownership until actual cessation, the 100,000-tick frame watchdog, transport
responsiveness and cancellation between frames; it introduces no intraframe
cancellation, guest fault, simulated progress, command replay or new protocol shape.
Runtime qualification uses neutral PBX/ABI fixtures, real distinct processes and
an isolated extracted distribution. It proves SUCCESS, termination, exact readback
without resave and stable appId across cartridge versions. Consumer source-language