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.