MW3 keyboard-only readiness at 0x4f7ae0

Evidence: scratch/runs/20261111-mw3-keyboard-only-caller-cause-0520/. No original game, browser, or box was launched. The executable remains the existing test/binaries/shareware/mw3/ex/Program_Files/mech3demo.exe, SHA-256 df457ee6973f6f9d557c57aa3fc14258303486ec8b8742fd37b4369c1f37dbdc.

What the retained originals establish

The 0500 full main-menu image is visibly rendered, with the game's software cursor at its center. Its five-second recorder contains 57,055 keyboard GetDeviceData entries returning to 4f7ae0, device type 1, flags 1802 (70a hex), mouse flags 1/users 2/acquired 1. The sampler reports an open mouse gate. It also counts 57,056 PeekMessageA, GetTickCount and timeGetTime calls each, with complete dispatch entry/exit counts, no errors/drops/pending frames and no mouse requests/completions. These category counts lack a full chronology.

Crucially, reads: [] and records: [] in that recorder describe mouse observations. They do not report the keyboard HRESULT, returned count, flags, records, or the outer caller of 4f7aa0. Those values are unknown for 0500. Even 57,055 matching dispatch exits cannot reconstruct their keyboard data. The native menu-lock command failed before input at the unchanged five-second matched-read guard. This is neither proof of emulator input loss nor proof that the ordinary interactive menu was ready.

The successful 0345 original instead has completed mouse Poll/GetDeviceState calls returning to 4fa55f/4fa56c, plus normal keyboard polling at 4f76c8. Its actual scaled software-cursor motion and pressed/released reads are the evidence for ordinary mouse menu readiness. Reaching the same-looking background in another run does not establish the same internal menu state.

Authentic drain and its callers

4f7aa0(ECX=blocking) first ages key states through 4f7610. It initializes a local in/out count to 1, then calls the keyboard at 5fc90c through vtable+28, using stride 16, data buffer [5fc910], flags 0, returning to 4f7ae0. It copies the returned count to 5fc914.

HRESULT zero processes returned records. 8007001e calls Acquire and then processes the current count without immediately reissuing GetDeviceData. Other HRESULTs go through the error reporter 4fa810 and return zero. Alt (38/b8), Ctrl (1d/9d) and Shift (2a/36) update modifier bits 100/200/400 at 5fc920 and return no key. Non-modifier pressed records return DIK OR modifier mask; releases return zero. It updates the corresponding eight-byte key-state record at 5fc924 as well.

At 4f7bfa, a nonzero key exits. Otherwise, ECX saved at function entry determines whether to return zero or loop at 4f7ac6. There is no timer, message pump, sleep or mouse poll inside this loop. Its count is initialized only once: a blocking empty return leaves requested count zero on subsequent iterations. The compiled fixture reproduces this, including a subsequently queued key remaining unread until a fresh nonblocking invocation. This is an original-code property, not a diagnosed emulator defect. All five static direct callers (42149d/421510/421583/421694/563406) explicitly clear ECX. The 0500 record does not show which caller executed; the near-equal message and clock counts are consistent with repeated outer nonblocking calls, not evidence of the internal blocking loop.

The four 421xxx calls belong to control-binding UI branches. A separate important path is 563406 -> 4f7aa0, inside the sequence pump at 5633f0:

  1. A null current node (this+18) returns inactive without reading keyboard.
  2. A non-modifier key press calls node cleanup, stops the associated resource through 53a330/53a6c0, clears the node, and returns inactive immediately.
  3. With no key, the pump calls node virtual+4 with suppliedTime - this.start. An active node keeps the sequence active. A finished node is cleaned up, replaced with its next pointer, and the next node is initialized.
  4. On normal node completion the pump still returns active for that iteration; a newly null node returns inactive on the following call.

5634c0 supplies unsigned timeGetTime ticks converted through a zero-extended 64-bit integer and multiplier at 599cf0 (approximately .001). The repository disassembler labels df 6c 24 04 as word FILD; its ModRM /5 actually selects m64int, matching compiled execution. Preserve raw clock words when checking timer behavior. Sequence callers include 46acd1 (DEMO_INTRO), 46ad9c (SPLASH), 46af77, 40707c, 464f6e, 4731ee, and the synchronous sequence loop at 563350. Therefore caller 4f7ae0 alone cannot identify a menu mode.

The authentic WAIT node starts at 563c50 and tests at 563c60: active = suppliedElapsed < float(start) + float(duration). The authentic movie node 563b90 computes a frame from (elapsed - nodeStart) * movieRate and _ftol, skips decoding if the frame is unchanged, and otherwise uses decoder success to determine continuation. Fade node 563870 has its own duration/direction boundaries. None of these paths consults the mouse gate. An open dispatcher gate is useful only when execution reaches dispatcher 4fa160; it does not force any of these sequences to call it.

Tested bounded observer

tools/mw3-keyboard-readiness.cjs supplies a serializable attach diagnostic. Install it before instantiation on the verified owning Worker's imports, passing the existing serializable sample from mw3-menu-poll-decision.cjs, readCompletion from mw3-keyboard-completion.js, exports getter, shared memory, and actual region layout. Verify full executable/module/Worker/epoch identity outside the helper. It owns one known API-log setting for one window; do not run another API-log owner concurrently. Existing mouse admission remains intact.

It matches actual compiled entry/exit, reads requests only at 4f7ae0, and retains actual HRESULT/count/records, device/gates, blocking argument and outer caller. For 56340b, it also reads sequence/node identity, vtable step, next pointer, raw start/current double words and 12 node DWORDs. For verified 5634c0 wrappers it includes controller return address and raw tick words; movie nodes additionally expose their rate word. Authentic code prefixes guard the frame layouts. Unsuccessful returns survive before decoder rejection.

Storage has at most 64 aggregate rows by default, maximum 256; each retains count and first/last raw samples. Clock/sequence counters do not create unbounded keys. Different keyboard transitions remain separate. Overflow, decoder failure, replacement or incomplete frames are diagnostic failures, never readiness approval. Duration is at most 45 seconds, default five, with expiry checked on hooks and passive snapshots. Stop restores prior logging; restore leaves captured wrappers inert and reports table conflicts. This is bounded evidence, not a complete transition chronology or an input controller.

node --test tools/mw3-keyboard-readiness.test.cjs executes byte-identical drain, sequence, time wrapper and WAIT-node slices in the full production WASM with production renderer buffered edges and compiled Acquire/GetDeviceData. Synthetic caller, objects, callback counters and unrelated cleanup stand-ins are labelled in the test. It proves empty/nonblocking return, pressed/released and modifier behavior, the zero-count blocking loop, active/finished/null sequence branches, press-to-skip, raw stack/clock decoding, actual WAIT boundary at 1499/1500 ticks, overflow, failed HRESULT retention, changed-code refusal, expiry, single-use and inert/conflict handling. This is not original gameplay.

Remaining prerequisite

Capture this diagnostic in a separately authorized, identity-bound original readiness interval, with the existing deadline and no input/replay. The missing discriminator is the actual outer caller and, if it is 56340b, the controller caller, current node/step, raw time progression and completed keyboard returns. That distinguishes ordinary intro/splash/timed presentation from a frozen clock, failed keyboard API, control-binding mode, or another branch. Only then can one justify an ordinary menu action or a specific emulator/control repair. Do not send an arbitrary key, change the game's gates, treat absent reads as a defect, or lengthen the admission timeout to conceal the unknown state.

Ordinary launch integration (0530)

The existing small-input preparation command now recognizes the retained 0500 ordinary controller and automatically regenerates its serialized Worker prefix:

python3 -B tools/mw3-retention-repair.py \
  scratch/runs/20261111-mw3-complete-helper-cockpit-0500 OWNED_RUN

Use an owned destination with no colliding prepared files. This emits the browser, throttle adapter, dispatch observer, Worker prefix and unchanged owner/collector/recovery inputs. Stage the remaining existing small launch dependencies as usual and regenerate runtime pins before any separately authorized original. The direct four-file installer is node tools/mw3-readiness-install.cjs SOURCE OWNED_RUN. Neither command launches anything. Historical source inputs remain untouched.

The rebuilt prefix installs keyboard hooks before compiled instantiation, using the published sample/return decoder. attachDispatch forwards its three log hooks into a private keyboard hook table. Only the mouse recorder toggles API logging; the keyboard observer runs with apiLogOwner:false. It resets bounded storage on each mouse window and stops with that window. A keyboard diagnostic error remains in its snapshot without disabling mouse logging or changing mouse admission. The original standalone keyboard observer retains single-use logging ownership by default. Existing throttle observers remain separately inactive until their original controller route arms them.

Every ordinary dispatch snapshot now carries keyboard. The controller also saves identity-bound keyboard-readiness-last.json before identity/validation checks, and keyboard-readiness-final.json on stop. Thus the initial matched-read failure's existing finally block preserves actual keyboard results, outer caller, node and first/last raw clocks without issuing input. Preclick refusals retain the same data in their existing refusal snapshot. No mouse validator, native input route, command deadline, five-second stream guard or observation duration was changed.

node --test tools/mw3-readiness-install.test.cjs prepares through the existing Python entry point and executes the actual serialized prefix, compiled original drain/time/WAIT slices and exact ordinary controller execute() with real command transport. It proves causal retention with no mouse reads, failed HRESULT retention, one logging owner, reusable bounded windows, sticky refusal/no replay, and unchanged mouse move/press/release after a compiled completed mouse read. Caller objects, screenshot admission and native sends are labelled fixture substitutes; this is not an original-game readiness observation. Evidence: scratch/runs/20261111-mw3-readiness-integration-0530/.

Exact native key witness (0645)

The 0600 original retained trusted ArrowUp DOWN/UP with stale capture-microtask samples 4/5, while compiled GetDeviceData consumed sequences 5/6. Chromium can checkpoint microtasks between native listeners, before the later window capture listener forwards the event into the renderer. A later timer's global sequence would also be ambiguous in the presence of unrelated input.

The ordinary preparation command above now serializes tools/mw3-native-key-witness.cjs into that same early listener. Its read-only wrappers observe _recordDirectInputKey synchronously inside handleKeyDown/Up. Chromium's current DOM Event object connects that actual delivery to the early listener's WeakMap row. The receipt contains the producer's actual sequence, VK, direction, completion and errors. Missing current-event identity, suppressed or repeated input, conflicting wrappers, multiple producer records and producer exceptions cannot qualify. The wrappers preserve the original receiver, arguments, result and exception; they send no input and consume no buffer.

The prepared throttle.cjs uses correlateEdges: exactly one trusted DOWN/UP pair, each with exactly one completed matching producer receipt, is required. The original correlate then matches exact sequences, direction, DIK, device, buffer, count pointer and caller in successful non-peek compiled completions. The old before/after samples remain raw diagnostics. No sequence is inferred by adding one or by matching timestamps alone. Sticky controller failures and original no-replay admission are unchanged. Stage remaining dependencies only when absent, preserving the newly prepared throttle adapter, and repin all inputs.

node --test tools/mw3-native-key-witness.test.cjs uses local headless Chromium, the production browser bridge/renderer/host, compiled GetDeviceData, and the prepared serialized ordinary execute/transport/throttle/pulse/timed helpers. The synthetic device and owner identity are explicit; no original runs. Normal and loaded trusted ArrowUp pairs must qualify despite stale microtask samples; unrelated trusted ArrowLeft edges in the loaded hold make the target sequences nonconsecutive. Stale, wrong, duplicate and unrelated receipts/completions refuse. A trusted key ignored by the ordinary page-focus rules must fail and prohibit later transport input. An independent fixed local watchdog is armed before Chrome, and both children are actually waited with separate stdout/stderr EOF. Evidence: scratch/runs/20261111-mw3-post-dispatch-key-witness-repair-0645/.

Cockpit Enter review routing (0720)

The single original in scratch/runs/20261111-mw3-producer-witness-cockpit-response-0720/ reached the Bushwacker cockpit through ordinary pilot entry and Instant Action. Both Up Arrow and top-row 0 passed the synchronous producer witness and exact compiled GetDeviceData correlation (sequences 5/6 and 7/8 respectively). This establishes keyboard consumption; chassis displacement remains unproved.

The next Enter request was intended to cycle weapons, as the shipped readme specifies. The retained controller instead applied its Pilot Entry guard to every Enter key. It failed before native dispatch with actual full Pilot Entry review required, closed the browser, and became terminal. No weapon fired, no ammunition response was observed, and the stopped original was not replayed.

Ordinary preparation now installs tools/mw3-key-action-review.cjs. Pilot commands retain their existing dialog requirements. Cockpit weapon cycling requires cockpitAction: 'cycle-weapon', key Enter, and separate review evidence with scene: 'cockpit', fullImageReviewed: true, selectedWeapon naming the visible selection, and cockpitControls: ['weapons', 'speed']. A conflicting pilot flag, wrong scene, missing selection/controls or unknown purpose refuses before dispatch. Existing screenshot hash, live identity, admission, command deadline, balanced pulse and sticky failure checks remain in place.

node --test tools/mw3-key-action-review.test.cjs executes the prepared ordinary controller with the production transport, pulse and key mapping, using labelled synthetic image/identity/CDP sinks. It verifies cockpit and pilot Enter pairs, the retained bare-Enter failure, and refusal/no replay for invalid reviews. This repair was qualified locally after archival; it was not applied to the terminal original. A future original must prepare fresh inputs and repin them.

Static HTTP pins must follow staged source (0840)

scratch/runs/20261111-mw3-cockpit-motion-space-response-0840/ did not launch the original game. Fresh same-box harmless fixtures qualified the regenerated Up/0 producer witnesses and actual prepared Enter/Space controller routes, including compiled key consumption and held-fire polling. These are fixtures, not chassis movement, weapon selection or ammunition evidence from MW3.

The first supervisor refused before Node because its inherited six-minute reserve produced a child deadline beyond the owner's 30-minute cap under the 45-minute allocation. Its actual exit was preserved. The corrected calculation is min(allocationDeadline - 600, now + 1740); the allocation never moves.

The retry reached the ordinary controller's HTTP guard before Chrome. Its fresh files/uploadFiles pins contained /index.html SHA 02d9b1e41b8e9de27eae289740ae799ff747527e2ba312ed07bc4dc17d276357, while inherited httpPins still expected fa81b9ebfd01d3fbfa2852bfec4503a87d4b5ce47cf4522cd4c134ac82cfb11c. The guard correctly refused. The collector then treated absent Chrome receipts as terminal and performed the delegated normal stop. The box is archived; there was no cockpit, guest action or new movement/ammunition result.

After generating the complete fresh runtime graph, regenerate HTTP pins too:

node tools/mw3-runtime-http-pins.cjs INPUT_PINS_JSON NEW_PINS_JSON

Do this before allocation/provisioning and freeze the resulting manifest as the run's runtime-pins.json. The helper checks every static route against exactly one files and uploadFiles entry and actual local bytes. It emits a new file exclusively, preserves source identity and the input graph, and refuses absent, duplicate, stale or nonliteral routes. It changes no runtime HTTP guard, native input, deadline or admission requirement. Its regression test serves changed staged files through the production static server and checks real response hashes, refusal cases and exclusive output publication.

A future run must also distinguish a pre-Chrome owner exit from a live browser when collecting lifecycle evidence, so a recoverable preparation failure does not consume the remaining fixed allocation through automatic box shutdown. Preserve the failure and actual Node/outer waits; never invent Chrome waits.

Normal preparation and recoverable pre-Chrome failures (0940)

The ordinary tools/mw3-retention-repair.py RETAINED_0500 OWNED_RUN entry now installs prelaunch custody and a prepared pin.py. After staging the remaining small helpers, run that generated pin.py: it finalizes HTTP pins from the fresh files/uploadFiles graph through mw3-preparation.cjs. The controller still checks actual static HTTP responses before attempting Chrome. The owner child deadline is bounded by both allocation minus 600 seconds and now plus 1740 seconds, respecting owner.py's strict less-than-1800-second cap.

On a failure inside the controller before any Chrome spawn attempt, the controller publishes chrome-not-started.json with its Node PID. Recovery requires real failed Node/outer waits, both EOFs, joined readers, matching PID, and no contradictory Chrome spawn/process/stream/endpoint/launch evidence. It retains the terminal manifests and returns recoverablePreChrome:true. The recovery supervisor writes recoverable-prechrome.json without requesting normal stop, so the worker can repair inputs and retry a confirmed exited job within the original fixed allocation. Preserve each failed runtime directory; never resend an uncertain command. Once Chrome was attempted, or without the explicit marker, all Chrome wait/stream requirements remain mandatory.

Focused regressions: node --test tools/mw3-preparation.test.cjs tools/mw3-runtime-http-pins.test.cjs tests actual static responses; python3 -B tools/mw3-prelaunch-recovery-test.py OWNED_FIXTURE_DIR runs two actual failed prepared controllers under one deadline, verifies real Node and outer waits/EOF, and refuses unknown/contradictory Chrome state and incomplete EOF. The fixture launches no Chrome or original game.

The prepared owner embeds the pure deadline calculation, so moving the small owner input into a nested retention fixture does not change module lookup. Retention fixtures give that owner a 1000-second synthetic allocation and keep their independent 100-second watchdog; production allocation deadlines are unchanged. The retention runner selects the staged decision-sampling fixture when present. Actual successful and failed Node/Chrome/outer waits, both EOFs, the outer publication barrier, and missing-evidence refusal pass on this path.

2026-11-11 original gameplay consequence (0940 run): the repaired normal preparation launched the unchanged module 75ecda5701c15f6fe2c269455ead4e15457b90653733df15d35674b08e8849d5 through Pilot / Instant Action / Operation 1A / Launch. Full cockpit frames were personally reviewed before each action. The shipped Up and 0 controls produced matched compiled buffered consumption; the settled full-throttle frame showed speed 17 and OP Able 447 m, versus speed 0 and 449 m before. A later full frame showed speed 81, OP Able 341 m, and changed terrain. Enter selected the first M.Gun. A normal two-second Space hold produced an actual fire poll during the hold; the settled frame after release showed both M.Gun counts at 96, down from 100. No guest state was written.

The first weapon-cycle request was refused before dispatch for a stale scene (effects:0, refreshRequired:true). Its acknowledgement and failed local attempt are retained. A fresh full capture was reviewed before a distinct new command; no uncertain command was resent. Ordinary Browser.close followed the ammo consequence. Raw captures, matched module identity, input receipts, consumption timestamps and parent wait/EOF evidence are retained under scratch/runs/20261111-mw3-prelaunch-recovery-motion-fire-0940/.

The 312 runtime paths were double-SHA verified before normal delegated stop. Chrome, Node and outer owner waits and both EOFs passed; the independent watchdog was joined with actual wait 0 and both EOFs. Box bx_xx8j6y4q was independently confirmed archived at 06:21:12Z with expiry cleared. Stop stop_0d476bc029074aa8 completed without force or error, before the fixed 06:35:32Z watchdog deadline. The lifecycle supervisor finished with real wait 0 and both EOFs; its original terminal transport returned 143 with cause unknown, retained separately from the actual supervisor result.