Q3 capture latency: long glGetError boundary, offline diagnosis 1840
No safe causal repair was established. The preserved renderer GL ring narrows
the earlier 1816 limitation: a 12,034.885 ms opcode 12 (glGetError) boundary
on the actual owning WebGL renderer ends 0.390 ms before renderer identity
request 402 enters its expression. The expression itself takes 0.365 ms.
These intervals use the same renderer performance.now() clock. This is
stronger evidence than inferring work from a pending CDP call, but the opcode
boundary does not isolate the slow internal operation.
Evidence: scratch/runs/20261109-q3-renderer-read-latency-repair-1840/.
Starting Git base is da3d5f5b4e72d142cdabea5eb892722a09918511.
The prior native run remains immutable. No browser, Chrome, box, heavy runtime,
worker or runtime-queue entry was created. No production file was claimed or
changed. All capture, ownership, routing, debugger, identity and terminal
behavior remains intact, including 20-second work/CDP, 55-second ACK and
30-second cleanup limits.
Actual generated path and expression
The prior generated owning Python caller SHA-256 is
25acfe27a8160d4a8b396f71636e41ae4d172b3cb7e8b011cb283ce8ae7764f1.
Its launch path reaches the generated prepared/q3-runtime-caller.cjs, whose
relative import invokes q3-current-foreign-closure-v1.cjs.runCaller.
That validates the sealed closure, composes the authenticated native driver,
installs the pointer/diagnostic/wire hooks and execution observer, and loads the
retained 20261108-q3-gl-readiness-gameplay/browser-run.cjs consumer. The local
interactive controller forwards complete command lines to this Python caller;
it does not evaluate the renderer expression or serialize screenshot replies.
source-audit.cjs invokes that actual versioned composition and
compileBoundInput, intercepting compilation without launching the consumer.
The generated bound module's exported RENDER_READ hashes to
c8901fd4173060979c6421361d7d16585c4ed3db75547924d9ed9f8e380e84bf, exactly matching
native request 402's trace and execution markers. It reads endpoint/context
tokens, options, failure state and atomic control counters; it has no explicit
wait, asynchronous join, pixel readback or GL call. Offline controls execute
these actual generated bytes and verify stable tokens, changed instance and
endpoint epochs, and visible failure/error state. They do not reproduce the
native latency.
The actual capture order is capture.state, then chain.capture:
binding.before/readLive, screenshot, binding.after/readLive. The live read
checks page ownership, guest instance and live module bytes, renderer ownership,
producer receipt and renderer module bytes, then page-reference continuity.
Native requests 399–407 match this order. Request 401's guest module read took
220 ms; request 402 took 11,973 ms; producer 405 took 17 ms; renderer module read
406 took 176 ms; page continuity 407 took 9 ms. The complete binding.before
took 12,413 ms. No artificial stalled peer or injected delay is presented as a
reproduction of the native defect.
Native long boundary
The original retrieval index identifies the compressed console artifact in this
task's retrieved-input-references.json; that record supplies its exact retained
path, stored/raw SHA-256 and sizes. The audit independently rereads and verifies
stored and original hashes/sizes and gzip CRC before parsing. Full hashes and
references for every examined artifact are retained in that JSON; no source or
media archive is made.
The Q3_GL_PARTIAL delivered at 2026-11-09T18:29:36.378Z retains these committed
ring entries (same endpoint 1, owner 0, context 1, frame token 301304):
| Sequence | Boundary | Renderer time, ms | Duration, ms |
|---|---|---|---|
| 1811745 | opcode 12 enter | 138090.740 | — |
| 1811746 | opcode 12 exit | 150125.625 | 12034.885 |
| request 402 marker | identity expression enter | 150126.015 | — |
| request 402 marker | identity expression exit | 150126.380 | 0.365 |
opcode-audit.json verifies the actual enter/exit linkage, token equality and
same-clock relationship. lib/gl-render-worker.js wraps the synchronous
bridge.call with these markers. lib/gl-compat.js maps opcode 12 to
glGetError; its _call activates the current context, calls
flushPendingDraw(), then returns and clears a frontend error or calls the
context backend's getError(). lib/gpu-backend.js serves retained context
errors before delegating to the device; device getError() calls native
WebGLRenderingContext.getError().
Offline execution of the real OpenGLHostBridge.call(12,...) verifies that the
pending flush precedes the backend query, a backend error propagates, and a
frontend error is returned and cleared. The native marker encloses this whole
path: it does not distinguish context activation, pending draw submission,
frontend processing or a blocking backend query. No Chromium/GPU/driver cause
is established. Removing the error query, returning success, bypassing the
pending flush or moving ownership validation past capture would therefore be
unsupported changes.
The state immediately before the long call identifies backend webgl, the
actual endpoint and Intel/ANGLE context. Same-renderer requests 395/397/398
returned in 4/5/6 ms before the long boundary; request 411's same identity
expression returned in 7 ms afterward. This rules out treating every owner read
as inherently expensive. It does not prove a safe caller scheduling change.
Remaining blocker and next evidence
The actionable unresolved cause is the internal operation within this specific
glGetError boundary, followed by the separate screenshot 408 completion
failure. Its screenshot remained pending 6,911 ms at the work deadline.
Successful probes 409–412 neither establish compositor receipt nor explain
screenshot completion. Post-navigation send/transport timing is also absent:
the preserved transport observer explicitly stops at navigation settled.
The Node send-to-marker-delivery interval is not a target queue measurement.
A subsequent authorized investigation needs sub-boundaries around current
context activation, flushPendingDraw and backend getError, plus actual
post-navigation transport and screenshot completion evidence under the same
limits. This task does not authorize or perform another runtime. The existing
ring's overwrites prevent reconstructing missing internals from this run.
Passed offline checks: preserved trace/hash/CRC audit, actual generated-source
and expression authentication, identity and opcode semantic controls, and
node tools/q3-execution-boundary.test.cjs (including missing-entry uncertainty,
deadline/late/error/no replay and independent release). Initial audit setup
incorrectly treated the local controller as a remote provider; corrected audit
authenticates it against the Git base instead. An initial decompression check
also assumed nested gzip; the final audit uses gzip magic after verifying the
retrieved original. Neither affected source or native evidence. No code changed,
so no code regression or locked build is claimed. Stop with this narrower
source-backed blocker and release both owned paths.