Hype: The Time Quest demo

Current measurement acceptance — 2026-10-21

HYPE-BROWSER-FPS-20261013 is complete for one instrumented browser gameplay interval: 188 authenticated finish-callback entries / 10,708.68 ms = 17.5558518884 logical FPS, 108 real same-worker performance.now samples. Independent review accepted capture12e430474 and prior56c92dc2 against exact tested source b88c818ba; canonical module728e1de8, all59 originals and66 prior observer/validator tests verified/reused. Actual owner is slot1/internal tid1/ exported ID2, selected by emission; old106 slot0 samples remain invalid, not zero FPS. Ten rejection checks pass, but the validator alone does not authenticate files or owners. Four actual gameplay/input images reviewed.

Software ANGLE/SwiftShader WebGL only; no displayed FPS, hardware GPU, native software Glide, full-game/audio/parity or overhead-corrected-rate claim. Current access: coordinator snapshot-stopped bx_2ghgsv9d; final receipt records stop_223af722c87d2f18 completed12:36:32.756Z, error null. No runnable slot; no lifecycle or runtime action by this reviewer. See independent acceptance and scratch/runs/20261021-hype-fps-independent-integrate. Historical blockers and RUNNING handoffs below retain their original observation scope.

App: hype_glide_demo (experimental). Original executable: test/binaries/candidates/hype-time-quest-demo/launch-game/MaiDFXvr_bleu.exe. The executable directly imports 50 Glide 3 entry points. Static extraction, English installer mappings, package provenance and generated Windows INI are documented in the Glide 3 corpus report.

Startup DebugBreak: missing main-image export lookup

The 2026-09-29 remote CLI smoke stopped in the original sound plugin before establishing Glide gameplay. The relevant log is ~/nfs-movsd/build/hype-glide-smoke.log on the reserved test box. It loaded:

Image Original base Observed loaded base
MaiDFXvr_bleu.exe 0x00400000 0x00400000
dll/WAVx2BVR.dll 0x10000000 0x04301000

Thread 1 stopped at runtime 0x04302129, preferred DLL VA 0x10001129. The preceding instruction reads the callback cell at preferred 0x10024b9c; if it is zero, the plugin calls DebugBreak. After the break, the wrapper would call that same pointer, so ignoring the break would enter address zero rather than repair startup.

The plugin initializer at 0x10003fb0 first resolves _SND_fn_vDisplayError@8 from the main executable handle. Its lookup helper at 0x10003f40 calls GetProcAddress. If that returns zero, it constructs the message Function cannot be loaded dynamically and invokes the error callback that it has not yet initialized. Thus the visible break is the error-reporting path for the failed export lookup.

The original executable does export the requested callback:

Name Ordinal Original function VA
_SND_fn_vDisplayError@8 2229 0x004d5430
_SND_fn_vDisplayErrorEx@12 2230 0x004d5490

The executable has 2,739 export-address entries, no zero holes and no forwarders. Its export directory is RVA 0x194d70, size 115,602 bytes. This was checked against the original file, not inferred from strings.

handle_GetProcAddress previously searched DLL_TABLE, then known native API names. The executable is not a member of DLL_TABLE, so it could not answer this lookup. The fix resolves exports from the main image before that existing path, using the shared mapped DOS/PE headers to obtain the export directory. It must not rely on the loader instance's exe_export_rva global: Hype makes the call on a secondary guest thread. No sound configuration, executable bytes, or DebugBreak behavior changed.

The existing test/test-getprocaddress-sparse-name.js now checks the callback name and ordinal, out-of-range ordinals, a zero address-table slot, an absent name, stdcall stack cleanup and operation with the loader-global RVA zero. Its original sparse-heap Win32 lookup still passes. The focused test passed remotely on 2026-09-29 after correcting the synthetic fixture's name pointers to lie above the 16-bit ordinal range. The post-fix remote CLI run reached a visible main menu without the startup DebugBreak; evidence is build/hype-fixed-startup.log and build/hype-fixed-startup.png on the test box. The screenshot was opened for review. Browser Glide identity, entry into the playable world and input-driven movement remain pending; menu acceptance alone does not establish gameplay.

Reproduction

Prepare the original extracted corpus, then use a current compiled artifact on the remote test machine:

node tools/prepare-glide3-corpus.js --check
node test/test-getprocaddress-sparse-name.js
node test/run.js --app=hype_glide_demo --threads --no-build \
  --wasm=build/wine-assembly.wasm --quiet-api --max-batches=2000 \
  --png=build/hype-fixed-startup.png

Static evidence can be reproduced without executing the game:

node tools/pe-exports.js test/binaries/candidates/hype-time-quest-demo/launch-game/MaiDFXvr_bleu.exe
node tools/disasm.js test/binaries/candidates/hype-time-quest-demo/launch-game/dll/WAVx2BVR.dll 0x10001120 0x10001142
node tools/disasm.js test/binaries/candidates/hype-time-quest-demo/launch-game/dll/WAVx2BVR.dll 0x10003f40 0x10003fe7

Export lookup limits

Native KERNEL32 currently aliases the main image handle. A missing EXE export therefore retains the existing native-API fallback; removing it would break callers looking up Win32 functions through that alias. An unknown callback still returns zero. This is compatibility with the current handle model, not evidence that distinct Windows module handles are interchangeable.

The reused resolve_image_export helper validates ordinal bounds and empty address entries. It assumes valid name-to-ordinal indices and does not follow PE export forwarders. The new dynamic main-image path guards the export directory's RVA/size range: a resolved address inside it logs marker 0x46574452 (FWDR) and the address, then traps. It therefore cannot return a forwarder string as callable code. Named and ordinal forwarder cases have focused regressions, which also passed remotely. Hype has no such entries. This is an explicit unsupported case, not general forwarded-export support; malformed PE export tables remain outside this investigation.

Normal-input gameplay probe

The original launch-game/Readme.txt, section IX, documents the default QWERTY bindings: arrows control the character, left Shift runs, Ctrl jumps, Space performs an action, and Enter uses magic. Up/Down navigate menus; Left/Right turn in the world. Do not assume a held Enter key moves the player. Gamedata/Options/Default.cfg is binary data, not a text configuration to edit.

The existing investigation probe build/glide-app-probe.js can launch hype_glide_demo webgl 120 build/hype-gameplay-webgl. It records desktop and actual Glide drawable screenshots every five seconds, plus API version, endpoint/backend and draw/present counters in states.jsonl. Its screenshots are observations, not automatic world acceptance. A normal New Game menu selection must be verified visually before calling a changed image gameplay. After reaching the world, compare a stationary frame against a held ArrowUp interval and a turn, while confirming API version 3, a glide endpoint and advancing geometry/presents. The probe accepts investigator input through input.json, for example [{"hold":"ArrowUp","ms":3000}]; this drives ordinary browser input and does not modify the guest state directly.

Menu input, viewport and FIFO polling (2026-09-30)

The menu initially ignored held keys despite correct host physical-key state. Original code at 0x48e3bd checks DIDEVCAPS.dwFlags & DIDC_ATTACHED before enabling its keyboard. Our capabilities omitted that flag. Correct attached keyboard/mouse reporting, plus the correct dwButtons offset 16, passes the remote DirectInput regression for both 24-byte and 44-byte structures. Normal Enter now loads the level. Keyboard flags change from 0x12 to 0x13, and the guest poll counter advances. No focus or input-transport workaround was needed.

The resulting level capture still occupies only part of the 640×480 drawable. A read-only snapshot confirms the top window has a 640×480 client, while its three nested children retain 388×268 clients. Hype initializes its logical resolution globals 0x5d8108/0x5d810c to 640/480 and correctly selects Glide resolution enum 7. Its viewport creation (0x49a730) uses the parent's client rectangle, and DEV_Device::OnSize (0x499250) resizes the child. The Glide fullscreen path changed geometry without the normal resize notification. A candidate delivered WM_WINDOWPOSCHANGED after releasing the Glide lock, allowing normal DefWindowProc processing to produce WM_SIZE. The subsequent build/hype-full-world-webgl.log snapshot still had 388×268 child clients. The candidate and its callback fixture were removed: it did not improve the layout and its internal synchronous dispatcher bypassed window-owner thread routing. A subsequent owner-thread fix is described below.

The matched hype-capture3-webgl / hype-no-notify-webgl captures also exclude notification as a necessary cause of the observed bad geometry. Both capture three triangles with nine vertices: five X values are NaN and all finite X values are zero. Their draw state and non-finite field patterns match; all eight drawable PNGs in both runs share SHA-256 d38b77b951118e53418317ab5ab5fea654c449b3dc757ede3c171383b4902ceb.

Static inspection narrows the next trace: CPA_MainFrame::OnSize at 0x499fe0 calls helper 0x477a70, which always returns zero. It therefore takes the branch that conditionally waits on the application's semaphore before calling native MFC42 ordinal 5030 through thunk 0x4f442c. That MFC handler (preferred address 0x5f40df89) invokes its default handler and then virtual method +0xd0 (frame layout) unless the size type is minimized. Counting entries to 0x499fe0 and 0x499250, alongside child creation and Glide open, will distinguish missing dispatch from notification timing or layout suppression. No compositor scaling workaround is justified by this evidence.

For upstream geometry diagnosis, original polygon clipper 0x483670 takes the vertex count in ECX, a 60-byte-stride vertex buffer in EDX, and the renderer context at [ESP+4]. Float clip bounds in that context are top +0x3daa8, bottom +0x3daac, left +0x3dab0, and right +0x3dab4. Screen-quad producers 0x486a30 and 0x486d20 use staging buffer 0x835ae0 (four vertices), but which produced the captured frame remains unverified.

The Y-edge interpolator at 0x483bf0 is a specific candidate for the NaNs: it calculates (boundary-yA)/(yB-yA), interpolates X and attributes, and writes the boundary directly as Y. This can produce the captured finite-Y / NaN-X and attribute pattern. At its entry ECX is the output vertex, EDX is vertex A, and stack offsets +4,+8,+12,+16,+20 hold vertex B, yA, yB, boundary, and context respectively. Capturing these inputs and the pre-clip staging buffer will distinguish invalid source geometry or bounds from arithmetic failure; the instruction sequence alone does not establish which occurred.

The subsequent world stall is a separate query bug. The rendering thread repeatedly reaches 0x4f1626, the grGet import thunk. Calls at 0x482427, 0x482442 and related sites ask for GR_FIFO_FULLNESS (3), length 8, and loop while the first output word exceeds 2,000,000. The unimplemented query returned zero without writing the output, leaving a stale stack value to drive an infinite polling loop. The query now drains pending commands and waits for backend completion (WebGL finish, synchronous native software), then writes the SDK's free-entry count and status words. This adds no pixel readback. ABI ordering, invalid-length and output-boundary tests pass remotely, as do software and WebGL 1/2 completion tests. The render loop now progresses.

A subsequent captured frame still cannot change the picture: it clears only depth, then submits three invalid/degenerate triangles. Five of nine vertices have NaN X; the other four have X=0. Both software and WebGL retain the menu. This first post-load frame was not enough to characterize steady gameplay. The later matched notification comparison and frame captures below narrow the observation without establishing a CPU arithmetic bug.

Evidence on the remote machine: build/hype-attached-webgl/ contains the first world capture; build/hype-world-diagnostics.log and its corresponding states.jsonl record the window tree and stalled thread. These captures do not yet demonstrate movement.

Later frame comparison

Matched runs build/hype-steady-default/ and build/hype-steady-interpreter/ use the same no-notification WASM and normal Enter, Space, ArrowUp and ArrowRight route. The second disables both the micro-op tier and x87 folding. A frame captured after 800 presents contains no geometry in the default run, versus 390 triangles with 1,170 finite vertices in the interpreter run. This comparison does not isolate either optimization or prove a CPU bug: the captured frames can represent different points in the application's execution.

Interpreter screenshot 006-drawable.png shows the character in a blue corridor, still restricted to 388×268 pixels. It was opened in Preview. The other 15 drawable captures retain the exact earlier menu hash. LFB read/write counts stop at 238 and remain unchanged through the later capture interval, so repeated LFB uploads do not explain that return to the menu image. Later actual-presentation captures below identify the alternating guest swaps; this was not dropped delivery by the shared render worker.

Owner-thread resize and movement

Glide fullscreen open now posts WM_MOVE and WM_SIZE through the existing owner-routed USER queue, matching DirectDraw's mode-change path. It does not call the window procedure on the rendering thread or while holding the Glide lock. The focused ABI regression opens from one instance with a window owned by another, verifies the ordered payloads and absence of inline callbacks, and checks that a failed open posts nothing.

On the trusted fallback server, build/hype-post-size-webgl/ captures a 636×476 child viewport inside the 640×480 drawable, replacing the earlier 388×268 viewport. Actual presentation frames in build/hype-swap-callers/ show normal ArrowUp movement and ArrowRight turning; world-present-661.png and world-present-1047.png were compared visually and opened in Preview. Default CPU settings in build/hype-default-callers/ also produce four captured world frames with 403–406 triangles and no nonfinite fields. The earlier single-frame optimized/interpreter comparison sampled opposite halves of the UI/world alternation and does not establish a CPU bug. The remaining empty UI swap still prevents stable visible presentation.

Alternating world and UI swaps

The eight adjacent swaps in build/hype-swap-callers/frame-capture.json all originate from thread 1, return to 0x4671d4, and use interval 1. World frames have higher caller 0x43f631; empty frames have caller 0x42252b. Device 0x03f012d8 has field +0x38 == 0, and both globals 0x77728c and 0x5da054 are zero throughout this sample.

Static disassembly explains the pair: frame-finish callback 0x43f610 (installed at 0x5b2290, paired with render callback 0x43f180 at 0x5b228c) finalizes descriptor 0x71cd04, swaps surface ID short[0x71cd02], then directly calls 0x422260 at 0x43f678 before releasing semaphore [0x71cd6c]. That second function acquires surface short[0x71cd70] into descriptor 0x71cd74, visits UI objects from [0x7136e0] through links at +0xd8 using 0x41f300, finalizes the descriptor, and unconditionally calls the same swap wrapper. These are nested guest paths, not two independently scheduled windows or threads.

Wrapper 0x467180 decodes its second argument as device index /16 and surface index %16, clears the surface's acquired flag at +0x64, and calls Glide swap when [0x77728c] == 0. Acquisition 0x467070 sets that global from whether device field +0x38 is nonzero. No renderer suppression is justified by this evidence. The follow-up capture records world surface ID 0 and UI surface ID 1 on device 0, an empty UI-list head at 0x7136e0, mode byte 9 at 0x71c620, and zero flags at 0x5d9680/84. The unresolved question is why this device/surface configuration requests a second flip without intervening color drawing.

Device field +0x38 is not populated by a Glide capability query. Constructor 0x466810 allocates a 0x10c-byte device and copies the caller's first 0x6c configuration bytes into it at 0x466b9e–0x466ba5. The normal MFC creation path at 0x499450 explicitly sets configuration +0x38 to zero at 0x49949e, then calls this constructor at 0x49950d. An alternate path at 0x499320 sets it to one, but its entry checks 0x477a70, whose original implementation is exactly xor eax,eax; ret; consequently that alternate path is disabled in this executable. The constructor can also clear a nonzero value if an existing device already has it set. The observed zero therefore matches the original executable's selection, and changing Glide query results or forcing this field would not be a supported fix.

The pinned Glide 3 SDK's gglide.c implementation of grBufferSwap unconditionally cycles current/front/back indices modulo the configured buffer count, queues the swap command, and selects the new drawing buffer. It has no exception for an empty frame. Its fast clear also respects the RGB write mask, so a depth-only clear correctly preserves the older menu color. These rules agree with the observed alternating buffer contents. One concrete difference remains: our handle_grBufferSwap does not pass the guest's swap interval to the host; it flips and publishes immediately. The SDK encodes interval 1 as a retrace-synchronized swap and bounds pending swaps. Browser compositing may therefore repeatedly sample the second UI presentation when our two swaps happen close together. Correct pacing would preserve both requested flips; it is not evidence that the retained menu pixels should be discarded or that pacing alone fixes gameplay.

Buffer initialization does not explain the alternation either. All four original grSstWinOpen call sites request two color buffers and one auxiliary buffer. The executable imports no grRenderBuffer, grGlideGetState, or grGlideSetState; it keeps the default back-buffer target. The SDK's initial physical buffer numbering differs from ours, but the logical front/back rotation is equivalent. Initial parity cannot account for menu pixels retained after the later LFB uploads.

An isolated 120-second default-CPU replay then tested an interval-1 wait before each swap using the existing virtual-vblank scheduler. It preserved every requested flip and left canonical WASM and production source unchanged. build/hype-vsync-default/frame-capture.json still alternates four finite world frames (403–406 triangles) with the same old menu. Device and main-thread present counts agree; the run ends without errors. World visibility between actual publications was about 32–38 ms, versus 36–47 ms in the unpaced sample. These are diagnostic observations, not controlled performance measurements. Pacing alone did not fix stable presentation and was not promoted to production.

2026-10-05: authenticated UI clipping starts with nonfinite inputs

The corrected owning-Worker trace armed only after the successful world swap (EIP4f1644, returns4671d4/43f631), before nested UI422260. It retained four entry483bf0/post483c35 pairs, zero observer errors, then disabled its exact owned trace at the cap. Original EXE spans and actual served module/source are pinned in the immutable run.

The first UI pair already has yA=NaN (ffc00000), yB=0; its A vertex is (635,NaN). The second enters with yA=+Infinity (7f800000), yB=NaN. Later pairs also contain infinity. Therefore this observation does not establish Y interpolation as the first corruption and does not justify patching its arithmetic. Next trace the incoming quad and earlier X clipping to locate the first nonfinite value. Preserve raw float bits; JSON null is not a sufficient numeric description.

Evidence: scratch/runs/20261005-hype-ui-clipper-nonfinite-input (207 artifact hashes rechecked); raw clipper SHA256 c0ecfa49e04bc0a296f5f7d68696aa4d21665802e9788f66cf276e9ad87a45ee. Session74195 exited0, browser/server closed10:33:12.696Z. after-trace.png shows the knight/street world, but this intermittent scene is not stable gameplay or input qualification. No FPS or normal-timing claim under trace.

UI polygon before X clipping (attempt7)

The first authenticated UI polygon is already (0,0),(+Infinity,0),(+Infinity,+Infinity),(0,+Infinity) at483670. Its raw caller return4870c9 identifies the quad path486d20. Two X entry/post pairs are captured, with no observer errors; the next swap matches the expected UI caller and ends the phase. NaN X/Y interpolation results follow the already-infinite input rather than establishing an emulator clipping defect.

Source486d51..486d71 copies XY from four16-byte input records to four60-byte staging vertices at835ae0. The input pointer is original ESP+0xc; context is original ESP+0x1c. The next minimal capture is function entry486d20 (actual caller/input64bytes) and post-copy486d73 (same pointer/staging240bytes), followed by the polygon entry to detect any intervening change. Do not assume the original source coordinates are infinite without this observation.

Immutable evidence: scratch/runs/20261005-hype-original-ui-quad-infinite,207 artifact hashes verified; rawSHA256 fa676bf6bc64403017f60ac961765e984dccee3c14f76e1bb3e8b80b59cb4ac7. Session35108 exited0, browser/server closed10:42:22.298Z. The image remains menu-only; gameplay and FPS remain unqualified.

Incoming rectangle confirmed infinite (attempt8)

The ordinary UI-phase probe captures the complete486d20 entry →486d73 copy →483670 polygon chain with zero observer errors. Actual caller469a5b authenticates the rectangle constructor469710. Incoming quad0420f988 already has (0,0),(+Infinity,0),(+Infinity,+Infinity),(0,+Infinity); all XY bits match both copied staging and later polygon. Neither copying nor clipping introduces the first infinity in this capture.

Immutable run scratch/runs/20261005-hype-incoming-quad-infinite has207 rechecked artifact hashes; rawSHA256 da1af7a6181198834030fa7630b500c529e1adeb330a555c5d2d4cbd545fbe2c. Browser7356 exited0, closed11:11:54.802Z. Menu-only image; no gameplay/FPS qualification. Next inspect actual469710 incoming rectangle, descriptor dimensions, live reciprocal table entries, and post-scaling arguments before its quad construction. Do not assume which size/angle branch executes.

Actual rectangle caller and smallest missing divisor evidence (attempt9)

Observed caller is41f17c, correcting the earlier static candidate41f352. The original rectangle arguments already contain (0,+Infinity,0,+Infinity). Live descriptor dimensions are636x476, reciprocal table words are004ccccd/00088889, and the post-scale width factor is finite0.9937500357627869. Therefore469710 size scaling is not the first infinity producer in this capture.

Original caller41f0e4 divides1 by71cdd0 (descriptor71cd74+5c), and41f125 divides1 by71cdd4 (+60), then multiplies actual dimensions and submits at41f177. Initializer4678ed/4678fa stores width/640 and height/480 in these fields after466cc0. Later466cc0 updates dimensions but does not write+5c/+60. This identifies a precise dependency, not proof that initialization was skipped or the fields are zero. Previous84-byte descriptor capture ended before them; the next approved extension reads exactly these8raw bytes at the same authenticated rectangle entry. Zero/denormal inputs can produce nonfinite results under correct arithmetic; finite-normal inputs still require exact x87 operands/precision proof before blaming CPU execution. No guest-state repair or clipping patch is justified yet.

Immutable evidence scratch/runs/20261005-hype-rectangle-caller-divisors has207 verified artifact hashes; rawSHA256 406e004704de98fa44f56bfb424cf0905944ddd4d557bf46927345754fc30624. Browser78398 exited0, closed11:24:11.451Z. Intermittent world image is not stable gameplay qualification; no FPS claim.

Zero descriptor scales observed (attempt10)

The exact eight bytes at71cdd0/71cdd4 are 0000000000000000: both descriptor scale divisors are positive zero at authenticated rectangle entry from41f17c. This directly explains the positive infinities through the original1/+0 arithmetic, without establishing a CPU division bug. The observation does not yet explain why initialization or later lifetime handling left those fields zero. Do not replace guest values or suppress swaps.

Immutable scratch/runs/20261005-hype-zero-descriptor-scales has207 verified artifact hashes; rawSHA256 471da24aff6154699b09aafcc796cf6330fb68fc482d3f3bdb9e901b312020a0. Session27505 exited0; browser/server closed11:33:01.065Z. One complete rectangle/quad chain, zero observer errors, exact trace disabled. Image remains menu; no gameplay/FPS claim.

Static lifetime distinction:404c80 registers the UI descriptor71cd74 via466de0, which allocates a separate104-byte heap surface record, copies100bytes into it, updates dimensions with466cc0, copies100bytes back and stores the heap pointer in the device surface table.467730 later initializes+5c/+60 on the heap surface, not necessarily the static UI descriptor;467010 copies100bytes from heap to caller. Thus static-versus-heap identity must be checked before calling this skipped initialization. A bounded read of the live UI surface ID71cd70 and its device/surface-table pointer at use can distinguish a stale static descriptor from zero scales in both records. No broad renderer trace is needed.

Refined next observation: authenticated acquisition copy, no pointer walk

The proposed ID/device-table lookup is superseded by the exact live copy path:4222b3 calls467070, which resolves the actual heap surface and copies100bytes to static71cd74 at4670ce on every UI acquisition. Read actual EAX source and EBX destination at4670c3, verify caller4222b8 at original stack+24, then record both100-byte records after the copy. Use known branch-entry checkpoints4670e1/467105, not an assumed post-REP block at4670d0; require same TID, ESP+8, ESI=source+100, EDI=0, ECX=0 and retained EDX/EBX identity. Compare dimensions and scales with the later authenticated rectangle-use snapshot. One acquisition/rectangle chain, three seconds or next swap, no guest mutation.29 focused tests pass.

Source ordering within467730 is dimensions-update466cc0 before scale stores4678ed/4678fa for each heap surface. Surface creation itself466de0 updates dimensions and copies descriptor fields but does not compute scales. Actual ordering between initial creation, mode changes, scale initialization and later copying is not yet observed. A zero heap source would shift diagnosis to that lifecycle; different source/postcopy/use values require their own provenance before any repair.

Heap source is already zero; descriptor copy is faithful (attempt11)

Authenticated acquisition resolves heap surface042fef50 and static UI descriptor71cd74. Before copy, heap+5c/+60 are zero; static destination is the expectedcccccccc prefill. After the100-byte copy, destination matches source exactly, including zero scales, and the rectangle-use snapshot retains those zeros. No copy defect or intervening scale overwrite is shown. One complete identity-checked chain, zero observer errors, owned trace disabled.

Immutable run scratch/runs/20261005-hype-heap-zero-scale-copy,207 artifact hashes verified, rawSHA256 92009c5b634ab403eb58e9e4dc64a46edde0c5b8e599bbe03a3bbbb3cf09ade6. Session2554 exited0 and closed11:49:16.362Z. Menu screenshot only; no gameplay/FPS qualification. Evidence files were hardlinked after closure to avoid redundant disk use; contents and paths are preserved.

Next examine creation/mode lifecycle, not rendering: source466f60/466c77/4674a5/4678c3 calls dimensions-only466cc0; only the467730 mode/reset loop then stores scale fields at4678ed/4678fa. UI surface creation466de0 can therefore leave scales copied from zero static storage until such a loop includes the new heap. Caller49977e invokes467730 conditionally when frame+54 is zero;499921 invokes it after466460. Their actual order relative to UI surface creation remains unobserved. Do not infer skipped initialization from use-time zeros alone.

2026-10-05: bounded startup census ties zero scales to creation and resize

Attempt12 (scratch/hype-route-prep-20261005/attempt12/analysis.json) captured actual Worker startup, before any Enter or Space input. Slot1/TID2 created static UI descriptor71cd74 into heap042fef50: both scale fields+5c/+60 were zero in the incoming descriptor and remained zero after dimensions helper466cc0 produced388x268. Slot0/TID1 subsequently updated the same heap to636x476 through caller466c77/return466c7c; scales remained zero. This narrows the observed lifetime without asserting that initialization never occurred outside the captured intervals.

All three origins emitted coverage start/end and disabled their owned trace. Slot1 rejected an unexpected UI-acquisition caller after about5.6seconds; the old helper unfortunately rejected before emitting its stack, so the actual caller is unknown (expected4222b8). Slots0/2 reached their30-second deadlines. No mode467730 or scale-store completion was observed in those bounded windows. The new source-only observer records the exact32-byte stack, expected/actual caller and heap before retaining the same failclosed rejection;16 pure-JS tests pass, including both real Worker run callsites. No repeat or game patch follows from the missing field alone.

Static event distinction: the original MFC message-map entry for message5 points to499250 (record at file offset18fda0; handler pointer18fdb4). That WM_SIZE path calls466c20 at499281 when frame+54 is zero, subject to477a70 and frame+58 gates.466c20 obtains GetClientRect through IAT5906a4, updates device dimensions, and invokes dimensions-only466cc0 for existing surfaces; it does not call the scale initializer467730. Thus the observed resize path is not itself evidence of a lost scale-initialization call.

Both467730 callsites49977e and499921 belong to499710, a mode/window-state toggle routine: on one branch it calls467730 only when frame+54 is zero and then sets that flag; the other branch reconfigures via466460 and calls467730 before toggling the flag. Its callers include the WM_SYSCOMMAND handler499e20 (message112 in map at file offset1900c0) and WM_ACTIVATEAPP handler49a160 (message1c in map at190090), plus a CallNextHookEx-based hook497fb0 that recognizes a structure's message400/wParam69. These paths are distinct from ordinary WM_SIZE. Their exact runtime conditions/order relative to UI creation remain unobserved; do not invent a required display-change notification or force one. Next useful evidence is the actual mode/frame state and dispatch cause around creation, not another renderer/clipping trace.

2026-10-05: original build selector narrows activation path

Further source correction: original477a70 is33c0c3 (xor eax,eax; ret), so unmodified499710 takes49988b and initializer499921, not the conditional49977e branch discussed above. WM_ACTIVATEAPP handler49a160 likewise selects49a37a. Activation TRUE reaches the mode toggle only with app+e0 nonzero and frame+54 zero, protected by recursion guard6ac514; initial activation need not initialize scales. The emulator source has both explicit first-ShowWindow and implicit-WS_VISIBLE activation chains (09a5-handlers-window.wat and09b-dispatch.wat), but execution on Hype's historical f40 module is not thereby proven. No missing-message claim or patch is justified.

A separate source-only transition observer now authenticates original selector bytes and captures named activation/frame/device/heap provenance, armed once before normal Enter/Space rather than rearming startup evidence. Bounds remain32records/30seconds per origin; unknown callers and late code/owner mismatch stop capture with cleanup. Ten pure-JS tests cover app lookup, frame/device/heap pairing, original forwarding, foreign instrumentation and late failures. Browser integration remains pending; no new runtime or timing claim. Source details: scratch/hype-route-prep-20261005/activation-source-analysis.md and transition-observer.js.

2026-10-05: ordinary control check still alternates menu and world

Immutable scratch/runs/20261005-hype-ordinary-control-interleaving uses202 pinned canonical app/source identities, actual f40 module, no private Worker or trace. After ordinary Enter/Space, a personally reviewed world gate shows knight/street. The finite Up600ms/Down600ms batch captured menu already at its before image, world after Up, then menu after Down and after2seconds settlement. Root independently reviewed after-Up and settled images. Stable player-controlled gameplay remains unqualified; the gate did not remain valid through the batch. No FPS, reversal, sound-quality or level-completion claim. Browser/server closed12:28:23.927Z, exit0/errorsnone.

Historical upstream front/back evidence locates world/menu alternation in the same GPU presentation chain, before page composition, with distinct world/UI guest presenter callers. That does not prove simulation state toggles. Invalid UI geometry leaving an old menu color buffer is a hypothesis only; do not suppress swaps.

Static dispatch resolution now identifies46ef70:46ed90 returns table7c4360; initializer482960 writes offset10c at482c0e to4823e0, hence7c446c→4823e0 for that table setup.4823e0 increments render counters, calls4825a0, drains queued geometry and grGet-based completion checks. It is not justified to call this pointer merely a context/window activation. Both presenter paths subsequently reach common467180→grBufferSwap4f1644 when77728c is zero. Actual table contents/flags at the problematic call still require existing captured evidence or bounded passive authentication; no engine fix follows yet. Next source focus is queued UI geometry/clear and buffer selection, not another wide instruction trace.

2026-10-05: bounded attachment comparison supports stale menu color

Immutable scratch/runs/20261005-hype-attachment-stale-menu preserves64 hashed artifacts and raw receipt SHA25620a734491ba801f880dfd0927907a8d52ce05f6ddb719eca6778dc179a0cc2c4. The observer now wraps actual Device.execute recursion: the earlier Device.submit wrapper missed commands inside opcode0 batches. An actual-source regression reproduces that failure and verifies the corrected boundary. Attempts15/16 remain unqualified; no missing-receipt inference is carried forward.

Attempt17 captured four swaps/eight readbacks, with owned hooks restored and no observer errors. In pairs1/3, the same attachment retains identical coherent menu pixels before its clear and after three executed draw commands. The clear's original mask includes COLOR_BUFFER_BIT and DEPTH_BUFFER_BIT, but all color-write channels are disabled and depth writes enabled. World pairs2/4 use the other attachment, execute403/405 draw commands, and change pixels. Readbacks changed their initial sentinel, framebuffer status was complete, and context-loss checks were false. GL error state was deliberately not consumed, so equality remains conditional evidence supporting stale menu color exposure, not an unconditional readback proof or a demonstrated new menu repaint. Counts describe executed commands; batch merging can combine primitives. No stable gameplay, physical FPS, sound or performance claim follows.

The automatic route completed in48.122seconds and cleanup at13:10:44.368Z closed browser/server without errors. Its post-Space limit was30 screenshot iterations, not30 elapsed seconds; screenshot overhead could exceed that inner limit. The source helper is now corrected to an elapsed deadline, rejecting late screenshots, with a timing-overhead regression. The historical record is unchanged. The90second route and180second session limits were retained in the actual run.

Next causal target remains scale initialization of the same UI heap. Original467730 can fail after467600 or466810 before any scale stores, and only iterates sixteen restored surface pointers after both succeed. Its original constants are1/640 and1/480, producing nonzero scales for636x476 dimensions if that exact heap reaches the stores. Initializer entry alone, or a call before UIheap creation, does not establish initialization. A cold mode-entry/return and membership proposal distinguishes these cases without another wide render trace or a swap workaround.

2026-10-05: cold mode probe found no post-title invocation

Immutable scratch/runs/20261005-hype-cold-post-title-nonobservation preserves attempt18. Raw cold receipt SHA256ce8319e69bcff70e18007d370dcb94ed1930fa6568518efb8bbaf081fcb7b141 records actual owning slots0/1/2 (TIDs1/2/3) starting before the ordinary Enter/Space input. Each observed zero callbacks in the cold499710–499a85 range during this declared post-title interval. Consequently no initializer return or same-heap scale result was captured. This does not establish absent startup initialization or a missing activation message.

The automatic route completed in20.057seconds with two world-template matches; its last image shows the knight/street. There were no movement inputs and no stable gameplay qualification. Explicit host diagnostic close produced all three owning trace-disabled end receipts; browser/server closed13:34:43.641Z, exit0, no cleanup errors. Next bounded observation belongs before title, after mapped-code authentication and immediately before the first actual guest run, not another repetition of this post-title interval. Historical startup receipts place surface creation about1.1–1.3seconds after the first observed guest run; whether the relevant initializer runs in that window remains unobserved.

2026-10-05: bounded startup mode non-observation and actual UI constructor

Immutable scratch/runs/20261005-hype-cold-startup-nonobservation preserves42 hashed artifacts from attempt19 (raw SHA2565a2c721d5700461c76160c9e031e4c17c24937e7f0ca19638b67290f3e2c9bf2). All three actual-first-run origins authenticated mapped code and enabled the cold outer-mode range; each recorded zero callbacks over22.145–23.479seconds through title and ordinary Enter/Space/world images. Route completion closed the interval before its30second maximum. All three trace-disabled end receipts and browser/server cleanup were retained; exit0,13:44:58.268Z, errorsnone. This captures no initializer or same-heap outcome and does not establish that mode467730 must execute. No stable gameplay or FPS claim.

The earlier attempt12 evidence identifies the actual UI constructor more directly: slot1/TID2 enters466de0 with return404cb8, deviceID0, descriptor71cd74 and outputID71cd70. Descriptor scale fields+5c/+60 are already positive-zero bytes before allocation/copy; the paired heap042fef50 retains them after466f65 calculates388x268 dimensions. Original404c80 initializes only percentage rectangle fields0/100/0/100, and complete dimension helper466cc0–466da4 does not write the scales. Later registration functions49c910/589620 only store descriptor pointers. These observations support initially missing scale values, not a demonstrated later overwrite.

Alternate bulk descriptor updater467450 clears/copies104/100bytes and recalculates dimensions; UI wrapper404e8f changes percentage fields but supplies the existing descriptor scale bytes. That can propagate zero values without proving where nonzero values were expected to originate. Source investigation now concerns the normal constructor/backend view contract and alternate writers, not repeated mode probes or forced scale/swap workarounds.

2026-10-05: normal scale initialization requires an unsupported message hook

Source analysis of the exact Hype EXE (SHA256 635f394121e50001227b97741dbf304f0a88f819c6f2ba2378cf61d9fa2a6344) found a concrete initialization path, replacing the earlier speculation about activation or arbitrary mode changes. Startup 498058 calls SetWindowsHookExA(WH_GETMESSAGE=3, 497fb0, hModule, currentTID). The original PE import table confirms the hook API and GetCurrentThreadId identities.

Immediately after UI construction 401f9c→404c50, startup unconditionally calls 401fa1→401400. That helper posts thread message 0x400, wParam 0x69, lParam zero to the application thread stored at app+30, using the verified PostThreadMessageA import at 5906b4. Hook 497fb0 recognizes PM_REMOVE and those exact MSG fields, then calls 499710 at 497fe7. The constant-zero selector follows 499921→467730; after successful device release/recreation, the existing 16 surface slots are restored and 4678ed/4678fa write width/640 and height/480 into descriptor +5c/+60. Thus the normal request occurs after the zero-valued UI descriptor has been created.

The current USER hook implementation explicitly accepts classes 2 and 5 only; install_supported_hook rejects class 3. Get/PeekMessage have keyboard-hook delivery but no WH_GETMESSAGE delivery. The same hook fragment is byte-identical in the immutable Moorhuhn2 source bundle bound to historical module f40d4ca3…, used by these Hype diagnostics. This is a concrete missing API contract, not proof that a captured Hype post succeeded or a hook-install return was dynamically observed. No gameplay fix is claimed.

The source writer audit also covered descriptor aliases: allocation and descriptor replacement copy all 100 bytes, getters/acquisition copy heap→caller, and destruction poisons 104 bytes before freeing. Initial WM_CREATE path 499450→49950d→466810 selects flag-zero device creation and does not initialize surface scales; 467990 only registers associated pointer +50. Explicit offset-store scans are not a proof excluding arbitrary computed-pointer writers.

Next work is generic owning-thread WH_GETMESSAGE support with real guest-call before/after regression: preserve the original MSG pointer and edits, PM_REMOVE versus PM_NOREMOVE, ignored hook return, CallNext/unhook/lifetime semantics, and existing keyboard/CBT behavior. No forced game notification, scale assignment, or swap suppression is justified. Source receipts and reproducible inventory are retained under scratch/hype-route-prep-20261005/; no runtime was used for this finding.

2026-10-05 — WH_GETMESSAGE candidate reaches ordinary controlled gameplay

The isolated generic hook repair (implementation commit 6604fb90, main base 5d7b94b7) passed the full build gates, including allocation/shake checks, all 16 real-WASM hook regression groups, and existing keyboard/CBT tests. Its private module SHA256 is 2638e876e6002d0e34cf7acba3d85ddbabb02069f559695f28fe6bad4620eb95. The generated region mirror belongs to this module; the historical f40 traces remain unchanged.

Ordinary attempt21 selected New Game with Enter, displayed the actual loading and control-instructions screens, then continued with the requested Space key. In the resulting nighttime street, 600ms Up moved the knight toward the barrels and 600ms Down reversed that movement. Root personally reviewed world-before.png, after-up.png, after-down.png and settled.png: the final scene retained the world without the earlier stale menu. This is narrow player-controlled gameplay acceptance, not level completion, audio quality, FPS or release readiness. No trace, forced hook call, scale write or other guest-state bypass was used.

Immutable evidence: scratch/runs/20261005-hype-wh-getmessage-gameplay/result.json; 273 hash-listed artifacts include input timestamps, four gameplay screenshots, root review, 229 served-resource receipts, exact source closure and private module. Browser/server closed normally at 2026-10-05T14:57:24.418Z, session84058 exit0 and no cleanup errors. Attempt20 is separately preserved: it stopped before input because its old exact-image reference rejected the now-rendered menu; this was a harness gate mismatch, not a guest failure.

The source-derived PostThreadMessage→WH_GETMESSAGE→mode initializer path now has a successful ordinary-route outcome with the generic contract implemented. The run did not separately instrument every initializer instruction, so the precise internal scale-write sequence remains source attribution rather than a new dynamic trace. Global injected hooks and suspended-before-init remote registration are outside this implementation's supported scope.

2026-10-10: CLI gameplay and a qualified frame counter

The plain CLI now reaches gameplay under the software Glide backend (no WebGL headless): a frozen --control session at the default 1,000-block batches has the title menu by batch 2000; Enter starts a new game, the loading screen ends on the instructions page (~6000), Space enters the 3D alley, and holding Up walks the knight forward between the barrels, with no stale menu layer. Evidence: scratch/runs/20261010T0620Z-hype-glide-cli-frames.

Two swaps per game frame, measured. Native hit counters over batches 6921-7421: frame-finish callback 0x43f610 99, nested UI pass 0x422260 98, swap wrapper 0x467180 196 — exactly the world + empty-UI pair the static analysis above describes. Count frames at 0x43f610; any grBufferSwap rate (including the browser's Glide present rate) is twice the game's frame rate in gameplay. Title and loading screens swap without the callback (605 swaps vs 2 x 279 frames over the whole run). --present-distinct sees nothing on this path: the CLI software Glide backend does not reach the present hook.

2026-10-11: gameplay cost, and the worker page-index thrash

Route on current main (CLI, default 200 ms/batch clock). The intro page ("Press SPACE to continue") needs Space held: a 2-batch tap is missed. Space held over batches 10000-10050 starts loading; held again over 12650-12700 it passes the controls page; the knight is in the 3D alley by batch 13700. No Enter is needed. --input=10000:keydown:32,10050:keyup:32,12650:keydown:32,12700:keyup:32. Frames (0x43f610): 268 by 14000, 993 by 17000; they follow the guest clock, so they are identical across builds.

Cost. Gameplay batches 14000-17000: ~45 s user CPU for ~725 frames, about 62 ms per frame on one boat core. The whole game loop runs on guest worker thread tid1 (7701 distinct hot blocks, flat profile: the top block is 1%); music (mpgmxbvr.dll, MPEG decoder) runs on tid3, the main thread idles in MFC. About a third of CPU was spent building threaded code ($decode_block, $page_publish, x87 fusion, emitters); the Glide JS path is about 15%.

Cause. A worker's page index held 16 compiled 4 KB pages ($PAGE_INDEX_WORKER_SLOTS; main 512). tid1 recompiled 4.48M pages in those 3000 batches, 4.38M forced by "index arena full", = 47M block decodes. Code writes were not involved (invalidations flat). Doubling the worker code partition (768 KB -> 1.5 MB) halved full clears but saved only ~2.6%: the partition was not the limit. Found with run.js's per-thread cache report (3f223733d), which prints these counters for every guest thread.

Fix (86cf7ae36). workerHeavyCodeCache: true in lib/apps.js switches the process to main 256 / workers 32 page-index slots in the same arena. tid1 page compiles 6.21M -> 2.71M per 17000-batch run; gameplay CPU about -12.7%; whole-run user CPU -10.2% over 3 interleaved reps. Still 2.5M forced recompiles at 32 slots: the game loop needs more pages than that, so a shared on-demand pool (and code-partition pooling with it) is the remaining lever. Evidence: scratch/runs/20261011T0850Z-hype-fps-measure-boat, 20261011T1000Z-hype-page-index-boat, 20261011T1030Z-hype-page-index-ab-boat.

2026-10-21: original browser movement, FPS owner-attribution blocker

Exact integrated main b88c818ba3a071877e889e7cc779975a193591ce was staged on authorized bx_2ghgsv9d through documented exec/file APIs.6731 Git blobs and59 originals38067871bytes verified before/after; canonical build and 66 accepted observer/validator tests passed, including restored exact-HEAD append-only API-table baseline. Module728e1de80ec20a284fc41b339895ee8ac29f16e4ded83325b27576cfacd4466c.

Two bounded browser attempts: first reached menu then synchronous API30s timeout closed it; second used detached exec and ordinary Enter/Space to reach the nighttime street. Reviewed ArrowUp600ms/ArrowDown600ms images show movement/reversal and stable world. Chrome151.0.7922.108, real Workers, Glide WebGL endpoint on ANGLE/SwiftShader software rendering,4vCPU x86_64.

No FPS accepted. The sampler matched get_current_thread_id()==1, initially ambiguous across guest/render workers, then filtered guest-worker URL and selected slot0. Its106 real performance.now samples were count0 while gameplay advanced. src/13-exports.wat sets exported current_thread_id to internal tid+1: the startup log's internal tid1/slot1 is not exported ID1. Live callback code authentication alone did not establish emitting ownership. The unchanged accepted validator rejects the receipt with fps:null; this is a harness attribution blocker, not zero FPS or a demonstrated game defect. No third capture or source repair.

Evidence/report/recovery: scratch/runs/20261021-hype-browser-fps-authorized; tracked review/archive docs/reviews/hype-browser-fps-authorized-20261021*. Browser/server closed12:10:30Z; source/build/originals retained on same box, left RUNNING idle/healthok, expiry14:01:16.889Z, coordinator lifecycle owner. No SSH retry, public deployment, main merge or workers.

Additional dated branch findings

These historical observations supplement the current facts above; they do not establish a new current-main runtime result.

Earlier input-loop observation (2026-10-04)

The ordinary menu Enter changed the title to "Chargement de la map" before returning to Hype The Time Quest, so a blanket "Enter was not delivered" diagnosis is unsupported. Swaps stopped at2057 while thread1 slice counts advanced; sampled PCs 0x493243, 0x49413c and 0x496635 belong to input evaluation. IPT_fn_vReadInput starts at 0x4930e0; caller 0x4208e0 has a no-render loop 0x420925..0x42097d polling literal Action_Key until its command state becomes positive. The readme maps Action to Space. Other callers exist, so this is a hidden Action-prompt hypothesis, not proof of the active stack. Later observations above remain authoritative.