Quake II 3.14 demo

Brighter first-launch defaults (2026-10-15)

The bundled config now seeds vid_gamma 0.7; Q2's gamma exponent becomes brighter as it decreases. Saved player configs still replace the seed. Before/after Chrome captures of demo1 are under scratch/runs/20261015-quake-brightness/quake2_demo-{before,after}-verified. The comparison uses the stable deployed WASM with intercepted seed configs.

Package and layout

The local dropdown uses a host extraction at installed-extracted/Install/Data/. Its required runtime set is quake2.exe, ref_soft.dll, ref_gl.dll, baseq2/gamex86.dll, and baseq2/pak0.pak. pak0.pak is 49,951,322 bytes with SHA-256 cae257182f34d3913f3d663e1d7cf865d668feda6af393d4ecf3e9e408b48d09.

Installer path

The package reaches its WinZip dialog after these formerly missing APIs:

Start extraction through the normal guest input path:

/opt/homebrew/bin/timeout -s KILL 360 node test/run.js \
  --app=quake2_demo_installer --no-build --screen=800x600 \
  --max-batches=1000000 --max-seconds=330 --batch-size=20000 \
  --loop-superops --repaint-every=2000 --quiet-api --quiet-blocks \
  --input=5:0x111:1 --reg-export=/private/tmp/q2-installer-registry.json

5:0x111:1 queues WM_COMMAND/IDOK for the guest pump. Do not use dlg-click for this button: it synchronously enters the x86 WndProc from the host and decompression legitimately exceeds that bridge's 64-round safety limit.

On 2026-08-25 the run displayed 277 file(s) unzipped successfully. A case-insensitive path, length, and SHA-256 comparison against a direct ZIP extraction reported 277 expected, 277 actual, and no missing, extra, or mismatched files.

Registry delta

The completed --reg-export snapshot contains 62 entries and is byte-for-byte identical to a clean pre-extraction snapshot from the same app (SHA-256 0571abe5d87e78d5934f966882e89710a1d75fbe5c66ddd37db9e1c392eeae1a). tools/registry-snapshot-diff.js reports no added or removed keys and no added, changed, or removed values. This WinZip package only unpacks the 277 files; it does not register Quake II or invoke the nested InstallShield setup. Therefore the playable quake2_demo manifest needs no game-specific startupRegistry entries.

Launching the installer-produced copy

For an arbitrary extracted path, preload both native game DLLs; the app registry's quake2_demo entry does this automatically for the dropdown:

/opt/homebrew/bin/timeout -s KILL 140 node test/run.js \
  --exe='/private/tmp/q2-install/windows/desktop/quake2 demo/install/data/quake2.exe' \
  --args='+set vid_ref soft +map demo1' \
  --vfs-include='baseq2/**,ref_soft.dll' \
  --dll-seed='/private/tmp/q2-install/windows/desktop/quake2 demo/install/data/baseq2/gamex86.dll,/private/tmp/q2-install/windows/desktop/quake2 demo/install/data/ref_soft.dll' \
  --no-build --screen=800x600 --max-batches=20000 --max-seconds=100 \
  --batch-size=20000 --no-close --png=/private/tmp/q2-gameplay.png

The exact installer-produced files load gamex86.dll and ref_soft.dll, create the Quake 2 window, and render demo1 in the software renderer at 320x240, 8bpp. Running an arbitrary EXE without preloading gamex86.dll fails with the game's own FreeLibrary failed for game library message; that is an incomplete ad-hoc mount, not an emulator failure.

There was a distinct lifecycle failure after dying in demo1: loading the autosave could reuse the resident gamex86.dll HMODULE, but FreeLibrary's old consecutive-call sentinel was never reset by that successful reload. The next normal map teardown therefore returned FALSE and Quake raised the same message. A successful LoadLibrary now starts a fresh lifetime for that exact handle, while two consecutive frees still return TRUE then FALSE for the NSIS unload-loop compatibility case.

Browser black-screen report

The browser must be tested separately from the CLI because DirectDraw pixels pass through a per-window _dxFrameLayer, the desktop compositor, and optionally the WebGL presentation canvas.

On 2026-08-25 the pre-fix manifest (+set vid_ref soft) produced non-black gameplay in all fresh-profile probes: desktop 2D, desktop SwiftShader, hidden runtime log, and an iPhone-sized page-fullscreen viewport. The fresh demo automatically enters its attract map; no menu frame appears. The phone capture has black top/bottom letterboxing around the 4:3 game, but the game crosses the visible viewport centre and the canvas itself starts at the top of the viewport.

The dropdown now passes +set vid_ref gl +menu_main so users see Quake's ordinary main menu through the hardware-accelerated compatibility renderer. The browser scheduler gives quake2_demo a 10,000-block slice. The generic 100,000-block default is unnecessarily coarse during immediate-mode startup; 10,000 keeps the renderer cooperative. The later first-frame exit reproduced at both slice sizes, proving slice length was not its cause. The exact failure was a missing dynamically resolved legacy presentation entry point, described below. test/test-quake2-demo-web.js explicitly overrides that production default to +set vid_ref soft +map demo1 inside its fresh page because it is the separate software/DirectDraw gameplay regression. It drives the actual selector and trusted Launch button, emulates iPhone page-fullscreen, asserts both Quake's own DirectDraw layer and the visible browser screenshot are non-black, and compares two raw game-layer frames to prove the demo world is moving rather than accepting a menu or frozen loading plaque.

OpenGL renderer gap

This was measured from ref_gl.dll and runtime API traces without consulting Wine source. ref_gl.dll dynamically resolves the complete Windows OpenGL 1.1 table: 336 gl* names and 21 wgl* names. All 357 currently resolve to zero; there is no OpenGL/WGL implementation in the runtime. That lookup count greatly overstates the first playable target, because Quake's generated dispatch table contains wrappers for every OpenGL 1.1 export.

Filtering those wrappers out of the binary's call sites leaves 48 GL functions called by Quake's renderer code:

The platform code references seven standard WGL functions: wglCreateContext, wglDeleteContext, wglGetProcAddress, wglMakeCurrent, wglChoosePixelFormat, wglDescribePixelFormat, and wglSetPixelFormat. This particular 1998 renderer additionally calls GetProcAddress("wglSwapBuffers") and stores the result in its EndFrame slot. That spelling is a legacy compatibility requirement of the shipped binary, regardless of the normal Win32 GDI32!SwapBuffers API. Both names therefore lower to the same backend-neutral presentation operation. Optional SGIS multitexture, EXT paletted-texture/point, swap interval, and NVIDIA gamma-ramp symbols can remain unavailable when the synthetic glGetString advertises no extensions.

A rendered probe gets a valid Quake HWND/HDC and succeeds through the existing ChoosePixelFormat, SetPixelFormat, and DescribePixelFormat handlers. It then jumps to EIP zero on the first missing wglCreateContext call. The zero HDC seen with --no-renderer is only a headless-canvas artifact, not a browser blocker.

The implemented browser design is a fixed-function OpenGL 1.x frontend over a generic WebGL/GLES-shaped backend, not a software renderer. It lowers immediate mode into vertex batches, matrices into uniforms, texture/state operations into backend resources, and owns WGL context/DC lifecycle plus per-window GPU presentation. The reusable backend boundary is intentionally suitable for a future hardware Direct3D frontend.

The focused backend/fixed-function/presentation tests and full API build pass. In real Chrome, the authentic ref_gl.dll loads and renders both the textured main menu and the GAME difficulty submenu at 640x480. The production 10,000-block slice also reaches unmistakable Easy gameplay: textured world geometry, weapon, crosshair, health, and ammo HUD all render. A normal forward key changed 11,432 of 307,200 pixels between captured frames; console scrolling, loading backgrounds, context creation, and menus do not satisfy that acceptance.

Runtime renderer switch

The dropdown now starts OpenGL directly. A separate lifecycle regression keeps the user's reported transition path: it overrides only its test-page command line to start the software-rendered main menu, opens Quake II's Video menu, selects OpenGL, and Applies. It will distinguish an intentional renderer-DLL unload/reload gap from a real ExitProcess or last-window teardown before changing runtime semantics.

The first UI capture pins the important control: Right on the selected driver row changes [software] to [default OpenGL]. Keyboard-only exploratory probes initially returned to the main menu without applying. The decoded trace proves that run only called LoadLibraryA("ref_soft.dll"), ddraw.dll, and dsound.dll; it never requested ref_gl.dll, destroyed the window, or exited. Per-step captures explain why: at the generic 100,000-block browser slice the first six Down key pairs had not been observed when photographed, the seventh finally moved the cursor to Reset, and Enter activated Reset rather than Apply. Waiting until the host queue drained was still insufficient because Quake polls key state and an immediate synthetic down/up can be invisible by the time the guest checks it. Absolute mouse clicks likewise left the selection on driver. The acceptance therefore lowers only the post-menu slice to 10,000 blocks, holds each key across several cooperative slices, waits until its events drain, saves all seven cursor positions (Reset is skipped by keyboard navigation), and presses Enter on the real Apply row. This changes scheduler granularity, not the production manifest, command line, or renderer choice.

First-frame OpenGL exit

The production cold start later regressed to a visible menu followed by EIP=0. Instrumentation ruled out ExitProcess, DestroyWindow, last-window grace shutdown, a WebGL exception, and missing optional extensions. The final 512 guest GL calls were valid texture uploads and immediate-mode menu quads; the final one was glGetError returning GL_NO_ERROR inside ref_gl's exported EndFrame routine at original VA 0x1000e060. The next indirect call at 0x1000e087 jumped through zero.

Static slot mapping identifies [0x10052dbc] as the result of GetProcAddress("wglSwapBuffers"). Removing that legacy alias during an API cleanup made the first real EndFrame call NULL before any present. Restoring the name as a one-argument stdcall alias to generic GPU present fixes the exact failure without a Quake-specific address patch. A focused regression now asserts that the static GetProcAddress name table exposes it, its stack cleanup is correct, and both it and GDI32!SwapBuffers reach opcode 55.

The next gameplay attempt exposed a separate generic bridge bug at runtime EIP 0x00cab7d9 (ref_gl original VA 0x1000a7d9), immediately before its glVertex3fv call. The recorded vertex pointer was 0x4e306050, in Quake's high sparse VirtualAlloc arena. The old JS bridge subtracted the main image base directly and produced host offset 0x4df18050, outside the 512 MiB WASM memory, causing the reported DataView bounds error. Pointer-bearing GPU calls now use the emulator's exported canonical $g2w translator, which understands the direct image window, DIB arena, and sparse mappings. The focused regression maps that exact guest address to backing 0x10006050, and the real Chrome gameplay run subsequently renders and moves without the fault.

Gameplay light flashes

The initially reported harsh light flicker is present in the raw WebGL framebuffer, before the browser compositor sees it, but it is not random state or presentation corruption. A no-input Chrome probe intercepted 12 consecutive SwapBuffers calls (write sequences 45 through 56), read every 640x480 RGBA frame directly with gl.readPixels, and recorded the complete GL call stream, texture updates, and terminal raster state for each frame.

The bright sequence visibly contains Quake's scripted opening explosions: fireball geometry and orange particles enter the scene as mean framebuffer luma rises from 13.46 to 32.25, then fade as it falls through 29.80, 27.21, 24.48, 21.84, and 19.08. The peak is not an unexplained full-screen toggle. It coincides with three glTexSubImage2D writes to lightmap texture 1024, chiefly a 128x67 atlas strip; the preceding frames update 128x49 and 128x61 strips as the same visible blast grows. Captures are under scratch/quake2-gl-flicker/flash/.

The GL state sequence remains structurally stable throughout. Every captured frame restores depth writes, GL_LEQUAL, normal alpha blending, and the same end-of-frame 2D state; there is no alternating depth, blend, cull, scissor, texture-enable, or presentation state. Write sequences are consecutive, so the compositor is neither repeating nor skipping between two surfaces.

A later no-input control captures the explosion disappearing and the same view settling. Across its final six frames, mean luma stays between 13.99 and 14.12 (under 0.9% spread); remaining changed pixels are the weapon idle animation and a few particles. Even frames with dozens of small updates to lightmap textures 1035-1037 remain in that brightness band, which rules out the subimage path itself randomly corrupting illumination. Those captures and the per-frame JSON traces are under scratch/quake2-gl-flicker/settled/.

That stationary evidence did not cover a separate movement-only presentation bug. A trusted mouse-look probe caused the compositor to repaint at time 112493.1 after 645 glEnd draws of the next frame but before gpuPresent sequence 71 at time 113462.5. The resulting screenshot was a bright, incomplete base-texture pass with no weapon, HUD, or lightmap. The compositor's GPU layer directly referenced the WebGL canvas on which the guest was still drawing; pointer movement merely supplied the otherwise-unrelated repaint that exposed it.

The generic WebGL/GLES backend now separates its live draw canvas from a compositor-visible 2D snapshot. Only present/SwapBuffers flushes and copies a completed GPU frame into that snapshot, so keyboard, mouse, window, and desktop repaints between cooperative guest slices retain the preceding whole frame. This ownership boundary is backend-generic and can also be used by a future accelerated Direct3D frontend. test/test-gpu-atomic-present.js proves that partial drawing cannot mutate the exposed surface and that explicit present publishes one complete, correctly resized, pixel-exact snapshot.

The conspicuous no-input explosion flashes remain authentic scene content made harsher in wall time by the low guest frame rate. test/test-opengl-frame-state.js locks the generic invariants exercised here: lightmap subimages update only the selected texture, multiplicative blending and disabled depth writes do not leak past the lightmap pass, sparse bytes are copied unchanged, and one GPU present produces exactly one repaint and one FPS event.

Gameplay input

Quake's keyboard path consumes the Set-1 scan code in Win32 message lParam, not merely the wParam virtual-key value. Browser keyboard events now carry their physical DOM code through the renderer so WM_KEYDOWN/WM_KEYUP include the scan, extended, previous-state, and transition fields. In the production GL acceptance, a trusted held W reached the host input queue as WM_KEYDOWN lParam=0x00110001 and WM_KEYUP lParam=0xc0110001; the renderer's held-key state remained down after the message queue had drained, cleared after the release was consumed, and the forward step changed 6,660 of 307,200 pixels.

The remaining mouse problem was at the browser boundary. An API trace of real gameplay shows Quake calling SetCursorPos(159,119), ClipCursor, and ShowCursor(FALSE), then polling GetCursorPos continuously. The virtual Win32 cursor honored those calls, but the physical DOM cursor stayed absolute: after Quake recentered its virtual point, the next DOM coordinate was measured against a centre the physical cursor had never visited. Mouse look therefore accelerated incorrectly and stopped at the browser edge.

The browser now requests pointer lock from a trusted canvas mouse-down only when an exclusive guest presentation has an active ClipCursor region. While locked, movementX/Y is scaled into logical-canvas space and applied relative to the guest cursor that SetCursorPos controls, then passes through the normal mapped WM_MOUSEMOVE path. Releasing ClipCursor or running an ordinary desktop window retains absolute mouse behavior. The renderer regression covers the inverse transform at 2x scale, explicit guest recentering between samples, Win32 queue coordinates, and the inactive-clip negative control.

test/test-quake2-input-web.js drives the exact dropdown +set vid_ref gl +menu_main path with trusted browser events. Its final run recorded the active [0,0,639,480] clip, acquired real pointer lock, routed six nonzero relative samples, visibly changed the camera, and saved the input queue, mouse deltas, and screenshots under scratch/quake2-input-web/.

One boundary remained before capture. Pointer Lock requires a trusted click, but ordinary absolute mousemove events were still delivered after Quake hid and clipped its cursor and before that click occurred. Quake polls the offset from (159,119) and recenters its virtual cursor every frame; the browser's physical cursor does not follow that guest-only SetCursorPos. Each small DOM move therefore reintroduced the whole physical distance from centre, making the view rotate faster the farther the pointer wandered. The browser bridge now holds absolute moves while a relative exclusive guest is awaiting Pointer Lock. The acquisition click still reaches the guest and starts relative movementX/Y; nonexclusive desktop applications retain their ordinary absolute hover and move path.

Pointer Lock must be requested synchronously inside the trusted click. A trial of its unadjustedMovement option broke capture on browsers which reject that option: the Promise rejection arrives after transient user activation has expired, so an optionless retry cannot lock. Capture therefore uses one plain, synchronous request. Reliable unbounded motion takes priority over raw-device deltas until support can be selected before consuming the user gesture.

The browser bridge accepts both the standard Pointer Lock names and WebKit's older prefixed request, lock-element, and change-event names. This matters on macOS Safari builds which support Pointer Lock but expose some or all of that surface under webkit*; the request remains synchronous in both branches.

Quake is also marked relativeMouse in its app manifest. The browser shell carries that declaration onto the live app record, and the input bridge uses it whenever Quake owns an exclusive presentation. Its late ClipCursor/ShowCursor timing is therefore no longer an eligibility race: the capture click asks for Pointer Lock even if Safari reaches the click before the guest's current frame has published its cursor state.

Threads/OpenGL throughput

The severe slowdown with the browser Threads switch is not a guest lock or a bad interaction between Quake threads. An isolated-Chrome +set vid_ref gl +map demo1 probe on 2026-08-27 found zero CreateThread workers: the switch only moved Quake's one main thread into guest Worker slot 0. The regression is the synchronous host-import boundary. Every OpenGL entry reaches gpu_gl_call, and in Worker mode each call posts to the browser main thread and parks in Atomics.wait until the WebGL frontend returns.

The settled six-second measurements used the same current worktree, fresh profiles, 640x480 scene, 10,000 configured block slice, hidden runtime log, and headless Chrome SwiftShader:

mode completed presents scheduler guest rate GL calls sync RPC delta async RPC delta
cooperative 36 3.85M blocks/s 786,684 0 0
guest Worker 6 0.259M blocks/s 110,493 110,358 221,136

Scene motion makes exact calls per frame vary, but both runs were in the same range: about 18,000--22,000 GL entries per present. One representative Worker frame contained about 6,400 glTexCoord2f, 6,400 glVertex3fv, 2,750 glColor4f, and 1,286 glBegin/glEnd pairs. The sync-RPC delta is one-for-one with those GL calls. The two async messages per call are dispatch log and log_api_exit; their browser handlers are no-ops with runtime logging hidden, but the generic Worker broker still posts them. This is why changing the Worker block slice cannot solve the problem. The current adaptive probe fell from the 10,000 configured ceiling to 1,000 blocks, but the per-GL-call rendezvous remained.

There is a separate non-Threads cost in this software-GPU measurement. Cooperative glGetError took 3.23 seconds across 36 frames, about 90 ms per frame, because it synchronizes the queued SwiftShader work. That explains why the cooperative baseline is not fast on this host; it does not explain the roughly 6x Worker frame loss or 15x scheduler-throughput loss. Real hardware must be measured independently before quoting those absolute frame rates.

The useful fix boundary is a Worker-side GL command stream, not a larger guest slice: capture value arguments and copy pointer-backed data while it is valid, then replay a frame-sized batch on the browser thread. Flush before operations whose return or output is guest-visible (glGetError, glGetFloatv, glReadPixels, WGL lifecycle calls), and at glFinish/SwapBuffers. Suppress the no-op dispatch-log messages in the same fast path. This removes the cross-thread rendezvous per vertex/state call. It does not reduce the roughly 1,300 WebGL draw submissions per frame; combining compatible glBegin/glEnd batches is a second optimization after the RPC boundary is fixed.

That command stream is now the only normal transport in both modes. gpu_gl_call records arguments into a 2 MiB local buffer; capacity pressure submits a batch without presenting, while queries/readback, WGL lifecycle, glFinish, and SwapBuffers synchronously replay the ordered stream. Worker dispatch logging for GL stays local unless verbose/API tracing is enabled. Replay carries the originating Worker slot so concurrent guest GL threads keep their own WGL current-context binding across delayed batches. Small client arrays (vertices, colours, matrices, texture-name lists) are copied at call time because the guest may reuse them before the batch flushes.

Texture images use a different lifetime rule to avoid copying the large payload. The encoder appends texture metadata naming the original shared guest allocation to older buffered commands and synchronously submits the combined batch. The guest remains parked until browser-thread replay has passed that direct typed-array view to WebGL, so the allocation cannot be changed or freed while borrowed. A real Chrome SwiftShader run accepted this SharedArrayBuffer-backed upload path, including live glTexSubImage2D updates; no compatibility copy was needed.

A matched post-change six-second run completed 20 Worker presents versus 26 cooperative presents. The prior matched result was 6 versus 36, so the relative Worker throughput rose from 17% to 77% of cooperative. The Worker executed 389,533 GL commands in that window without a per-command host round trip and reported no browser errors. Remaining time is now dominated by the explicit per-frame glGetError barrier under SwiftShader: 4.14 seconds for 21 Worker calls and 2.95 seconds for 26 cooperative calls. That is a separate GL error semantics/software-GPU issue, not command transport; removing it would require maintaining a trustworthy frontend error shadow rather than silently returning GL_NO_ERROR.

The next CPU pass compiles each valid immediate-mode glBegin/glEnd block in the encoder. Per-vertex color and texture-coordinate calls update local state; the resulting positions, colors, and coordinates are emitted as one interleaved packed draw record. Fans, strips, quads, and line strips/loops are expanded to independent triangles or lines so adjacent records with unchanged render state can be concatenated safely. Replay flushes that merged geometry before any ordinary state command, query, texture operation, context transition, or presentation. This both removes thousands of small replay operations and reduces WebGL buffer uploads/draw calls for runs of compatible surfaces.

The WebGL backend now caches the active program, buffer/texture bindings, uniform values, capability/raster state, enabled attributes, and complete attribute-pointer layout. The fixed-function frontend independently marks only changed matrix/scalar shader uniforms dirty. Repeated draws therefore retain their established program, matrices, scalar uniforms, and three interleaved attribute pointers rather than reissuing them. Borrowed texture uploads also no longer pre-flush older commands: the normal case is one ordered synchronous submission instead of two, while buffer overflow still submits as required.

An isolated SwiftShader verification of this pass rendered the live demo1 scene without browser/runtime errors in both cooperative and real Worker modes. The representative pre-change sample had about 19,353 transport commands and 1,293 WebGL draws per frame. The post-change cooperative sample had about 1,557 commands, 1,297 packed immediate blocks, 58 actual WebGL draws, 31 dirty-uniform submissions, and 7.8 batches per frame. Worker mode had about 1,540 commands, 1,292 packed blocks, 55 WebGL draws, 30 dirty-uniform submissions, and 5.2 batches per frame. Thus packing removed about 92% of replay commands and compatible merging removed about 96% of WebGL draw submissions; uniform submission fell by over 99% from the former ten calls per tiny draw. Batch rate now follows texture uploads plus the three normal per-frame barriers, without a second pre-upload batch. A cooperative CPU trace with glGetError temporarily excluded found uniformMatrix4fv, vertexAttribPointer, attribute enable, and drawArrays reduced from the former prominent samples to collectively below 0.1% of all trace samples. This exclusion was profiling-only; runtime error semantics remain unchanged.

Command decode allocation cleanup (2026-08-30)

The OpenGL hot-path item in fable-review.md was still current. The Worker-side encoder's u32At() constructed a DataView for every 32-bit stack argument, even though the WebAssembly memory buffer is fixed, and browser-thread replay did the same in _u32, _f32, and _f64. Both sides now retain one view per backing buffer. Immediate primitive normalization also writes vertices directly from source indices instead of allocating slice() arrays and then splice()ing flat colors into each triangle. Required expansion of quads/fans/strips and the command-owned packed-vertex copy remain: the former supplies WebGL-supported primitive topology and the latter prevents guest scratch reuse from changing an asynchronous batch.

The identical test/test-quake2-gl-web.js gameplay acceptance passed before and after at 640x480 with textured motion. It reported 13.7 guest fps before and 15.8 after (+15.3%). This is directional only: system load was far above the project's <4 validity threshold (roughly 188 falling to 17), and the attract scene positions differed. The focused command-stream, fixed-function, frame-state, backend, and atomic-present tests all pass. Re-measure headful on an idle host before treating the observed delta as a user-visible gain.

The stream is still a single 2 MiB buffer with a synchronous handoff per flush, not a producer/consumer ring. A multi-slot ring can overlap copied command and packed-vertex replay with guest encoding, but borrowed texture uploads and all query/readback/context/finish/present operations must remain fences. Profile batch replay versus the existing glGetError/SwiftShader wait before building that larger change; prior Quake measurements already found the explicit error barrier dominating the software-GPU configuration.

Pointer-lock button release

A cooperative browser regression after the GL optimization exposed a separate input bug: firing once could leave Quake firing indefinitely. The trusted DOM mouseup was present, and the renderer's host mouse-button mask changed from one to zero, but pointer lock reported unusable clientX/clientY coordinates at (0,0). That point was outside the exclusive presentation viewport, so handleMouseUp returned before it queued WM_LBUTTONUP; Quake retained its own button-down state.

The browser input bridge now derives pointer-locked button-up coordinates from the guest's current virtual cursor through the inverse exclusive-presentation transform. Ordinary unlocked releases still use DOM client coordinates. The bridge also retires a held guest button when a later pointer-lock move reports no physical buttons, pointer lock is lost, the window loses focus, the page is hidden, or another press arrives without an observed release. Those recovery paths cover browser/OS transitions that can omit mouseup entirely. The real cooperative test/test-quake2-input-web.js acceptance now performs twelve clicks after pointer lock is active and proves every trusted down/up pair reaches the Win32 queue as WM_LBUTTONDOWN followed by WM_LBUTTONUP, with the renderer mask released after every cycle.

The dropdown also mounts a first-launch baseq2/config.cfg with WASD movement, permanent mouse look, mouse-one fire, mouse-two/Space jump, Ctrl/C crouch, mouse wheel weapon selection, always-run, and a crosshair. The original default.cfg still supplies every binding not explicitly modernized. Browser persistence is enabled for this config: an existing saved config is restored after the bundled default is mounted, and later in-game customization is saved, so the defaults do not overwrite user choices on subsequent launches.

Multiplayer over the virtual LAN

Quake II's network layer is plain UDP. The only WSOCK32 imports are by ordinal: socket, bind, setsockopt (SO_BROADCAST), ioctlsocket (FIONBIO), sendto, recvfrom, closesocket, htons/ntohs, inet_ntoa, gethostbyname, WSAStartup, WSAGetLastError. The server listens on 27910 and the client on 27901. src/09d-winsock.wat already serves all of it, so no Quake-specific emulator work was needed: the first two-process attempt (2026-09-20) put a client into a deathmatch.

node tools/vlan-pair.js --log-dir=/tmp/q2lan \
  -- --app=quake2_demo --args='+set vid_ref soft +set deathmatch 1 +set maxclients 4 +map demo1' \
     --trace-net --quiet-api --quiet-blocks --batch-size=20000 --max-batches=100000000 --max-seconds=200 --no-close --png=/tmp/q2lan/host.png \
  -- --app=quake2_demo --args='+set vid_ref soft +connect 10.0.0.1' \
     --trace-net --quiet-api --quiet-blocks --batch-size=20000 --max-batches=100000000 --max-seconds=200 --no-close --png=/tmp/q2lan/client.png

Read the client's send sizes in order (grep '\[net\] ->' seat-2.log):

size what it is
17 getchallenge
92 connect + protocol, qport, challenge, userinfo
26-32, with 10-byte keepalives signon stages (new, configstrings, baselines, begin)
25 one usercmd per frame: the client is in the game

In that run the client sent ~120 getchallenge/connect pairs before one was answered. That is not a reconnect loop. It is Quake's own 3-second resend while the server loads demo1, and the client stops for good once it gets in. After that there were 1,343 usercmds against 1,428 server packets, and the two captures show two different players on demo1. test/test-quake2-vlan-gameplay.js is this run as a gate.

Server discovery works as well. Started 120s after the server, a client opened with +menu_joinserver broadcasts info to 255.255.255.255:27910, and the server answers 10.0.0.2:27901 directly. So in a browser room either seat may host: the joiner's list is filled by broadcast, not by assuming the server is at .1.

Other players drawn as a yellowish diamond (first real browser match, 2026-09-20) is ref_gl's R_DrawNullModel, the stand-in for an entity whose model did not load. The demo ships its player models loose in baseq2/players/{male,female}/ (59 files, tris.md2, weapon.md2, skins and _i icons), outside pak0.pak, and the registry mounted only the pak. Gibs (models/objects/gibs/, in the pak) looked fine, which is the tell. The manifest now mounts all 59. With them, +menu_playerconfig renders the grunt preview, and it could not before.

Solo play never makes a socket. A +map demo1 run calls WSAStartup and nothing else from WSOCK32. Quake opens its UDP sockets only from NET_Config, i.e. once a player starts or joins a network game. So $handle_socket asks host_net_link_open first, the same question DirectPlay's DPOPEN asks, and the registry entry sets lan.onDemand. The browser lobby then appears at Start/Join Network Server and never in a single-player game. Hosts without a lobby (the CLI, every non-onDemand app) answer 1 immediately.

The star room and the host probe (2026-09-20)

The browser no longer shows a lobby for Quake II. lan.room: 'auto' in lib/apps.js puts it in a star room (lib/vlan-room.js, lib/vlan-star.js): whoever gets there first is the owner at 10.0.0.1, everyone else holds one link to the owner at .2 and up, and the owner routes member↔member frames.

The wire cannot tell a server from a client, because a Quake II client binds 27910 just as a server does. So the owner's page asks its own guest the way a server browser does: \xff\xff\xff\xffinfo 31 from seat .254, whose answer is caught before it reaches the wire. Only SVC_Info on a server with maxclients > 1 answers, and its status line ("noname demo1 0/4") labels the Join card. The protocol is 31, not the retail 34. The demo's CL_PingServers pushes 0x1f beside its "info %i" (exe 0x4094bb), and a 34 gets "wrong version". test/test-quake2-host-probe.js runs the real game both ways: the server answers, and a client stays silent through 77 questions.

An unread UDP socket used to freeze the whole wire. A client binds 27910 and never reads it, so the first broadcast info or probe landing there filled the slot, and $vsock_deliver stalled every later frame behind it. That did not matter with two players and breaks at three. Each UDP socket now carries "patience" (VSock flags bits 16-23, $VSOCK_UDP_PATIENCE = 64). It is topped up on every recvfrom and spent on each stall. At 0 the datagram is dropped, as a real stack drops into a full receive buffer.

Joining from the card launches with lan.join.launchArgs (+connect {host}), leaving out lan.join.dropArgs (+menu_main, which would sit over the match).

A game that is already running when the room is joined (the mid-game toast) is joined by lan.join.inGame, which types connect {host} into the console. The console key is the trap: Con_ToggleConsole_f (exe 0x415710) runs d1, the attract demo, while cls.state (0xa86a60) is 1 (disconnected), so a blind ` at the menus opens nothing and the menu eats the rest; the first try landed in the Game submenu. The recipe reads cls.key_dest (0xa86a64, 3 = menu) and presses Escape until the menus are closed. While disconnected, key_game already feeds Key_Console, so typing is enough; in a level, ` opens the console first. test/test-web-quake2-room.js covers both joins across three browsers.

2026-09-22: demo1 gameplay on the WAT software GL path

ref_gl through --gl-renderer=software renders Outer Base — world, lightmaps (multi-pass: GL_SGIS_multitexture is reported absent), view weapon and HUD. Loading is the slow part: at --batch-size=20000 the console still reads loopback: client_connect after 200s; at --batch-size=100000 the level is up inside 300s.

node test/run.js --app=quake2_demo --no-build --gl-renderer=software \
  --args='+set vid_ref gl +map demo1' --quiet-api --quiet-blocks \
  --stuck-after=1000000 --batch-size=100000 --max-batches=99999999 \
  --max-seconds=300 --no-close --gl-census --png=out.png

Census at exit: 4,710,009 triangles, 101,281 dropped at the eye plane, 1,065,868 culled, 1,570 presents, 217 texture uploads, none refused.

2026-10-08: ordinary ref_gl gameplay on emulator software OpenGL

Fresh temporary-browser run scratch/runs/20261008T000901Z-quake2-software-ordinary/result.json passes the registered Game → Easy → forward/reverse/idle route with the original +set vid_ref gl +menu_main arguments. No ref_soft switch, console command, forced control, guest-state edit, or asset patch was used. Enter was held 750 ms on Game and on Easy; W and S were each held 1000 ms through ordinary browser input, after personally reviewing the preceding screenshot.

Six captures were personally reviewed. loading-1.png already shows the textured world, weapon, crosshair, and health HUD, by 49.617 seconds after the Easy-selection command. Forward approaches the diagonal support until it fills the central view and occludes the wall emblem. Reverse restores the wider room, support base, and right-wall emblem; idle retains that geometry. These landmarks establish actual viewpoint translation, beyond weapon bob.

Every capture records gl-renderer=software, the live host GL endpoint's software option, and the same option read directly from the owning renderer Worker's endpoint table. The unchanged gl-render-worker.js passes that option to OpenGLHostBridge; its software context branch creates the WAT raster backend directly without creating or falling back to a WebGL GL context. The ordinary GL presentation layer advances throughout gameplay. A generic legacy endpoint is also initialized with webgl, and the unchanged synthetic GL renderer string says WebGL fixed function (src/01-header.wat). Both observations are retained; neither identifies the selected GL backend. The proof concerns this ref_gl workload, not an absence of every WebGL facility in the browser.

This is an explicitly accepted reference-build validation: module fb1be916c309bf619a9331c8fd46c4319f9051af76b05b236d3c362bb632638f, built source 096889e174488a97529b8e73076d3a1e2feb2345, and its entire unchanged matching host closure. All 325 host files match that Git object; with the module these are 326 runtime source pins, alongside 66 original fixtures and seven harness files. All 399 pins passed before launch and after cleanup; originals were also rehashed locally. This does not certify a newly built current main.

Chrome exited 0, browser/server closed, streams drained, and driver/Chrome process absence and listening-socket baseline were independently checked. The owned remote prefix was removed after the complete runtime archive and captures were durably copied and hash-verified. Twelve refused local unpinned VLAN publisher API requests remain in the raw errors; network play is unqualified. One room and one traversal cycle were tested; combat, level completion, FPS, and audio were not qualified. See the software handoff for exact identity, timings, backend proof, resource grant, and cleanup.

2026-10-30: native browser movement, firing, death and autosave reload

Run scratch/runs/20261030T2210Z-quake2-browser/result.json records a fresh local Chrome 151 profile using the registered quake2_demo selector and Launch button, unchanged +set vid_ref gl +menu_main, and ordinary trusted browser input. Game → Easy enters Outer Base (demo1). W approaches the diagonal support until it occludes the room; S restores the wall emblem and wider view. Mouse-one under pointer lock produces visible blaster bolts, impact sparks and dynamic lighting. Held guest in_attack has key 200 and state 5; after release key is 0, state 4 (held bit clear), and the host mouse mask is 0.

Native W/arrow-key navigation reaches the lower room. An enemy attacks: inspected captures show health 100 → 73 → 61 → 0 and the rolled death camera. Enter opens the ordinary Load Game menu with ENTERING Outer Base selected; a second Enter loads that autosave. The starting view and health 100 return. Further W/S movement and a new mouse-one burst work after reload, including visible projectile/impact captures and cleared attack state after release. No console command, guest-memory write, asset modification, or forced input handler was used. No runtime blocker reproduced and no repair was made.

This run uses game ref_gl, emulator WebGL 1, and Chrome ANGLE SwiftShader. SwiftShader is the browser's software GPU implementation; this is neither game ref_soft nor the emulator's WAT software GL backend. The live layer owns a WebGLRenderingContext; guest threads and render workers were disabled. The retained, actually downloaded module is d69d1158f7707c8f46d5f4c0909494913db73bfcb745ca1a3f320be9ad62db91. Launch HEAD was 24af711e78857d8d22adfba794d235447017de90; the shared tree had another worker's uncommitted GL changes, so the compiled source commit is unknown, not certified as a pristine build of that HEAD. Served file hashes and the launch diff are retained. The 67 registered file hashes include 65 original extracted assets and the two host control/source files; all remained unchanged. The original installer was absent, so no new full installer/extraction comparison is claimed. pak0.pak matches the documented SHA-256 above.

The screenshots and input timestamps were reviewed directly. Coverage is one death/autosave cycle, movement and blaster firing before and after it; enemy defeat, level completion, hardware GPU behavior, audio quality, FPS, networking and WAT software rendering remain untested here. Own browser and both local server/controller ports were closed and checked; no Boat was used. The static harness also logged HTTP 404 responses; their URLs were not captured, and they are not evidence of successful network or service integration. No page exception, guest trap or FreeLibrary failed message was recorded.

2026-10-30: retained-module native gameplay on emulator software OpenGL

Run scratch/runs/20261030T2220Z-quake2-software/result.json passes the registered selector/Launch → Game → Easy → Outer Base route with unchanged +set vid_ref gl +menu_main. The browser URL selects gl-renderer=software; the game still uses original ref_gl, never ref_soft. The static server routes the module request to the prior browser run's exact retained module, SHA-256 d69d1158f7707c8f46d5f4c0909494913db73bfcb745ca1a3f320be9ad62db91. Its compiled source commit remains unknown; this does not certify current main.

Actual loaded-module counters prove the emulator WAT raster path is active: gl_sw_enabled() is 1, triangles advance from 1,050,157 to 1,466,293, and software presents from 451 to 604. Both samples report 1,422 texture uploads and zero unsupported uploads. The window has no WebGL frame layer. Guest threads and the render Worker are disabled. The generic GPU dropdown still reads WebGL, the synthetic guest GL renderer string still says WebGL fixed function, and Chrome was launched with SwiftShader flags; none of those labels overrides the directly observed WAT software-raster counters.

Personally inspected captures show native W moving toward the diagonal support until it occludes the room, and S restoring the wider view and wall emblem. Mouse-one under pointer lock produces blaster bolts/impact particles and dynamic yellow illumination. Five held-fire samples read guest attack key 200, state 5, host mouse mask 1; release reads key 0, state 4, mask 0. The saved timeline contains trusted browser events only. No console command, guest-memory write, forced handler, asset modification, or runtime repair was used.

All 67 registered file hashes, including 65 original extracted assets, match the preceding run; the documented pak hash also matches. The installer remains absent, so this is not a fresh installer/extraction comparison. Served runtime hashes and the exact downloaded module are retained. Coverage is the starting room, movement and blaster firing/release; combat progression, death/reload, level completion, audio, FPS, networking and Worker rendering are untested in this software run. Static-harness HTTP 404 messages remain; no page exception, guest trap or FreeLibrary failed message was observed. Own browser and server ports were closed and checked, profile removed, no Boat used, and /home free space remained above 2 GB. No blocker reproduced and no code repair was needed.

2026-10-30: native combat, death and autosave on WAT software OpenGL

Run scratch/runs/20261030T2225Z-quake2-software-combat/result.json advances native W/arrow-key movement into the lower area with debris, medkits and a live armored enemy. Trusted mouse-one bursts produce blaster impact particles and light. Enemy attacks reduce player health 100 → 73 → 43 → 0; the rolled death view appears behind the ordinary Load Game menu with ENTERING Outer Base selected. Enter restores the autosave's starting room and health 100. Postreload W movement approaches the diagonal support, and a fresh blaster burst produces visible particles and yellow illumination. Five held-fire samples have key 200/state 5/mouse mask 1; release clears these to key 0/state 4/mask 0. A further close enemy encounter reaches health 32 and a second health-zero death. Further ordinary mouse attack starts another autosave load; that second reload's completed movement was not inspected.

The close enemy, red particles and native firing attempts were inspected, but enemy damage and defeat remain unverified. The corpse already present by the debris is not credited as a kill. This run verifies player damage/death, one completed ordinary autosave reload and resumed movement/fire, not enemy health accounting or level completion. No console command, guest-memory write, synthetic game state, forced input handler or asset edit was used. No runtime blocker reproduced and no repair was needed.

This is original ref_gl on emulator WAT software OpenGL, not ref_soft. Actual loaded-module gl_sw_enabled() remains 1; triangles advance 313,125 → 4,327,627 and presents 183 → 1,720, with zero unsupported texture uploads. The window has no WebGL frame layer; guest threads and render Worker are disabled. Generic WebGL UI/string labels and Chrome SwiftShader launch flags do not supersede these actual backend counters.

The exact retained and downloaded module remains d69d1158f7707c8f46d5f4c0909494913db73bfcb745ca1a3f320be9ad62db91; its compiled source commit is explicitly unknown. This is not certification of a fresh current-main build. All 67 registered file hashes, including 65 original extracted assets, match the preceding software run; the known pak hash matches. The installer remains absent. Served host/module hashes, native input timestamps, reviewed captures and scoped checks are retained in the run. Focused module/assets/backend/native-input/release/cleanup checks pass. No page exception, guest trap or FreeLibrary failed was recorded; static-harness HTTP 404 messages remain. Audio, FPS, networking and Worker rendering are not qualified. Own Chrome and both servers closed, ports checked, profile removed, no Boat/test boxes used, and /home free space stayed above 2 GB.

2026-10-30: bounded WebGL combat attempt; defeat still unverified

Run scratch/runs/20261030T2334Z-quake2-combat/result.json reuses the retained module and original extraction through registered Launch → Game → Easy. Inspected captures show the lower debris doorway, a live armored enemy in its corridor, native blaster bursts, player health 53 → 17 → 0, and ordinary Enter autosave reload to health 100. A second approach collects normal health pickups (102 and 114 visible), encounters the enemy again, then loses health 90 → 20 → 0. A second ordinary autosave completes. The final approach remains in the starting room. Enemy defeat and subsequent room progression are not verified. Close enemy poses and red particles do not establish a kill; the corpse by the debris predates combat. The filenames enemy-down.png and next-room.png actually show the player's death/Load Game menu, as explicitly recorded in inspected.json.

The concrete execution limit was two player deaths during close corridor aiming; no emulator blocker or causal runtime repair was proven. Short native arrow holds produced uneven observed turn distances, but this run does not establish an input implementation defect. A direct CDP relative-motion experiment was visually inconclusive and temporarily resized the viewport to 800×600; subsequent native commands restored 1024×768. All recorded DOM inputs are trusted browser events. No console command, guest-memory write, health or ammo edit, enemy edit, cheat, or asset modification was used.

Actual backend probes identify original ref_gl / emulator WebGL 1, with gl_sw_enabled() = 0, threads and render Worker disabled. Despite the retained harness requesting SwiftShader flags, the live context reports ANGLE Intel Mesa UHD Graphics 620 (KBL GT2), OpenGL 4.6 Core / Mesa 23.2.1. This is the observed backend, not a SwiftShader claim. The exact downloaded module remains d69d1158f7707c8f46d5f4c0909494913db73bfcb745ca1a3f320be9ad62db91; its compiled source commit remains unknown, so current-main certification is not claimed. Served host hashes are retained; lib/host-audio.js changed in the shared tree after being served, and its recorded served hash must not be replaced by the later file's hash. All 67 registered files, including 65 original assets and the documented pak hash, match the preceding run. The installer remains unavailable for a fresh extraction comparison.

The bounded attempt closed its browser and both servers, checked all three ports and browser PID absent, removed its profile, and retained useful images before teardown; no Boat was used and /home remained above 2 GB free. There was no observed page exception, guest trap or FreeLibrary failed; static harness HTTP 404s remain. The task's defeat/progression acceptance is not met, rather than recast as a successful gameplay or emulator repair result.

2026-10-31: first guard defeated and next room entered

Run scratch/runs/20261030T2355Z-quake2-ranged/result.json verifies the requested combat milestone. Personally inspected captures show the live guard in the narrow corridor, sustained native mouse-one fire with S retreat and S+D/A strafe, hit reactions, and a new fallen body beside the player. This is distinguished from the corpse already lying farther down the corridor. The game's ordinary F1 help/status screen reads kills 1/18 after loading the unchanged native post-combat quicksave. Native W then crosses the corridor into the larger room beyond it: next-room-entry.png shows the new room's metal walls and pickup crate, with the player alive at health 42.

The broader room view reveals a second attacking guard. Health falls to 20, then 12 during another native quicksave, and finally 0 before the final menu capture. The safer post-combat save at health 42 is retained separately from the dangerous later room save, along with a pre-guard save. Save bytes were read from the browser VFS without modification, exported with hashes, mounted as ordinary files on recovery, and loaded using native F9. The run directory contains save manifests and recovery instructions. No console commands, guest-memory writes, cheats, asset patches or forced game handlers were used.

The attempt and recoveries occupied approximately 12 minutes of controller gameplay, below the 20-minute limit. The first Chrome disappeared during navigation; the second Chrome's process exit explicitly reports SIGKILL at 00:00:06Z, before room-entry capture. Its sender and cause are unknown. A third browser recovered the exported native save, confirmed kills 1/18, and completed room entry. No emulator defect or runtime repair is established.

Actual backend probes identify original ref_gl / emulator WebGL 1 / ANGLE Intel Mesa UHD Graphics 620, with gl_sw_enabled() = 0, guest threads and render Worker disabled. SwiftShader command-line flags do not override this observed renderer. Every downloaded module matches retained SHA-256 d69d1158f7707c8f46d5f4c0909494913db73bfcb745ca1a3f320be9ad62db91; its compiled source commit remains unknown. This does not certify a fresh current-main build. All 67 registered inputs, including 65 original assets and the documented pak hash, remain unchanged; all 472 recorded served responses match their retained input hashes. The installer remains absent.

Focused module/assets/save-byte/backend/trusted-input/cleanup checks pass. No source was changed. Static-harness HTTP 404 messages remain; no page exception, guest trap or FreeLibrary failed was recorded. The final quit request was followed by a controller ERR_STREAM_WRITE_AFTER_END, so clean controller exit is not claimed. All three browser PIDs and five known ports were independently checked absent/closed, the profile was removed, and held gameplay keys and attack were released. No Boat or test box was used. Audio, FPS, networking, further combat and level completion remain unqualified.

2026-10-31: second guard defeated; room crossed

Run scratch/runs/20261031T0010Z-quake2-second/result.json continues the unchanged retained native health-42 post-combat save. Personally inspected captures show the second guard pursuing the player into the corridor, native mouse-one fire, and the guard falling. The ordinary F1 screen reads kills 2/18. Native F6 saved the result at health 12; native F9 subsequently reloaded it, and a second F1 capture still reads 2/18. The player then crossed the room and collected armor shards (HUD armor 2, then 4). A further guard killed the player during room exploration. Another room or level transition is not established; the visible health box was not collected.

The run preserves separate byte-for-byte native save exports: the original health-42 starting save, second-guard-save-manifest.json (recommended new checkpoint, health 12 in the corridor, two kills), and room-save-manifest.json (health 12 near the health box, after reloading the two-kill save). Recovery instructions accompany them. Three earlier combat attempts ended in inspected player deaths; another was abandoned alive at health 2. Opening the native menu clears the guest's attack state, so resuming requires a fresh native fire press. The successful corridor engagement renewed mouse-one after closing the menu. This is a control finding, not an emulator repair. Gameplay occupied about nine minutes, below the 20-minute limit. No guest patch, console command, cheat, memory write or synthetic game state was used.

Actual provenance remains retained module SHA-256 d69d1158f7707c8f46d5f4c0909494913db73bfcb745ca1a3f320be9ad62db91, compiled source commit unknown, original ref_gl, emulator WebGL 1, ANGLE Intel Mesa UHD Graphics 620, software flag 0, threads and render Worker off. The harness's SwiftShader flags do not describe the observed context. All 67 registered inputs, including 65 original assets and the documented pak hash, are unchanged. All 164 served responses were hash-verified. Shared host.js changed after launch; its exact served bytes were recovered from launch HEAD a3ab89d44 and retained with their matching hash. This does not certify a fresh current-main module. The installer remains unavailable.

Focused module, asset, served-byte, native-save, backend, trusted-input and cleanup checks pass; no runtime source changed. No page exception, guest trap or FreeLibrary failed was recorded. Static-harness HTTP 404s remain. Quit again produced controller ERR_STREAM_WRITE_AFTER_END; clean controller exit is not claimed. Browser PID 1175593 and all three known ports were independently absent/closed, profile removed, attack and gameplay keys released. No Boat or assigned test box was used. Further combat, audio, FPS and level completion remain unqualified.

2026-10-31: health pickup and recoverable two-kill checkpoint

Run scratch/runs/20261031T0023Z-quake2-third/result.json continues the unchanged native room save. Personally inspected health.png shows the Health pickup and HUD increase from 12 to 22. Native F6 writes a quicksave; eight resident current/quick files were exported byte-for-byte. Ordinary remount and F9 restore health 22 (recovered22-resume.png), and the native F1 screen still reads kills 2/18 (health22-kills.png). health22-save-manifest.json and recovery.txt retain this checkpoint separately from the earlier health-12 save. An armor-shard pickup followed. Further encounters ended in inspected deaths; no third kill, next-room completion or level transition is established.

The harness initially tried to read two lazy save0 headers synchronously, raising VfsPendingError before capture; the export skips those unmaterialized headers. Direct CDP capture works. The mouse was also left over the host Launch button, so a native firing click restarted the app. Moving it inside the game area avoids that target error; the exported save recovered the progress. These are harness limitations, not demonstrated emulator defects. No guest-memory write, cheat, console command or original-asset edit supplied progress.

The retained module is SHA-256 d69d1158f7707c8f46d5f4c0909494913db73bfcb745ca1a3f320be9ad62db91, compiled source unknown. Actual rendering is original ref_gl through WebGL 1, ANGLE Intel Mesa UHD 620, software flag 0, threads/render Worker off. All 67 registered inputs (65 originals), 240 served responses and eight exported save files pass hash checks; all 95 recorded input events are trusted. Physical mouse buttons were released, although the dead guest retained attack state 1. No further execution occurred after shutdown. No runtime source changed.

Focused verification passes. Cleanup required SIGTERM followed by a targeted SIGKILL of the controller after its browser closed but servers remained open; clean controller exit is not claimed. Both owned PIDs are absent, all three ports closed and profile removed, with over 7 GB free. No Boat was used. Next: continue the health-22 native checkpoint and engage the remaining guards from cover, keeping the mouse inside the game area.

2026-10-31: four kills and passage beyond the guards

Run scratch/runs/20261031T0032Z-quake2-health22/result.json continues the preserved health-22/two-kill checkpoint. Personally inspected captures show two guards near the passage pursuing the player, native blaster fire from the corner, hit reactions and both guards falling. The ordinary F1 screen confirms kills 4/18, with the player alive at health 11. Native F6 saves that checkpoint. F9 recovery retains four kills. Eight exported native save files were then mounted as ordinary app files after stopping/restarting the app; F9 and F1 again confirm health 11 and kills 4/18. Exported bytes after this external recovery match the combat save exactly.

The player subsequently entered the slatted passage beyond those guards. A further guard killed the player there; no fifth kill, completed next room or level transition is established. The recommended recovery is combat-save-manifest.json, before passage entry. recovery.txt, remount.cjs, the eight native files and the original starting health-22 files are retained separately. The corner save is an earlier position, not the recommended four-kill checkpoint. Browser gameplay and recovery ran from approximately 00:29:01Z to 00:36:43Z, below eight minutes and the 20-minute bound. No guest-memory writes, console commands, cheats or original-asset changes supplied progress. No emulator defect or runtime repair is demonstrated.

The exact retained module remains SHA-256 d69d1158f7707c8f46d5f4c0909494913db73bfcb745ca1a3f320be9ad62db91, compiled source unknown. Actual backend probes report original ref_gl, WebGL 1, ANGLE Intel Mesa UHD 620, software flag 0, threads/render Worker off. This does not certify a fresh current-main build. All 67 prior registered inputs, including 65 original assets, remain unchanged; the current manifest has 74 entries including eight checkpoint files. All 158 served responses pass hash verification. The original installer remains unavailable.

Focused module/assets/served-byte/native-save/backend/input/cleanup checks pass. All 212 recorded input events are trusted; final physical mouse mask and native attack bit are clear. A redundant release request returned left is not pressed; no page exception, guest trap or FreeLibrary failure was recorded. Static-harness HTTP 404s remain. Browser close was requested; the controller records browser SIGKILL, with its precise sender unknown. Controller shutdown required SIGTERM followed by targeted SIGKILL, so clean process exit is not claimed. Both owned PIDs are absent, three ports closed, profile removed and over 7 GB free. No Boat or assigned test box was used. Next: recover the four-kill save and engage the passage guard from cover; health 11 remains fragile.

2026-10-31: passage guard defeated; five-kill save recovered

Run scratch/runs/20261031T0042Z-quake2-passage/result.json continues the unchanged four-kill/health-11 checkpoint. Personally inspected captures show entry into the slatted passage, the next guard approaching, and native blaster fire while retreating down the passage. The guard falls; the ordinary F1 screen confirms kills 5/18, with health 11 retained. Native F6 saves the result. Eight native current/quick files were exported without alteration to fifth-save-manifest.json, then mounted as ordinary files after stopping and restarting the app. Native F9 recovery and inspected external-five-kills.png / external-resume.png confirm five kills and health 11. The recovered save hashes exactly match the exported checkpoint.

The recommended successor checkpoint is that fifth-guard save; recovery.txt and remount.cjs describe recovery. The earlier four-kill save remains intact. No later room or level transition is established. Browser gameplay and recovery occupied approximately 00:39:30Z–00:41:38Z, below the 20-minute bound. All progress used native browser keyboard/mouse input; no guest-memory writes, console commands, cheats or original-asset changes were used. No runtime repair was needed.

Exact retained module SHA-256 remains d69d1158f7707c8f46d5f4c0909494913db73bfcb745ca1a3f320be9ad62db91, compiled source unknown. Actual probes report original ref_gl, WebGL 1, ANGLE Intel Mesa UHD 620, software flag 0, threads/render Worker off. This does not certify a fresh current-main build. All 67 prior registered inputs, including 65 original assets, remain unchanged; all 158 served responses and eight native save files pass hash verification. All 92 recorded input events are trusted; final physical mouse mask and native attack bit are clear. The installer remains unavailable. Audio, FPS, networking and level completion remain unqualified.

Focused evidence verification passes; this is a documentation-only change. No page exception, guest trap or FreeLibrary failure was recorded; static harness HTTP 404s remain. Browser exit reports code 0 with no signal; the controller was stopped with targeted SIGTERM. Both owned PIDs are absent, all three ports closed and profile removed. No Boat or assigned test box was used (ID/state/expiry N/A); ownership is handed back. Next: continue down the cleared passage from the five-kill save and seek health before further combat.

2026-10-31: health 21, sixth guard and open courtyard

Run scratch/runs/20261031T0046Z-quake2-next/result.json resumes the native five-kill/health-11 checkpoint. Personally inspected captures confirm F1 kills 5/18, passage exploration, and return to the adjoining room. A live guard approached through the opposite doorway. Native blaster fire while retreating collected Health, raising the HUD to 21 (sixth-fight.png). Further fire defeated the guard; sixth-kills.png confirms 6/18, health 21. Native F6 saved this result, and eight unchanged native current/quick files were exported to sixth-save-manifest.json.

The player then crossed that doorway into the open red-sky courtyard with crates, ramps and a lower water channel. Exploration reached the channel; health subsequently read 18, with the damage source unqualified. F9 restored the six-kill/health-21 checkpoint. A second courtyard entry and F6 export preserve courtyard-save-manifest.json at health 21, with another live guard visible below the entrance. No seventh kill or level transition is claimed. The safer recommended recovery is the sixth save, before courtyard entry; the courtyard save is a separate, more exposed position.

The browser received SIGKILL during an in-page stop/relaunch remount check; its sender is unknown. A fresh browser mounted the exported sixth save as ordinary files. Native F9 and personally inspected recovery/external-six-kills.png / recovery/external-resume.png confirm six kills and health 21. All eight recovered file hashes match the export. recovery.txt, recovery-driver.cjs and the manifests preserve recovery. Gameplay and recovery occupied approximately 00:45:30Z–00:50:27Z, below the 20-minute limit. No guest-memory write, console command, cheat, original-asset edit or emulator repair supplied progress.

Both sessions loaded exact retained module SHA-256 d69d1158f7707c8f46d5f4c0909494913db73bfcb745ca1a3f320be9ad62db91, compiled source unknown. Fresh recovery probes report original ref_gl, WebGL 1, ANGLE Intel Mesa UHD 620, software flag 0, threads/render Worker off. This does not certify a current-main module. All 67 prior registered inputs, including 65 original assets, and all recorded served bytes pass hash checks. Recovery input events are trusted and native attack is clear; the initial session's full trust/held-state snapshot was lost with Chrome, so complete initial-event verification is unavailable. The native action log remains. No page exception, guest trap or FreeLibrary failure was recorded; static harness HTTP 404s remain. The original installer remains unavailable.

Focused module/assets/served-byte/native-save/recovery/cleanup checks pass. No runtime source changed. The recovery browser exited code 0; both controllers were stopped with targeted SIGTERM. All four owned PIDs are absent, four known ports closed and both profiles removed, with over 7 GB free. No Boat or assigned test box was used (ID/state/expiry N/A); ownership is handed back. Next: recover the six-kill/health-21 save, enter the courtyard and engage its next guard from the doorway before exploring the ramps.

2026-10-31: courtyard guard defeated; safer seven-kill checkpoint

Run scratch/runs/20261031T0055Z-quake2-courtyard/result.json resumes the exported six-kill/health-21 native checkpoint. Personally inspected frames confirm the starting F1 count 6/18 and health 21. The first doorway engagement ended in player death while adjusting aim. Ordinary F9 restored the unchanged checkpoint. On the retry, native blaster fire and S retreat drew the courtyard guard through the doorway into the room. Inspected guard-lured.png, guard-hit.png and guard-fall.png show his approach and defeat; seventh-kills.png confirms 7/18, still at health 21.

Native F6 saved from farther inside the room, behind the courtyard doorway. Eight untouched current/quick files are exported in seventh-save-manifest.json. A fresh browser mounted those exports as ordinary files; native F9, F1 and inspected recovery/external-seven-kills.png and recovery/external-resume.png confirm seven kills and health 21. All eight recovered file hashes exactly match the export. This is the recommended new checkpoint; recovery.txt and recovery-driver.cjs pin the recovery recipe. The earlier sixth checkpoint remains unchanged. The bounded session and recovery took approximately four minutes, below 20 minutes. No eighth kill, completed courtyard traversal or level transition is established. No guest-memory writes, cheats, console commands or original-asset edits were used.

Both sessions loaded retained module SHA-256 d69d1158f7707c8f46d5f4c0909494913db73bfcb745ca1a3f320be9ad62db91, compiled source unknown. Actual probes report original ref_gl, WebGL 1, ANGLE Intel Mesa UHD 620, software flag 0, threads/render Worker off; requested SwiftShader flags do not describe the observed context. All 67 prior inputs, including 65 original assets, 424 served responses and eight exported save files pass hash checks. All 75 gameplay and 11 recovery input events are trusted; final physical mouse mask and native attack bit are clear. The installer remains unavailable; this does not certify a current-main module. Audio, FPS and networking remain unqualified.

Focused verification passes; no runtime source changed or causal emulator defect was proved. The initial background controller ended before READY; its owned Chrome was terminated and a persistent foreground session used. The gameplay controller's quit produced ERR_STREAM_WRITE_AFTER_END, and the recovery controller required targeted SIGKILL after SIGTERM left HTTP ports open. Recovery Chrome records SIGKILL after an explicit CDP close; its signal sender is unqualified. The copied backend query inherited an old action timestamp; its DOM event times and surrounding actions retain this run's times. Clean controller exit is not claimed. No page exception, guest trap or FreeLibrary failure was recorded; static-harness HTTP 404s remain. The task explicitly delegated own browser/server/profile cleanup: all owned browsers/controllers are absent, five known ports closed, both profiles removed and watcher stopped, with over 7 GB free. No Boat or assigned test box was used (ID/state/expiry N/A); ownership is handed back. Next: recover the seven-kill save and explore the courtyard ramps while seeking health.

2026-10-31: courtyard channel explored; flooded pillar passage reached

Run scratch/runs/20261031T0101Z-quake2-ramps/result.json resumes the seven-kill indoor checkpoint. Inspected start-kills.png confirms 7/18 and health 21. The first launch accidentally passed export-manifest rows without converting path to registration vfsPath; native F9 reported no save. Closing it and using the original mount format recovered the unchanged checkpoint. This was a harness setup error, not a game or emulator blocker.

Native movement crossed the courtyard, descended into its lower channel and checked the sloped supports. Forward/jump did not climb those supports. bank.png, ramp-top.png and climb2.png show the accessible bank/stairs returning to the cleared room. Further channel exploration entered the dark water-level opening; tunnel-out.png and sewer.png show a new red-lit, flooded pillar chamber. No health pickup or new live enemy was found.

The deeper chamber requires swimming: pausing there twice led to drowning and death. Ordinary F9 recovered each time, and trusted CDP jump held down kept the player at the surface at health 21. Final native F1 still shows 7/18; exploration-save-manifest.json exports eight untouched F6 current/quick files from the passage. A fresh browser mounted them as ordinary files; native F9 and inspected recovery/external-world.png / recovery/external-count.png confirm health 21 and seven kills. All eight recovered hashes match. This exploration save needs prompt jump/swim-up input; it is not safer than the original indoor checkpoint, which remains unchanged in starting-save-manifest.json. recovery.txt documents both recipes, including the hold-space.cjs helper and native export commands. No eighth kill, health gain, dry exit or level transition is established.

Gameplay/setup and fresh recovery ran approximately 00:59Z–01:10Z, within the 20-minute bound. No cheats, guest-memory writes, console commands, asset edits or emulator repair supplied progress. Both valid sessions loaded exact retained SHA-256 d69d1158f7707c8f46d5f4c0909494913db73bfcb745ca1a3f320be9ad62db91, compiled source unknown. Actual probes report original ref_gl, WebGL 1, ANGLE Intel Mesa UHD 620, software flag 0, threads/render Worker off, despite requested SwiftShader flags. This does not certify a current-main module. All 67 prior registered inputs, including 65 original extracted assets, 324 served responses and the eight recovered save files pass hash checks. All 209 gameplay and 19 recovery recorded input events are trusted; final mouse mask and native attack bit are clear. The installer remains unavailable; audio, FPS and networking remain unqualified.

Focused verification passes; no runtime source changed. The malformed-mount browser quit hit the inherited controller ERR_STREAM_WRITE_AFTER_END. Both valid browsers closed through CDP with exit 0; their controllers were stopped with targeted SIGTERM. No page exception, guest trap or FreeLibrary failure was recorded; static-harness HTTP 404s remain. Own cleanup was explicitly delegated: browsers/controllers are absent, five ports closed, three profiles removed and watcher absent, with over 7 GB free. No Boat or assigned test box was used (ID/state/expiry N/A); ownership is handed back. Next: use the safer indoor save to seek the outer ledge pickups, or continue the flooded exploration save while holding jump and locate its dry exit.

2026-10-31: far-side flooded duct located; entrance remains blocked

Run scratch/runs/20261031T0114Z-quake2-dry-exit/result.json continues the seven-kill/health-21 checkpoint with the same retained driver and module. Inspected courtyard jump attempts did not reach the opposite ledge pickups. The prior final exploration export restores near the courtyard-side passage; it should not be interpreted as a deep pillar-room checkpoint. The separately retained sewer-save-manifest.json restores inside that chamber.

One sewer recovery attempt ended in drowning before swim-up took effect. Native F9 recovered it. Closing the native load menu and issuing a fresh jump press, then holding jump, surfaced the player at health 21. Input held across loading/menu changes alone was insufficient in this attempt. Native movement then traversed the far side of the red-lit flooded chamber and located a low, red-lit duct opening (sewer/far-corridor-right.png). Forward and crouch/swim attempts reached its lip but did not establish traversal. No dry exit, health pickup, new live enemy, eighth kill or level transition is claimed. This is a navigation blocker, not an isolated emulator defect.

Native F6 exported eight untouched current/quick files to sewer/duct-save-manifest.json. A fresh browser mounted them as ordinary files; F9 and inspected recovery/external-count.png confirm kills 7/18, health 21. All eight recovered hashes exactly match. This save is submerged at the duct approach and requires prompt swim-up/retreat; it is not a safer replacement for the unchanged indoor checkpoint. recovery.txt retains the recipes and that limitation. Gameplay and external recovery ran approximately 01:13Z–01:27Z, within 20 minutes. No cheats, console commands, guest-memory writes or original-asset edits supplied progress.

All four browsers loaded retained module SHA-256 d69d1158f7707c8f46d5f4c0909494913db73bfcb745ca1a3f320be9ad62db91, compiled source unknown; this does not certify a current-main build. Actual rendering remains original ref_gl, WebGL 1, ANGLE Intel Mesa UHD 620, software flag 0, threads/render Worker off despite requested SwiftShader flags. Verification passes for 67 prior registered inputs (65 originals), 648 served responses, all 232 recorded trusted input events, and eight byte-exact recovered save files. Final mouse masks and native attack bits are clear. No page exception, guest trap or FreeLibrary failure was recorded; static-harness HTTP 404s remain. The installer remains unavailable; audio, FPS and networking remain unqualified. No runtime source changed.

All four owned browsers exited code 0 through CDP close; their controllers were stopped with targeted SIGTERM. All eight owned PIDs are absent, twelve known ports closed, four profiles removed and the watcher stopped, with over 7 GB free. No Boat or assigned test box was used (ID/state/expiry N/A); ownership is handed back. Next: recover the duct approach only with immediate swim-up input and solve the low entrance alignment, or return to the safer indoor checkpoint to investigate another courtyard route.

2026-10-31: flooded lip traversed; dry duct refuge recovered

Run scratch/runs/20261031T0129Z-quake2-route/result.json first recovered and explored the unchanged seven-kill indoor checkpoint. Courtyard ledge attempts did not collect health; the channel's left bank returned toward the entrance. The worker then switched to the retained submerged duct approach. Fresh swim-up and retreat after closing the load menu surfaced the player, with two health lost (21 → 19), but no death in this run.

Long forward/crouch input submerged the player below the opening. A later short W+C 400 ms, then W 700 ms, with held swim-up released, entered the low red-lit duct (duct/lip-middle.png). Subsequent native crouch movement traversed its interior. Exploration returned to a dry standing shelf inside the duct mouth, looking toward the flooded pillars (duct/stand-exit.png). This establishes escape from submersion into a dry refuge, not a route to a new room. Fifteen seconds without movement or swim-up retained health 19. F1 confirmed kills 7/18. No pickup, new enemy, eighth kill, next room or level transition is claimed; onward navigation remains unresolved.

Native F6 exported eight untouched files to duct/dry-save-manifest.json. A fresh browser mounted them as ordinary files; native F9 and inspected recovery/external-dry-wait.png / recovery/external-count.png confirm the same dry shelf, health 19 and seven kills. Another 15-second no-input wait caused no damage. All eight recovered file hashes exactly match the export. This new dry checkpoint needs no swim-up; the original indoor health-21 save remains intact. recovery.txt and recovery-driver.cjs retain both recipes. Gameplay and fresh recovery ran approximately 01:29Z–01:41Z, within 20 minutes. No cheats, console commands, guest-memory writes, binding changes or original asset edits supplied progress. No emulator defect was isolated.

Read-only inspection of the mounted config and original default.cfg clarified navigation: always-run is already enabled (cl_run 1), so Shift slows movement; C/Ctrl are swim-down/crouch; End centers the view; Z looks down; PageDown looks up. PageUp has no default binding. These controls were not remapped.

All three browsers loaded retained module SHA-256 d69d1158f7707c8f46d5f4c0909494913db73bfcb745ca1a3f320be9ad62db91, compiled source unknown. This does not certify a current-main build. Actual valid-session backend probes report original ref_gl, WebGL 1, ANGLE Intel Mesa UHD 620, software flag 0, threads/render Worker off. Verification passes for 67 prior inputs including 65 original assets, 486 served responses, eight byte-exact recovered files, and all 123 duct / 13 recovery trusted input events. The initial browser's full input snapshot was lost; its action log remains. The installer remains unavailable; audio, FPS and networking are unqualified.

The initial indoor Chrome disappeared with SIGKILL before requested close; its sender is unknown. The subsequent close attempt produced an unhandled ErrorEvent. Both valid duct/recovery browsers exited code 0 through CDP close; all three controllers were stopped with targeted SIGTERM. Six owned PIDs are absent, nine ports closed and three profiles removed, with over 6 GB free. No page exception was recorded; static-harness HTTP 404s remain. No runtime source changed. No Boat or assigned test box was used (ID/state/expiry N/A); ownership is handed back. Next: recover the dry shelf and investigate the remaining duct/chamber route, keeping the indoor checkpoint as health fallback.

2026-10-31: dry duct onward sweep; navigation remains unresolved

Run scratch/runs/20261031T0145Z-quake2-onward/recovery.txt copies the prior recovery driver to new ports and mounts all eight native save files byte for byte. Both browser restores reached the dry shelf at health 19, kills 7/18. Backward crouching first moved deeper into the duct. Native turns and crawls then traversed the red-lit stretch to a wall (retry/far-end.png); the adjacent dark corners and sideways movement showed openings toward the same flooded pillars (retry/corner-return.png). A short native blaster wall/fixture-direction probe did not visibly open a route. No onward room, health pickup, new enemy, eighth kill or level transition was established. The blocker is unresolved navigation at this duct's wall/corners; these observations do not prove that all possible routes are closed. No drowning, death or health loss was observed, and no lip calibration was repeated.

The first Chrome disappeared with SIGKILL at 01:48:45 UTC, sender unknown. Its frames and action log remain, but its full trusted-input snapshot was lost. A fresh browser recovered successfully and repeated the deeper crawl. Final F9 returned to the original shelf; an extra Escape opened the menu and was corrected before the measured 15-second unpaused world wait, which retained health 19 (retry/restored-world-wait.png). F1 confirms seven kills (retry/restored-count.png). Read-only export retry/retained-save-manifest.json matches all eight starting files exactly; no new F6 checkpoint was made. The prior safer indoor health-21 save remains unchanged. recovery.txt retains the new ports, scripts and navigation limits. The bounded attempt ran approximately 01:45Z–01:52Z, below 20 minutes. No cheats, console commands, guest-memory writes, binding changes or asset edits supplied progress; no emulator defect was isolated.

Both browsers loaded retained module SHA-256 d69d1158f7707c8f46d5f4c0909494913db73bfcb745ca1a3f320be9ad62db91, whose exact compiled source remains unknown. This does not certify a current-main build. The retry reports original ref_gl, WebGL 1, ANGLE Intel Mesa UHD 620, software flag 0 and threads/render Worker off. verification.json passes for 65 original assets, 67 prior inputs, 324 served responses, eight exact native save files, all 53 retry input events trusted, no held keys and mouse mask 0. The initial input snapshot limitation remains explicit. No page exception was recorded; static-harness HTTP 404s remain. Audio, FPS and networking remain unqualified. No runtime source changed, so no build was run.

Retry Chrome exited code 0 through CDP close; controllers were stopped with targeted SIGTERM. Both owned browsers/controllers are absent, six known ports closed and two profiles removed, with over 6 GB free. No Boat or assigned test box was used (ID/state/expiry N/A); ownership is handed back. Next: establish an onward route beyond this local wall/corner sweep, or use the unchanged indoor health-21 checkpoint to investigate another route.

2026-10-31: indoor side door reaches a live stair guard

Run scratch/runs/20261031T0154Z-quake2-indoor/ uses fresh native F9 to recover the unchanged health-21, kills-7/18 indoor checkpoint. A courtyard running jump landed in the lower channel without collecting the opposite ledge pickups. F9 restored the indoor position; no dry-duct corner sweep was repeated. Turning left from the saved view instead enters a slatted corridor. Its mechanical door opens into a room with two barrels and stairs toward red-sky openings (live/door-through.png, live/retry-door.png).

The first stair approach ended in death (HUD -2); the damage source was not identified in that attempt. Native F9 restored the original save again. On the retry, inspected live/stair-fight.png and live/stair-retreat.png show a live guard on the stairs, with health reduced to 9. Native blaster fire was visibly aimed too high after PageDown; no hit or eighth kill is established. This is a newly inspected enemy encounter reached by the indoor side route, not a claim that the room itself was previously unvisited. The next engagement request failed because Chrome received SIGKILL at 01:58:57Z, sender unknown. No new F6 checkpoint was made.

A fresh browser remounted all eight original indoor save files. Its initial F9 was issued during startup, so early captures remain loading evidence only. Actual world recovery is confirmed by retry/load-wait.png (F1 7/18, HP 21) and retry/restored-wait.png (same room and health after 15 seconds without input). Read-only VFS exports in retry/retained-save-manifest.json match the starting checkpoint byte for byte. recovery.txt, driver.cjs, retry-driver.cjs, and the action logs retain the route and recovery details. Gameplay/recovery ran about 01:54Z–02:04Z, within 20 minutes. No cheats, game/console commands, memory edits, binding changes or asset changes were used.

Both browsers loaded retained module SHA-256 d69d1158f7707c8f46d5f4c0909494913db73bfcb745ca1a3f320be9ad62db91, compiled source unknown; this does not certify current main. Fresh recovery probes report original ref_gl, WebGL 1, ANGLE Intel Mesa UHD 620, software flag 0, threads/render Worker off. Focused verification passes for 65 original assets, 67 prior inputs, 324 served responses, eight exact save files, and 107 initial / 11 recovery trusted input events. The last retained snapshots have no held keys or mouse buttons; rejected post-disconnect requests are not counted as delivered. No page exception was recorded; static HTTP 404s remain. Audio, FPS and networking remain unqualified. No runtime source changed, so no build was run.

The first controller was stopped with targeted SIGTERM. Fresh recovery quit responded successfully, then its controller raised the inherited ERR_STREAM_WRITE_AFTER_END; no browser exit event was retained, so clean exit is not claimed. All owned browser/controller processes are absent, six known ports closed, two profiles removed and over 6 GB free. No Boat or test box was used (ID/state/expiry N/A); ownership is handed back. Next: recover indoor21, follow the left corridor through the mechanical door, and engage or lure the stair guard from doorway cover with centered aim before advancing.

2026-10-31: centered doorway lure draws multiple guards; checkpoint retained

Run scratch/runs/20261031T0213Z-quake2-door/ makes one bounded native engagement from the unchanged indoor 21 HP, kills 7/18 checkpoint. The initial Chrome received SIGKILL at 02:07:37Z, sender unknown, during F9 loading; it established no gameplay recovery. A fresh profile remounted the same eight save files, and inspected retry/starting-count.png confirms the actual world, 21 HP and seven kills.

The verified left corridor/mechanical-door route reached the barrel/stair room. Native End centered the view, avoiding the earlier excessive PageDown pitch. A short forward firing peek and backward retreat drew multiple live guards into the room: retry/lure-retreat.png shows one close at the right, another by the barrels and another on the stairs. Health fell to 9. A further brief right turn and retreating burst ended in one player death, HUD -2 and explicit Player died. (retry/cover-retreat.png). No eighth kill, pickup, onward room or new F6 checkpoint was established. The concrete blocker is this multi-guard encounter overwhelming the attempted retreat at low health; no emulator defect was isolated. Next attempt should establish cover farther back before firing and avoid the forward peek that exposed the player here.

Native F9 restored indoor21. Inspected retry/restore-count.png again reads 7/18, and retry/restore-stable.png retains 21 HP after 15 seconds unpaused without input. Read-only VFS export retry/retained-save-manifest.json matches all eight original checkpoint files exactly. The original save remains the recommended recovery. recovery.txt and the action logs retain timings and evidence. Gameplay and recovery ran approximately 02:07Z–02:10Z, within 20 minutes. No cheats, game/console commands, memory writes, binding changes or asset changes supplied progress.

Both downloaded modules match retained SHA-256 d69d1158f7707c8f46d5f4c0909494913db73bfcb745ca1a3f320be9ad62db91, compiled source unknown; this does not certify current main. Actual recovery backend is original ref_gl / WebGL 1 / ANGLE Intel Mesa UHD 620, software flag 0, threads/render Worker off. Original assets, served-file hashes, native save bytes and recorded trusted inputs pass focused checks. The initial browser's F9-event snapshot was lost at disconnect; its action log remains, so complete initial-event verification is unavailable. Final recovery keys/buttons are released. Installer remains unavailable; audio, FPS and networking remain unqualified. Static HTTP 404s remain; no page exception was recorded. No runtime source changed, so no build was run.

Recovery Chrome exited code 0 through explicit CDP close. The initial controller was stopped with targeted SIGTERM; the retry controller exited 143 after browser close, sender unknown, before its requested SIGTERM. All four owned PIDs are absent, six ports closed and two profiles removed, with over 1.5 GB free. Other sessions were preserved. No Boat or assigned test box was used (ID/state/expiry N/A); ownership is handed back. The bounded attempt stops with the original safe checkpoint retained and the combat objective unmet.

2026-11-01: native indoor restore; door approach interrupted

Run scratch/runs/20261101-quake2-indoor-guard/ retained one native quake2_demo original, using the registered renderer/config and supported --vfs-mount for the eight unchanged indoor21 save files. Ordinary F9 at batches 100/101 restored the world; startup/menu frames alone were not treated as recovery. Inspected starting-count.png shows the saved indoor room and 21 HP; starting-count-stable.png shows kills 7/18, goals 0/1 after the F1 pair and eight further batches without input. Left turns and W movement then followed the slatted corridor toward its mechanical door. End centered the view at batches 1067/1068. The final W hold at 1075–1077 has before, held, released and settled captures; door-approach-settled.png at batch 1080 and the identical final.png show the closed door close ahead and 21 HP. No live guard engagement, outgoing hit, eighth kill or onward room is visibly established. No attack or F6 input appears in the retained input trace.

The blocker for this attempt is worker/launcher interruption before the planned encounter, not an established door or emulator defect. The bounded last worker events end after the door approach. Worker 01a1971b-bad6-77b1-942e-50435034f369, launcher handle 2746, exited 143 without launcher final/result artifacts; its signal sender/cause is not established here. The coordinator requested finish.json at 12:51:22Z. exit.json records original PID 3661918 exiting 0 after 318.559 seconds, ending at batch 1080; coordinator-interruption.json records cleanup at 12:51:49Z. Original exit 0 does not establish gameplay success or a clean worker completion. A fresh evidence-only worker finished this note without resuming the old worker or starting another original.

Focused artifact validation passes: all 61 PNGs pass chunk CRC and IDAT decompression checks, the complete runtime gzip decodes, all 32 ordinary key edges (16 pairs) are dequeued, routed and dispatched to hwnd 0x10001, and all eight retained host save files still match their starting sizes and SHA-256 values. save-mounts.json, checkpoint-before.json and recovery.txt preserve the byte-exact recovery recipe. No fresh guest VFS export or final F1 count was retained, so post-run guest-save equality and a final kill-count readout are unavailable. The final known scheduled/pending/cross-thread/ renderer queues are empty. Sampled physical/async movement keys are released; pressed latches are not held keys. W, D and End lack final per-key samples, although their up events were dispatched. Guest post queue, button state and SDL consumption remain unknown. The short settled captures are not a matched long no-input control for the final door approach.

The accepted-build receipt matches 4,392 source pins and 141 prior observed reads from accepted build d86935e8274cd5d70a53bcc50c5d8bf5632d95c3. Actual run baseline was main f581e849f29be47c3d68da7cdf1c72a93ecde4df. Recovery validation finds 4,444 source/module pins, 67 original/manifest inputs and original-tree membership unchanged, with all 132 actual runtime reads still matching. The runtime compiled module SHA-256 is dd43e4a6624d2449d7133b731d687c32530f7fcf0041a69ba71a09f78c09aaf4. Retained observer validation exercised actual sync/async compilation, whole 512 MB shared-memory read-only behavior, clock identity and late event 10001 retention. String-path file reads are observed; descriptor/direct OS reads are not comprehensively covered. Runtime compilation identifies module bytes, not compiler-source reads. This native software-bridge run does not establish browser/GPU, audio, FPS, networking or full-suite parity. No new runtime, build or gameplay tests were run during evidence-only completion; no tracked code, configuration or assets changed.

The retained runtime minimum free disk was 2,068,029,440 bytes. Coordinator cleanup and a fresh process check find the original/controller, gate waiter, disk guard and their known groups absent, with no matching own helpers or new wa-child-* temporary directories. Evidence remains in the existing scratch run. Native box ID/state/expiry are N/A; shutdown was delegated to the coordinator and ownership is handed back. The original checkpoint remains intact. Next gameplay work, if separately authorized, still needs visible proof of the stair-guard outcome or an onward room; this interrupted attempt does not resolve that objective.

2026-11-01: native doorway cover yields the eighth kill

Run scratch/runs/20261101-quake2-native-door-encounter/ completes the guard objective with 8/18 kills and 21 HP. Supported --vfs-mount mounted the eight unchanged indoor21 files from 20261031T0213Z-quake2-door/retry/; ordinary F9 at batches 100/101 restored the checkpoint. Startup/menu images were not accepted as recovery. starting-count-stable.png confirms the indoor world, 7/18 kills, goals 0/1 and 21 HP at batch 989.

Short observed turns, W movement and a D offset followed the left slatted corridor and cleared its corner pillar. End centered the view. A three-batch W approach and one-batch touch reached the mechanical door. The subsequent 20-batch no-input interval shows it open, with the barrel/stair room and an upright guard at the right jamb (door-opening-wait-settled.png, batch 1144). The closed approach frame was therefore not an obstruction. No further forward input was issued after that touch. The player remained at the doorway while the guard approached, avoiding the earlier exposed forward firing peek.

Enter bursts and small ordinary keyboard/relative-mouse aim corrections initially produced sparks near the jamb; those frames alone do not prove hits. close-guard-burst-settled.png at batch 1208 clearly shows blood from the identified guard. The final eight-batch burst has before/held/released/settled captures (pointblank-burst-*, batches 1242/1250/1251/1253), showing heavy blood and backward collapse; pointblank-settle-settled.png continues the collapse. verified-count-wait.png at batch 1290 and final-count.png at 1344 both read 8/18, with 21 HP and goals 0/1. This establishes one guard defeated, without establishing a level transition or another room beyond this encounter.

Matched no-input sequences are retained alongside the action sequences, including three-batch door-neutral-* versus the three-batch approach and eight-batch final-neutral-* versus the final burst. In the door control, the complete upper scene rectangle (0,0)–(640,270) is pixel-identical before/held/settled; weapon motion changes the full frame. The final neutral sequence includes delayed F1 closing and is not a stationary full-frame control. Other settle frames also show delayed aim/menu effects or enemy animation. Browser milliseconds were not converted into native batches, and scheduled input times are not asserted as guest effect times.

Focused validation passes all 196 PNGs through chunk CRC/IDAT decoding, the complete runtime gzip, and 74 key edges / 37 balanced pairs, dequeued and dispatched in order to hwnd 0x10001. Three relative-mouse inputs bring the final scheduled/dequeued/routed/dispatched totals to 77. Final known scheduled, pending, cross-thread and renderer queues are empty. All sampled physical/async keys, explicitly including W, D, End and Enter, are released; pressed latches are not held keys. Guest post queue, button state and SDL consumption remain unknown. No console, save-byte, binding, asset or guest-memory edits supplied progress.

Supported --save-vfs exported all eight guest save files on exit. focused-validation.json verifies each exported file and each original host file against the retained size/SHA-256: all eight match exactly. No F6 checkpoint was made, so recovery remains the original 21 HP / seven-kill save; the eighth kill is evidenced in this run, not persisted as a new save. save-mounts.json, the controller scripts and exported guest-vfs/ retain the recovery recipe. Identical PNGs within this run share hardlinks to save disk without changing their bytes; no external artifacts were removed.

The Thief II fresh launcher final/result and explicit runtime/source/build release opened the gate at 13:04:29Z, actual main e6814d7b96263fdd354c1eae8fafa4da99e3e427 (dispatch was 90aa4059d). All 4,392 accepted source pins and 141 prior observed reads matched, allowing accepted module reuse. Fresh before/after validation finds 4,444 source/module pins, 67 original/manifest inputs, original-tree membership and 132 actual runtime reads unchanged. Actual compiled module SHA-256 is dd43e4a6624d2449d7133b731d687c32530f7fcf0041a69ba71a09f78c09aaf4. Before original use, the observer passed actual sync/async compilation and execution, whole-512 MB shared-memory read-only checks, native/host clock identity and emitted late-event-10001 retention. Its string-path file-read coverage does not comprehensively cover descriptors/direct OS reads; runtime compilation identifies module bytes, not compiler-source reads. This native software-bridge result does not qualify browser/GPU, audio, FPS, networking or full-suite parity. No tracked runtime/helper/test/configuration or backend changed, so no new build was needed.

One original, PID 3681491, exited 0 after 499.982 seconds, ending at batch 1344, within the 25-minute gate window. Runtime and auxiliary disk guards retained a minimum of 2,017,398,784 bytes free, above the required 2,000,000,000-byte floor. Own runtime/controller, gate monitor, guards and watchers are absent with no remaining own groups or new wa-child-* temps; cleanup and publication checks are retained. Native local box ID/state/expiry are N/A. Explicitly delegated shutdown is complete and ownership is handed back. The requested eighth-kill objective is complete; no second original or further gameplay is needed for this assignment.

2026-11-01: eighth-kill F6 exported; disk floor stops further recovery

Run scratch/runs/20261101-quake2-eighth-kill-checkpoint/ reproduced the covered encounter with one native quake2_demo original. Supported --vfs-mount mounted the unchanged eight-file checkpoint from 20261031T0213Z-quake2-door/retry/; ordinary F9 restored 21 HP, 7/18 (starting-count-stable.png, batch 989). The previous controller's ordinary turns/movement were replayed through the mechanical door. The three-batch no-input door control retained identical pixels throughout the upper 640×270 scene, while the matched approach advanced to the door. A further touch and 20-batch wait opened it normally. There was no exposed forward peek after the touch at batch 1121.

Covered Enter bursts and the previous small aim corrections reproduced the guard's blood/collapse (pointblank-burst-*, batches 1242–1253). verified-count-wait.png at 1290 shows 8/18, 21 HP, goals 0/1. Ordinary F6 at 1290/1291 then produced visible Quick Saving... while the same eight-kill overlay remained visible (checkpoint-f6-settled.png, 1294). After 40 more batches, a read-only export copied actual ctx.vfs.files entry bytes to checkpoint-eight/save-0.bin through save-7.bin. This is a game-created save, with no edited save bytes, memory, bindings, assets or console commands.

checkpoint-eight/manifest.json records all eight actual guest-to-host mappings. Each row below applies to both guest directories c:\baseq2\save\current\ and c:\baseq2\save\quick\:

Guest filename Export indexes: current / quick Bytes SHA-256
server.ssv 0 / 4 2464 33717c18914725eb1a5155f2ac14635084bf7530cea888b51a8f7f79dacda0d8
game.ssv 1 / 5 5308 156d97736cef1ea136107a9d2c13c2dc4a5a8a3d494b114ffdb2c972b3903985
demo1.sav 2 / 6 323095 83cb6c6ef993f8f0ba35caad600a6731b63d9f2703dc625d108cc51731a597d0
demo1.sv2 3 / 7 104448 6ad6c039d4efb8e81628badb5bfaeb8d50ff8e5974aad0b55d3eccaf0b3086c3

All eight differ from the original seven-kill saves. On clean runtime exit, supported --save-vfs exported the guest save tree again; save-export-validation.json verifies all eight files byte-for-byte equal to the earlier actual guest-byte exports, not merely to host copies. mounted-guest-validation.json independently compares the pre-F6 guest response bytes against all eight unchanged original host files. Two initial read-only observation attempts encountered a JavaScript quoting error and an incomplete streamed JSON record; the complete retained runtime response was parsed offline for the latter comparison. Neither supplied guest state.

Ordinary F9 at batches 1334/1335 returned to the doorway world at 21 HP. However, the attempted post-load F1 pairs, including a later attempt after 600 no-input batches, did not yield a visible statistics overlay in the retained frames. Thus this run establishes the F6 save and exact exported guest bytes, but does not independently verify 8/18 after F9. Those world frames are not evidence of a stable no-input statistics control. The label onward-cover-neutral-* denotes an ordinary End centering pair, not a no-input control. No onward movement or room traversal was attempted after recovery, and no additional kill or level transition is claimed.

The first terminating blocker was free disk below 2,000,000,000 bytes. The controller detected 1,999,884,288 bytes and requested ordinary runtime quit; the auxiliary guard subsequently recorded 1,998,979,072 bytes. PID 3705696 exited 0 after 245.421 seconds, final batch 2385. The continuous floor requirement therefore failed; it is not presented as a compliant runtime. No second original or runtime restart was attempted. Next, after disk capacity is restored, mount the eight new files using their recorded guest mappings, allow F9 to settle, verify the visible kill count, then use short consumed controls to advance from doorway cover.

Thief II worker 01a1973e-91a3-7693-9c72-46cc90af1d5f fresh launcher final/result and explicit runtime/source/build release opened the gate at 13:28:37Z. Dispatch was 8f2f8a802db44745a1ac00fe3c65e25965eb587f; the repinned main was 787aaad95b6c3bcd435e4d2186956e1c8a6d57e5. All 4,392 accepted source pins and 141 prior observed reads matched, allowing reuse of module SHA-256 dd43e4a6624d2449d7133b731d687c32530f7fcf0041a69ba71a09f78c09aaf4. Fresh before/after checks passed 4,444 source/module pins, 67 original and manifest inputs, original-tree membership and 132 actual runtime reads. Before original execution, the observer passed actual sync/async module execution, whole-512 MB shared-memory read-only checks, clock identity and emitted late-event-10001 retention. String-path observations do not comprehensively cover descriptors/direct OS reads, and runtime module identity does not prove compiler-source reads. No tracked runtime, helper, test, configuration or backend changed; no new build was required.

Focused checks pass 80 PNGs through CRC/IDAT decoding, the complete runtime gzip, and 82 key edges / 41 balanced pairs, all dequeued and dispatched in order to hwnd 0x10001. Three relative-mouse events bring final scheduled/dequeued/routed/dispatched totals to 85. Final known queues are empty and sampled physical/async keys, including F6/F9, are released; pressed latches are distinct. Guest post queue, buttons and SDL consumption remain unknown. Identical screenshots share hardlinks without byte changes; a control-log segment is retained losslessly as gzip.

Own original/controller, gate monitor, guards and publication watcher are absent, with no own process groups or new wa-child-* temps remaining. Local native box ID/state/expiry are N/A; explicitly delegated own shutdown is complete and ownership is handed back. Cleanup, publication, fresh run final/result and evidence checks are retained in the run directory. No browser/GPU, audio, FPS, networking or full-suite claim is made. Work stops at the disk blocker with the new game-created checkpoint preserved.

2026-11-01: eighth-kill recovery stopped after a false gate match

Run scratch/runs/20261101-quake2-eight-save-onward/ did not verify the restored 8/18 count or advance through the guard room. The first blocker was a worker gate-checking error: the substring predicate matched its own “WAIT coordinator … runtime/source/build RELEASE” board entry as though the coordinator had released the runtime. At 13:44:33Z the lighting result.json existed, but the required explicit coordinator release was absent. The apparent gate receipt is invalid and the append-only board contains a correction. This run does not satisfy the pre-runtime gate.

The worker noticed the incorrect receipt and requested ordinary quit before any gameplay input. One original, PID 3721734, exited 0 after 19.646 seconds at startup batch 25. The reviewed capture is a blank gray startup frame; all scheduled/dequeued/routed/dispatched input counters are zero. No F9, F1, movement, attack or F6 was issued. Key samples at this startup stage are unknown, so this is not a final per-key release demonstration. There is no restored-world, kill-count, cover-movement, neutral-control or objective claim.

All eight supplied checkpoint files and both checkpoint manifests retained their pinned sizes and SHA-256 values before/after. The startup command used exactly their supported --vfs-mount mappings. The game-created eighth-kill checkpoint remains preserved at the preceding run's checkpoint-eight/; startup shutdown exports are not promoted as a checkpoint.

Before the error was noticed, the identity check recorded 4,444 source/module pins and matched the accepted build's 4,392 source pins and 141 observed reads, reusing module SHA-256 dd43e4a6624d2449d7133b731d687c32530f7fcf0041a69ba71a09f78c09aaf4. The observer check passed actual sync/async execution, whole-512 MB shared memory read-only checks, clock identity and emitted late-event-10001 retention. These checks ran prematurely and do not cure the invalid gate. String-path reads do not comprehensively cover descriptor/direct OS reads; module identity does not prove compiler-source reads. No new build or tracked source/helper/test/configuration/backend change was made.

The controller's minimum observed disk was 2,206,560,256 bytes; the separate one-second guard minimum was 2,207,477,760 bytes. Own original, controller, gate waiter, disk guard and board watcher PIDs and known groups are absent; no new wa-child-* temporary directory remains. Local native box ID/state/expiry are N/A; explicitly delegated own shutdown is complete and ownership is handed back. Fresh cleanup and gate-correction records are retained. The scratch gate predicate now requires exact coordinator/RELEASE tokens and has not been rerun. No second original was used. Next recovery requires a valid coordinator release, then F9 and a consumed, visibly settled F1 count check before onward input. No browser/GPU, audio, FPS or full-suite claim is made.

2026-11-01: eighth-kill save restored; two more guards and upper stairs

Run scratch/runs/20261101-quake2-eight-save-restoration/ verifies the new game-created eighth-kill checkpoint and advances across the guard room onto its raised right-side stair route. One native quake2_demo original used exactly the eight ordered --vfs-mount arguments from 20261101-quake2-eighth-kill-checkpoint/checkpoint-eight/mount-arguments.json. A read-only export independently matched all eight actual mounted guest files to those pinned host bytes. The eight files and both original manifests remain unchanged. No seven-kill fight was repeated.

Ordinary F9 at batches 100/101 loaded the saved doorway at 21 HP. Its release was initially queued during loading; at 304 both edges were consumed. After 700 no-input batches the restored world was visible behind the startup menu. Escape closed that menu. The first consumed F1 pair at 838/839 left help hidden, including after another 230 no-input batches. Only then was a second F1 pair issued at 1072/1073. restored-eight-count.png at 1126 and restored-eight-count-stable.png at 1146 visibly show 8/18 kills, 21 HP, goals 0/1. No movement or attack preceded this verified restoration.

The player first offset behind the jamb. A one-batch D pair was not consumed until its release batch and supplied little movement; the three-batch offset visibly established cover. The door subsequently closed and a short ordinary W touch reopened it. A lower guard approached the doorway. Covered Enter bursts produced blood, but did not initially kill him. A backward retreat into the slatted corridor restored separation; a small relative-mouse adjustment and further burst produced the collapse. ninth-kill-count-settled.png at 1649 confirms 9/18, 17 HP. Ordinary F6 at 1671/1672 created the exported checkpoint-nine/ save.

The cleared threshold was crossed with short, observed controls. A diagonal left approach initially remained near the jamb; the subsequent lateral clearance and inside-room-step-* sequence visibly entered the room. The left-wall health pickup then raised health 17 → 42 (health-pickup-approach-settled.png, 1843). Another guard approached the alcove wall. Retreat/fire controls, a small aim correction, and a rightward escape supplied further hits and his collapse. F1 at 2017/2018 produced second-guard-count-settled.png at 2031: 10/18 kills, 30 HP, goals 0/1. Initial live commentary misread the small health digits as 12/22/6; enlarged read-only screenshot crops in analysis/health-crops.png establish the correct 17/42/30 readings. The original full captures are retained.

The player then passed to the right of the barrels. Several approaches reached the narrow side of the stair flight; their filenames alone do not prove ascent. Backoff, a walking lateral adjustment, and a final ordinary left/jump adjustment aligned the flight. final-flight-step-settled.png shows the raised corner; upper-route-look-left-settled.png at 2234 shows the steps meeting the raised floor and the onward passage along the right wall. final-count-settled.png at 2222 still shows 10/18, 30 HP. The lower-room crossing and upper stair route are established; completing the base elevator objective or a level transition is not. Goals remain 0/1.

Ordinary F6 at 2234/2235 saved this final position. After 40 additional batches, checkpoint-onward/manifest.json records eight read-only exports of actual guest save entries; mount-arguments.json supplies the supported recovery command arguments. save-export-validation.json verifies all eight byte-equal to the clean-exit --save-vfs exports. Each row below applies to both c:\baseq2\save\current\ and c:\baseq2\save\quick\:

Guest filename Export indexes: current / quick Bytes SHA-256
server.ssv 0 / 4 2464 28bdc0cd29a209df05d997057984eb5de81cebd483b6e8ebd7881027c90c955e
game.ssv 1 / 5 5308 0a1efd61231a97bba92f62086e4f5e557eb9ce2f0be28b7047c0691a85565561
demo1.sav 2 / 6 322145 19ac24b934d020dcd83076efc8cb5aced10518ced310ff1cc6659de33c91cfbe
demo1.sv2 3 / 7 104448 6ad6c039d4efb8e81628badb5bfaeb8d50ff8e5974aad0b55d3eccaf0b3086c3

This final save has not itself been F9-restored. For further play, mount its recorded exact bytes and verify the settled F1 count before continuing along the upper passage. The original eighth-kill checkpoint and the intermediate nine- and ten-kill exports remain available. No console, memory/save edits, new bindings or guest assets supplied progress.

The valid gate opened 14:00:13Z, after exact author/action parsing of thief2-left-route-interaction DONE/PUSH RELEASE ... runtime/source/build, both fresh launcher final/result files, launcher termination, and direct verification that the predecessor's owned PIDs/groups were absent. The predecessor's cleanup schema differed from Quake's; the scratch waiter was adapted before any validation or original execution. The old false-positive worker's WAIT predicate and startup were not accepted as restoration. Dispatch was 4942ab64b3dbb341e1dc7892277782b3b82c53ba; repinned main was 8552125804a6994de385d7f00858e789fd59024f.

Accepted-module reuse matched 4,392 source pins and 141 prior observed reads, module SHA-256 dd43e4a6624d2449d7133b731d687c32530f7fcf0041a69ba71a09f78c09aaf4. Fresh before/after validation passed 4,444 source/module pins, 77 original, manifest and checkpoint inputs, original-tree membership, and 136 actual runtime reads. The observer passed actual sync/async execution, whole 512 MB shared-memory read-only comparison, unchanged clock identity, and emitted late-event-10001 retention before the original. String-path read observations do not comprehensively cover descriptor/direct OS IO; module identity does not prove compiler-source reads. No new build or tracked source/helper/test/configuration/backend change was made.

Focused validation passes 259 PNGs through CRC/IDAT checks, the complete runtime gzip, and 132 ordered keyboard edges / 66 balanced pairs. Two relative-mouse events bring final scheduled/dequeued/routed/dispatched totals to 134. Final batch 2280 has empty known input queues and released physical/async samples for every used key, including Shift, Space, A/D/W/S, Enter, turns, Escape, F1/F6/F9. Sampled mouse virtual keys are also released; the mouse-button mask, guest post queue and SDL consumption remain unknown. Before/held/released/settled captures and matched no-input controls are retained. The 1/1/20-batch neutral has zero changed pixels throughout the upper 640×270 scene; other matched 3/1/20 and 6/1/20 controls contain small scene changes (including the active door/enemy), so are not claimed stable. PNG IDAT recompression was verified lossless; equal captures share hardlinks.

PID 3738515 exited 0 after 1380.730 seconds, final batch 2280. The controller's outer deadline won just before the requested finish file; the enclosing tool shell reported 143, with its signal cause unknown. These limits do not erase the earlier reviewed gameplay/save evidence. The controller minimum free disk was 2,110,734,336 bytes; the one-second auxiliary runtime guard minimum was 2,115,596,288 bytes, above the 2,000,000,000-byte floor. Subsample excursions cannot be ruled out and the auxiliary retains its latest sample/minimum, not a full history. No RAM gate or foreign cleanup was used. No second original was started.

The run-local artifact check passes without missing files or containment/schema errors; the global checker reports ten unrelated containment errors, left untouched. The original, controller, gate waiter and runtime disk guard have exited. Cleanup and publication records accompany the final run result. Local native box ID/state/expiry are N/A; explicitly delegated local shutdown is complete and ownership is handed back. The task stops with the new checkpoint preserved; further objective progress is untested.