Original GLTron production gameplay counter — 2026-11-04
No gameplay FPS was measured for either backend. The existing production logical marker can count the original nonzero-dt gameplay update without raw callback wall timestamps. The compiled original boundary passed offline tests in both current modules. Two local launches stopped before gameplay because this diagnostic's HTTP pin inventory omitted boot dependencies. These were runner errors, not evidence of a production counter or rendering defect.
The omissions are repaired and tested offline. Both per-backend launch allowances were consumed; neither backend was retried. No gameplay was viewed, no before/after gameplay captures exist, and no live gameplay interval or logical rate is claimed. The remaining measurement blocker is obtaining a separately authorized fresh attempt using the repaired preflight, then reaching and personally reviewing gameplay before collecting the bounded interval.
Evidence: scratch/runs/20261104-gltron-production-frame-counter/. Git plus
the run's binary diffs and new-file patches is the source archive. Original
media and modules are referenced by existing path, size and SHA-256; no source,
media or module copies, snapshots or tarballs were made.
What a logical frame means
The unchanged original executable is
test/binaries/gltron-0.70/gltron.exe, 180,224 bytes, SHA-256
85fb5184262490f0b5967c2b12ee27c77da058364e594b0fc86be7b5814e40ec.
All 92 registered files still match their original hashes and sizes, totaling
4,968,893 bytes. No configuration, guest code, media or pacing was changed.
The exact original gameCallbacks table is at 0x42a200; its idle callback
is GameMode_Idle at 0x40518f. Current callbacks are referenced through
0x42b230. After Time_Idle, the original code at 0x40519c loads game2
through 0x43d284, compares its integer dt at offset 0x30 against zero,
and branches to 0x4051a9 only when nonzero. That address CALLs Game_Idle
at 0x4040de once. A zero-dt poll takes 0x4051a7 → 0x4051c2 instead.
Game_Idle can perform several physics substeps per entry.
The candidate marker therefore means one nonzero-dt gameplay update entered,
not a completed update, display callback, swap, screenshot, host step, idle
poll or physics substep. Live attribution additionally requires the correct
instance/main thread and active gameCallbacks; static addresses alone do
not establish gameplay.
Existing production mechanism and compiled proof
host.js::_setLogicalFrame(address, pace) arms its instance, the main guest
Worker if present, and other guest threads. _readLogicalFrameCount() sums
the main and child per-instance counters. That total cannot by itself identify
which thread entered the candidate. This diagnostic supports the observed
page-main execution route only, reads the main instance directly, and rejects
worker endpoints and any child gameplay count. Other endpoint arrangements
need their own ownership proof.
The decoder places handler 476, $th_logical_frame, as the first operation
of the marked block. Block splitting, $fuse_stop and op-index poisoning keep
the marker from being swallowed by folds or whole-block rewrites. The uop
compiler excludes that address from a program, exiting back to its threaded
block. With pace=0, the marker increments the lifetime unsigned i32 counter
and reads guest ticks, without sleeping or changing the global debug guards.
Changing its address requests a decoded-cache recycle. The setter does not
reset the lifetime count. Production source has only the increment assignment
to that counter; a fresh instance has a new observation generation.
probeCompiled loads the exact original PE and executes its original compare,
branch and CALL instructions through the actual compiled interpreter. Only
fixture registers, stack and data are initialized; executable bytes are never
patched. Ordinary one-block budgets stop before running the callee. Across
chaining/uop settings 00, 10, 01 and 11, repeated dt values 0/16/0/1/32 count
0/1/0/1/1, with correct original branch/callee endpoints, zero debug-tier
guard and no sleeps. The actual host setter/reader methods are exercised
against that instance. Disabling/rearming also exercises cached marker removal
and lifetime-count preservation.
These tiny original blocks being tested with uop enabled does not mean they
entered an installed uop program. The existing
test/test-present-logical-frame.js separately passes 50 checks per module,
including a hot loop that actually installs and enters the uop tier while
preserving the logical marker boundary. Neither fixture is gameplay timing.
Both tested module paths remain available:
| Module | Bytes | SHA-256 |
|---|---|---|
build/wine-assembly.wasm |
2,148,150 | 78a0b1d61b23428a1ae909d739440ae0de059bbbd84a69a2ad3e4c37471ad664 |
build/wine-assembly.compat.wasm |
2,150,763 | 99b579cd17b57f94145df92ae6d28110f24fc284d13a1b2c0ebe3596bd10a77f |
No host/lib/src repair or additional production instrumentation was necessary.
Unlike trace_eip and set_count, the existing marker does not globally disable
the normal tiers. The previous note's requirement for per-callback wall
timestamps was unnecessarily restrictive for an average FPS measurement.
Counter-delta measurement contract
The executable diagnostic is tools/gltron-logical-fps.cjs; the bounded local
driver is tools/gltron-logical-fps-local.cjs. The page adapter retains the
actual host, instance, memory, thread-manager and observed instantiation
generation references. It requires main thread ID 1, checks instance
replacement and visibility/frozen transitions, and samples active callbacks,
marker address, pacing and execution-tier settings. Guest pointers are read
using that instance's guest_to_wasm, with raw guest addresses, translated
offsets and values retained. An arbitrary observation may have dt=0: the
original branch filters events, not a host poll's dt snapshot.
Every synchronous main-counter getter is bracketed by performance.now()
in the page's monotonic clock domain. The diagnostic retains raw unsigned
counts and read brackets, samples nominally every 250 ms, rejects reads over
5 ms or observation gaps over 1,500 ms, and accepts only an interval whose
minimum elapsed bound is at least 5 seconds and maximum is at most 10 seconds.
It bounds storage at 64 observations. Counter reset, stale generation, wrong
owner/scene/marker, pacing and tier changes fail closed. A single unsigned wrap
is accepted only near the wrap seam and under an explicit 40,000-frame delta
bound; larger or ambiguous deltas fail. Synthetic wrap/reset/rate fixtures are
tests, not measurements.
For start bracket [a0,a1], end bracket [b0,b1] and count delta N, elapsed time lies in [b0−a1,b1−a0]. The diagnostic reports the midpoint rate and the resulting enclosing rate bounds. Those are observation-timing bounds, not confidence intervals or uninstrumented-performance estimates. No poll timestamp is relabeled as a callback timestamp. Endpoint identity is checked at every observation; a scene transition entirely within a guest slice is unobserved.
Instrumentation overhead includes the marker dispatch, tick read, enforced block/uop boundary, one cache recycle when arming, and periodic ownership and counter reads. The adapter records its read duration. A future reported rate would include that overhead and the initial cache recycle. Module hashing occurs before the measurement; the renderer-reference hook removes itself after its first call. There are no per-draw hooks or globally debug-disabled tiers. No overhead percentage was measured.
Actual attempts and remaining limitation
The MDK poll-history worker released local resources at 18:53:13Z and the
new Stronghold current-hover worker explicitly released at 18:58:20Z. Runtime
began only after both releases, using /tmp/wine-local-runtime.lock for both
sequential arms, with 180 cumulative browser seconds and 180 cleanup seconds
reserved before the 21:15Z/21:18Z cutoffs.
| Requested arm | Actual result |
|---|---|
| Software | The runner's seal omitted manifest.webmanifest and the five stock .fon files; requests received HTTP 500. Startup never reached an emulator instance or gameplay. Chrome PID 951345 exited 0, signal null. |
| WebGL | The repaired font inventory passed, but the seal still omitted local stdole2.tlb and the shared msvcrt.dll. It stopped during startup. Chrome PID 956338 exited 0, signal null. |
The WebGL arm's actual loaded main module hash matches the canonical module
above. webgl/ready.json records page-main cooperative execution, generation
1, thread 1, uop enabled, chaining disabled and debug-tier guard zero, but
callbacks/game2 pointers and logical marker/count are all zero. It records no
GL context and no owning rendering bridge. Requested backend is not an
observed active renderer. No backend/context/renderer performance comparison
can be made. Both arms sent zero gameplay inputs and never armed the marker.
The first software capture request made after closure received connection refused. The queued WebGL startup capture was not executed because the first seal failure stopped its command loop. No image was available to personally view, and no screenshot or gameplay review is claimed.
Total Chrome time, including closure, was 18.705 seconds. Both direct
Browser.close requests were followed by actual owned child exits with code
0 and no signal; the helper sends no process signals or process-group kills.
Both owned Node/Chrome pairs were absent afterward and HTTP ports 36407/33143
refused connections. Local heavy resources were explicitly released at
19:05:41Z. Box ID/state/expiry: N/A. Coordinator retains future box and
shutdown ownership; no boats/API/SSH runtime, installs, allocations, subworkers
or deployments were used.
The final preflight derives required stock fonts and system data from the production boot lists and the shared CRT from the production DLL registry. Focused tests reject each omitted/stale boot pin before Chrome. All 365 recorded requests from the two failed arms match the repaired inventory by path/hash. This is an offline regression, not a successful new launch or a proof that every future request is known. Original failures remain preserved.
Final validation: 37 focused checks, original registration check, syntax/diff checks, both compiled original-path probes, 50 existing tier-boundary checks per module, and the locked full build. Logs and exact source pins/patches are in the run. No production gameplay counter defect was demonstrated. A fresh authorized runtime must still validate the owning active gameplay scene and collect personally reviewed before/after captures plus its >=5-second raw count/time interval. Stop here under the no-retry instruction.