Forsaken demo (Acclaim/Probe, 1998, Direct3D 5)

App id forsaken_demo, candidate forsaken-demo (registered 2026-10-11, w5).

November 12: combat white viewport and joined state trace

Current original combat on module04c53419… shows living movement and player damage/respawns, followed by a persistent white viewport on both recorded renderer owners. The 1645 WebGL trace, commit eec039872, observes a complete state chain for the first retained post-corridor sampled-pixel transition to white. Live state before enqueue, owned and published packets, replay source/workspace and description all agree on additive ONE/ONE. Opaque restores reach live memory, then later natural writes enable additive state again before that draw. This excludes a state snapshot/replay mismatch for the joined witness; it does not establish why the guest writes those values or prove the intended rendering.

Root independently rehashed326 recovered outputs, checked ten full PNGs and 19 within-capture binding fields, inspected the corridor/respawn/white frames, and recomputed the190-drain analysis. All40263 observed next-boundary state readbacks match their requested values. There are no recorded boundary gaps, drops, errors or state mismatches. Startup CPU drops,15 ground-sample caps and two unjoined tail replay keys remain explicit. The sampled white transition precedes primary keydown; the later full-white frame follows primary/respawn, so no input-cause attribution follows. No rendering patch is justified.

The observer's separate paused-worker startup failure is repaired in run-local helpers, with actual Chrome CPU/GPU bootstrap, encoder byte-identity and negative controls. That repair enables observation; it does not repair the white scene. Actual Chrome/browser/outer and local lifecycle waits/EOFs pass, and the box stops normally.

The 1715 original-command trace, commit a51eacd69, then matches all33723 observed state applications to explicit original Execute-buffer commands. The 1735 selector trace, commit 9bae6e181, shows that the original x87 compare deliberately selects the additive buffer when its float differs from zero. Root independently recomputed 620 selected and1142 equal-restoration calls: CPU condition bits, branch, arguments and actual handle agree with zero mismatches. Static writers and vertex-color consumers support a death/respawn fade; live writer timing and intended visual duration remain unproved.

Root checked297 recovered hashes, eleven full PNGs,19 identity fields and eight independently released trusted input pairs. The first retained sampled white draw precedes the first observed selector call and uses a different texture from the selected scene; preserve these as separate witnesses. Startup CPU drops,29 ground-sample caps and three unjoined tail keys preclude a global-first-white claim. Actual Chrome/browser and lifecycle waits pass; a separate unified wrapper exit143 remains unexplained. The box stops normally. Next: original texture provenance, uploaded/sampled texels and ordered prior target contents for one retained draw. No blend override or runtime patch is justified by the current evidence.

The 1805 retained-texture analysis, commit aae90a9d0, identifies SMLEXPL.PPM at all16 retained native RGB565 coordinates and matches the four triangles' atlas rectangles to smlexpl.off. The immediate preceding opaque draw supplies the sampled destination color; the target is not already white. Root independently recomputed the70-input, nine-source-pin analysis. These are sampled content and immediate ordering proofs, not a complete DIB/upload or live loader-copy proof. The inherited observer retains at most four covering triangles out of60 submitted, and ideal four-hit arithmetic is not an actual GPU fragment oracle. Next: complete coverage, actual sampling and depth context for one natural submission. No new original execution or runtime patch occurred in1805.

The 1815 complete-draw study, commit 793bbfd56, captures a different natural draw:14 triangles,42 vertices and the complete131072-byte uploaded texture, identical to the decoded cache. Actual pinned GL sampling and per-triangle native565 stores preserve its already-white incoming pixel under all16384 conservative depth outcomes. This explains that submission; individual depth visibility remains unknown. Root independently recomputed the complete analysis, checked868 sealed hashes, 577 recovered paths,19 full PNGs/identity fields and13 trusted balanced key pairs, and inspected the native room and bright combat frame. Remote parents and durable manager/watchdogs close normally; the initial local caller143 owner join remains unknown. No renderer defect is proved.

The historical onset still lacks56 of60 triangles: a retained count180 is not the full5760 vertex bytes. Ideal four-triangle arithmetic also omits native565 rounding between triangles. Next: an unsaturated incoming pixel that naturally turns white, or its preceding whitening submission, with complete coverage, uploaded texture and unchanged target/depth context. A saturated later draw does not qualify the earlier transition.

The 1845 unsaturated transition, commit c458e7c51, then captures a complete fresh28-triangle submission and its full uploaded texture. Original color changes115,65,33 →231,146,66 →white match actual GL sampling and native565 rounding in every step. The changes prove triangles1 and3 passed depth; triangle13 arrives after saturation and remains ambiguous, with either outcome preserving white. Root independently recomputed the analysis with zero mismatches and checked881 sealed hashes,498 recovered paths and20 complete PNGs/19 fields. The retry retains12 trusted balanced input edges; the first attempt lacks a final global native-input export. Its3500ms request was refused before DOWN by the2000ms cap. Both boxes stop normally and their new local lifecycle waits pass. No renderer patch is justified by this fresh explained transition. Historical missing56 triangles and the broader old white interval remain unresolved; no global-first-white or input-cause attribution follows. The final fresh combat frame remains a readable room. Earlier paired evidence and limits: combat and owner observations.

Source and licence

Layout

tools/is3-extract.js unpacks DATA.Z (873 files). The fetch tool's is3Extract post-extract step runs it. 7z and unshield both refuse this format. The extracted root holds ForsakenDemo.exe (3.7 MB), a3d.dll, biodome.dmo, forsaken.scg, data/ (levels volcano, subway) and opt/. The installer's default path is C:\Program Files\Acclaim\Forsaken Demo. The game also runs from C:\, which is how the manifest mounts it. Static imports are system DLLs only: DDRAW, DINPUT, DPLAYX, WINMM, WSOCK32, AVIFIL32/MSVFW32, ole32 and the core four. No registry seeding is needed.

Route (headless, --batch-size=200000)

node test/run.js --app=forsaken_demo --no-build --quiet-api --quiet-blocks \
  --batch-size=200000 --max-batches=1260 --stuck-after=100000000 \
  --input=300:keydown:13,301:keyup:13,450:keydown:13,451:keyup:13,600:keydown:13,601:keyup:13,750:keydown:13,751:keyup:13,1050:png:ingame.png,1180:keydown:17,1182:keyup:17,1188:png:fire.png

The bug it found

The level load creates about 300 execute buffers after many other DirectX objects. Our execute-buffer cache table ($D3DIM_EB_CACHE_PTRS) was keyed by DX_OBJECTS slot but held only 512 entries (out of $DX_MAX 8192). Every buffer in a slot of 512 or above got E_OUTOFMEMORY from SetExecuteData. The game reported "Mload : SetExecuteData Failed", then "RenderScene failed". The fix gives the table its own $DX_MAX-sized region, and test/test-d3dim-execute-buffer-slots.js covers it.

Open

Evidence: scratch/runs/20261011T0420Z-forsaken_demo-gameplay-w5.

Browser Volcano movement/combat, 2026-10-31

Evidence: scratch/runs/20261031T0401Z-forsaken-play/, including the explicit/ retry. Personally inspected actual gameplay beyond the briefing; readable sustained play is blocked by severe rendering corruption. No production repair, enemy kill, or level exit is claimed.

Both executions loaded module SHA-256 7f9da4e9da5183e9f7f061d2356cd34626fe74bdbaf7da0345f6693dd81152be; compiled source/commit remains unknown. Observed checkout HEADs in started.json are not module provenance. EXE SHA-256 366ec5d0943daca839836296f9fb52724e94dc155630c6b0c30d7181106b5e24, local manifest SHA-256 587ce145ab73a3fed2c7136425bb6a7bcf28def312d430c8bf7d1be802b2260b. The 107 fetched runtime snapshots are retained by hash; original inputs and served bytes have before/after checks. Exact wall-clock inputs, launch flags, backend reports, verification and recovery instructions are in the bundle.

Current default controls, confirmed against the original readme §VI: A/Z forward/reverse, arrows rotate, Ctrl primary, Space secondary, Alt strafe, Escape pause. This supersedes the older “A did nothing” observation as a control mapping. Both owned browser/controller processes exited, profiles and HTTP/CDP ports were removed/closed. No Boat/test box allocated (ID/state/expiry not applicable); ownership returned. Next investigate the WebGL transition / frame-clear or presentation boundary with this retained module and originals; those are investigation targets, not established causes.

Known-source WebGL frame investigation, 2026-10-31

Evidence: scratch/runs/20261031T0427Z-forsaken-frame/. This bounded investigation made no production repair. It reproduced the rendering blocker on known source and separated GPU target contents from page display.

Source identity is module SHA-256 8459597c8d66e098d727fb4ab53e1cf46332241dc7eef2e158f3c475a78b1676, the retained ReVolt 20261031T0403Z-revolt-backbuffer/after.wasm from its successful locked canonical build. All 292 entries of that run's source-after-manifest.json matched the checkout before this execution. The browser served those retained source bytes and module, with fetched runtime snapshots retained again in this bundle. This identifies an exact saved source tree, including the then-concurrent font work; it is not a clean-commit build claim. The previous 7f9… module remains source-unknown, and its old images are not current regression evidence. Other workers began source edits during wrap-up; the retained pins identify this run independently.

The runtime waited for UT2004 to close, acquired /tmp/wine-browser.lock at 04:37:13 UTC, checked the process list, and held the lock for its entire lifetime. One original Enter route reached Start Volcano, the briefing and the room. Default guestWorker, Threads, explicit d3d-renderer=webgl, and 1024×768 stayed enabled. Native Ctrl 500 ms, A 500 ms, Right 300 ms, A+Ctrl 1200 ms, A 1800 ms, and Escape exercised firing, movement/rotation and the native pause menu. PULS fell from 2000 to 1994 and then 1978. Personally inspected briefing-continue.png and primary-fire.png show a readable room and green projectiles. thrust-short.png, rotate-short.png, corridor-move.png and pause.png show retained briefing/world fragments; advance-fire.png and settled-no-fire.png show saturated projectile areas. Sustained readable movement, an enemy kill and level completion are unproved.

The observation wrappers delegate the original renderer methods unchanged; they record clear arguments, draw states, uploads and completed readbacks. The built-in owning-draw trace omits clears and initial color/depth/CPU writes, so it cannot alone answer this question. Full-target readPixels samples were also taken without flushing or changing render state. Their bottom-up RGBA bytes are retained and converted losslessly to PNGs.

First unresolved blocker: why full world coverage is absent while the flip-chain backing still contains briefing/projectile pixels. The sampled render states/readbacks do not preserve a complete frame's initial color/depth, owning draw/resource inputs and intervening CPU writes. They cannot assign the fault to execute-buffer/front-end coverage, backing synchronization, or GPU rasterization. No speculative clear/blend/lighting change, guest state/clock patch, cheat, asset edit or validation bypass was made. A repair requires identifying the first missing/ineffective world draw across that boundary; no successor task was launched.

Original input hashes pass before/after (873 files). All 107 runtime pins verify, and 26 recorded native events are trusted. The measured live legacy/WebGL endpoint uses ANGLE on Intel UHD 620 / Mesa 23.2.1, despite launch flags requesting SwiftShader, with zero GPU errors, fallbacks and completed software draws. Existing pure-JS mock tests for GPU batching/clear ordering, depthless Z, and async Flip pass. test-d3dim-gpu-fallback-counters.js fails on unchanged source at fallbackDrawTexture (expected 1, actual 0); this is recorded, not claimed as the game cause or repaired. No new build or new source regression is claimed for this docs-only investigation. Helper syntax and evidence checks are retained in the bundle.

Browser PID 1536530 exited 0; controller 1536494, lock holder 1527163 and watcher 1528360 are absent. HTTP 35875 and CDP 34131 are closed, the profile is removed, and no keys remain held. The controller tool returned 143 after its finally completed; that exit's cause is unknown. No Boat/test box was allocated (ID/state/expiry N/A); delegated local shutdown is complete.

Complete renderer boundary: world vertices already degenerate (2026-10-31)

Run scratch/runs/20261031T0552Z-forsaken-boundary/ advances the 0427Z partial-window observation. One native Volcano run captured two complete clear-entry-to-next-clear-entry intervals, each containing exactly one original Flip. Frame 1 spans epoch milliseconds 1793426468823.48–1793426469383.7852. This identifies the first ineffective world draw in that frame; the first historical corrupting operation remains unproved. No production repair was made.

The retained module is SHA256 8459597c8d66e098d727fb4ab53e1cf46332241dc7eef2e158f3c475a78b1676, with the exact matching 292-source ReVolt0403Z snapshot. Its manifest is 9dee97b3f74481ba14d6808ecce1d4b665099d8b03c58235e0b02812b234e379. All 107 runtime response pins and original 873 inputs verify; current host sources were not substituted. Default guestWorker, Threads, explicit WebGL and 1024×768 were measured live. The actual legacy endpoint uses ANGLE on Intel UHD 620 / Mesa 23.2.1. Native Enter reached Single Player/Start Volcano; the synchronized capture used trusted A for 500 ms. No game state, asset, clock or validation edits were used.

boundary-trace.json retains initial/end GPU color, framebuffer/depth attachment identities, CPU backing/object snapshots at renderer handoffs, uploads, clear arguments, owning command/state bytes, texture bytes, all actual submissions, per-draw before/after GPU pixels and readback. The initial depth renderbuffer contents cannot be read directly; the first successful full (0,0,640,480) flags 2, Z=1 clear defines the depth used by every captured draw. CPU snapshots do not record every individual guest instruction store. The separate original Execute/TRIANGLE/Flip trace has no overflow and brackets the same complete intervals.

Precise missing capture dependency: the first native initialization of these world buffers, first source-cache creation, subsequent Lock/Unlock and vertex writes, and source-cache/matrix/viewport inputs immediately before the first divergent PROCESSVERTICES. The successful guest trace began after all referenced world positions were already collapsed. Later correctly decoded world-caches.json also contains collapsed screen-like coordinates. Retained 09ab-handlers-d3dim-core.wat reads the source cache and writes transformed TL vertices into the live execute buffer; 09aa-handlers-d3dim.wat Unlock refreshes the whole source cache from that buffer. Feedback through that refresh is a candidate mechanism, not an established first cause. This run cannot distinguish it from original game writes or another earlier front-end operation. No speculative cache, clear, blend or lighting change is justified.

Replay the focused evidence check with python3 scratch/runs/20261031T0552Z-forsaken-boundary/check-boundary.py. It passes both complete intervals, all 16 Execute/transport/submit matches, 1,340 degenerate world triangles with zero changed pixels, four effective object draws, exact 565 upload/color reconstruction, and all input/source/ runtime hashes. This is an observation check, not an old-source-rejecting repair regression. No new build is claimed for this docs-only change.

Capture limitations are preserved in late-observation-limit.json: the startup instantiate hook missed its instance; the successful observer used an always-false conditional breakpoint in the original dx_trace import. The initial cache decoder assumed 8192 slots/64 bytes; actual retained layout is 16384 slots/32 bytes, so its half-index slot and cacheGuest:0 metadata are invalid. Raw Execute bytes are independently validated against the transport. A subsequent Ctrl 500 ms screenshot failed; a later live observation found no guest workers, cause unknown. No new primary-fire image contrast is claimed. A late empty-page capture overwrote boundary.png; exclude it and use only the synchronized GPU PNGs above.

Own Chrome 1630186 exited 0; controller 1630169, holder 1630168, tracked children/crashpads are absent. HTTP 41779 and CDP 44313 are closed, profile removed and keys released. The browser lock covered the entire runtime, including the process/profile gate; another worker's orphan was left to its owner to close before launch. No Boat was allocated (ID/state/expiry N/A); delegated local cleanup is verified. Evidence and replay instructions are retained in the run's RECOVERY.md; no successor.

2026-10-31: first native source-cache feedback captured

Run scratch/runs/20261031T0617Z-forsaken-first-mutation/ retains the predecessor's exact 8459597c8d66e098d727fb4ab53e1cf46332241dc7eef2e158f3c475a78b1676 module, matching 292-source manifest 9dee97b3f74481ba14d6808ecce1d4b665099d8b03c58235e0b02812b234e379, 107 pinned runtime responses and 873 original inputs. No current runtime was substituted into that retained build. Original input checks passed before and after the native run. Default guest workers, Threads and explicit WebGL ran at 640×480 inside the 1024×768 page; no guest state, clock, asset or DLL changes.

A CDP auto-attach observer pauses each guest worker immediately before WebAssembly.instantiate, wraps the actual host imports, and removes the breakpoint. startup-observer.json records installation with no instance; the first DX observation finds no execute buffers in the actual 16384-slot, 32-byte table. This fixes the predecessor's startup installation race.

The authoritative after-native-a-worker-2.json segment has no overflow or observer errors. Slot 1352, buffer size 6784, is observed from creation (event 415), first Lock (417), 876 initialization byte-delta observations, first Unlock (1294/1295), cache population and first Execute. Replaying every delta reconstructs Unlock-entry bytes exactly. Changes are sampled at original block boundaries and API boundaries; this is not an instruction write barrier. The original color loop is retained and disassembled: 0x43a445 mov [edi],eax, with 32-byte source/destination strides. Addresses identify this run only.

The causal chain is now established for this original native buffer:

Both first and first-divergent PROCESSVERTICES include the 4096-byte device state, WORLD/VIEW/PROJ/previous composite and canonical viewport descriptor; first-pv-state.json decodes these. The trace occurs before composite recomputation, so the retained composite is explicitly the previous value.

This buffer's instruction offset/counts differ from the predecessor's six Volcano world draws: offset 5408, PROCESSVERTICES groups 40/21/108. Personally inspected startup/room/copyright screenshots do not establish the Volcano briefing route. Do not relabel this startup/attract-room observation as the predecessor's exact first Volcano world buffer. It proves the generic mutation mechanism; that exact route identity remains a separate observation dependency. Earlier unfiltered initialization segments hit the observer's event bound and are excluded from the causal claim. A TextDecoder SharedArrayBuffer issue in the initial observer was corrected before the authoritative segment; retained secondary-worker errors and earlier saturated segments are not hidden.

The generic repair keeps application source and processed TL output in separate regions within one owned cache block. Unlock refreshes source; transforms write output, and triangles/points/lines/Pick read output after processing. Before processing, direct TL buffers retain their live-buffer path. Release frees both streams together. Allocation failure must not transform live source. The sparse-vertex regression now asserts source preservation, stable positions and updated colors after a color-only Unlock; the instruction regression reads COPY/viewport results from driver output and separately checks unchanged source.

The fresh repaired native candidate is 41f5c4c737ce7b428455aaa9dfe0c5045cd1ead7b00b96070feebb8368d4a2a4, with matching 295-source/7-compiler snapshots in repaired/, identical source and compiler manifests before/after the locked build, 106 pinned runtime responses and 873 unchanged originals. Personally inspected enter2.png, single-player.png, start.png, native-enter-volcano.png establish the native menu → single player → START → VOLCANO → briefing route. world-frame.png shows a complete room and HUD; native-response.png shows the view pitched downward and pulse ammunition 2000 → 1998 after trusted ArrowUp+Control for 500 ms. All 18 retained browser events are trusted.

repaired/check-source.py verifies the matching original Volcano instruction layout, offset 5184, first PROCESSVERTICES 5196, slot 536 in this run. All 162 original XYZ vertices stay unchanged across 12 Execute cycles; 24 pre-PROCESSVERTICES observations retain source/live equality, separate TL output, device state and viewport. Thus the repaired source cannot accumulate the proven feedback from the earlier native trace.

repaired/check-redraw.py verifies two complete depth-only-clear intervals (flags 2, unchanged valid semantics). Each has six world draws totaling 642 triangles, followed by two object draws. Every world draw has distinct positions and changes actual GPU pixels. Frame 1 world changes per draw are 166618 / 126250 / 5938 / 1058 / 4181 / 3056; frame 2 is likewise effective. Summed pixel-change events are 307101 / 307489 (overdraw counts repeatedly; these are not unique frame pixels). This proves current world rasterization, rather than relying on a full-looking inherited backing. The visible native view differs from the predecessor's 670-triangle view; no identical-camera pixel comparison, sustained play, performance or completion claim is made.

Focused old-source rejection fails specifically on preserving Lock-visible source. The repaired reproducer passes 32 color-only cycles. Focused sparse, cache replacement/OOM, lifetime, descriptor, instruction/branch, 2470 vertex pixel comparisons and viewport checks pass, as does the locked build. A final review corrected an allocation-failure guard after this native capture; its final build/identity and focused allocation-failure check remain pending. The captured native normal path always had separate output; the guard concerns only missing output storage. Native candidate and final build closures remain separately pinned, without substituting current runtime into either module.

A later optional screenshot capture stalled after the demonstrated input. An external connection captured final-live.png while changing its viewport to Puppeteer's default 800×600, then closed our browser. Exclude that teal cleanup frame and the failed native-after capture from visual validation. The controller's finalizer closed the server and removed its profile; its browserExit:null is not an exit-0 receipt. Independent cleanup verifies all 17 recorded owned PIDs absent, HTTP 44385 and CDP 37021 closed, profile/process match absent, no held keys and original 873 inputs unchanged. No foreign processes were touched. Browser/heavy checks held the browser lock for their entire lifetime. No Boat was allocated (ID/state/expiry N/A).

At the bounded stop the repair remains uncommitted WIP in src/09aa-handlers-d3dim.wat, src/09ab-handlers-d3dim-core.wat, test/test-d3dim-execute-vertices-sparse.js and test/test-d3dim-execute-instructions-sparse.js. Final review changed only the allocation-failure guard after the tested native candidate; that final change needs its focused failure/retry regression and locked build. The other worker still owned the browser/heavy-CLI lane at the stop, so our queued check PIDs 1687827/1687832 were canceled and verified absent. No source changes are committed, no final-guard build is claimed, and no successor is launched. The native-tested candidate, exact closure, screenshots and pixel proof above are complete; normal-native-to-final-guard.json checks the exact one-condition difference. Next required work is the final guard regression/build before any scoped source commit.

2026-10-31: final separate-output repair verified

Fresh run scratch/runs/20261031T0658Z-forsaken-output-land/ completes the released repair's final checks. The final module is SHA256 d2c1df73d975daa4e7425152fb900274ebd9552c5a689249415084cfe8ac026b (1,898,571 bytes). Its exact 295-source manifest is SHA256 4d8c8330e34c5230fb9e17855b3f7db9394857d2ed49de0789e3d98d2f33b132; all source, seven compiler inputs and two changed test files match before/after verification. final.wasm, manifests, snapshots, patch and final-build-identity.json retain the tested dirty-source closure based on f992c7fa84b2804aa877697377ac5044f9ebca20.

The generic repair owns source and processed output in one cache allocation. Unlock refreshes only source; PROCESSVERTICES writes driver output, which is consumed by triangles, lines, points and Pick. Direct TL buffers keep their live-buffer path until processing begins. Replacement allocation preserves the old owner until success, and release frees both streams together. The final guard normalizes the COM-pointer condition and skips processing when output still aliases live application storage after allocation failure.

Cheap syntax, manifest, fragment, logical-operand and whitespace prerequisites passed before heavy work. Under the full-lifetime browser lock and a clean live process/profile gate, the released reproducer rejects old source on Lock-visible source corruption and rejects the native candidate's guard specifically on OOM source corruption. Final source passes 32 color-only cycles, allocation failure without source mutation, and successful retry with matching projected positions and color. The checked-in sparse regression now runs 32 cycles across all three PROCESSVERTICES modes and owned/sparse cache cases, preserving all source bytes outside application color edits. All six focused scripts pass: vertices-sparse, cache, buffer-lifetime, buffer-oom, data-sparse and instructions-sparse. Coverage includes replacement/retry/release ownership, 16 buffer allocation failures, descriptor/status transactions, 2,470 vertex pixel comparisons and viewport behavior. flock /tmp/wine-build.lock bash tools/build.sh also passed.

The native-tested candidate remains the historical 41f5c4c7… module above. Read-only verification of its 295 source and seven compiler snapshots proves that final runtime source differs only by the failure guard; compiler inputs are unchanged. Replaying its 24 native pre-PROCESSVERTICES observations confirms matching cache allocations, separate output and unchanged original XYZ for 162 vertices across 12 Executes. Both guards continue on every captured normal-path observation. The final d2c1df73… build received no fresh native retest; Volcano redraw, pitch and ammunition evidence belongs to the prior candidate. No further normal-path engine change was made during this final verification.

Historical evidence and native-candidate snapshots were preserved; the old checks.sh was not rerun. Fresh RECOVERY.md documents safe replay into the new run. No browser, runtime, ports, profile or test box was started by this worker; no Boat was allocated (ID/state/expiry N/A). The foreign Deus runtime was left untouched and all heavy work waited for its lane release. Disk stayed above 2 GiB. No public deployment or successor is part of this task.

2026-10-31: landed final build, further native Volcano play

Run scratch/runs/20261031T0713Z-forsaken-repaired-gameplay/ gives the landed d2c1df73… final build its own native gameplay evidence. It serves the exact retained 20261031T0658Z-forsaken-output-land/final.wasm and matching after/source closure, never the historical 41f5 candidate or current host files. All 295 runtime files match the landed df174b3cf git objects; all seven compiler inputs and the final module hash verify. No source repair or rebuild was needed for this gameplay task; the locked build/six focused regressions remain the landing run's evidence.

Personally inspected native menu captures establish Single Player → Start → Level Volcano → loading/briefing → game. Default guestWorker, Threads, explicit d3d-renderer=webgl and 1024×768 stayed enabled. The original readme controls were used through trusted browser keyboard/mouse events: A thrust, arrow look, Ctrl primary, Space secondary, Alt+arrow strafe and Escape pause/resume. No game state, clock, INI, asset, cheat or input-queue edits were made.

Readable gameplay captures span 07:26:21–07:29:47 UTC, including several movement/look/firing sequences, deaths and pauses rather than uninterrupted survival. Lives fell 5 → 1; ammunition resets on respawn, so the entire run is not a monotonic ammunition sequence. Bright combat effects remain. Pause/ resume captures also contain white menu/background frames. In particular, beyond-corridor.png and sustained-thrust-fire.png are command labels whose images show the pause menu, not movement proof. route-pause.png shows a death transition. Subsequent native thrust restored the readable far-corridor view above. These limitations are retained in visual-review.json; correct pixels on every intervening frame are not claimed. No enemy kill, hidden-door opening, level completion, FPS or audio claim is made.

The strict server initially omitted five required launcher fonts and stopped before game startup. That failed attempt is preserved under startup-font-rejection/ and closed cleanly. The retry adds 18 pinned ancillary static assets, all matching historical response hashes; no font file was edited. All successful responses are retained by hash; fixed-body optional 404 responses are separately recorded. Fresh checks pass for 873 original files before/after, 609 successful responses (555 distinct URLs), 95 trusted native events, balanced keys and 41 intact 1024×768 PNGs. Read-only runtime telemetry confirms the default guestWorker/selected WebGL route and live D3D draw/flip counters; zero errors/fallbacks are not pixel proof. Recovery and replay checks are in this run's RECOVERY.md and verify.py.

The browser lane lock covered startup, gameplay and cleanup, after waiting for the Deus worker and passing the actual live-process gate. Browser 1726273 exited 0; controller 1726264, holder 1726255 and all 59 recorded owned PIDs (controller/descendants, including transient helpers/crashpads) are absent. HTTP 37653 and CDP 40157 are closed; profile removed and no keys held. The failed startup's owned processes/ports are independently checked too. The final outer runtime tool returned 143, cause unknown, despite the browser exit-0 receipt and verified cleanup; controller exit 0 is not claimed. No watcher, Boat/test box, public deployment or successor was started (ID/state/expiry N/A). Next gameplay work can continue toward the hidden-door objective; its enemy/door conditions are still unproved.

2026-11-06: current-main registered software Volcano gameplay

Run scratch/runs/20261106-forsaken-current-software-gameplay/ advances GLD3D-CORPUS-27-20261006, candidate forsaken-demo, through the registered forsaken_demo launcher. Fresh flock /tmp/wine-build.lock bash tools/build.sh passed against commit 75c4ccb331a7c377496f088958853ed45af90cc2. The actual instantiated standard module is 2,180,791 bytes, SHA256 2fa9f377dde5e477eb811baceb64032889fbe9b27a664b213477e84627e5eb94. Launch-time source-identity.json records commit dc09732f272a592749518446751ddae8a495d2b7; only TODOS.md changed since the build commit. The relevant binary diff and the new-file patch for the already-present untracked lib/wininit-boot.js preserve the tested closure. Git is the source archive; no source tree or repeated game media was copied. All 1,470 pinned inputs, including 873 original Forsaken executable, manifest and media files, match after play. The original EXE SHA256 is 366ec5d0943daca839836296f9fb52724e94dc155630c6b0c30d7181106b5e24.

This is fresh software gameplay, beyond the briefing and independent of the accepted historical WebGL run. Chrome 151.0.7922.108, 1024×768, default guest Workers and Threads were used with explicit d3d-renderer=software. Every live CPU Worker's actual module bytecode was hashed through CDP. Main CPU slot 0, endpoint 1, target C93D27F48E28390FB08B973B8C9C8F8E, has GPU disabled. Passive sampling of that owning Worker resolves viewport_draw_textured_span, rasterize_triangle_textured and D3DIM Execute functions. Resolution uses a separate compiler-generated name-section artifact whose executable sections equal the canonical loaded module; it does not guess function names from source order. software-owner-proof.json records this inline software renderer evidence. No separate D3D render-worker endpoint was present. CPU samples are not completed-draw counts or FPS measurements.

Personally inspected trusted native controls establish Single Player → Start → Level Volcano → loading/briefing → readable world. The original readme's A, Z, arrows, Ctrl, Space, Alt+arrow and Escape controls were used through ordinary browser keyboard events. No guest state, asset, clock, cheat or input-queue edits were made.

The strict paused-response collector finishes with no fault, no missing receipt and complete lifecycle coverage: 689 successful responses, 580 distinct successful URLs, all exact pinned bytes/hashes. 80 captured native events are trusted; all 78 keyboard down/up events target the guest screen and balance. All 27 main-run 1024×768 PNGs were personally inspected; per-image review files distinguish menus, gameplay, bright effects and death. Three failed setup attempts are retained separately: omitted manifest pin, missing ?candidates causing an asserted-selector correction, and an absent optional launcher icon needing an exact 404 policy. These were run-local setup errors corrected before the healthy session, not emulator diagnoses. The selector attempt launched default Notepad; the icon attempt fetched the original Forsaken executable. Neither contributes gameplay evidence.

The locked full build, existing 32-cycle vertices-sparse regression, second-instance software Worker parity test and 99 synthetic/real-byte collector lifecycle cases pass. No reproducible emulator discrepancy was established, so no production fix or speculative regression was added. No enemy kill, hidden-door opening, level completion, audio, FPS or full-scene parity claim is made. The next gameplay objective remains locating/opening the hidden door after satisfying its enemy condition.

The healthy browser exited 0 on ordinary stop, all held keys were released, HTTP 34387 and CDP 43653 closed, and its profile was removed. Final cleanup independently checks every recorded startup and gameplay process, port/profile, the lock holder and all four local runtime/build locks. No test box was created (ID/state/expiry N/A), no public deployment occurred, and disk stayed above 2 GiB. See verification.json, cleanup.json and aggregate-cleanup.json; setup-attempt cleanup records retain their historical held-lock state rather than rewriting it as a release.