Two things land together: the plan and contract draft P6 needs before it starts, and the
working notes that until now existed on exactly one machine.
1. P6's plan and contract draft (neither started; not one line of code)
docs/Disaggregated/P6-SPAWN-PLAN.md the package plan
docs/Disaggregated/P6-CONTRACT-DRAFT.md the contract draft (moves to
MG_Remote/CONTRACT-P6.md when c6 lands)
The three findings that mattered, all written into the documents:
a. P6 is SMALLER than its roadmap cell suggests. The transport primitives are already in
the tree and already tested: SocketDoorbell including hangup detection and the two
lost-wakeup fences (Doorbell.cpp:211-360, four cases in FdPassingTest), SCM_RIGHTS fd
passing, ShmSegment::Adopt, and the SurfaceOp / WindowKind schema already defined in
protocol.fbs. inproc uses a real second shm mapping rather than an alias, and
SessionRings.h:22-28 says that was done so today is not the first time it runs. P6 is
assembly plus a control plane plus a process, not "write a socket transport".
b. The evidence for "P6 is only a transport swap" has EXPIRED. It was bought by P5c, whose
audit found 59 direct memory accesses in a tree that already looked clean. P5e changed
the tree again. So the first package, a6, is a read-only audit that writes no code, and
every contract row that depends on it is marked PENDING a6 rather than decided in
advance.
c. P6 does not get a game running on the phone. ANativeWindow* is meaningless in the child,
and protocol.fbs:186-196's own comment says Android transfers the window out of band -
that band is P12. P6 lands pbuffer / surfaceless / offscreen, which is what HeadlessGL,
the split-equivalent lane and trace replay need, and which is exactly what P6's own exit
gate measures. A real window reaching the server is a named refusal. This gets its own
section because "P6 is done" would otherwise read as "the game runs now".
The contract adds rule G: a role may not name a process-local handle. It extends P5c's
rule E (a role may not name the other role's memory) from memory to identity - EGLDisplay /
EGLSurface / EGLContext / ANativeWindow* / fd number / pid / mapped address either cross as
a token this contract defines or they do not cross, and a descriptor crosses only through
SCM_RIGHTS, where the kernel renumbers it.
What P5e left for P6 gets its own section. The latch semantics are already designed
(ARCHITECTURE.md:504) and are copied unchanged. What is new is that after run-ahead the
client no longer waits while the peer process can DIE: the client holds records that were
published and will never be applied, and Android's freezer suspends the child without
closing anything. So slow and dead must be distinguishable WITHOUT a timeout threshold.
That is P6's only new design; everything else is carriage. It shares a predicate with E1's
outstanding re-specification (ID-122), and the two should be designed together.
Two gates carried over from P5e's lessons: G2 requires integration-spawn's test-name set to
match integration-split's name for name, because a differing set means the lane is quietly
running less; and the arm-proof gate requires every entry to record the child pid and
transport=spawn in its OWN private log - ID-124 established that this kind of false green
really happens, and a spawn lane that actually ran monolith would pass every other gate.
S2's shape must be settled before it is written, and the document says why: E1 is the
cautionary case.
2. The working notes move into the repository (docs/Disaggregated/notes/, 415 .md files)
ROADMAP / CURRENT_STAGE_PROGRESS / MEASUREMENTS cite ruling numbers, audit line numbers and
the provenance of gate figures from ~/w7/notes/, a directory that exists on one machine and
is under no version control. A record cited hundreds of times that lives only locally is not
a record, so it moves in whole, with its directory structure intact.
Only .md moves. Scripts, run logs, census and gate result JSON, patches, APKs and nm dumps
stay where they are: they are evidence DATA rather than documents - large, regenerated per
run, and mostly carrying absolute paths and device serials that mean something only on the
machine that produced them. The mapping and this split are written in
docs/Disaggregated/notes/README.md.
Two exceptions are recorded there too: P6's BRIEF has been promoted to a first-class
document and keeps no copy under notes/, so the two cannot drift apart; and recovered/ holds
material salvaged from failed workflow runs, which may duplicate the like-named phase
directories and is kept because a few of those were the only complete version at the time.
CI's citation lint takes docs/Disaggregated/*.md only (non-recursive), and notes/ is
deliberately outside it: those notes' file:line citations were written against their own
code heads, and resolving them against today's HEAD would fail wholesale - which is not an
error, it is their correct state as a historical record. To check one, use the revision it
declares (--rev).
3. Inconsistencies fixed in passing
- README.md's status line still said P5e was in progress while the stage table already said
closed.
- CURRENT_STAGE_PROGRESS's next-step item 1 still listed the exit gate as pending, though
(a) and (b) were run in the previous commit; rewritten to closed plus the one item that
actually remains (E1).
- ROADMAP's P6 row still had the pre-phase plan in three of its cells; it now carries the
package order, the scope boundary and the two new gates.
Checked with check_doc_citations.py: 125 citations across docs/Disaggregated/*.md, 0 problems.
20 KiB
P1 package A (p1-core) — c2..c6 on top of the contract
Tree ~/w7/p1-core, branch p1/core, base feat/disaggregated @ 087685d1, contract bf86b1ed (tag p1/contract, see core-contract.md). Nothing pushed. Working tree clean apart from the three untracked build directories.
Commits (oldest first, all on p1/core after p1/contract)
| sha | subject |
|---|---|
3aa4d8af1ff2ca6f95c9ab3e047e70bc0e0cf65f |
[Feat] (Pipe): fill PipeInputs per verb class from GLContext and stamp per-verb generations - a read of a field the verb did not fill is Fatal{UnmigratedPipeInput} |
a196ada4c11b59f23587596486d265124ea06a6f |
[Feat] (Impl): call MGP_FILL before every GLFunctionsTable entry - 83 statements over 69 verbs, a no-op in the pull build |
275dd3edb4909fe2a23af0f9a2667fb8215d24be |
[Feat] (Pipe): the MOBILEGL_PIPE_VERIFY shadow comparator - a per-verb entry compare over the fill set and a compare-at-read in every accessor, first differing field and verb serial, fatal by default |
83b16561c20428dd15995ed3b2b4ad5496a97bab |
[Feat] (Pipe): give the six value structs G4 field lists and assert the lists cover their members - the memcmp fallback is now a compile error, floats in vector types compare bitwise |
440d3c52534e2c227b8b4d83251d8afcb0849e3f |
[Test] (Pipe): pin the P1 poison and verify shapes - 63 fields, 69 verbs, the seven sticky fields, an omitted GenerateMipmap field leaves exactly that field stale, a corrupted snapshot names its field, reading an unfilled field aborts with SIGABRT |
git diff --stat p1/contract..HEAD: 17 files changed, 1587 insertions(+), 72 deletions(-). Files touched (all inside A's ownership row of C.5): MobileGL/MG_Backend/MGPipe/PipeInputs.{h,cpp}, MobileGL/MG_Impl/Pipe/PipeFill.{h,cpp}, the seven MobileGL/MG_Impl/GLImpl/{Drawing,Framebuffer,Texture,Getter,Program,Query,Sync}/*.cpp, MobileGL/MG_Pipe/PipeFields.def, MobileGL/MG_Pipe/generated/PipeVerify.inc, scripts/gen_pipe.py, MobileGL/MG_Test/Pipe/{CMakeLists.txt, PipeCatalogueTest.cpp, PipeInputsTest.cpp}. Not touched: MG_Backend/DirectGLES/**, MG_Backend/DirectVulkan/**, PipeCalls.def, Coverage.def, FillPoints.def, PipeInputsSwitch.h, CMakeLists.txt (root), Config.h/ConfigLoader.cpp, fixtures. No signature in PipeInputs.h / PipeFill.h / PipeInputsSwitch.h that B/C/E code against changed (the accessor set, MGB_CTX, MGP_FILL, the knob names and log lines are as in the contract); the additions are listed under deviations 5-7.
What each commit does
- c2 filler (
PipeFill.cpp):MGPipeFillForVerbwalkskMGPipeClassFieldMask[kMGPipeVerbClass[verb]];MGPipeFillAccess::CopyFieldis one switch over the 56 stored fields, each branch calling theGLContextaccessor of the same name (D4's fill column verbatim: loops of 8/16/32,GlobalBufferTargets/BufferBindPointTargetsfor the slot/point bases,&ctx.GetTextureUnitObject(0)/&ctx.GetImageTextureBinding(0)as array bases, Blend x8 + ScissorTest x16 for the indexed capabilities, all 35 capabilities incl.FramebufferSrgb's constant false); every copied field is stamped with the new serial; the seven sticky fields getFilledGen = 1on the first live fill.MOBILEGL_PIPE_POISON_OMIT(<Verb>:<Field>) is parsed once at the first fill;MGPipeSetPoisonOmission(verb, field)is the programmatic form; the omitted pair keeps its value copy and loses only its stamp; unknown names areFatal{PipeVerifyBadKnob}. - c3 fill points: the 83
MGP_FILL(X);statements of B.7 (36/11/8/3/1/18/6 per TU) plus#include <MG_Impl/Pipe/PipeFill.h>after each TU's lastMG_State/MG_Backendinclude, inserted by a patcher (scratchpad/wf4/core/patch_c3.py) that refused any target line not spelling its verb. - c4 comparator (
PipeFill.cpp,PipeInputs.{h,cpp}): entry compare at the end of every fill (SnapshotFromGLContextinto a file-static secondPipeInputs,MOBILEGL_PIPE_VERIFY_CORRUPTapplied to the snapshot arm,MGPipeVerifyInputsover the mask, first differing field); compare-at-read throughMGP_INPUT_VERIFY_READ->MGPipeVerifyReadHook(*this, field, i0, i1)(re-reads the field from the live context into a scratch block and compares against the live block only);MGLOG_F("MGPipe: Fatal{PipeVerifyDiffer, \"%s@%s\", verb=%llu, where=%s}")+abort()unlessMOBILEGL_PIPE_VERIFY_FATAL=0(counts,MGLOG_Esummary at teardown);MGLOG_I("MGPipe: verify armed - 63 fields, 69 verbs, fatal=N"),MGLOG_I("MGPipe: verify corruption armed - F"),MGLOG_I("MGPipe: poison omission armed - F@V"); a push build without the comparator answersMOBILEGL_PIPE_VERIFY=1with oneMGLOG_W_ONCE. - c5 G4 growth (
PipeFields.def,gen_pipe.py, regeneratedPipeVerify.inc): the six field lists (RenderStateParameters 65, PixelStoreParameters 8, PerBufferBlendState 7, StencilFaceState 7, DynamicBackendParameters 85, MGHostSpan 4),kMGPipeVerifiedPayloadCount63 -> 69;MEMCMP_FALLBACK_TYPESempty and the fallback branchstatic_assert(sizeof(T) == 0, "no field list in PipeFields.def for this type");Array<T,N>overload; VecBase detected by a probe and compared bitwise overdata;check_field_lists_cover_struct_members(),scan_live_accessors()(both modes),--self-testwith six negative controls and a positive one. - c6 tests: the four
PipeCatalogue.*additions and the fivePipeInputsTest.*cases (new unit target, ownmain()forMOBILEGL_LOG_FILE_PATH, fork/waitpid, neverEXPECT_DEATH).
Verification (WSL, ~/w7/p1-core; logs under ~/w7/p1-core-*.log)
Every command below was run on the final tree (440d3c52) unless a commit is named.
| command | actual output |
|---|---|
python3 scripts/gen_pipe.py --check |
gen_pipe: 71 calls (11 screen, 60 context), 69 verify payloads, 63 PipeInputs fields (7 sticky), 69 verbs, 9 classes / inventory 477 rows: ... 0 UNMAPPED / 1 accessor row(s) no backend reads: GetBoundTransformFeedbackName / generated files are up to date, rc=0 |
python3 scripts/gen_pipe.py --self-test |
six controls "tripped as expected" (struct member without F, F that is not a member, payload with no struct, verb missing from FillPoints.def, verb not in GLFunctionsTable, field row naming a non-accessor), positive control OK, rc=0. Before the whitespace-tolerant fix the three FillPoints controls reported DID NOT TRIP and the run exited 1 - the "zero trips is an error" arm was exercised. |
cmake --build build-linux + ctest -L unit --no-tests=error |
rc=0; 100% tests passed, 0 tests failed out of 1475 (1466 before c6 + 9 additions) |
python3 scripts/symbol_report.py --before ~/w7/p1-before-libMobileGL.so --after build-linux/libMobileGL.so --threshold 0 |
.text 10792579 -> 10792579 (+0, +0.000%), .data +0, .bss +0, .rodata +0, Total +0, 27799 -> 27799 defined symbols: 0 added, 0 removed, 0 resized, 0 renamed, 27060 normalised names unchanged. G1 holds after every commit (checked at c3, c4, c5, final). readelf -S section sizes identical. cmp -l shows 34 differing bytes: 20 in .note.gnu.build-id, 14 in .rodata = the GIT@5d99ee4 -> GIT@087685d configure stamp and glslang's Timestamp: 2026-09-05T23:14:30 -> 2026-09-06T01:32:05 string - build stamps of equal length, not code. (Markdown/JSON: ~/w7/p1-core-symbol-final.{md,json}.) |
grep -rc "pGLContext" MobileGL/MG_Backend | sort | diff - ~/w7/p1-before-pglcontext.txt |
only the two contract files appear, both :0 (MG_Backend/MGPipe/PipeInputs.cpp:0, PipeInputs.h:0); every catalogued file's count unchanged - A converts no site |
grep -c "pGLContext" MobileGL/MG_Backend/MGPipe/PipeInputs.h PipeInputs.cpp |
0 0 |
grep -c "MGP_FILL(" MobileGL/MG_Impl/GLImpl/*/*.cpp | awk ... |
83 (Drawing 36, Framebuffer 11, Texture 8, Getter 3, Program 1, Query 18, Sync 6) |
cmake --build build-push + ctest -L unit --no-tests=error |
rc=0; 100% tests passed, 0 tests failed out of 1475; MOBILEGL_PIPE_PUSH=1 on every compile command, MOBILEGL_PIPE_VERIFY=1 on none |
cmake --build build-verify + ctest -L unit --no-tests=error |
rc=0; 100% tests passed, 0 tests failed out of 1475; MOBILEGL_PIPE_VERIFY=1 on all 497 compile commands |
ctest --test-dir build-push -L integration-gpu --no-tests=error -j 4 (at c3, a196ada4) |
99% tests passed, 1 tests failed out of 868; the one failure DirectVulkan.PointSizeDemotion.PointSizeDemotionScenario.TheDemotionIsActuallyArmedWhenTheEnvironmentPinsItOn (0.23 s) passes alone in build-push AND in build-linux (100% tests passed ... out of 4) - a -j 4 flake of an env-pinned lane, the case the integrator script's --rerun-failed -j 1 exists for; zero Fatal{ lines in the log |
ctest --test-dir build-push -L integration-gpu --no-tests=error -j 4 (final tree) |
ITEST_FINAL_PLACEHOLDER |
ctest -N name diff (pull): comm -23 ~/w7/p1-before-ctest-names.txt - |
2343 names, 0 removed, 9 added (PipeCatalogue.{VerbTableIsTheFunctionTable, StickyFieldsAreExactlyTheSeven, FloatVectorsCompareBitwise, SixValueStructsHaveFieldLists}, PipeInputsTest.{OmittingOneFieldForOneVerbLeavesExactlyThatFieldStale, ReadingAnOmittedFieldAbortsNamingTheVerb, ReadingAFilledFieldCompletes, CorruptedSnapshotFieldIsNamedWithItsSerial, EveryVerbFillsItsClassAndNothingElse}); the same 9 names exist in all three configurations (skips are visible, not vanishing). The padding-tolerant regex '^\s+Test\s+#[0-9]+:' is used, as in the contract report. |
G4 unit (build-verify, PipeInputsTest.CorruptedSnapshotFieldIsNamedWithItsSerial) |
Passed: clean snapshot compares equal over kDraw's mask; MGPipeApplyVerifyCorruption(snapshot, GetRenderStateParameters) -> MGPipeVerifyInputs false naming GetRenderStateParameters, whose stamp equals the fill serial; a corruption of a field outside the mask is not seen; a forwarded field cannot be corrupted. Skips visibly in build-push ("verify not compiled in") and build-linux ("push not compiled in"). |
G4 lane-level smoke (build-verify, MOBILEGL_PIPE_VERIFY=1 ctest -R 'DirectGLES\..*ClearThenReadPixels') |
clean: 100% tests passed ... out of 5, log has MGPipe: verify armed - 63 fields, 69 verbs, fatal=1, 0 Fatal{. With MOBILEGL_PIPE_VERIFY_CORRUPT=GetRenderStateParameters: 0% tests passed, 5 tests failed out of 5 (rc=8), log has MGPipe: verify corruption armed - GetRenderStateParameters and Fatal{PipeVerifyDiffer, "GetRenderStateParameters@Clear", verb=1, where=entry} |
G5 unit (build-verify, PipeInputsTest.{Omitting..., ReadingAnOmittedFieldAbortsNamingTheVerb, ReadingAFilledFieldCompletes}) |
all Passed: with SetPoisonOmission("GenerateMipmap","GetActiveTextureUnit") the GenerateMipmap fill leaves GetTextureUnitObject fresh and GetActiveTextureUnit stale, a following DrawArrays fill leaves it stale while GetBoundVertexArray is fresh, and a BindImageTexture fill (same class, different verb) heals it; the forked child that draws, reads a filled field, fills GenerateMipmap, reads the sibling and then the omitted field dies with WTERMSIG == SIGABRT and the log carries exactly Fatal{UnmigratedPipeInput, "GetActiveTextureUnit@GenerateMipmap"}, no @DrawArrays, no GetTextureUnitObject@; the sibling child without the omission _exit(0)s with no Fatal{. In build-push (Release/INFO, no POISON) the two poison cases skip visibly and ReadingAFilledFieldCompletes passes. |
nm -D --defined-only build-verify/libMobileGL.so | grep -c MGPipeVerifyInputs / same on build-push |
1 / 0 - the symbol E's retrace-verify job probes exists only in the verify library |
EveryVerbFillsItsClassAndNothingElse (build-verify) |
Passed: after each of the 69 fills a field is fresh iff its class bit is set (sticky included); ContextIdentity() is the live context address |
Not run: the 40-trace retrace under verify and the integration-verify lane (E's files; D.3 on the integrated tree). The verify-build integration-gpu was only smoked (5 ClearThenReadPixels entries) - on this tree no backend reads gPipeInputs, so its full run would only repeat build-push's proof.
Deviations from the brief (with reasons)
- Nine fill points precede a guarded expression rather than the bare call (D7 says "after every early return the call is behind; a verb whose table entry is null never bumps"):
GL_Query.cpp260/300 (if (handle && getQueryResult64 && !getQueryResult64(...))), 289 (outValue = (!f || f(h)) ? 1 : 0), 522/533/645 (handle = f ? f() : nullptr), 774 (supported = ... && f && f()),GL_Sync.cpp177 (signaled = !f || !h || f(h)) andGL_Drawing.cpp1331 (if (auto sync = backendGL.FenceSync()), inside theFenceSync && ClientWaitSyncguard so this one is exact). At the other eight the fill precedes the statement that holds both the null guard and the call, so a null entry bumps the serial once with nothing to read it (kQuery fills one field; no backend read happens between two fills without a fill). Chosen over a comma-expression ((MGP_FILL(X), f(...))) or splitting the statements because either would touch the code shape of the pull build, and G1 asks for byte identity. - Compare-at-read re-reads the WHOLE field, not only the indexed element (D8: "re-reads the same accessor with the same indices"). The hook copies the field from the live context into a scratch block through the same
CopyFieldthe filler uses and compares withMGPipeInputsFieldEqual; the indices decorate the report (MGLOG_Ebefore the Fatal). A superset: a divergence in an index the backend did not ask for is still a boundary-vs-live divergence. One copy switch instead of a second 56-way index-aware switch. MGPipeVerifyReadHooktakes the block as its first parameter ((const PipeInputs& self, field, i0, i1); the brief spells(f, i0, i1)): the macro expands inside member functions of anyPipeInputs(the snapshot's accessors run in the tests), and only the live block is verified; withoutselfthe hook could not tell them apart. No backend code spells the hook.- VecBase bitwise compare is a probe inside the generic
MGPipeFieldEqual, not an overload (D8 says "two overloads ... partial ordering picks these overconst T&"). ForFloatVec4the overload onconst VecBase<D,T,N>&needs a derived-to-base conversion and LOSES overload resolution to the exact-match generic template before partial ordering is consulted; theArray<T,N>overload is exact and does win, and is emitted as the brief says.PipeCatalogue.FloatVectorsCompareBitwisepins the behaviour (NaN equals itself, -0.0f != 0.0f,a == bis IEEE and disagrees). MGPipeInputsFieldEqualtakesconst PipeInputs&(the contract hadPipeInputs&), with a constVisitStorageoverload added; nobody outside A calls it.MGPipeVerifyInputscarries__attribute__((visibility("default")))(not in the brief): the library is built with hidden visibility, so without it E'snm -D build-linux/libMobileGL.so | grep -q MGPipeVerifyInputsstep (C.4 (c)) could never pass. No MGPipe symbol was in the dynamic table before; this is the only one now.- Pointer corruption flips the low bits instead of nulling (D8 says "swap a pointer for nullptr"): a pointer that is already null (an O-class field before the first fill, or a null
GetProgramForDraw) would make the corruption invisible to the compare; aSharedPtrbecomes an aliasing pointer with no control block. The snapshot is only ever compared, never dereferenced. SnapshotFromGLContextandMGPipeFillForVerbshareCopyFieldrather than being two copies of the copy logic; the snapshot is still its own function (the branch that survives P13) with its own file-static block.CurrentVertexAttributeValuecompares bitwise inPipeInputs.cppwith asizeof == 48static_assert: it isMG_Statestorage (three scalarArrays, no padding), not a payload, so it gets noPipeFields.defrow and the struct-member check does not searchCore.h.PipeInputsTestis a separate unit target (the brief allowed it "if the verify-only tests need it"): the fork cases need their ownmain()to pointMOBILEGL_LOG_FILE_PATHat a file before anything logs, and the fake-context cases needMobileGL_s;PipeCatalogueTeststays context-free. Its five cases areGTEST_SKIPin a pull build and the poison/verify cases skip in a push build without those switches.- A push build without POISON acknowledges
MOBILEGL_PIPE_POISON_OMITwithMGLOG_W_ONCE("no stamp exists to omit") instead of theMGLOG_I("poison omission armed")line, which is emitted only where the omission can act. - The sticky one-time stamp moved from an unconditional loop into the mask walk (every class mask carries the seven sticky bits, so the result is identical).
gen_pipe.py --self-testalso runs the field-list coverage check on the real inputs first (main()order: calls -> payloads -> coverage check -> coverage -> self-test), so a broken real list fails before the canned controls run.
Where the tree contradicted the brief's numbers
- B.7
GL_Drawing.cpp:907 MemoryBarrier (TextureBarrier): line 907 is the closing brace; thememoryBarrier(GL_TEXTURE_FETCH_BARRIER_BIT | GL_FRAMEBUFFER_BARRIER_BIT);call is at 906. Every other B.7 line number held (the patcher checks each target line for its verb; the six XFB sites use abbreviated captured namesbeginXfb/endXfb/pauseXfb/resumeXfb/deleteXfb/bindXfb,GL_Getter.cpp:1176spellsgetIntegeri(). - B.7 continuation lines: seven listed lines are the call's continuation line of a multi-line statement (
GL_Query.cpp261, 301, 523, 534, 646, 775;GL_Sync.cpp178 for the 177 entry) - the fill goes before the statement start (260, 300, 522, 533, 645, 774, 177). - D8 "all 67 members of
struct RenderStateParameters": the struct has 65 direct data members (MGPipeValueTypes.h:239-387,MAX_VIEWPORTSis static).DynamicBackendParametershas 85 (brief gives no count). - D4
IsCapabilityEnabled"37 entries,MGPipeValueTypes.h:168-204":CapabilityInputhas 35 enumerators beforeCapabilityInputCount; the storage is sized from the enum, so nothing depends on the number. - C.1 "7 files change" for c5's regeneration: only
PipeVerify.incchanges at c5 (the field lists feed G4 alone); the contract commit already regeneratedPipeFilled.incand createdPipeFillPoints.inc. - The integration-gpu count: 868 entries in build-push's
integration-gpulabel (the brief's "371 + 3 new cases" is E's post-integration figure). ctest -Nregex ('^\s+Test #', C.1): as recorded in the contract report, ctest right-aligns the test number, so the padding-tolerant regex is what produces the 2334/2343 name lists.
Unfinished / notes for the integrator
- Nothing in A's scope is unfinished. The verify library's full
integration-gpu, theintegration-verifylane and the 40-trace retrace under verify are D.3 items on the integrated tree (they need B/C's sites onMGB_CTXand E's lanes to mean anything). MGB_CTX_LIVE-guardedRecordErrorand the twoInvalidateCompileEnvcalls at backend init run before any fill; they are sticky and pass the poison from the first live fill on, as designed. If the verify lane finds an@<none>Fatal for any other field, the answer is a fill point at that boundary, never a sticky flag.- The
-j 4flake ofPointSizeDemotionScenario.TheDemotionIsActuallyArmedWhenTheEnvironmentPinsItOnreproduced neither alone nor in the pull build; it is not caused by this branch but the integrator's--rerun-failed -j 1step stays worth keeping. scan_live_accessors()will start reportingMGB_CTX->reads the day B/C land; today it reports one unread row (GetBoundTransformFeedbackName, dead by design).