Cooperative GLTron ring decoder, 2026-11-07
Sound_Decode returns repeatedly. The original refill stays in its loop because
the ring remains far short of its fill threshold while the auxiliary consumer
continues requesting audio. No WAT/JS disagreement was demonstrated, so no
production source was changed. First menu geometry remains absent.
Evidence: scratch/runs/20261107-gltron-ring-decoder/ (ignored), following
sound startup. This was one bounded task,
one fresh UUID and one original cooperative execution, without nested workers.
Natural decoder and caller boundaries
The run helper wraps instantiation and the existing host.log_eip diagnostic,
preserving import calls, arguments, receivers and returns. It arms the existing
WAT set_trace_eip_range export, reads register exports and translates original
guest memory through lib/mem-utils.js. It does not write guest state, execute
guest callbacks, force completions, change configuration or change clocks.
Block tracing has overhead and disables some fast execution paths; these are
observations of this diagnostic run, not an equal-progress comparison.
Runtime sdl_sound.dll base is 0x765000. Natural Sound_Decode entry is
0x766b6b; its original caller return is 0x4132ac. Each main-instance request
gets a serial number and retains its sample pointer, stack pointer, return
address, original ring object and the existing callback-token registers.
Return pairing requires the same instance/request and entry ESP + 4. Callback
tokens are independent completion-context markers, not decoder request IDs.
| Boundary | Result |
|---|---|
| Decoder entry/return | 6,093 refill requests entered; 6,092 returned, zero orphan returns. Request 6,093 was naturally pending at the harness deadline. |
| Decoded length and status | Every paired return has EAX = 4,096 and sample flags = 0; neither original tested error/EOF bit (0x40000000, 0x20000000) is set. |
| Ownership | Producer instance 1 and consumer instance 2 share ring object 51160292 and sample 28990700. These are observed addresses, not durable ABI constants. |
| Refill caller | One entry at 0x413258, zero hits at its 0x4133dc exit. All five 0x412c52 manager continuations precede this refill entry; zero occur afterward. Outer continuation 0x40cbf5 is never reached. |
| Retained detail | First 12,000 selected records cover 16,114.832–21,507.080 ms after preload, with 316 complete decoder pairs. Thereafter only whole-run aggregates continue. |
For example, request 314 enters with last-returned callback token 4752 and
returns with token 4766 after 22.930 ms. Request 315 spans tokens 4766–4785;
request 316 spans 4785–4801. These are natural repeated invocations, not one
decoder stuck beneath a reused stack return address. The bounded detail and
aggregate distinction is explicit in ring-analysis.json and ring-summary.json.
Original ring arithmetic agrees with observed execution
Original disassembly is retained in ring-original.asm. The object fields are
sample +0x20, decode target +0x24, ring storage +0x28, capacity +0x2c,
read index +0x30, write index +0x34. Capacity is 163,840 and target is 8,192.
At 0x41326e, equal indices take the decode path. Otherwise the original
computes (read - write + capacity) % capacity and exits only when that free
space is at most 8,192. Thus the ring needs at least 155,648 occupied bytes to
leave this refill. After decoding, the original updates
write = (write + decodedLength) % capacity and loops. The consumer at
0x4130d9 advances its read index only when its requested bytes are available.
The retained detail verifies all 316 producer updates against that modulo formula, and 4,459 consumer entry/end pairs against unchanged or 22,048-byte read advances; 58 advance. At the 317 retained loop checks there is one initial equal/empty case; every other free-space value is 137,760–159,744, above the exit threshold. The observed branch agrees with the original instructions.
Whole-run aggregates independently reconcile both indices across wraparound:
| Progress | Bytes / final index |
|---|---|
| 6,092 producer returns × 4,096 | 24,952,832 produced; modulo capacity = write 49,152. |
| 1,131 successful consumer paths × 22,048 | 24,936,288 consumed; modulo capacity = read 32,608. |
| Produced minus consumed | 16,544 occupied bytes, exactly the final original ring difference. |
There are 90,018 consumer entries; success-path counts are not interchangeable with output submissions or attempted reads. SDL submits 90,271 output blocks of 22,048 bytes while this ring supplies only the successful reads above. No unobserved successful read or lost producer update is needed to explain the final indices. There is no observed error/EOF reset.
The remaining boundary is the scheduling/timing relationship between decoding, SDL read attempts and timed output servicing: why the cooperative route keeps consuming the available ring before its producer can fill to 155,648 bytes. The final synthetic audio clock is 36,929,000 guest ms over a 125.537-second harness run. That disparity and the interleaved token/read progression locate the next discriminator; they do not establish a violated primitive or justify changing the clock, skipping audio or forcing completion as a semantic repair. A further source change needs an exact incorrect scheduling/completion decision against the original request and clock domain, then a focused failing regression.
Checks, source recovery and lifecycle
The unchanged callback evidence also retains 1,987 admission/return pairs with exact saved-context restoration and 1,955 grants consumed. All 126 per-instance samples have zero pending encoder bytes/commands and zero scene spans/vertices. GL reports 172 texture uploads, one clear/publication and zero scene draws. All six capture commands acknowledge, with no UNKNOWN or replay. Seven PNGs have verified pixel inventories: teal at five seconds, black at ten seconds through final. The distinct image contents were visually reviewed. No gameplay input was sent before a reviewed menu, so no held DOWN required an UP.
Runtime pins record Git dff50f0c1839a66bd09e076af46587490b2c895e, relevant
tracked diffs and the existing untracked lib/wininit-boot.js patch. Standard
module SHA-256 remains
f9650607181301b5d2a9990420f437bd9f1ca10d40ac73067339f07499d53121
(2,182,500 bytes). All 129 observed runtime reads match staged pins; 546 staged
inputs and 162 native dependency pins match before/after. Existing passed
controls were reused, with fresh-box headless GL and WGL context/readback checks
passing. The 92 original-media paths have size/hash references. Source/media
archives were not created; Git SHA plus relevant source/helper/note patches and
the retained modules provide recovery.
test-probe.cjs, analyze-ring.cjs and analyze.cjs pass the diagnostic-call
preservation/pairing checks, ring arithmetic, callback restoration, capture ACKs,
pixel inventories, loaded-input pins and retrieval hashes. Helper syntax and
note whitespace checks pass. No production repair, regression or new locked
build is claimed. The global evidence checker still reports seven unrelated
containment errors; this owned investigation has none. No menu/gameplay, audio quality, parity, FPS or historical
coverage claim is made. This unregistered app remains in investigation notes.
46 artifact references / 41 unique contents, 18,348,385 referenced bytes, were
retrieved and SHA-256/size verified before requesting normal stop. Launch free
disk exceeded 5 GB locally and remotely. The independent detached 25-minute
watchdog and normal-stop delegate were armed and observed before allocation;
watchdog maximum heartbeat gap is 1.073 seconds. Explicit delegated normal stop
stop_2f799a4f463a3f25 completed at 2026-11-07T22:52:57.438Z, forced=false,
error=null. Box bx_urhra99r is archived, current expiry null; its original
expiry was 2026-11-07T23:14:38.726Z. Stop request/result and final state are
retained in lifecycle-stop-result.json and normal-stop-confirmed.json.
Both delegates exit zero, supervisor remaining children are empty, and owned
runtime processes, ports, profiles, held input and local watchers are closed.
No resume, delete or public deployment occurred. This bounded task ends here.