Sid Meier's Pirates! (2004)

test/binaries/candidates/pirates-2004/digital/app/Pirates!.exe, registry id pirates_2004 (d3d9Programmable, bigMemory). Direct3D 9, statically linked (d3d9.dll import), with msvcr71/msvcp71, Bink, Miles (mss32 plus its win32/*.asi, *.m3d, *.flt providers) and oleaut32 from the game directory.

Route to the main menu (CLI, software D3D9 arm)

node test/run.js --app=pirates_2004 --d3d9-renderer=software --batch-size=100000 \
  --max-batches=1000000 --max-seconds=180 --stuck-after=1000000 --no-close --png=menu.png

The D3D9 main menu (Play Sid Meier's Pirates!, Load A Game, Change Your System Options, Visit The Firaxis Website, Visit The Hall Of Champions, View Credits, Quit, over the Caribbean map) is up by batch ~1000 at --batch-size=100000. Assets load from assets\pak*.fpk one byte per ReadFile, which is slow but correct. Evidence: scratch/runs/20261006T033534Z-pirates_2004-dxinit.

Startup, as reverse engineered (2026-10-06)

Fixed

commit what
ba161dfb D3D9 caps advertise MaxTextureBlendStages = 6 (was 0)
12408feb a CoCreateInstance whose in-proc DLL is missing resumes the caller (the yield pump left EIP on the thunk and re-ran it on the caller stack) and clears *ppv
d7f5a429 test/run.js honours bigMemory (2048 MB); at 512 MB the asset load runs out of guest heap

Not yet looked at

Gameplay (Play Sid Meier's Pirates!), audio, the WebGL arm at this build. ole32.dll is absent from this box's test/binaries/dlls, so the Miles providers' ole32 imports fall to WAT stubs.

Fixture, original disc EXE and early bring-up facts (2026-10-01)

(Recovered from branch archive/shared-tree-presync-20261011, Oct 2026.)

TG77 cooperative thread attach (2026-10-14, unresolved)

Safari reported DllMain did not complete for module 0x9f1000, reason 2, with restored caller EIP 0x9fc4bb. Chrome cooperative evidence supplied by the runtime investigator (scratch/runs/20261014-pirates-browser-cooperative) places the actual msvcr71.dll callback at 0x7503fc0, yield 9 / halt 4: a critical-section wait. The section owner remains to be captured.

Source inspection and the cheap node tools/pirates-attach-gap.js witness confirm that the synchronous callback runner restores the caller and releases the callback gate on this wait; retrying the notification repeats previously completed DLL callbacks. This mock reproduction is not real-PE acceptance. See continuation interface and regression plan for the required owning-thread scheduler integration, cleanup contracts and unexecuted real-PE/browser gates. No production fix is included.

Cooperative thread-attach regression (2026-10-14, TG77)

The Safari report on module SHA256 e6ac188dd8c7b16d04eaa4b74446ab2c4ab211422738709e33cffda5db444e7e reports DllMain did not complete: module=0x9f1000 reason=2. Reproduced with the existing pinned corpus acquisition on temporary bx_tgbme2h7, Chrome, isolated page, ?debug&no-threads&app=pirates_2004. Source was 43f04c7c4ac8914c385c37a7be96c7e1b9f61623, same module hash. No guest patch, capability override, or DllMain completion bypass was used.

The loader identifies 0x9f1000 as msvcr71.dll, preferred base 0x7c340000, entry 0x9f329f. Several prior callbacks complete normally. The failing callback stops at EIP=0x7503fc0 yield=9 halt=4: a critical-section wait, not the callback budget limit. The later crash report's 0x9fc5ec (Safari reported 0x9fc4bb) is the restored caller state, not that wait thunk. Increasing budgets or marking the unfinished attach complete would hide the scheduling problem.

Next capture the contended section and its owner, then implement resumable thread-attach scheduling with a real contended-lock regression. Preserve the callback frame, loader serialization, and exactly-once notifications while allowing the owner to run. pumpThreadsOnce deliberately refuses entry while already running a cooperative worker, so it is not a drop-in fix here. The owner and precise lock have not yet been established. Worker-mode and Safari retests remain separate; no fix or gameplay acceptance is claimed.

Evidence: scratch/runs/20261014-pirates-browser-cooperative/ contains the 90-second probe, six captures/state snapshots, browser log and process receipt. The final fatal-error screenshot was reviewed. The original user report is in scratch/runs/20261014-pirates-user-crash/report.txt.

Cooperative continuation candidate (2026-10-14, runtime verified)

Task branch task/pirates-attach-fix now retains the notification generator, module cursor, snapshot pins and loader gate through ordinary scheduler turns. Candidate production source 16961623b freshly built to WASM SHA256 70c6d329d51eee5db553715f53ffc47f3e6e2491b54ae5327f1b8b012427d655 passes the real-PE contended-section regression and existing main/Worker DllMain completion, load-context and callback-serialization tests.

The original cooperative Chrome startup now reaches the visible Main Menu. The actual msvcr71 callback still parks at 0x7503fc0, yield9; captured section guest 0xa3c190 (WASM 0x64e190) is owned by thread1/main, recursion1. First recorded tid6 park retains its actual frame and loader gate [6,1]; 5.415ms later its callback returns, followed by sequence completion and gate release [0,0]. Four such waits complete during the 90-second run. Thus this route's owner can run and release the section with ordinary scheduling.

Evidence scratch/runs/20261014-pirates-attach-candidate/ includes raw traces, test/build receipts and reviewed final menu capture. The baseline module is older, so the screenshots alone are not a controlled version A/B. No gameplay input, affected Safari validation, merge or deployment is claimed. Blocking nested initialization and synchronous exit-detach remain existing boundaries; see docs/pirates-attach-candidate-20261014.txt for exact test scope.

Original browser main menu (2026-10-31)

The registered original pirates_2004 reached an inspected Main Menu in Chrome 151 using the WebGL selection and retained module 573e235db16e351668289f49e2f279ff48bcad56e7ca533167cb94cd6f4ec3fc. This was a retained-module run; its full source identity was not reconstructed, so it is not a fresh current-main build or a controlled comparison with the October 14 callback candidate. Original assets and host sources were unchanged.

The title splash preceded the menu. Escape, Enter and one canvas click were recorded as trusted input; keys and buttons were released. The UI slice changed from Auto (logged as 100000) to 5000, then 50000. The menu capture shows Play, Load, Options, credits and Quit over the original Caribbean map. Its late metadata records a visible 800×600 game window at GPU sequence 3. Subsequent Play-selection/control requests failed or stopped completing while browser target discovery still responded. There is no verified Play consumption, character creation, sailing or gameplay result, and no established cause for the control failure. Resource lookup 404s occurred; no fatal API trap was observed. No production fix is claimed.

Evidence: scratch/runs/20261031T0200Z-pirates-original-browser/, especially loading-3min.png, loading-3min.json, actions.jsonl, verification.json and recovery.txt. Verification covers 1374 original input pins, 266 served responses and 141 unique host paths. The controller exited 0 after explicit quit; its browser, profile and three ports were closed. No Boat was used. The next runtime check should start with a small UI slice and test original menu selection; this capture establishes rendering only.

Original new game reaches sailing (2026-10-31)

A second local Chrome 151 run started with UI slice 5000 before Launch, cooperative execution and the same retained 573e235d… module. Native mouse and keyboard input advanced Play → Crew Signups → tavern → English captain welcome → crew decision → cast off at Port Royale. The inspected sailing view shows the ship, ocean, port, 600 gold and 41 crew. Subsequent paired Right and Up key inputs were delivered; the ship becomes visible and the coast/port position changes across the captures. This establishes progression beyond the menu and an updating original sailing scene; the small sample does not isolate each key's effect or qualify a voyage, combat or objective.

Rendering remains visibly defective: the mountains are white, and the console records 270 “specular lighting is not implemented” errors. Their causal relationship is unproven. No source fix, complete graphics acceptance, audio acceptance or persistent save is claimed. This retained module's full source identity remains unknown; it is not a newly built main revision.

Evidence: scratch/runs/20261031T0215Z-pirates-small-slice/. Personally inspected play-enter.png, crew-confirm.png, captains.png, captain-continue.png, captain-next.png, cast-off.png, sailing-turn.png and sailing-sails.png show the route. actions.jsonl and screenshot metadata retain timing and 25 trusted input events, with all keys/buttons released. Verification matches 1374 original input pins, 465 served responses and 141 unique host paths; 179 artifact hashes preserve the run. Explicit quit closed the browser, controller (exit 0), three ports and profile; no Boat was used. recovery.txt records the exact native route. A next graphics investigation should first reproduce the white terrain with a source-identified build and compare a matched scene, rather than infer a cause from the specular warning.

Current-main build identity check (2026-10-31)

A locked canonical tools/build.sh passed at main 90c0c0c48. Tracked source hashes remained unchanged across compilation. Its 1,896,705-byte module has SHA-256 573e235db16e351668289f49e2f279ff48bcad56e7ca533167cb94cd6f4ec3fc, exactly matching the retained module used for the successful sailing run above. This supplies a reproducible current-main source identity for those module bytes; it does not turn the earlier execution into a fresh runtime replay.

The new browser run rendered Main Menu, but its browser PID disappeared and CDP refused connections before the new-game route completed. The cause is unknown. No new sailing or terrain comparison is claimed. Evidence is in scratch/runs/20261031T0220Z-pirates-main-sailing/: build.log, source-before.json, build-identity.json, inspected captains.png, and verification.json. Explicit controller quit completed; its browser, profile and three ports were closed. No Boat was used. The next graphics task still needs a matched sailing scene and a measured rendering contract before attributing the white terrain to the unsupported specular path.

WebGL fixed-function specular lighting (2026-10-31)

lib/d3d9-fixed.js now computes the fixed vertex stage's specular RGB using material specular times the sum of each light's specular color, half-vector power, attenuation and spotlight factor. It follows Microsoft's D3D9 specular equation, including the finite camera-to-vertex viewer vector and the infinite viewer's (0,0,1) vector. Material/COLOR1/COLOR2 selection uses the existing fallback and COLORVERTEX rules; normals use the inverse-transpose world-view transform and optional normalization. Back-facing lights and degenerate vectors produce no highlight. Power zero avoids GLSL's undefined pow(0,0) case.

The specular sum is clamped per vertex, interpolated separately, and added after the texture cascade without changing its alpha. Mixed programmable pixel shader post-specular and software-backend specular remain unsupported and guarded. This rendering implementation does not establish the cause of the white terrain in Pirates.

Focused test/test-d3d9-specular-web.js passes 86 actual WebGL1/2 pixel checks against an independent scalar vertex-lighting/interpolation reference: directional, point and spot lights; attenuation/range/cones; material sources and missing-color fallbacks; COLORVERTEX; powers 0/1/2/4/20; finite/infinite viewer and translation; inverse-transpose normals and normalization; zero vectors/backfaces; accumulation/clamping; texture replacement and alpha. The mixed-stage and software-backend regressions pass. The unmodified existing lighting WebGL suite fails with invalid light attenuation on its known “all-zero attenuation reads as 1” fixture. A diagnostic run excluding only that case passes the remaining 76 pixel checks; the full suite is not a pass. Locked flock /tmp/wine-build.lock bash tools/build.sh passes and reproduces the canonical 573e235d… module. Evidence is retained in scratch/runs/20261031T0221Z-pirates-specular/, including test/build logs, renderer source patch/hash and original-asset verification.

The bounded original-asset retest reached sailing with the new renderer. The successful attempt is under final/: UI slice 5000, cooperative execution, Chrome 151 / ANGLE SwiftShader, canonical 573e235d… module, and served d3d9-fixed.js SHA-256 13c8e353e63ecc11f544259aee8891f9f2ecf8a9aa0f99d0d96e2805da8791a6. Native Play → Crew Signups → tavern → English captain reached St. Kitts, with 600 gold and 41 crew. Escape briefly opened System Options; returning showed the sailing scene, then the ship entered town. Native Sail away → “No matter, cast off!” returned to sea. Right and Up inputs followed; inspected cast-off.png, castoff-turn.png and castoff-sails.png show changing ship orientation and coast position. Their individual control effects are not isolated, and no combat, voyage objective, audio or persistent save is qualified.

White terrain persists. The successful run has zero specular rejection messages and no page exceptions; its console errors are 28 HTTP 404s. Thus specular support does not resolve this visible defect. This is a different starting port from the earlier Port Royale capture, not a frame-matched terrain comparison, and the terrain's cause remains unproven.

The first attempt captured the title, then timed out on premature menu input and returned to the launcher; the reload's cause is unknown. A retry correctly refused a canonical-module/generated-map mismatch after another worker changed the shared map. The successful run therefore serves the first captured host source versions from this run, including the new renderer and canonical 54a33f1054df7c3f map, with a retained URL-to-hash mapping. It does not pair the old module with the concurrently edited mirror. All 1374 original input pins match the prior canonical run; the successful route retains 466 served responses and 34 trusted input events, with no held keys/buttons. Own browsers, controllers, servers and profiles were closed; no Boat/test box was used. recovery.txt and verification.json retain the exact route and limits. Next: investigate the actual terrain texture/material draws with a matched scene; do not treat removing the specular rejection as a terrain fix.

White-coast draw boundary investigation (2026-10-31)

The white coast is reproduced using the previous run's matched 573e235d… module, 54a33f1054df7c3f map and specular renderer 13c8e353…. There is no terrain repair in this change: the measured renderer behavior agrees with the submitted state, and the upstream reason for that state remains unresolved. Evidence and a self-contained source/module recovery recipe are in scratch/runs/20261031T0240Z-pirates-terrain/recovery.txt.

A bounded original sailing trace identifies a 4,936-triangle coastal draw that writes the pale pixels. It has stride 32, FVF 0x112 (position, normal, one UV), no vertex colors, no bound textures, and null vertex/pixel shaders. Stage 0 selects DIFFUSE; diffuse/ambient material is (0.5,0.5,0.5,1), with lighting enabled and specular disabled. The directional light's diffuse RGB is 1.78559768. This is not a texture decoder producing white texels: this draw has no texture to decode. A subsequent 700-call sea trace retains neighboring texture pixels and finds the same untextured terrain, no draw errors and no offscreen color attachment in the bounded scene. Neither trace establishes that all terrain draws or all frames use this path.

Read-only guest/WAT draw-state snapshots confirm null texture pointers before the JavaScript bridge copies the draw. Original game renderer inspection finds NiD3DDefaultShader, equal to the renderer's default at +0x898; the observed mesh has zero property-state and shader-extra pointers at +0xc0/+0xc8. Disassembly around 0x5c4270 shows the shader-extra lookup and default fallback; the draw reaches DrawIndexedPrimitive at 0x5c43b7. Shader counters report 12 creations and zero refusals, with zero declaration rejects. These facts locate the investigation before backend pixel shading; they do not prove whether initialization, capability handling, state emulation or original game logic caused the absent terrain attachment. No missing-asset or lighting-root- cause claim is made.

The retained real geometry/state is replayed through actual WebGL 1 and 2 with an independent scalar lighting, projection, depth selection and interpolation calculation. Both sampled points match exactly in both versions: [225,220,249,255] and [191,186,216,255]. replay-frozen.cjs uses the exact retained renderer sources; its four pixel assertions pass. Changing shared lighting or substituting a texture would mask this evidence without addressing the demonstrated default-shader/material selection. The existing all-zero attenuation fixture failure predates this investigation; its suite was not rerun or claimed to pass. A fresh locked tools/build.sh passes, but produces a different module/map and was deliberately not substituted into this replay.

Native St. Kitts Sail away → No matter, cast off! returns to sea with 600 gold and 41 crew. Inspected castoff-settled.png, native-turn-after-trace.png, native-sails-after-trace.png and sailaway-final.png show movement past Nevis to a Port Freedom landing prompt; Enter on “No, sail away” returns to the sailing HUD. White coast persists. Simulation continued during diagnostics, so individual key effects are not isolated; this does not qualify combat, voyage objectives, audio or saves. All 50 recorded inputs are trusted and released. All 1,374 original pins and 472 served responses match; zero specular rejects/page exceptions, 28 HTTP 404s. Own browsers/controllers/ports/profile are closed; no Boat/testbox used.

Next: instrument original terrain construction near 0x4e6bc2 and the 0x4ee360/0x4ec000 binding path, capturing capability results and the mesh property/shader attachment lifecycle. TerrainShader is enabled at runtime; its capability bypass flag is zero. The blocker is the unexplained absence of terrain texturing/shader attachment before draw submission, with a recoverable original sailing route and measured backend behavior, not a tested terrain fix.

Upstream terrain setup and queue boundary (2026-10-31)

A further bounded investigation retains the same original 573e235d… module, 54a33f1054df7c3f map and frozen host in a new run, scratch/runs/20261031T0258Z-pirates-attachment/. White coastal terrain is again visible at Barbados in attempt2/sea.png (600 gold, 41 crew). No game flags, assets or production emulator code were changed. No terrain repair is established; the previous independent pixel replay was deliberately not repeated.

The successful startup capture has 179 guest breakpoint records in capture/complete-records.json: five setup observations followed by 58 tiles at each of three boundaries. 0x4e6b51 returns true from the Landscape.ini helper. After capability helper 0x5002f0, 0x4e6bc7 has version results 11 / 14, meaning VS 1.1 / PS 1.4. Disassembly reads the versions from GetDeviceCaps offsets 0xc4 / 0xcc. The force-disable flag 0x8cad10 is zero and the TerrainShader flag at 0x7263b8 is enabled. Setup proceeds to stage 2 and selects the factory whose vtable is 0x70fe58, retained at tile +0xa8. This excludes an early zero-capability rejection in this captured initialization; it does not qualify the full caps structure or shader execution.

The two suggested attachment addresses have more limited roles:

Tile +4 is initially a NiNode, not the measured NiGeometry draw mesh; its +0xc0 / +0xc8 fields cannot be interpreted using the geometry layout. The unresolved causal boundary is now between successful factory/texture collection initialization and the eventual geometry property/shader attachment (or its later removal). The prior actual coastal geometry still supplies the opposite end of that boundary: null property/shader-extra and default shader. Static next targets are the selected factory's first virtual method 0x4edac0 (allocates and calls 0x51ccf0) and deferred terrain-manager processing through 0x515cb0, including queue consumption at 0x5161b0 and its virtual call at 0x516268. Correlate their generated child geometry with the coastal draw before assigning a caps, synchronization or shader defect.

A diagnostic obstacle was reproduced separately: the retained WASM debugger can skip the first arrival after changing a breakpoint. The focused regression fails on that module (retained-debugger-regression.log); it is not a terrain root-cause finding. The final run-local tracer consumes the old breakpoint's resume step before retargeting and handles successive breakpoint halts in a loop. Earlier failed or missed captures are retained as such. The complete JSON export is authoritative; Python readers of JSONL must split on literal newline, since sampled guest strings can contain Unicode line separators.

Diagnosis/runtime ended within the 25-minute limit. Evidence checks cover the 179 records, all original input pins, all served response hashes, and cleanup. All six own browser/controller executions and profiles are closed; no Boat or assigned test box was used (ID/state/expiry N/A). Recovery instructions and limits are in the new run's recovery.txt; no before/after repair or new build pass is claimed for this documentation-only change.

Deferred output correlated with coastal draw meshes (2026-10-31)

Run scratch/runs/20261031T0318Z-pirates-deferred/ advances the deferred boundary without changing production code, original assets, flags or shader selection. The original white coast was inspected first at St. Kitts/Nevis (capture/sea.png), then at Port Royale (retry/original-coast.png, 600 gold, 41 crew). No backend reference test was repeated and no repair is claimed.

The first execution observes factory 0x4edac0 returning through 0x512ba7 on thread 5 with work object 0x09de1f00, vtable 0x70fdd4. Its later live snapshot has ten references at +0x8c, its own NiNode at +8 (0x09de1b70), and child 0x09de2de0. Tile +4 is a different node. This execution's queue breakpoint did not fire; that limited observation does not establish that queue processing was skipped. The page subsequently crashed after installing a draw observer, leaving no usable draw export from this execution; cause is unestablished (capture/crash.jsonl).

The retry supplies 97 breakpoint records: factory entry/return plus 19 complete generator cycles at 0x4efcf0, 0x4efe5c, 0x4eff53, 0x4eff5b and 0x51ceae. Eighteen geometry returns are non-null; one is null. At 0x4efe5c, EAX is the geometry factory's output. At 0x4eff53, the geometry in EBP has become a child of work +8, after the node's virtual +0x70 call at 0x4eff1d. Virtual work +0x38 (0x4efcc0) then inserts it into the cache through 0x524e90; this is not itself a direct shader setter. The generator returns through 0x51ceae to work setup. The first work object remains the tracer's factoryOutput/node snapshot across later cycles; use each cycle's ECX/ESI and returned EAX/EBP for other work objects.

Crucially, ten distinct non-null generated geometry pointers match actual coastal draw submissions in retry/mesh-evidence.json (11 observations, plus one unmatched ship mesh). Examples are 0x09e896c0 / 4334 triangles, 0x09e8e010 / 5358 and 0x09e87280 / 7606, all FVF 0x112. The pointer correlation closes the factory-to-draw identity gap for these meshes. The first generated geometry 0x09e849c0 already has four property-list entries at factory return, with +0xc0 and +0xc8 zero; those fields stay zero through node attachment, cache insertion and generator return.

retry/properties.json walks each observed draw mesh's actual property list and resolves property RTTI through its guest vtable. The ten generated draw meshes carry NiAlphaProperty, NiRendererSpecificProperty, NiTexturingProperty and NiVertexColorProperty. The renderer-specific property has non-null data at +0x20; the texturing property has non-null storage at +0x2c and +0x44. These are attachment observations, not proof that their internal maps or textures are valid. The draw shader's RTTI is NiD3DDefaultShader, and all observed generated draw meshes still have zero +0xc8. Thus absence of the geometry's property list is excluded for these draws. The newly bounded unresolved transition is consumption of the attached renderer-specific/texturing properties into effective shader state and the shader-extra path used by 0x5c4270. Trace that transition and its input payload before changing capability flags, substituting shaders or asserting an emulator cause.

Diagnosis/runtime stopped at 03:38 UTC, within the 25-minute bound. The retained module remains 573e235d… with its matching frozen host. Recovery, all static excerpts, original/served hash verification and local lifecycle checks are retained in the run directory. Both owned browsers, profiles, controllers and servers are closed; no Boat or assigned test box was used (ID/state/expiry N/A). This documentation-only result has no new production build or before/after repair claim.

2026-10-31 effective-property boundary (03:41Z, no fix)

Evidence: scratch/runs/20261031T0341Z-pirates-effective/. This bounded follow-up reuses the retained 573e235d… module and its 140 matching frozen host files; source identity remains unknown. It does not repeat capability, backend or factory discovery. No production code or original assets changed.

Static original-EXE tracing narrows the boundary:

The live boundary remains unobserved in this run: three owned Chrome pages crashed during native progression. The retry reached a rendered tavern (retry/no-quit.png) and crashed before any diagnostic helper was installed; the final attempt stopped at the Play menu while loading openpc.wav. The generic page-crash events do not establish a runtime cause. The prior run's original Port Royale white-coast screenshot was personally inspected; there is no new gameplay coast capture or before/after repair claim.

recovery.txt preserves static excerpts, replay drivers and the unexecuted final/boundary-trace.js. Next, recover native coast progression and capture 0x5c429e, 0x5c42c2 and 0x5c4375: compare attached renderer-specific and texturing pointers with effective property-state slots +0x18 and +0x28, retain payload wrapper/object words, and trace map consumption. Record the prepass return before assuming later breakpoints are reachable. No shader substitution is justified by the current evidence.

verify.py passed all 1,374 original input hashes, 140 frozen mappings, 876 served responses and all three loaded-module hashes. All owned browser PIDs, profiles, controllers and static/control/CDP ports are closed; no Boat or test box was used (ID/state/expiry N/A). Disk remained above 2 GB. This is documentation-only; no new production build or focused code-test claim.

2026-10-31 known-source crash/boundary investigation (04:55Z)

Evidence: scratch/runs/20261031T0458Z-pirates-knownsource/. The prior 573e235d… module's retained locked build log proves a successful build and map 54a33f1054df7c3f, but its HEAD/renderer-patch metadata does not enumerate all compiled inputs amid concurrent edits. The earlier recovery claim of a reproducible revision is therefore insufficient to establish complete source identity. This investigation uses the explicitly recoverable fallback: module SHA-256 8459597c8d66e098d727fb4ab53e1cf46332241dc7eef2e158f3c475a78b1676 with all 292 exact matching files from 20261031T0403Z-revolt-backbuffer/source-after/, copied into this run and individually verified. The source manifest SHA-256 is 9dee97b3f74481ba14d6808ecce1d4b665099d8b03c58235e0b02812b234e379. The retained successful build-after.log supplies build provenance; there is no claim that current HEAD compiled this module. All 1,374 original Pirates input hashes passed before launch. Host source requests are confined to the saved source tree, with separately frozen supporting fonts/icons.

The prepared observer distinguishes geometry +0xb4 property state from +0xb8 effect state, records renderer +0x14 and raw property slots +0x18/+0x28, and retains wrapper/object/map words. It records prepass EAX at 0x5c42c2 before selecting a later breakpoint; a nonzero return skips 0x5c4375. A synthetic helper smoke test passes zero/nonzero return paths, bounded stopping and original-instance restoration; this is not live guest evidence. The corrected observer caps each thread at four complete meshes, 240 hits or 30 seconds. Original-EXE excerpts additionally identify object +0x10 as entry count and +0x14 as 0x18-byte entry storage at 0x5c9680; 0x5c96f0 copies separately indexed size/data pairs and 0x5c9560 retrieves them. These raw structures do not establish shader identity or valid texture consumption.

Live result: one browser followed the native Main Menu → bartender → English captain → System Options → sailing route. native-coast.png was personally inspected before helper installation: ship/HUD near St. Kitts and Nevis, 600 gold, 41 crew, white coast. Natural simulation subsequently docked at Nevis; native Sail away / No matter, cast off selections returned to sea. native-turn.png shows changed ship/coast placement after an 800 ms Right input plus elapsed simulation. final-sailing.png shows the ship offshore. This is native sailing progress, not a repair, voyage, combat, save, audio or complete rendering qualification.

third-boundary-export.json contains 12 identity-checked records: four complete same-mesh sequences at 0x5c429e, 0x5c42c2 and 0x5c4375. All four prepasses return EAX zero. At all three boundaries, geometry +0xb4 equals renderer +0x10; slots +0x18 and +0x28 equal the actual attached NiRendererSpecificProperty and NiTexturingProperty pointers. The effect-state pointers are captured separately. All four select NiD3DDefaultShader and have geometry +0xc8 zero. Therefore the attached properties are not lost between attachment and these effective-state boundaries in these samples. Null shader-extra does not establish a missing property.

Three sampled mesh pointers also match actual large indexed draw submissions in consumption-export.json: 0x09f179b0 / 1,392 triangles, 0x09f15160 / 4,784, and 0x09f14c60 / 5,338, all FVF 0x112. The fourth boundary mesh lacks that draw correlation in the bounded capture. Payload wrapper +4 objects have two or three entries with retained size/data pairs, including 2,880-, 12,128- and 40,048-byte buffers. No shader identity is inferred from those buffers.

The ordinary seven map pointers at texturing-property +0x2c are zero in all four boundary samples. The first seven sampled slots of the separate array at +0x44 contain five non-null entries; map-arrays.json preserves its actual data-pointer indirection and raw descriptor words. This is a bounded prefix, not the total array occupancy: its retained headers have ends 9, 7, 11 and 11. This does not prove valid texture contents. consumption-final-export.json supplies two same-mesh consumer records for 0x09f179b0: default setup 0x5d458a receives the matching property state, and 0x5d4600 has UV count one while the ordinary map slots remain zero. The attempted later map-load breakpoint and subsequent capped probe supply no records; actual downstream map loading/consumption remains unverified. The next causal work is why this geometry has empty ordinary maps plus populated separate maps while using the default shader, and which consumer is intended to use those separate maps. No renderer repair or shader substitution is justified.

The first observer sequence is explicitly rejected for cross-boundary comparison: its later EBP values belonged to different meshes because the helper cleared the breakpoint before its one-block advance. The corrected helper keeps that advance guarded, verifies mesh/renderer identity and restores all instances/breakpoints on completion. A second installation while in town found no matching meshes; that is not evidence of missing properties. All attempts and limits are preserved in RECOVERY.md.

Crash sweep: Chrome stderr, page/worker events, CDP target/Inspector crash events and 142 cheap process/memory samples cover the browser lifetime, including a sample before launch. No page/CDP crash or page exception was recorded; browser exit is zero. Peak sampled renderer RSS was 2,735,096 KiB; summed RSS includes shared pages and is not unique memory. Cgroup memory counters were unavailable. There is no new crash diagnostic, no established cause for the earlier crashes, and no helper/OOM attribution. The controller tool reported 143 after completed cleanup; its cause is unknown.

The runtime guard first refused to launch when UT2004's orphaned Chrome remained alive despite its free lock; that browser was left to its owner. Pirates launched only after the owner closed it and the process guard found no conflict. Full-lifetime locking then covered the single Pirates browser. Original inputs, exact source/module, all 467 served responses, 22 trusted input events, helper syntax/control-flow and sequence identities pass the retained checks. All owned browser/child/crashpad/controller/lock-holder/ watcher PIDs are absent, three ports closed, profile removed. No Boat or assigned box was used (ID/state/expiry N/A); delegated local shutdown is complete. This docs-only change has no new production build or code-fix claim. The investigation and cleanup finished within the 30-minute bound.

2026-10-31 separate-map writer/consumer contract (05:20Z)

Evidence: scratch/runs/20261031T0520Z-pirates-maps/, including RECOVERY.md, original-EXE disassembly, writer-export.json, consumer-export.json, identity-export.json, draws-export.json and causal-validation.json. This bounded follow-up establishes the original writer and the encoded separate-map reader, with four matching generated mesh/property pairs at the default setup boundary. It does not establish the production source cause of white coast or a repair.

The run retains the exact 8459597c… module, all 292 matching source files, manifest 9dee97b3…, historical successful build log and 1,374 original input pins described above. Original EXE SHA-256 is 6e88b90e4e2e30248d9e4de747b521cc03822b7ffeb214fd272b8ad1817447c9. No current host source was served with the old module.

The original application mesh builder at 0x51c490 constructs and attaches NiTexturingProperty (0x51c894–0x51c927), then walks map definitions. At 0x51cb19 it constructs a descriptor using the source texture reference; 0x51cb27 stores the low-byte index at descriptor +0x1c. 0x51cb35 calls 0x542cb0 with ECX = destination property and arguments index/descriptor. That setter lazily creates the separate array and stores it at property +0x44 (0x542ce9); it does not populate ordinary +0x2c slots. Array +4 is data, +8 capacity, +0xc end and +0x10 non-null count; original 0x5606f0 explicitly maintains those fields. The stream reader at 0x542d70 also loads ordinary and separate arrays independently; its separate-array allocation/store is 0x54300e / 0x5430e7. Thus zero ordinary slots alongside populated separate slots can result from an explicit original writer; it is not proof of lost property attachment.

The original consumer contract is equally explicit. 0x5cb4b0 masks its stage object's encoded map reference with 0x0f000000. Kind 0x02000000 (0x5cb59f) selects property +0x44 (0x5cb5aa), bounds the low 16-bit index by array end, and calls getter 0x4b1230 at 0x5cb5be. The getter follows array +4 to that indexed descriptor. Descriptor +4 is then passed through the renderer texture-resource resolver (0x5cb620) and the result to the stage-binding virtual call (0x5cb631). Caller 0x5bef00 walks pass stages, obtains texturing property from effective state +0x28 at 0x5bef2e, and calls through 0x5cb790 to this consumer. A second encoded-kind reader at 0x5e3d90 uses the same getter at 0x5e3e67. This establishes an original separate-map consumption interface, not the identity of the shader/pass intended for these particular coastal meshes, valid texture pixels, or successful live binding through that interface.

Before the native probe, the diagnostic boundary error was isolated using only the retained module and copied original instructions 0x5d4600–0x5d465d. block-smoke.cjs passes with chaining on and off: branch target 0x5d465c positively halts after ordinary-map loads; interior instruction 0x5d462a does not halt. The pinned debugger checks EIP at decoded-block entry (source-after/src/13-exports.wat, run-loop breakpoint check); its set_bp does not reset bp_skip_once. The observer therefore retains the old breakpoint during run(1) before retargeting and records the owning instance/thread plus mesh, property, ESP and shader pointer. The synthetic observer test verifies bounded capture, guarded advance and restoration; these tests are not live gameplay evidence.

One browser, acquired only after UT2004's owner closed its browser and the process guard found no conflicts, followed native menu/bartender/crew/ English-captain inputs into sailing. system.png and native-coast.png were personally inspected: ship/HUD near St. Kitts and Nevis, 600 gold, 41 crew, white coast. The writer observer captured 545 post-call records at 0x51cb3a, on cooperative thread 5. Every stored descriptor equals the argument retained in ESI. Four mesh/property pairs match later default setup on the main instance:

Mesh Property Separate end / populated Matching large draw
0x09de7f20 0x09de7d70 9 / 7 1,392 triangles, FVF 0x112
0x09de6e80 0x09de6cc0 7 / 5 Not in bounded draw sample
0x09de5730 0x09de5520 11 / 9 4,784 triangles, FVF 0x112
0x09de5f20 0x09de5d80 7 / 5 Not in bounded draw sample

For each pair, writer index/descriptor records exactly reproduce every populated separate slot at the consumer boundary. All ordinary slots are zero. Each has a complete same-instance, same-mesh/property/ESP/shader sequence at 0x5d458a, 0x5d4600 and 0x5d465c. Effective property state equals geometry +0xb4, its texturing pointer equals the actual attached property, UV count is one, and the positive final branch has zero ordinary-map registers and saved map locals. Shader RTTI independently reads NiD3DDefaultShader (0x083f6cd0); geometry +0xc8 is zero. This proves that the sampled default setup reads the empty ordinary map namespace. It does not prove that every subsequent render stage ignores separate maps. No absent breakpoint event is used to assert skipped guest execution. The previous five-entry observation was only a seven-slot prefix; this capture reads each full bounded array end.

Remaining dependency: identify the original pass/stage selection or construction that should produce 0x02000000 | index references for these same generated meshes, and establish its relationship to shader selection at 0x5c4270. Its relationship to the attached renderer-specific payload is unproved. Neither the payload's shader identity nor the need to install it at geometry +0xc8 follows from these records. No production fix, shader substitution, asset/guest-state/clock/startup change is justified.

The probe stopped after those correlations. Natural simulation docked at Nevis before final-coast.png (personally inspected; a town menu, despite the filename). All observer instances/breakpoints and the bounded draw hook were restored before quit. Browser exit zero and all owned browser, controller, lock-holder and crashpad PIDs/ports/profile are verified closed; no Boat was used (ID/state/expiry N/A). Cheap stderr/process/crash diagnostics are retained; no crash was reproduced and no OOM/helper cause is assigned. Exact source/module, originals, served responses, trusted released inputs, helper tests, instruction checks, four correlations and scoped evidence references pass. This is a documentation-only result with no new production build claim; the retained build log is historical provenance. Investigation, cleanup and publication finished within the 35-minute bound.

Coastal terrain selection and serialized stages (2026-10-31, 05:35 run)

The next dependency is now localized before pass construction: the original application requests TTerrain_*B_UC for generated coastal meshes, but the shader factory returns null. The renderer consequently selects NiD3DDefaultShader. This establishes the requested shader family and the immediate fallback cause; it does not establish the underlying source defect. Evidence and runnable checks are in scratch/runs/20261031T0535Z-pirates-selection/RECOVERY.md.

Original-EXE selection chain (all addresses are guest VAs):

  1. Coastal cell rebuild 0x51cf40 calls its generator's virtual slot zero at 0x51d073. Constructor 0x51c440 installs table 0x71289c, whose entry is the already-proved mesh/property builder 0x51c490. The returned mesh remains in EBP. After attaching it, rebuild obtains its texturing property, reads separate-array property+0x44, and loads the array's populated count at +0x10 (0x51d154). At 0x51d161 it passes that count and the same mesh to manager 0x8cad50 virtual slot zero.
  2. Manager table 0x710328 resolves this call to 0x4f0130 and its name selector at slot +0x18 to 0x4efc50. That selector formats TTerrain_%dB_UC when manager byte +0x10c is nonzero, otherwise TTerrain_%dB. Constructor 0x4f0230 derives that byte from bit zero of a device-query result (not; and 1). This static bit operation does not establish a capability-reporting defect. The measured requests positively establish the UC branch for this run.
  3. 0x4f0130 calls 0x547730(mesh, name, 0), which delegates to factory virtual slot +8, 0x5be060. This calls factory slot +0x10, 0x5bd720, with name, implementation and report-failure flag. At the decoded-block continuation 0x5be077, EAX is the selected shader. Null takes the error return without writing geometry +0xc8. A nonnull result proceeds through shader geometry setup at 0x5be0bd and is installed at 0x5be0f6; even a false setup result logs and continues to installation. Thus null lookup and failed geometry setup are distinct cases.
  4. Renderer 0x5c4270 reads geometry +0xc8 at 0x5c427e, casts it to the expected shader type, and on null loads renderer +0x898 at 0x5c4298. The setup/cache path at 0x5c4080 makes the same choice. Empty +0xc8 therefore explains the observed default shader without deriving a shader identity from the renderer-specific property payload.

The encoded stage references already exist in the original binary shader assets. Original pass stage reader 0x5ed660 reads a count, allocates stage descriptions, and invokes 0x5eeff0 at 0x5ed6f4. The latter reads a string, a uint32 into description +4, then the serialized encoded map uint32 into description +8 at 0x5ef023, followed by two optional state groups and the transform fields. During pass construction, 0x5ed955 calls 0x5eef20 -> 0x5f0740; 0x5f074e..0x5f0751 copies description +8 to runtime stage +8. 0x5ed962 -> 0x5bf1f0 installs the stage at the loop's pass slot. This connects to the accepted 0x5cb4b0 -> 0x4b1230 separate-map consumer. It is not necessary to infer a new OR operation in this binary-pass branch.

A targeted decoder follows those original readers through complete stage records, including state groups and transforms. It validates these stage arrays in the unchanged Assets/Shaders/FX/TerrainShader/*.NSB files:

Requested asset Array starts (file offsets) Encoded base-map references
TTerrain_5B_UC.NSB 0xbd0, count 3 0x02000004..0x02000006
TTerrain_7B_UC.NSB 0xc44, count 4; 0x109a, count 1 0x02000004..0x02000008
TTerrain_9B_UC.NSB 0xc98, count 4; 0x10ee, count 3 0x02000004..0x0200000a

The original terrain_11_uncompressed.nsf agrees: texture attributes TerrainTextureBase0 onward use indices 4 onward. For 7B and 9B, TerrainSinglePass uses the first four base textures and TerrainDoublePass uses the remaining one or three; 5B uses three in TerrainSinglePass. These are original definitions associated with the requested names, not observed runtime terrain passes: creation failed before a shader was returned. No claim is made about every later default stage or about separate slots 0/1 from this targeted base-stage decode.

One bounded native probe, after the prior browser owner released the lock, tested whether factory lookup actually returned a shader for these meshes. It used exact module 8459597c8d66e098d727fb4ab53e1cf46332241dc7eef2e158f3c475a78b1676 and its retained 292-file source snapshot (manifest 9dee97b3f74481ba14d6808ecce1d4b665099d8b03c58235e0b02812b234e379). Served-source hashes and actual WebGLBackend identity are retained; execution used the main/cooperative instances, with guest worker disabled. The observer paired positive entries at 0x5be060 and 0x5be077, checking owning instance, stack displacement, saved mesh and name pointer. A synthetic test of the original first block validated both chaining modes. No writer capture or old interior-breakpoint observer was repeated.

All 66 captured TTerrain_*B_UC lookups returned null (implementation 0); 104 other shader lookups returned nonnull results. Nine distinct terrain meshes match 21 later large draws by mesh and identical property, separate-array header and complete descriptor list. All have empty ordinary slots, null geometry +0xc8, and independently read RTTI NiD3DDefaultShader (0x083f6cd0). Representative positive pairs:

Mesh / property Requested name Separate populated Later draw
0x09e10410 / 0x09e101e0 TTerrain_7B_UC 7 1,392 triangles, FVF 0x112
0x09e0fb70 / 0x09e0f960 TTerrain_9B_UC 9 4,784 triangles, FVF 0x112

These are fresh run identities, not assertions that addresses match the prior capture. sailing.png was personally inspected: ship/HUD by St. Kitts and St. Eustatius, 600 gold, 41 crew, white coast. native-coast.png shows system options and is not sailing evidence.

Remaining dependency: determine why 0x5bd720 cannot return the requested UC terrain shader. Its static path checks the renderer/name, queries the shader cache at virtual +0x18, then enumerates libraries at +0x34/+0x38 and calls library +4 with renderer/name/implementation. The captured null return does not distinguish registration, library lookup, requirements rejection or shader creation/compilation failure. Trace that factory/library decision next, retaining same-mesh identity; do not infer a source cause from missing events or substitute another shader.

The 15 original instruction checks, complete targeted stage decodes, nine correlations and a deliberately corrupted selected-pointer negative control pass. All 1,374 original inputs and 292 saved source files match before/after, including the served module and responses. All six observer instances and draw hooks were restored. Browser exit zero; owned browser, controller, holder, watcher and crashpad PIDs, three ports and profile are verified closed. Cheap stderr/process/target diagnostics remain in the run; no crash or OOM cause is assigned. No Boat was allocated (ID/state/expiry N/A). This is documentation only, with no production changes or new build claim; no source fix is justified by the current evidence.

Original shader factory/library trace (2026-10-31 07:37 UTC)

Evidence: scratch/runs/20261031T0737Z-pirates-factory/, with recovery instructions in RECOVERY.md. Static analysis precedes the single native probe. This run references the retained 8459597c8d66e098d727fb4ab53e1cf46332241dc7eef2e158f3c475a78b1676 module and its matching 292-file source/compiler and frozen support closure from 20261031T0535Z-pirates-selection; it does not combine that module with current host files. No production source is changed.

The original EXE installs factory vtable 0x6c70d0 in constructor 0x5be670. Its library registry is factory +0x20, iterator +0x1c; registration virtual +0x24 is 0x5be470, first/next library virtuals +0x34/+0x38 are 0x5be570/0x5be5f0. The registration callback 0x500460, installed at 0x5004ef, routes NSBShaderLib to 0x5e7c90 and NiD3DXEffectShaderLib to 0x5e0220. Loader 0x5478d0 registers its nonnull callback output through factory virtual +0x24.

0x5e7c90 creates the NSB library through 0x5e8050, installing vtable 0x6c9a58. Library virtual +4 is 0x5e7eb0: exact name search 0x5e7e20, then 0x5e9fb0(renderer, implementation) on the matched binary shader. That function checks the requested implementation at 0x5e9ff7 -> 0x5e8a70, tries suitable alternatives through 0x5e9bf0, then constructs and sets up the binary shader. Requirements failure and later setup/compilation/API failure remain distinct. Original NSB header names and hashes for all nine TTerrain_2B_UC through TTerrain_10B_UC files are retained in original-terrain-names.json; no stage decode was repeated.

The NSF references 16 distinct VS/PS program filenames; all 16 original files exist under Assets/Shaders/FX/DX9 and their hashes are retained in nsf-program-files.json. This establishes disk presence, not successful runtime resolution or compilation. The 15 original instruction checks and factory/NSB vtable checks pass (static-check.py).

Outcome: incomplete; no causal rejection or missing original dependency established. The one guest probe ran from 08:01:31 to 08:06:08 UTC with default guestWorker enabled (five guest workers), explicit WebGL and a stable 1024×768 viewport. Native Enter, Escape, Space and mouse input left it at the title screen. The host slice setting was raised from 5k to 50k; this changed the run budget, not guest state or clock. The five observers captured zero factory calls, including zero skipped names. Clearing their breakpoints during startup did not advance the title; all hooks were then restored, and a final unhooked Enter/wait also remained at the title. unhooked-title-final.png was personally inspected. The main worker was still retiring blocks (50,000 in the final unhooked snapshot); this is not proof of a shader or thread source cause.

Consequently, the selected runtime library/vtable and same-call terrain name/requirements/API result remain unproved. The static NSB registration chain above is not a runtime selection claim. check-evidence.py correctly rejects the empty call trace; check-outcome.py verifies the static findings, executor identity, restored observers, retained inputs and explicitly false causal-discrimination result. It also rejects an unrestored-observer negative control. No library null is labelled a source fix.

The accepted prior run's sailing.png was personally inspected: actual ship/HUD, St. Kitts/St. Eustatius, 600 gold, 41 crew and white coast. Its Threads box is unchecked. That is retained cooperative-run evidence, not a fresh sailing frame from this default-worker probe. No property writer, NSB stage decode or default-shader draw capture was repeated.

A preceding browser startup failed before loading any page/guest or installing a probe: the harness compared a resolved frozen-source path against its symlink alias and returned HTTP 500. Correcting that harness allow check enabled the sole guest probe; failed-startup/ preserves the failure and cleanup separately. Both browser exits were zero.

Before/after checks pass for all 1,374 originals and 292 exact saved source files including compiler sources. All 374 served responses and 106 source URLs, plus the loaded module, match the frozen closure. All 18 recorded inputs were trusted and no keys remain held. cleanup-check.py verifies all observed owned processes absent, HTTP/CDP/control ports 42137/36491/41127 closed and profile removed; failed startup ports 36693/40615 and its profile/processes are also closed/absent. No Boat was allocated (ID/state/expiry N/A). Documentation only; no production change, new build, shader substitution or source-fix claim. Work stops here without a successor; the requested causal result remains blocked by failure to reach a factory call in the required default-worker execution.

Default Worker title/startup boundary (2026-10-31 08:17 UTC)

Evidence: scratch/runs/20261031T0817Z-pirates-worker-title/; replay instructions and scope are in its RECOVERY.md. The comparison uses the same retained 8459597c8d66e098d727fb4ab53e1cf46332241dc7eef2e158f3c475a78b1676 module, 9dee97b3f74481ba14d6808ecce1d4b665099d8b03c58235e0b02812b234e379 292-file source/compiler manifest and 40 frozen support files as both prior runs. At initial comparison, seven current scheduling, loader and input files also matched those retained sources. The accepted sailing route has Threads unchecked; the factory run has default guestWorker enabled. Sailing remains historical cooperative evidence, separately inspected from the title screenshots.

The prior factory console contains two concrete startup errors: Workers 6 and 7 fail initGuestThread because DLL module 0xaf1000 does not complete reason 2 (DLL_THREAD_ATTACH). The main-thread samples are inside original 0x5516a0 and 0x5007e0, called by 0x4baaa0. That original function loops while resource-object field +0x50 is nonzero, waiting on the job manager at 0x8ca4e0 and pumping its queue at 0x8ca4c8/current job at 0x8ca4cc. Manager creation at 0x5515a0 starts a suspended CRT thread, stores its handle at +0x1ac, then resumes it; manager state is +0x198. static-check.py pins eleven original instruction sites and eight source contracts. These establish a resource-job wait, but alone do not establish that either failed Worker owns the required job.

The source scheduling distinction is specific. guest-worker.js awaits notifyDllThreadAsync before posting threadReady, including for a thread created suspended. The asynchronous loader's noncooperative callback runner stops on a blocking halt, restores the caller's frame and rejects incomplete notification. ThreadManager._spawnOnePendingWorker then records the failed thread as exited; _spawnPendingWorkersPass removes its pending entry. Cooperative scheduling skips suspended threads before notification and uses beginDllThreadNotification to retain the callback frame and scheduler continuation between turns. This static distinction motivates the bounded read-only trace below; static comparison alone does not justify a source fix.

The sole fresh default-Worker guest ran 08:43:46–08:46:17 UTC after the foreign MedicalRoom lane was released. An earlier process-gate rejection started no Pirates browser or guest. The full lifetime used the browser lock and an actual process gate. Source responses, module and originals stayed on the retained closure; explicit WebGL, 1024×768 and the shipped 5k slice were unchanged. The page observer adds one host roundtrip before each thread-init command; callback observations wrap the supplied run without changing its budget, owning instance, registers or guest memory. No breakpoint, factory, shader or property probe was installed.

Causal scheduling failure reproduced. Workers 6 and 7 enter original MSVCR71.dll at load address 0xaf1000, then park during reason-2 attach: halt=4, yield=9, critical section guest 0xb3c190 (WASM 0x74e190), owner main thread 1. Their stack retains the EnterCriticalSection return and argument. The loader restores the caller and rejects notification immediately. The same section is subsequently free, so the failed attach was a temporary wait, not evidence of an unreleasable original dependency.

Worker 7's CRT parameter names game entrypoint 0x551550, argument/job manager 0x83f3e40, handle 0xe1007, state 1 and filename fx_ship_bowfroth.nif. At that failure the manager and current-job pointer 0x9704a10 match the main Worker. Later snapshots retain that current job, with the thread exited code 1 and manager state 0; main executes 0x4baaa3 with resource 0x8dd640 field +0x50 still nonzero. The manager's name buffer later contains bullet_down.nif; that later string must not be substituted for the filename captured at attach failure. Original 0x551550 calls the load virtual then completion virtual +0x1c (0x500730); dropping the thread before its entrypoint prevents that completion path. 0x5007e0 will not dequeue another job while the current-job pointer remains set.

A single targeted native Enter has trusted down/up events. Before and after, takeInput has zero calls and its key/character/release messages remain in the renderer queue. This is a pre-input resource-job stall. Both fresh title screenshots were personally inspected, with five Workers enabled. Worker 6 was pending suspended at observation; Worker 7 had already been resumed. Consequently merely deferring suspended creation is insufficient to address the observed second failure.

The source repair adds an asynchronous blocking-wait continuation to DLL thread notification. The owning Worker recognizes the live CS argument, waits without executing guest code until the owner word changes, verifies unchanged EIP/ESP/yield, clears that wait and lets the original guest handler retry acquisition. The callback generator, saved caller, DLL gate and mapping pins remain owned throughout. Unrelated waits and synchronous incomplete callbacks still fail. Workers remain enabled. The two callback-inventory entries retain ownership: pending with an explicit lifetime review; no build validation was removed.

test-worker-dll-critical-section.js exercises the shipped notification path and Worker resolver with deterministic interpreter exports: retained frame, no guest retry while held, asynchronous release, caller restoration, stale frame/argument rejection and unsupported waits. It passes on the repair and rejects the exact retained old loader. The full locked build, 58 Worker scheduler checks, ThreadManager checks and callback-inventory mutation tests pass. An additional native serialization test never started: it waited behind the next foreign browser and its own queued lock was canceled. No pass is claimed for it. check-cause.py passes and rejects three corrupted causal controls (owner, completion and current job).

This proves and fixes the generic callback scheduling failure; patched Pirates startup/sailing is not runtime-verified within the one-probe limit. The retained cooperative sailing frame remains a separate historical result. All 1,374 originals, 292 frozen sources, 374 served responses and 106 source URLs match, including the loaded module. Four native events are trusted, no keys remain held and page/Worker observers are restored. Browser exit zero; all 71 observed owned PIDs are absent, ports 38077/38443/45869 closed and profile removed. No Boat was allocated (ID/state/expiry N/A). Recovery and small replayable evidence remain in the run directory. No successor is started by this worker.

Fresh default Worker replay after 81f47554e (2026-10-31 08:58 UTC)

Startup remains blocked; no fresh sailing or gameplay is claimed. The repair retains the contended DLL callback, but the host prevents its lock owner from running until worker bootstrap finishes. The subsequent bootstrap timeout terminates that callback owner and leaves the DLL callback gate held. This is the first remaining host dependency, before ordinary title input. Evidence and replay checks are in scratch/runs/20261031T0858Z-pirates-patched-default/RECOVERY.md.

Preparation stayed static while Deus durable owned the lane. After its explicit 09:30:57 release, the sole guest ran 09:31:35–09:35:06 under a detached wrapper and monitor holding /tmp/wine-browser.lock for the entire controller/browser/cleanup lifetime. The actual Chrome, crashpad, heavy CLI and live-profile gate was clear. The maximum was 18 minutes; this guest stopped after approximately 3½ minutes once the dependency was established.

This uses the fresh canonical build/wine-assembly.wasm produced by the existing successful 08:50 locked build, SHA-256 d2c1df73d975daa4e7425152fb900274ebd9552c5a689249415084cfe8ac026b (1,898,571 bytes), with current repaired source at 81f47554e. The complete 296-file runtime/compiler snapshot has manifest SHA-256 c12552b31fcdbd6808ae8bd7f1bb35a5ed5315025ce12f8a4711964fdd4f08f3; 40 current support files are separately frozen. The module was served through a hardlink to the canonical artifact; after cleanup, the one 1.9 MB retained image was detached and hash-verified so a later build cannot overwrite it. The loaded response is hash-only, with no second module capture. This does not reuse retained 8459597 with current host files. All 352 served responses and 106 source URLs, including the loaded module, match their frozen bytes; all 1,374 originals match before and after.

Execution uses default guest Workers, explicit WebGL, 1024×768 and the shipped 5k slice. The bridge reports backend/device kind webgl, seven submitted and completed operations and no queue error; GPU class/context-loss fields were unavailable in this worker-backed identity query. The read-only attach observer forwards the unchanged owning exports and run budget, with one page roundtrip before each thread-init command. That adds host timing. No factory, shader, property or breakpoint probe was installed, and no guest, original, clock or INI was changed.

The causal sequence is recorded directly:

  1. Slots 1–5 complete reason-2 DLL notifications. Slot 6 enters original MSVCR71.dll attach and parks at halt=4, yield=9, guest critical section 0xb3c190 / WASM 0x74e190, held by main thread 1. Its live stack retains the original EnterCriticalSection argument and return. The repaired loader preserves this frame instead of rejecting it.
  2. This is pending handle 0xe1006, CREATE_SUSPENDED, suspend count 1. CRT parameter 0x8d4a6c0 names game thread entry 0x4fac80 with argument 0x8d4a760; it is not the prior run's 0x551550 resource-job thread. Main is at original CRT 0xaf3139, immediately after EnterCriticalSection, ESP 0x74ffd54. Two snapshots 10,366 ms apart retain main slice sequence 8980, the same registers, pending child and lock ownership.
  3. The frozen host awaits threadManager.spawnPending() before the next main slice. runWorkerSlices() also awaits pending spawns. The single spawn pass awaits spawnThread(), which awaits initGuestThread(); that command awaits all DLL notifications before sending threadReady. Thus the creator cannot release the CRT lock while the child waits for it.
  4. At 09:32:16.968, 30,003 ms after attach began, the host reports worker 6 did not answer initGuestThread in 30000ms. The failed-bootstrap cleanup drops the worker. Its callback never reports success or failure; the scheduler records handle 0xe1006 exited with code 1 and a stopped link. Slot 6 is absent from the live link inventory.
  5. Main then advances and the CRT lock becomes free. However, two later snapshots retain the shared DLL callback gate at owner 6, depth 2, with generation pins on MSVCR71, binkw32 and OLEAUT32. Main is parked at LoadLibraryA thunk 0x7500180, return 0x614179, requesting d3d9.dll. Original call 0x614173 and the shipped LoadLibraryA handler's callback gate check explain this yield-9 retry. This is an orphaned host callback gate, not evidence that the original DLL or shader asset is missing.

One targeted trusted Enter down/up leaves three renderer messages queued; takeInput remains at zero polls before and after. No additional key sweep was attempted. The resource manager's current-job and queue are empty in later samples, but that does not establish completion of all startup jobs: execution has not reached ordinary input or the later resource-worker boundary. Fresh title screenshots were personally inspected. The 05:35 cooperative sailing screenshot was also inspected and remains historical.

The next generic repair must let the creator and existing threads run while a new thread's attach continuation is blocked, preserving single-flight bootstrap and suspended-thread semantics. Failed bootstrap must also retire the notification's frame, gate and pins before terminating its Worker. Increasing the timeout alone would retain the dependency cycle. No production change or patched-game success is claimed by this documentation-only run.

check-cause.py verifies the sequence and rejects five corrupted controls (creator progress, CRT ownership, callback ownership, live worker inventory and consumed input). Fourteen original instruction checks, seven repair contracts, observer fidelity, module/source/support/original pins, served hashes, trusted released inputs and focused documentation diff checks pass. No new build was necessary. Page wrappers and all surviving Worker observers are restored; slot 6's observer ended with its timed-out Worker. Browser and launcher exit zero. All 41 observed owned PIDs, three ports 37547/46669/44117 and the profile are verified closed/absent. The monitor ended without emergency termination. No Boat was allocated (ID/state/expiry N/A), the lane is released, and this worker starts no successor.

The coordinator identified a monitoring limitation during this run: Chrome's flattened command line defeated the monitor's exact-argv profile matcher. Its empty profilePIDs arrays are not cleanup proof. The original monitor is preserved; the independent process-tree/profile command capture and final PID/port/profile checks establish actual cleanup. The ignored recovery monitor and gate now match the exact bounded profile token in both NUL-separated and flattened commands, and validate PID start time plus command hash before signals. Captured commands from ten owned Chrome processes reproduce the old false negative and pass the corrected matcher; four token-boundary controls and a changed PID-start identity are rejected. A later read-only gate check correctly rejects the new foreign Deus light-exit runtime. No guest was restarted, no foreign process was signaled, and the corrected monitor has not been tested against another live Pirates runtime.

Generic bootstrap creator progress (2026-10-31 09:53 UTC)

The independently safe creator-progress repair starts asynchronous Worker bootstrap without awaiting it in the browser main loop or Worker scheduler. The creating thread and existing runnable Workers retain their ordinary slices while DLL_THREAD_ATTACH waits. Explicit readiness callers can still await spawnPending(). The pass remains single-flight, including synchronous backend reentry and threads appended during an await; unexpected background errors are observed once and delivered at the next scheduler boundary.

Running the creator also permits TerminateThread during pending attach. That request now retains its exit intent without signaling the handle or releasing locks owned by a live callback. Once attach unwinds, the scheduler retargets aliases to the completed record and retires its real Worker link before any user slice. CREATE_SUSPENDED remains effective throughout and after attach.

test-worker-bootstrap-progress.js drives the shipped host loop, ThreadManager, DLL notification generator and Worker critical-section resolver with controlled interpreter exports. Creator-owned and existing-thread-owned locks release, attach completes, both callback gate scopes unwind, and suspended user entry receives no slice until ResumeThread. It also covers multiple pending threads, backend reentry, pending termination through an alias, failed-link stack ownership and background metadata failure. The exact retained old host rejects the creator case and old ThreadManager rejects the existing-thread case, both at the held-lock dependency rather than a missing import or API. Existing scheduler fixtures explicitly await readiness; all 58 assertions are retained. Evidence and commands are in scratch/runs/20261031T0953Z-pirates-bootstrap/RECOVERY.md.

Failed-bootstrap callback retirement remains unresolved. Notifications run outside the scoped-loader transaction registry. WorkerLink.stop only asks for scoped-loader retirement when that registry was used; it has no endpoint-owned notification cancellation/acknowledgment. A safe repair must fence new commands, unwind the actual nested async generators/gate scopes, settle lookup and RPC continuations, and preserve generation quarantine and stack leases before termination. The current notification error path deliberately retains the unfinished image's quarantine pin; blindly decrementing every pin would be unsafe. This change adds no gate reset, callback skipping, guest patch or timeout increase. It fixes the scheduling cycle, without claiming that a separate timeout/error can no longer orphan callback ownership.

The focused causal regression, scheduler, ThreadManager, scoped-loader retirement and callback census/mutation checks pass. An additional test-thread-retired-stack-lease.js check fails in its pre-existing incomplete fixture (_authorityEvents missing at closeSyncHandle); the exact retained old ThreadManager reproduces that same failure. The fixture is unchanged. Native replay outcome will be recorded separately; these source tests do not establish fresh sailing or input progress.

Fresh default Worker replay of 9b1126f01

Fresh native sailing is now observed with default guest Workers enabled. The sole local guest ran 10:02:34–10:10:27 UTC, under eight minutes, after the explicit Deus lane release and a clear actual Chrome/crashpad/heavy-CLI/profile gate. The detached wrapper held /tmp/wine-browser.lock through browser, monitor and cleanup. No second guest or successor was launched.

This uses the newly built canonical module SHA-256 d2c1df73d975daa4e7425152fb900274ebd9552c5a689249415084cfe8ac026b with repaired source commit 9b1126f019dba2005f40773393076f59d4cde3f2. The unchanged WAT produces the same module bytes as the previous canonical build; the host and ThreadManager are the new repair. All 296 frozen source files, 40 support files, 1,374 originals and 2,112 served responses / 106 source URLs match. The complete source manifest SHA-256 is f3890c7f0ec55c6bc9633495f3929400cfcafd9556305c59f9c24a6a3b1d8e3b. The loaded response hash matches the fresh retained module. The prior run's read-only attach observer is retained, including its per-init host roundtrip; it changes timing and does not change guest instructions or callback budgets.

All 135 reason-2 attach notifications complete, including slot 6. No bootstrap timeout or notification failure occurs. Main advances through the resource-job startup, consumes the queued trusted Enter and reaches the main menu. Native navigation continues through Crew Signups, bartender, captain selection, the English captain's welcome, St. Kitts and its Sail away / cast off choices. The final snapshots have no pending spawns, callback gate [0,0] and zero pins on all 14 live DLL lifecycle rows. This demonstrates normal callback completion; it does not test failed-bootstrap retirement.

Personally inspected 19-world.png, 20-turn-left.png and 21-final-sailing.png show the ship and sailing HUD, the St. Kitts/Nevis coast receding, and the date advancing January 9 → January 12, 1660. A trusted Numpad-4/ArrowLeft down/up is consumed as WM_KEYDOWN/UP VK_LEFT. The final snapshot records 93 input polls; all 32 native events are trusted, and no key or mouse button remains held. No quantitative turn-rate, FPS, combat or broader rendering-correctness claim is made. The final bridge reports WebGL device kind, 126,574 submitted / 126,573 completed operations and no queue error; GPU class and context-loss fields remain unavailable through this identity query.

One harness limitation is explicit: a cache-control Puppeteer connection temporarily reset the viewport to 800×600. The original driver still captured 1024×768 screenshots, so those intervening screenshot coordinates were not reliable click coordinates. The mismatch was diagnosed from actual DOM bounds and restored at 10:06:07 with no guest restart. Captain/world navigation and the final identity run at verified 1024×768. Cache clearing/disabling was used to preserve the disk floor; minimum sampled free space was 2,030,845,952 bytes. No guest file, game INI or interpreter clock was changed.

The evidence verifier passes and rejects four corrupted controls: unfinished slot-6 attach, orphan callback gate, retained pin and zero consumed input. The corrected profile matcher detects live flattened/NUL command lines and uses PID-start/command identities, including the referenced crashpad. Browser, controller and wrapper exit zero; all 66 observed owned PIDs are absent, ports 33425/45119/33045 closed, profile absent and the full lock released. The post-cleanup actual-process gate was clear before releasing the lane; no emergency or foreign signals were needed. No Boat was allocated (ID/state/ expiry N/A). Recovery, raw traces, original-source rejection logs and bounded replay commands remain in scratch/runs/20261031T0953Z-pirates-bootstrap/.

Failed-bootstrap notification retirement, 2026-10-31

The remaining notification ownership boundary above now has a generic source repair. This task does not replay Pirates: the accepted native sailing and input evidence remains the preceding 9b1126f01 run. The new evidence is local correctness testing of the failed path, rather than another normal attach.

Each Worker binds its actual exports to an endpoint-owned DLL callback owner. That owner tracks asynchronous gate scopes and callback generators, including nested LoadLibrary initializers whose options do not carry the outer thread notification's wait resolver. A retirement control message validates endpoint identity and bypasses the blocked command queue to fence admission, reject pending DLL lookups and signal cancellation. The critical-section wait checks that signal without executing the guest or clearing the unresolved wait. Retirement then joins the real command queue: nested service calls must return, callback generators close through finally, and their own gate scopes release before the endpoint can produce its receipt. The existing scoped-loader registry is retired as part of that same acknowledgment.

Cancellation produces an incomplete callback outcome, allowing the actual mapping iterator to roll back its transaction. It never reports that DllMain completed. Notification/lookup pins release by their captured generation; failed notification pins remain reachable until endpoint retirement can release them. An unfinished DLL_PROCESS_ATTACH keeps its distinct mapping quarantine pin. Generation cleanup faults refuse acknowledgment, and an unresponsive Worker retains its endpoint, gate, pins, stack and slot for an explicit retry. There is no shared gate reset, blanket pin decrement, guest patch, callback bypass, Worker disabling or timeout increase.

WorkerLink fences new requests and settles pending ordinary requests as soon as retirement starts. It still serves an already inflight synchronous RPC: otherwise that Worker's Atomics.wait could prevent cancellation delivery. Lookup replies carry endpoint identity; stale replies and late bytes cannot publish into a retired endpoint. The Worker reports stack allocation before fallible TLS setup/attach, so failure without threadReady still transfers the stack lease to the host. Existing ThreadManager barriers require acknowledged Worker termination and a successful native stack free before slot reuse. Neither host.js nor ThreadManager needed a source change for this repair.

test/test-worker-bootstrap-retirement.js runs the production Worker queue, loader, LoadLibrary mapping iterator, RPC broker and scheduler retirement over deterministic interpreter exports in actual Node Workers. It covers nested attach cancellation in both a critical-section wait and a second DLL lookup; failure before attach and inside a nested initializer; the actual bootstrap request timer; pending ordinary requests; real inflight synchronous RPC; stale endpoint replies/control and DLL generations; lost acknowledgment; an endpoint unable to service cancellation while blocked in RPC; exactly-once generator unwind; the acknowledgment/Worker-exit gap; a busy native stack lease; cancellation while another endpoint owns the gate; and ordinary successful nested attach with caller registers restored. All owned fixture Workers exit.

The causal retained-source control compiles the exact original WorkerLink at its production filename with real sibling imports. Its older lookup reply envelope receives only the current endpoint-identity field in the test transport, so both variants reach the same genuine nested callback. Original stop/admission/ handshake code is unchanged. It actually terminates the Worker with gate [6,4], provider pins 2 and unfinished mapping pin 1, then fails the orphan-gate assertion. The repaired path has gate [0,0], provider pins 0, mapping pin 1, and a real receipt recording two generators/two unwinds. This rejection is ownership leakage, not a missing import, changed reply schema or absent API.

Bootstrap progress, all 58 scheduler checks, ThreadManager, critical-section notification, scoped-loader retirement, scoped DLL lifecycle, thread-send ownership, browser Worker slice/suspend/input source checks and affected callback census/mutation checks pass. The extra retired-stack fixture still fails before its own assertions because its Object.create fixture omits _authorityEvents. The retained pre-repair ThreadManager reproduces that same failure; the fixture is unchanged. The new regression independently checks the full acknowledged exit/busy-free/retry stack lease path without weakening those old assertions.

Run evidence and reproducible commands are in scratch/runs/20261031T1022Z-pirates-retirement/RECOVERY.md. After the Deus camera worker explicitly released the lane at 10:54:06 UTC, the full build passed at 10:55:16 under the browser lock followed by the build lock. Actual Chrome/crashpad/heavy-process/profile gates were clear before and after; free disk remained above 2 GB. No browser/native replay or Boat allocation is part of this task. Unresponsive endpoints and unfinished initializer images retain their respective quarantines; reclaiming arbitrary guest-owned locks is outside this local correctness repair.

Native terrain factory rejection: stale stream cap (2026-10-31 11:00 UTC)

Evidence and recovery: scratch/runs/20261031T1100Z-pirates-terrain/. The original factory's first rejection is now identified: its NSB shader packing requests four vertex streams, but the renderer copied a reported MaxStreams of one. Original 0x5d74c0 returns null before creating the vertex declaration. This is a capability mismatch with the existing generic sixteen-stream implementation. The source correction advertises sixteen; a fresh native replay of that correction remains outstanding, so white-coast visual acceptance is still PIRATES-TERRAIN-REVIEW.

This was one functioning default guestWorker/WebGL run, not a title-only probe. The fresh canonical build and current runtime/compiler/support snapshot were frozen before launch. Its source includes c6fa4878a retirement and the later f1a3e1333 documentation commit; native module SHA256 remains d2c1df73d975daa4e7425152fb900274ebd9552c5a689249415084cfe8ac026b because that intervening work did not change WAT. It was rebuilt here, not retained from an older module with a current host. Before/after checks cover 296 source/compiler files, 40 support files and all 1,374 originals. All 2,112 served responses and 106 source URLs match those frozen inputs.

The read-only observer followed three calls on actual Worker slot 6 from factory entry 0x5bd720 to saved continuation 0x5be077, validating ESP = entry ESP + 16. Each retired step remained one decoded block; registers, original data and guest clock were unchanged. All three requested implementation zero with report-failure one:

Requested shader Mesh at factory entry Factory result
TTerrain_10B_UC 0x09e92120 null
TTerrain_8B_UC 0x09e93040 null
TTerrain_7B_UC 0x09e91790 null

Each complete same-call trace positively establishes:

  1. Renderer/name validation passes; cache result at 0x5bd76d is null.
  2. Registered NSBShaderLib, vtable 0x6c9a58, is enumerated. Its exact-name lookup returns a nonnull binary shader at 0x5e7eba.
  3. Implementation requirements 0x5e8a70 return one at 0x5e9ffc. Platform/version predicates pass; there is no failed requirement here. Runtime construction proceeds through 0x5ea04e.
  4. Packing conversion 0x5ec050 -> 0x5eede0 calls 0x5d74c0 with renderer 0x01144c84, three packing entries and four streams. The factory loads renderer +0x454; at rejection block 0x5d74d4, EDI is four and EAX is one. Original 0x5d74d2 branches to allocation only when unsigned requested streams are at most that limit.
  5. 0x5eee1b and 0x5ea1f5 positively observe null. The original diagnostic identifies failure to convert the packing definition to NiD3DShaderDeclaration. NSB returns null, then NiD3DXEffectShaderLib also returns null, enumeration ends, and the original factory returns null to its saved caller.

The cap transfer is explicit in original instructions: 0x5c09fb loads renderer +0x700 and 0x5c0a12 stores it at +0x454. The D3DCAPS9 destination starts at renderer +0x644, so +0x700 is caps +0xbc / decimal 188 (MaxStreams). The native saved caps and subsequent read-only renderer snapshot both contain one. Shipped src/09ad-handlers-d3d9.wat still stored one at that offset, although its stream table, declaration validator and draw gathering already handle indices 0–15. This identifies the source of this rejection without inferring shader compilation failure or missing original files.

The production change only updates that generic cap to sixteen. The existing multi-stream test now queries actual device caps and verifies the last advertised stream, index 15, draws exactly the same pixels as the interleaved and stream-1 controls. Its unbound-stream rejection and index-16 rejection remain intact. The existing WebGL pipeline cap expectation is updated to sixteen; that browser test received syntax validation only in this task, which permits one native browser lifetime. No additional native run was made.

Focused causal check caps-causal.cjs compiles the exact frozen old caps source through the canonical compiler: it reports one and rejects the actual four-stream packing predicate. Current source reports sixteen and passes. The multi-stream pixel regression, adapter/device query regression, callback ownership census and census mutation checks pass. Full flock /tmp/wine-build.lock bash tools/build.sh passes while the browser lifetime flock is also held. Fixed-source/module identity is retained in fixed-build-identity.json; this is separate from the pre-fix native inputs. No callback assertions, timeout, worker selection, assets or INI were changed.

Native navigation followed Crew Signups, bartender, English captain, St. Kitts, Sail Away and cast-off into sailing. 18-coast-input.png was personally inspected: ship/HUD near St. Kitts/Nevis, white coast, 600 gold, 41 crew and January 15. Numpad4 trusted down/up reached guest VK_LEFT; all 34 input events are trusted and keys/buttons are released. The later draw sample contains 24 actual 0x5c43b7 draw boundaries, including 11 coastal records with populated separate maps, null shader-extra and NiD3DDefaultShader (examples 1,392 and 4,784 triangles). These later meshes were regenerated: their addresses do not intersect the three initial factory meshes. This is a native coast/default-draw observation in the same execution, not a new same-mesh factory-to-draw correlation. Historical accepted correlations remain separate. 13-native-coast.png is a town menu; 16-sailing.png includes a tutorial popup. Neither is substituted for the inspected final sailing frame.

Timing limitation: factory stepping and the inherited per-init host roundtrip change execution timing. Slot 6 records 2.683 seconds inside the run wrapper, including ordinary guest execution; this is an upper bound, not measured incremental observer overhead. The draw observer was installed twice because its first bounded window saw the town/menu interval and captured no qualifying coast records. Its second window auto-restored after 24 draws. A final duplicate stop logs a spurious changed holder warning in the temporary helper, which lacks an idempotent stop guard. The prior export proves it already stopped with no errors; records are unchanged, all final breakpoints are zero, and every observer is stopped. This diagnostic limitation is preserved and checked.

Runtime was 11:01:25–11:06:32 UTC; normal cleanup completed 11:06:39, with no monitor emergency signals. All observed owned processes, controller/wrapper, monitor and watcher are absent; HTTP/CDP/control ports 33609/33287/42041 are closed and the profile is removed. Actual global Chrome/crashpad/heavy-CLI and profile gates are clear, and the full browser flock is available after serialized build/tests. Full lane release was posted at 11:08:52. No foreign process was signalled. Minimum sampled free disk was 2,068,365,312 bytes; only this run's downloaded Chrome component caches were removed to maintain the 2 GB floor. Browser cache was disabled without reconnecting or changing viewport. No Boat allocated: ID/state/expiry N/A.

verify.py checks identities, all three causal traces, four deliberately rejected trace mutations, native input, later draw limitations, exact originals and cleanup. Next dependency: one separately authorized fresh matched native replay must determine whether the corrected cap lets the original terrain declaration/shader finish, and whether the coast textures render. This task establishes and repairs the first causal rejection; it does not claim that all later original declaration/program/pass paths now succeed.

Cap16 native terrain and textured coast accepted (2026-10-31 11:17 UTC)

Evidence/recovery: scratch/runs/20261031T1117Z-pirates-cap16/RECOVERY.md. The fixed native original terrain factory succeeds, and the coast now renders textured green/rocky land and beaches. This is a fresh default guestWorker, WebGL, 1024×768 session using the cap16 module and current retirement code. No additional production change was needed. The native result advances beyond the earlier static cause/focused regression result.

Reuse was conditional on exact closure, not merely the commit name: all 296 current source/compiler files match the prior canonical full-build snapshot plus its exact committed repaired fragment. The compiler files and build log are pinned in build-reuse-closure.json. The newly frozen current source, 40 support files and all 1,374 originals match before/after. Module SHA256 is 078d81cba6ab755d6a05e5e234a259df9e867ecc8848899705a45739fab0e9a9; the served/loaded module matches. There is no retained old-module/current-host combination. The earlier cap16 full build and pixel regressions are reused, with exact source/compiler identity checked; no additional full build or heavy CLI ran alongside the browser.

The read-only factory observer ran on Worker slot 6 and followed each saved continuation 0x5be077, with return ESP exactly entry ESP + 16 and no step exceeding one decoded block. Its three bounded calls are:

Requested original shader Entry mesh Returned shader Path
TTerrain_8B_UC 0x09de1780 0x09de13a0 NSB construction
TTerrain_9B_UC 0x09de34b0 0x09de4f70 NSB construction
TTerrain_9B_UC 0x09de5cd0 0x09de4f70 Factory cache hit

Both newly constructed calls find the exact original NSB name and pass requirements. Their packing requests still need four streams; actual native D3DCAPS9 +0xbc and renderer +0x454 now contain 16. Neither visits the old reject block 0x5d74d4. Packing conversion returns declarations 0x09de2800 / 0x09de4720, and NSB and the outer terrain factory return nonnull shaders. The third call positively reuses the second result through the factory cache. This run does not separately replay the prior run's TTerrain_10B_UC or TTerrain_7B_UC names.

The later native draw observer records 24 actual 0x5c43b7 boundaries on Worker slot 0, all NiBinaryShader, with shader-extra equal to the selected shader and populated separate material maps. Triangle counts range from 504 to 4,424. One selected shader is 0x09de4f70, the same shader object returned above. Entry meshes and later draw meshes differ, and creation and drawing occur in different Workers. This proves shared shader identity and actual later material selection; it is not same-mesh or same-Worker factory-to-draw correlation.

A separate bounded read-only bridge observer records 48 qualifying submitted commands in that sailing interval. Thirty-one have both original programmed shader stages, textures and successful issue result 1; recorded 512×512 texture pixels include [66,117,8,255] and [55,106,3,255], with nonwhite mip levels. These command records are not assigned mesh IDs from another Worker's registers. Personally inspected screenshots 16-town.png, 23-trusted-turn.png, 25-onward-sailing.png and 28-onward-coast.png show green terrain, rock, beaches and moving ships, rather than accepting camera labels alone. 16-town.png is actually the initial sailing view; its filename is not evidence of a town menu. Screenshot 18-current-coast.png is the actual Antigua town menu.

Native input followed Crew Signups, bartender, English captain, the arrival town, Sail Away, Cast Off and tutorial dismissal. This unchanged run selected Antigua, rather than the earlier St. Kitts starting town; that route variation is preserved, not forced by editing assets/INI/clock. Trusted keypad steering then moved the ship onward, triggered the Montserrat landing-party prompt (25-onward-sailing.png), declined landing, and passed another sailing ship whose native speech names St. Kitts (28-onward-coast.png). That speech is not proof that the player has arrived at St. Kitts. No combat encounter or St. Kitts town arrival is inferred from those frames.

The temporary draw-stop helper is repaired only in this NEW scratch run: repeated stop returns already-stopped without clearing another observer's breakpoint or reporting a changed holder. Actual repeated stops leave every observed breakpoint zero and every draw observer stopped with no errors. Factory instrumentation retains the original three-call/500,000-block cap; per-init read-only host roundtrips and decoded-block stepping change timing. Factory run-wrapper time includes normal guest execution and is not measured incremental overhead. The texture wrapper saw 8,815 command calls, retained only 48 qualifying records, and measured approximately 5 ms of its own snapshot work; it restored itself at its record cap. Remote observer request counts and complete timing are retained with the run's focused checks. No guest registers, shaders, callbacks, timeouts, worker selection, clock, original assets or protected Laptop/Heroes II/fonts were changed.

Observer accounting: 49 total control requests, including 11 Worker-evaluation requests and eight page evaluations, plus 135 init-observer host roundtrips. Slot 6's factory run wrapper totals 3.295 seconds, including normal execution; other armed Workers also include their ordinary run time. The exact per-slot values are in observer-timing.json. No FPS or benchmark was collected.

The sole native lifetime ran 11:19:14–11:26:34 UTC, with cleanup complete 11:26:42. A preliminary background shell failed before creating any controller or browser; the succeeding durable execution session owns the sole native launch. Deadlines were reset immediately before that launch. Deus explicitly posted FULLRELEASE at 11:18:40, and actual global process/profile gates passed before launch. Wrapper, controller and monitor all held the browser-lock FD for their lifetimes. Sixteen observed PID/start identities, including both global crashpads, are absent; HTTP/CDP/control ports 33041/46033/42217 are closed, the profile is removed, and the full flock is available. No cleanup signals or foreign signals were needed. There are no owned watchers or held keys/buttons. All 52 native input events are trusted; the guest input trace receives both steering directions as VK_LEFT/VK_RIGHT down/up.

Focused validation passes for 296 source/compiler files, 40 support files, 1,374 originals, 2,129 served responses / 104 source URLs, both constructed factory results and the cache hit, five rejected evidence mutations, native material/texture draws, input, idempotent observer restoration and complete cleanup. git diff --check passes. Minimum sampled free disk is 2,011,791,360 bytes, above 2 GB. Full lane release was posted at 11:27:14; no further native/heavy CLI work is planned. No Boat allocated: ID/state/expiry N/A. Remaining limits are the differing initial port and shader/mesh names, no St. Kitts arrival/combat acceptance, and no same-mesh factory-to-draw claim; they do not erase the observed fixed-native terrain/coast improvement.

Onward Montserrat landing; disk floor ends town approach (2026-10-31 11:34 UTC)

Evidence/recovery: scratch/runs/20261031T1134Z-pirates-onward/RECOVERY.md. A native landing party and movement ashore are inspected; onward town arrival, Enter/Attack response and combat remain unproven. The first observed dependency ending this attempt is the required free-disk floor, not an identified game/emulator fault. There is no startup-only acceptance.

Before freezing the new run, all 296 current source/compiler files and 40 support files exactly matched the accepted 11:17 closure. The served and loaded module is again SHA256 078d81cba6ab755d6a05e5e234a259df9e867ecc8848899705a45739fab0e9a9. All 1,374 original files match before/after. This fresh default guestWorker, WebGL 1024×768 session has cache disabled and tiny disk caches. No factory, draw, guest-run or thread-init observer is installed. The only input observer forwards the original renderer input poll unchanged. No production, original asset, INI, clock, save-byte or guest-memory changes were made.

Ordinary input follows the English captain to Antigua's initial town menu (16-antigua-approach.png), then Sail Away → “No matter, cast off!” and trusted Numpad4 steering. The visible approach frames 21 and 22 lead to the actual landing-party prompt at Montserrat's northern shore (23). Selecting “Yes, we'll anchor here” and pressing Enter changes the scene to the party at Hangman's Point, with “Press 'r' to return to ship” and native Move Forward/Turn controls (25-ashore.png). Personally inspected 26, 28, 30-town-walk.png and 31-inland-turn.png show the party moving along textured coast toward the visible Montserrat buildings. This is a real ashore transition and subsequent movement; a town label or destination speech alone is not accepted as arrival. The later town interaction was not reached.

The sole browser lifetime is 11:35:35–11:39:41 UTC. Free disk passed the prelaunch gate, sampled at 2,051,796,992 bytes at 11:39:04, then fell to 1,908,424,704 bytes at 11:39:41. The bounded controller/monitor closed the session during the last requested Numpad8 hold. Its requested final screenshot 32-town-approach.png was never produced. No second native session was launched. No original native save/export was reached or claimed.

Cleanup is explicitly qualified: the trusted final input stream includes Numpad8 keyup at 11:39:41.033, and all 58 trusted key/mouse events balance to no held input. held-final.json retains a stale controller Set entry for Numpad8 because the interrupted request's timer had not finished; that Set is not accepted as the input state. Browser exit is 0 at 11:39:41.451, the input observer was restored, all 16 unique observed PID/start identities including both global crashpads are absent, the profile and HTTP/CDP/control ports 35767/38981/45679 are gone, and the full browser flock is released. The owned monitor sent one PID/start-qualified SIGTERM to its still-live controller after browser closure; wrapper/controller exit 143 is preserved, not represented as a clean harness exit. No foreign process was signalled.

Focused closure/native-input/cleanup checks pass for 296 source/compiler files, 40 support files, 1,374 originals, 2,130 served responses and 31 PNGs. The checker explicitly retains the negative goal result, disk-floor crossing, missing final capture and interrupted-controller limitations. Full lane release was posted at 11:40:16. No Boat: ID/state/expiry N/A. Recovery keeps the frozen closure and complete ordinary-input route. Next requires restoring disk headroom before a separately authorized native attempt toward actual Montserrat town Enter/Attack or a nearby ship encounter.

Montserrat port and stable tavern; coast Enter/Attack still unproven (2026-10-31 11:49 UTC)

Evidence/recovery: scratch/runs/20261031T1149Z-pirates-town/RECOVERY.md. Actual Montserrat town interaction and a stable tavern interior are now inspected. The requested landing-party coast Enter/Attack route and combat remain unproven. This attempt takes the ordinary sea entrance to the town; it must not be described as completing the earlier Hangman's Point walk.

The untouched fresh game selected Nevis, rather than Antigua. Crew Signups, the English captain, Nevis's actual town menu (23-nevis-port.png), Sail Away and Cast Off were followed with trusted input. The native map (32-southward-turn.png, despite its filename) established Montserrat's location. Keypad steering and the inspected coastal approach led to the actual French Stronghold of Montserrat town menu (41-montserrat-response.png). Selecting Visit the Tavern and pressing Enter opened the rendered interior (44-tavern-response.png). A second capture 45-tavern-stable.png, over 11 seconds later, retains the interior, characters, fireplace and invitation to choose someone to talk to. Escape returns to the town menu (46). This is a new interactive scene, beyond destination speech or a town label.

Subsequent attempts to approach beach after sailing away instead automatically entered the harbor again (54, 62). No landing-party transition, ashore walking, coast Enter/Attack prompt, attack selection or combat was observed in this run. The first route dependency is the changed initial port, followed by harbor interception of these coastal approaches; no emulator defect is identified. The prior 11:34 landing-party result remains separate evidence.

The ordinary native Load/Save tab (69) → Save Game → first Empty Slot (70) returns to sailing with Game saved (71). A read-only copy of the native VFS result is retained as slot1.pirates_savegame: 1,028,097 bytes, SHA256 af989794bb4bce19b583806d42b69ec83d8985e79fe4108ad1a1584b6aca1d60. Its actual guest path is c:\my documents\my games\c:\slot1.pirates_savegame; the unusual embedded drive component is preserved. This is an offshore save after the town visit, not a save inside the tavern or an invented coast checkpoint. Native restore of the exported file is untested. No save bytes, assets, INI, clock or guest memory were edited.

All 296 current source/compiler files and 40 support files matched the exact 11:17 fixed closure before launch. The frozen, served and loaded module is SHA256 078d81cba6ab755d6a05e5e234a259df9e867ecc8848899705a45739fab0e9a9. All 1,374 original inputs match before/after. The default guestWorker, WebGL 1024×768 session has cache disabled, tiny disk caches, bounded console capture and no factory/draw/init instrumentation. The unchanged input-poll forwarder was the only runtime observer. Prelaunch free disk was 2,363,781,120 bytes; the minimum controller sample was 2,210,430,976 bytes. This attempt did not stop on the disk floor. No new build or heavy CLI ran.

Harness lifecycle limitation: initial wrapper/controller/monitor identities prove three distinct holders of the browser-lock FD. However, the launcher artifact says exit 0 at 11:53:40 while the browser/controller continued serving actions until 12:06:52. The execution session later returned 143. Original wrapper/controller/monitor finalizers and raw browser/controller exit records are missing; their disappearance's cause is unestablished. Full-lifetime wrapper/monitor correctness is therefore not accepted from this run. The stale launcher artifact is retained, not represented as a clean exit.

Recovery attached to the existing sole browser, retained all 126 trusted, balanced input events, restored the original input poll and called Browser.close. The recovery helper exited 0 and recorded closure at 12:07:26; this is not the unavailable raw Chrome exit code. All 15 recorded PID/start identities, including both global crashpads, are absent. HTTP/CDP/control ports 38323/33491/40805 are closed, the profile is removed, held input is empty, the actual whole-browser gate is clear and the full flock is available. No cleanup signals, foreign signals or second browser were used. FULLRELEASE was posted at 12:07:47, with a correction to the initial board summary's incorrect signal/count wording. No Boat: ID/state/expiry N/A.

Focused verify.py passes frozen/served identity (2,225 responses), originals, trusted balanced input, 72 captures, save hash and recovered cleanup; three negative controls reject a wrong module, untrusted input and a held key. It explicitly preserves the negative coast/combat result, untested restore, missing raw exits and unproven full-lifetime wrapper. The next useful work is an authorized native restore check and a northern landing route that avoids the harbor, with a durable wrapper/controller/monitor lifetime.

Fresh native slot restore and live sea combat (2026-10-31 12:20 UTC)

Evidence/recovery: scratch/runs/20261031T1220Z-pirates-restore/RECOVERY.md. The unchanged native slot restores an actual responsive world, and ordinary input subsequently enters sea combat and fires a broadside. A coast landing/Enter/Attack route, battle victory, captured ship and confirmed hit are not claimed.

Cheap original analysis preceded launch. The original lang0.FPK contains keymap_enu.ini and encyclopedia instructions for attacking nearby vessels and forming landing parties by steering into shoreline. The native save header reads Incognito|(Apprentice)|near Montserrat|8 February, 1660. The existing startup registry and Config.ini registration were preserved. The harness adds only the original 1,028,097-byte slot file to the ordinary file mounts, taking its exact guest path directly from the previous native export JSON: c:\\my documents\\my games\\c:\\slot1.pirates_savegame. Its source, served response and mounted VFS bytes retain SHA256 af989794bb4bce19b583806d42b69ec83d8985e79fe4108ad1a1584b6aca1d60. There is no path repair, save-byte edit or New Game replay.

The fresh native main menu (05) → Load A Game (06) → slot1 selection (07) produces the actual sailing world (09-load-pending.png, despite that filename): “Game loaded,” February 8, 1660, 600 gold, 41 crew, five months, and the ship at Hangman's Reef beside Montserrat and Nevis. No slot metadata preview was observed. Keypad 7 removes the Paused overlay (11); keypad steering visibly moves the ship and coast (12, 13, 17, 18). These inspected scene changes establish a responsive restored world. An initial queued title-screen click opened Quit confirmation; ordinary No returned to the main menu before selecting Load A Game.

Clicking the rendered Attack button (20) opens the native selector for English Merchantman Lovely Mary, six guns/50 men, against the player's Revenge, a sloop with eight guns/40 men. Selecting that ship enters a distinct sea-battle view (21), with both ships, their separate status displays and combat controls. Clicking native FIRE produces smoke and cannonballs beside Revenge and changes 8 guns loaded → 0 guns loaded (23). A later capture (24) retains the active battle with changed ship speeds and further visible smoke/projectiles. No damage or outcome is inferred from those effects.

The earlier keypad-5 taps reached the guest as VK_CLEAR (12), not VK_NUMPAD5; they did not open the attack selector. Short a and Space taps also produced no accepted immediate attack/fire response. Their cause was not isolated. The accepted attack and firing actions use ordinary trusted mouse clicks on the game's rendered controls, with no input bypass.

The game automatically created battle.pirates_savegame at the same native directory. A read-only export is retained: 1,028,093 bytes, SHA256 c6cdb98307401c401d70505d6ea6677757aeffdc8bccf89316cc3e625b92ba38. Restore of this new automatic battle save is untested. The original slot remains byte-identical after combat.

Before/after checks match all 296 source/compiler files, 40 support files and 1,374 originals to the accepted 11:17/11:49 closure. Frozen, served and loaded WASM is again SHA256 078d81cba6ab755d6a05e5e234a259df9e867ecc8848899705a45739fab0e9a9; there is no old-module/current-host mixture. Default guestWorker, threads, WebGL and 1024×768 remain active, with final device error null. Cache is disabled; no factory/draw instrumentation, production, asset, INI, clock or guest-memory changes were made.

The sole local browser ran 12:39:55–12:48:43 UTC, after fresh Deus Ex FULLRELEASE and actual global process clearance. A new durable Python supervisor retains the wrapper's real wait status; wrapper/controller/monitor share the inherited browser-lock FD. All 670 sampled live-profile observations retain those three holders. Actual Chrome, controller and wrapper exits are 0; the monitor also exits 0. Cleanup verifies 20 PID/start identities absent, including both global crashpads, three ports closed, profile removed, held input empty and full flock available. Runtime cleanup needed no signals; owned board watchers receive only PID/start/command-qualified cleanup. Minimum sampled free disk is 2,183,057,408 bytes. FULLRELEASE was posted at 12:49:13. This proves this new lifetime, not the old 11:49 wrapper's lifetime.

Focused checks pass 2,143 served responses, 42 trusted balanced native input events, 24 PNGs, immutable saves, inspected restore/combat evidence and cleanup; git diff --check passes. No Boat: ID/state/expiry N/A. The next useful work is separately bounded validation of the automatic battle checkpoint and further combat; coast Enter/Attack remains untested in this run.

Automatic battle-file load and onward combat damage (2026-10-31 13:01 UTC)

Evidence/recovery: scratch/runs/20261031T1301Z-pirates-battle/RECOVERY.md. The automatic battle file loads a real Nevis port scene; direct resumption of the previous battle is not established. Onward ordinary play enters a new Lovely Mary battle, damages the enemy, reloads fully and fires again.

The sole fresh browser mounts the unchanged 1,028,093-byte export, SHA256 c6cdb98307401c401d70505d6ea6677757aeffdc8bccf89316cc3e625b92ba38, at the exact path from the previous battle-export.json. Native Load A Game (08) → battle (09) → Enter leads to the actual English Trading Post of Nevis menu (11). The unmodified save header says “near Nevis,” February 12, 1660. Both pre-load and post-load mounted hashes match the export. This establishes a working native load, but does not establish why a file named battle restores this state or whether an earlier transient battle was present before the first inspected real scene. No New Game or tavern replay occurs. The original 11:49 slot and 12:20 battle exports remain byte-identical.

Native Sail Away → No matter, cast off! returns to the responsive world (14, February 19, 600 gold, 41 crew). Rendered Attack opens a selector (16) for Lovely Mary or Le Negociant Honnete. Choosing Lovely Mary enters actual sea combat (18): Revenge has eight guns/40 crew; the English merchantman has six guns/50 crew. Native FIRE produces smoke/projectiles and 8 guns loaded → 0 (20). Sustained native keypad steering changes heading, wake and speed. Reload progresses through 1, 2, 4, 5, then 8 guns loaded (22–26). After the first broadside, the enemy HUD falls to four guns/44 crew (24), persisting in subsequent inspected frames. Revenge remains at eight guns/40 crew. A second rendered FIRE click returns eight loaded guns to zero (27), followed by visible smoke/projectiles (28). These are observed enemy losses, not an inferred hit from smoke alone. No hull percentage, sinking, surrender, victory or captured ship is claimed.

Cheap read-only extraction of the original keymap and encyclopedia preceded launch: round shot damages hulls, broadsides require maneuvering, and combat may end through surrender, sinking or separation. This run uses rendered FIRE and native keypad steering; it does not claim a fix for earlier short Space or VK_CLEAR/keypad-5 behavior. Native onward attack replaces the mounted VFS battle entry with a new automatic save; that in-session version is not exported or claimed as a validated recovery checkpoint. Existing source exports survive.

Before/after checks again match all 296 source/compiler files, 40 support files and 1,374 originals. Frozen, served and loaded WASM remains 078d81cba6ab755d6a05e5e234a259df9e867ecc8848899705a45739fab0e9a9. All 2,226 served responses, including the three pinned auxiliary files, match. Default guestWorker, threads, WebGL and 1024×768 remain active; final device error is null. No production, factory/draw instrumentation, assets, INI, clock, guest memory or save bytes were edited; no build or heavy CLI ran.

The one browser ran 13:02:37–13:08:45 UTC (367.462 seconds), after prior FULLRELEASE and actual whole-Chrome/global-crashpad clearance. Durable supervisor/wrapper/controller/monitor retain real wait results, all zero, including Chrome. All 468 live-profile samples retain three inherited FD9 holders. Minimum sampled free disk is 2,126,659,584 bytes; the 2.1 GB early stop was not triggered. Cleanup verifies 20 PID/start identities absent, including both global crashpads; HTTP/CDP/control ports 34689/41907/33355 closed, profile removed, inputs balanced and full flock available. Runtime cleanup used no signals. FULLRELEASE was posted at 13:09:15; later publication watchers receive only qualified cleanup. No Boat: ID/state/expiry N/A.

Focused checks pass identity, 42 trusted balanced input events, 28 captures, unchanged source saves, inspected scene transitions and lifecycle evidence; the documentation diff check passes. Direct battle resume is a negative finding, not an accepted checkpoint capability. Next work must account for the automatic file's observed Nevis restore semantics; the original slot remains the separately proven fallback. Victory/capture remains untested.

Combat interception attempt; disk guard stopped the outcome (2026-10-31 13:15 UTC)

Evidence/recovery: scratch/runs/20261031T1315Z-pirates-outcome/RECOVERY.md. New live combat, repeated reload/fire and closer positioning are inspected; boarding, surrender and capture were not reached. The one browser ended early when free disk fell below the required 2.1 GB guard.

The unchanged 1,028,093-byte battle export, SHA256 c6cdb98307401c401d70505d6ea6677757aeffdc8bccf89316cc3e625b92ba38, is mounted at the exact previous native path. Ordinary Load restores Nevis port (10); Sail Away/Cast Off and rendered Attack lead to a fresh battle (14). No New Game or tavern replay occurs. The original 11:49 slot and 12:20 battle exports remain byte-identical. No new checkpoint was exported.

Revenge starts with eight guns/40 crew against the merchantman's six guns/50 crew. Enemy guns fall to four (22); enemy crew remains 50 in this run. Rendered FIRE discharges at 15, 25 and 39; full reloads to eight are inspected in 24 and 37, followed by zero loaded guns after each subsequent discharge. Chase view (24) identifies Revenge as the smaller black-flagged vessel and makes the approach easier to inspect. Sustained port steering brings the merchantman nearly ahead (30–31), but Revenge stalls at zero and briefly minus one knot into the wind (33–36). Reefing restores forward motion to two knots (39–40). After further steering and full sails, the last inspected overhead frame (47) shows Revenge at eight knots against the enemy's four, two guns reloaded and the vessels still separated on converging courses. Contact, boarding/duel, surrender, sinking and capture are not established.

Capture filenames are historical labels, not scene assertions: 13 shows the world, 14 actual combat and 15 the first FIRE response. The attack selector itself was not captured. The original keymap/encyclopedia were read before launch; native keypad steering/sails and rendered FIRE were used. No short-Space or VK_CLEAR fix is claimed.

Before/after identity checks match 296 source/compiler files, 40 support files and 1,374 originals. Frozen, served and loaded WASM remains 078d81cba6ab755d6a05e5e234a259df9e867ecc8848899705a45739fab0e9a9; all served responses, including the three auxiliary pins, are checked. Default guestWorker/threads, WebGL and 1024×768 are retained. The disk guard closed the browser before a final device-error or VFS snapshot; neither is claimed. No production, factory/draw instrumentation, assets, INI, clock, guest memory or save bytes were edited; no build or heavy CLI ran.

The sole browser ran 13:28:40.667–13:39:48.143 UTC (667.476 seconds), after Deus Ex FULLRELEASE and actual global Chrome/crashpad clearance. The guard triggered at 2,077,941,760 free bytes; the minimum sampled during shutdown was 2,038,018,048 bytes, still above the 2 GB floor. The pending 48 capture was interrupted; no 48 or 49 image exists. Durable supervisor/wrapper/controller/monitor retain actual zero wait results, including Chrome. Cleanup verifies all tracked PID/start identities absent, both global crashpads absent, three ports closed, profile removed, held inputs empty and full flock available; no runtime cleanup signals were needed. FULLRELEASE was posted at 13:40:11. No Boat: ID/state/expiry N/A.

The immediate blocker was disk headroom. Gameplay still requires completing the intercept or landing further effective broadsides. This session is used; no second browser or new save-validation claim follows from these captures.

Longer straight close; no boarding before the runtime deadline (2026-10-31 13:46 UTC)

Evidence/recovery: scratch/runs/20261031T1346Z-pirates-close/RECOVERY.md. The straight approach closes visibly, but contact, boarding, surrender and capture remain unproven. This attempt reaches its runtime deadline with adequate disk headroom; it is not another disk-guard stop.

Original lang0.FPK controls and encyclopedia were read before launch, along with prior captures 14, 24, 31 and 47. The encyclopedia describes boarding by ramming. The unchanged 12:20 battle export again restores Nevis port (08), followed by ordinary Sail Away/Cast Off. This run captures the actual selector naming English Merchantman Lovely Mary, six guns/50 men (12), and actual combat (13). No New Game or tavern route is replayed.

The initial starboard correction points Revenge away from the target and costs time. Later port steering brings the merchantman into the forward chase view (35–40). Rendered FIRE discharges the broadside (23), and enemy guns subsequently fall from six to four (30), with crew remaining 50. Revenge fully reloads to eight (34). No second discharge is claimed.

After releasing port steering at approximately 14:10:50, the course is held until 14:15:07: over four minutes without a steering command. The only intervening control is rendered Full Sails. Inspected frames 40, 42, 44, 46, 48, 50 and 52 show the ships drawing nearer, while Revenge slows from eight to five knots and the merchantman from five to four. The target drifts left of the bow; two late port corrections reduce Revenge to three and then two knots (53–54). The last frame still shows separated vessels, enemy four guns/50 crew, and eight loaded guns. There is no native boarding/duel, surrender, sinking or capture screen. The remaining gameplay dependency is completing the intercept while retaining closing speed. This run does not demonstrate the previous zero/minus-one-knot stall.

Trusted input observation records unshifted Numpad6 as ArrowRight/VK39. An ordinary Shift+keypad chord produces VK102, matching the original Num6 binding, but its steering effectiveness is not established. Rendered turn controls, shifted/unshifted keypad holds and ordinary port taps were tried. These observations do not establish a keypad fix or isolate the cause of slow alignment; no input bypass or production input change was made.

Before/after identity checks pass all 296 source/compiler files, 40 support files and 1,374 originals. Frozen, served and loaded WASM remains 078d81cba6ab755d6a05e5e234a259df9e867ecc8848899705a45739fab0e9a9; all 2,226 served responses, 106 source URLs and three auxiliary pins match. Default guestWorker/threads, WebGL and 1024×768 are retained. A 14:06:34 device snapshot has null error; the final query was refused after shutdown, so no final device-error claim is made. Both immutable source saves remain unchanged. No new checkpoint or final VFS export was made. No production, factory/draw instrumentation, assets, INI, clock, guest memory or save bytes were edited; no build or heavy CLI ran.

The sole browser ran 13:58:59.464–14:16:02.730 UTC (1,023.266 seconds), after Deus Ex's 13:57:56 FULLRELEASE and actual global Chrome/crashpad clearance. The fresh runtime deadline triggered shutdown; minimum sampled free disk is 2,216,898,560 bytes, above the required floor and early-stop threshold. All 1,234 live-profile samples retain three inherited FD9 holders. Actual browser/controller/wrapper/monitor exits are zero. Cleanup verifies 20 tracked PID/start identities absent, both global crashpads absent, three ports closed, profile removed, balanced inputs and full flock available. No runtime cleanup signals were needed; FULLRELEASE was posted at 14:16:30. The initial board watcher and two request shell sessions returned 143; their completed action/capture artifacts survive, and this is not reported as an all-helper-zero result. The request shells' Python-helper PID/start identities and raw Python exits were not separately retained; a qualified scan found no remaining request helper. No Boat: ID/state/expiry N/A.

Focused checks pass identity, 146 trusted balanced input events, 54 captures, immutable saves, inspected transitions and runtime lifecycle evidence. The single browser is used; there is no second runtime or promoted checkpoint.

Native ram reaches the boarding deck (2026-10-31 14:23 UTC)

Evidence/recovery: scratch/runs/20261031T1423Z-pirates-native-turn/RECOVERY.md. Actual contact and entry into the native boarding duel are established. The last capture shows the initial, still-fading deck scene, fencing controls, 50 Englishmen and 40 Pirates (57). No duel input, victory, surrender, sinking or captured-ship outcome is established. There is no new checkpoint.

Original lang0.FPK keymap/encyclopedia and prior native captures were read first. The encyclopedia describes boarding by ramming. The unchanged 12:20 battle export is mounted at its exact native path and loaded through the ordinary menu. Actual Nevis port (10), Sail Away/Cast Off, the selector naming Lovely Mary with six guns/50 men (13), and combat (14) are inspected. No New Game or tavern route is replayed. The early title/menu sequence also visits an unintended quit prompt and Hall of Champions; both are dismissed before the inspected main menu and Load sequence. They are not gameplay claims.

The first steering actions are ordinary rendered Turn Left holds of two and six seconds (15–16), followed by eight rendered taps (17). The overhead views show a small heading change as Revenge accelerates from about three to nine knots. An ordinary eight-second Numpad4 hold (18) continues the same qualitative direction. Chase view and further left steering bring Lovely Mary ahead while retaining 10–11 knots (20–22). This short comparison does not establish an emulator defect, corrected keypad mapping or measured turn rate. No shifted-keypad workaround or input bypass is used.

Rendered Full Sails and the early course close the gap (23–29), with Revenge slowing to seven knots against six. A short rendered right correction and overhead inspection (30–32) expose the crossing geometry. Subsequent ordinary right steering follows the merchantman's changing course, retaining roughly 7–12 knots rather than reproducing the previous two-knot late turn. The first crossing misses; later overhead captures show the stern approach, temporary increasing separation and renewed convergence. One rendered FIRE command discharges (39); no enemy gun/crew reduction is established, with six guns/50 men still displayed. Generic firing/reload is not requalified.

After the final right correction (53), the course is held. Capture 54 shows a new native close-up of Revenge meeting the merchantman's side; 55–56 show the black transition, and 57 shows the boarding deck and duel interface. This sequence establishes boarding entry beyond apparent proximity. The remaining gameplay dependency is playing and resolving that duel. The runtime deadline arrives immediately after its first captured scene.

Before/after checks match 296 source/compiler files, 40 support files and 1,374 originals. Frozen, served and loaded WASM remains 078d81cba6ab755d6a05e5e234a259df9e867ecc8848899705a45739fab0e9a9; all 2,745 responses, 106 source URLs and three auxiliary pins match. Default guestWorker/threads, WebGL and 1024×768 are retained. Device snapshots at 14:34:16 and 14:48:01 have null queue error; the latter precedes the deck scene. The last evaluation's device value was overwritten by screenshot metadata, so final boarding-scene device error remains unknown. The source battle export and slot1 are unchanged. A read-only VFS inspection fails with HTTP 500; no pre/post VFS save validation, export or recoverable boarding save is claimed. No production, factory/draw/input-forwarder instrumentation, assets, INI, clock, guest memory or save bytes were edited; no build or heavy CLI ran.

The sole browser ran 14:31:25.071–14:48:25.222 UTC (1,020.151 seconds), after Deus Ex's 14:30:36 FULLRELEASE and actual global Chrome/crashpad/profile clearance. The fresh deadline ends the session; minimum sampled free disk is 2,146,115,584 bytes, above the early-stop threshold. All 1,270 live-profile samples retain three inherited FD9 holders. Actual browser/controller/wrapper/ monitor/request-daemon exits are zero. Durable Popen waits retain all 70 request-helper exits: the VFS query returns one, the other 69 return zero. Cleanup checks 90 tracked PID/start identities absent, both global crashpads absent, three ports closed, profile removed, 108 trusted balanced input events and full flock available. No runtime cleanup signals were needed; FULLRELEASE was posted at 14:49:01. No Boat: ID/state/expiry N/A.

Focused identity, served-pin, input, capture-hash, immutable-save and lifecycle checks pass. The single browser is used. Boarding entry is the tested result; duel play, capture and save recovery remain untested.

2026-10-31 15:06 UTC — duel continuation blocked before native Load

Run scratch/runs/20261031T1503Z-pirates-boarding-duel/ preserves a failed continuation of the accepted 14:23 run. The previous result remains boarding entry only. No duel checkpoint had been exported, so this attempt mounted the unchanged 12:20 battle export at its original native path. It did not reach native Load, sailing, boarding, fencing, capture or any new save.

Read-only extraction of the original lang0.FPK keymap and encyclopedia preceded launch. Duel controls are keypad 4 thrust, 5 parry, 7 chop, 1 slash, 8 jump, 2 duck and 6 taunt. The encyclopedia describes a ram followed by a captain's duel, with victory required to capture the vessel. Prior trusted input timestamps and captures were inspected and an early intercept route prepared; none of those combat inputs was executed in this run.

The first page renders the Pirates title but remains there after Enter, Escape, Space, clicks and held mouse input. A single ordinary page reload inside the same browser, followed by remounting the identical export and launching Pirates, reproduces the title stall after click, Enter and Escape. Personally inspected captures 12, 16, 17 and 18 show the unchanged title. Both device samples report seven submissions, seven completions and null queue error. DOM events are trusted and balanced; that alone does not prove guest consumption. No input-forwarder, draw/factory wrapper or guest memory diagnostic was installed. The fresh page's app picker resets to Notepad after launch; the actual launch log and rendered title show Pirates. The cause of the stall is unknown; this is a precise first dependency, not new gameplay or a fencing-input failure.

The frozen WASM remains 078d81cba6ab755d6a05e5e234a259df9e867ecc8848899705a45739fab0e9a9. Before/after checks cover 296 source/compiler files, 40 support files and 1,374 originals; both immutable saves are unchanged. Default guestWorker, threads, WebGL and 1024×768 are retained. No save, asset, INI, clock or production file was changed; no build or heavy CLI ran. No new save is exported or called recoverable, and no VFS query was attempted here. The predecessor's failing read-only VFS helper remains a separate known limit.

One browser launched after Deus Ex's 15:06:11 FULLRELEASE and a fresh whole-Chrome/global-crashpad/profile PID/start gate. It ran from 15:06:37 to 15:11:26 UTC, ending early on this dependency. Durable waits record zero browser/controller/wrapper/monitor/request-daemon exits. The first cleanup audit raced final process exits and failed; the subsequent audit passes with all tracked runtime/helper PID/start identities absent, three ports closed, profile removed, empty held inputs and full flock available. No cleanup signals were needed. FULLRELEASE was posted at 15:12:06 UTC. Boat ID/state/expiry are N/A. The next gameplay dependency is restoring ordinary title-to-Load navigation on these exact pins; the prepared fencing and early-intercept plan remains unexecuted.

2026-10-31 15:15 UTC — title/Load recipe comparison; no supported repair

Evidence: scratch/runs/20261031T1515Z-pirates-title-load-cause/RECOVERY.md. This is a cheap comparison of accepted 70589baac and 18aa9d6a5, with fresh immutable-file checks. No new browser was launched, no harness was repaired, and title-to-Load remains unresolved. The live Deus Ex 15:14 browser was left alone; no older FULLRELEASE was used as launch permission.

Actual files rule out a demonstrated controller-version difference: the drivers are byte-identical, SHA-256 ddbb6aa1d153ec718f9edabfd702a4dc3e034ab7a98fa57bfab9496516b35b42. Thirteen compared files match, including driver, supervisor, monitor, process guard, request daemon, preparation, registrations and manifests. The lifetime wrapper differs only in the required predecessor release name and timestamp. Both actual screenshots show 5k, Threads and WebGL; the same driver selects 5000 before launching. Frozen selectedRunSlice reads this selection at wine.run; applyRunSlice before launch has no running app to update. No scheduler drift is established. Realized worker scheduling state was not separately retained and is not inferred from these settings.

Readiness does differ observationally. Driver ready.json means the control server is listening, not that the guest accepts input. The successful first capture already shows the title; the failed first capture is still teal. The failed first Enter precedes the final canvas resize. The successful run also remains at the title through captures 01–04; the first captured response is the quit prompt at 05, after its later 500 ms Enter. Failed later clicks and held keys still leave the title, so an early-input race alone does not explain the retained failure. Asset and thread-creation logs progress substantially more slowly in the failed first page, but those counts do not identify a cause or prove guest input consumption.

Frozen launch code focuses the canvas. The failed run's retained DOM sample at 15:09:03 identifies canvas#screen as active; successful DOM focus was not sampled. Initial registrations match exactly, including the unchanged 12:20 export and native path. The failed reload's later Notepad picker label does not establish a wrong guest: its actual launch log and title identify Pirates. Neither focus nor picker evidence supports changing the harness.

No discriminating ordinary-input test or safe repair follows from this comparison within the task's restrictions. Repeating title keys, choosing a different scheduler budget, or extending waits without a measured readiness condition would not isolate the cause. The precise first dependency remains the frozen runtime's title-to-native-main-menu/Load transition, reproduced as title persistence on both pages in the accepted 15:03 run. Guest consumption and cause remain unknown; no crash is established. Native Load, fresh-page restored Nevis gameplay, duel play/victory/capture and a new recoverable save are not claimed. The prior boarding result remains entry only, and its read-only VFS helper failure remains a separate limit.

Fresh before/after checks retain the exact 078d81cb… module, all 296 source/compiler files, 40 support files, 1,374 originals and both immutable saves. Only this documentation and new scratch evidence were written. No production, guest/input instrumentation, memory reads, game clock, assets, INI or save-byte edits were made. No browser, input, server, profile, runtime lock or test box was created; no foreign process was signalled. Boat ID/state/expiry are N/A. This attempt stops at the documented first dependency without spending another runtime.