Files
MobileGL/docs/Disaggregated/notes/p4a/p4a-results/esprytobj-review-v1.md
T
swung0x48 aba329cc53 [Docs] (Disaggregated): P6's plan and contract draft; the working notes move from a local directory into the repository
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.
2026-09-18 23:31:39 -04:00

34 KiB

P4a package D — p4a/esprytobj adversarial review, v1

Reviewed: refs/heads/p4a/esprytobj 7aa598fa..9bb95335 (six commits) against the tag p4a/contract (08192d72). Worktree read-only; experiments in ~/w7/p4a-review-esprytobj (detached, removed at the end of this round). Sources read in full: the whole git diff 08192d72 HEAD (Managers.cpp +1208 / Managers.h +360 / SanityTest.cpp +196) plus the surrounding bodies of every function it touches, plus SlotTables.h's handle overloads, p4a/wire@3c07c8c3's PipeApply.{h,cpp}, p4a/clientfb@8946061e's TextureEmit.h / FramebufferEmit.h / TextureObject.cpp and p4a/esprytdraw@0b00f7f0's DirectGLES.cpp (only to refute findings, never to grade them).

Verdict: REWORK

One critical, four majors, ten minors. The critical and two of the majors are behavioural and are invisible on this tree by construction (no records exist yet), so none of them could have been caught by the package's own verification — which is exactly why they have to be fixed before the real-path round rather than found by it.

What the package got right is worth stating first, because it is most of it: the refusal discipline is genuine (every handle arm declines with a named MGLOG_E_ONCE and returns; I could not find one silent fall-back that would make a lane pass), the four arm resolvers and the three dependency refusals are D-K2/D-K3 verbatim, the death-notice arm is idempotent by construction, the G5 set is byte-identical (recomputed independently), the macro hygiene is complete, and the purity greps are clean.


1. Critical

C-1 — the handle arm silently stops configuring every framebuffer that is not the currently bound one, which is all five DSA / blit entry points

MobileGL/MG_Backend/DirectGLES/Managers.cpp:8216-8228 (FramebufferImpl::PushedFramebufferRecord) and :8450-8473 (the decline inside BackendFramebufferObject::SyncToBackend).

PushedFramebufferRecord(asTarget, fbo) answers only MGPipeApplier().DrawFramebuffer / .ReadFramebuffer — the applier's working state for the two bound targets — and returns null when record.Fbo != fbo. SyncToBackend then does:

GLenum glFBOTarget = ...;
Bind(asTarget);                                   // :8432 - the driver FBO is bound FIRST
...
pushedRecord = PushedFramebufferRecord(asTarget, fbo);        // :8450
if (pushedRecord == nullptr) { MGLOG_E_ONCE(...); return; }   // :8451-8457

Failure scenario. glClearNamedFramebufferfv(fbo, ...) with bit 9 set: ClearNamedFramebufferfv (DirectGLES.cpp:7960) → SyncAndBindFramebufferObject(framebuffer, Draw, forceSync=true) (DirectGLES.cpp:3262-3294) → registry.GetOrCreate(framebuffer) mints a fresh twin with no attachments → InvalidateSyncedState() → SyncToBackend(framebuffer, Draw) → Bind(Draw) → the record names the application's bound FBO, not this one → refusal → return → back in the caller, backendObj->Bind(target) → glClearBufferfv is issued against a driver framebuffer with no attachments at all. Result: GL_INVALID_FRAMEBUFFER_OPERATION and nothing cleared. On the legacy arm the same call configures the FBO from the frontend and clears correctly. The same holds for BlitNamedFramebuffer (DirectGLES.cpp:6474-6475, both targets) and the other three ClearNamedFramebuffer* (:7980, :7997, :8017).

This is not the benign case the report describes. §2-d4 says a mismatch "is answered with null rather than with the other framebuffer's attachments" — true, and the alternative it rejects would indeed be worse — but the caller's response to null is to do nothing at all, and doing nothing to a framebuffer that is about to be cleared or blitted into is a third outcome the report does not consider.

Refutations attempted, all four failed.

  1. Does package B emit a record for a DSA-named framebuffer? No. p4a/clientfb:MG_Impl/Pipe/FramebufferEmit.h:219 EmitFramebufferState(GLContext& ctx) builds only from the two bound slots (:237-244, drawFbo/readFbo), which is D-C2 as written ("once per bound target that moved"). A named-but-unbound framebuffer never gets a record, and it must not: writing one into DrawFramebuffer would make the applier claim it is bound.
  2. Does package E fix the call site? No. p4a/esprytdraw@0b00f7f0's SyncAndBindFramebufferObject (DirectGLES.cpp:3982-4013) is unchanged in this respect and still calls backendObj->SyncToBackend(framebuffer, target). E's e1 rework is confined to SyncCurrentFBO / BindCurrentFBO / ForceBindCurrentFBO.
  3. Does ForceBindCurrentFBO repair it afterwards? It re-syncs the application's framebuffer, not the named one, and the clear/blit has already been issued by then.
  4. Is the path dead? No — ClearThenReadPixelsScenario, OrientationScenario and FramebufferTest.NamedFramebufferDrawBuffersDoNotModifyDefaultFramebuffer all drive it, and the Minecraft/Iris traces drive it every frame.

What the fix has to decide (this is a contract question, not a one-line patch): either (a) the applier grows a per-object framebuffer record beside the two working-state ones so a named FBO can be addressed by handle — which is a real change to D-B2/D-I2 and A's file; or (b) Espryt keeps a named arm for the not-currently-bound case and says so out loud (it is still a decline on the handle arm, just not a silent one); or (c) B emits a third, explicitly-not-bound record kind. What is not acceptable is the present state, where the only visible symptom is one MGLOG_E_ONCE line and a framebuffer that quietly never gets attachments. This is the finding the integrator most needs before the real-path round, because on the integrated tree it will present as "the 183 went to zero, but the DSA scenarios are red" and look like a seam defect in B.


2. Major

M-1 — the server's own re-dirty of the frontend model is invisible to the handle arm's upload loop

Managers.cpp:6046-6049 (MGB_LEVEL_NEEDS_UPLOAD) replaces IsStorageDirty on the handle arm rather than OR-ing with it:

(pushedStorage != nullptr
     ? FindPipeTextureUpload(*pushedStorage, (Uint16)tgt, (Uint16)lvl) != nullptr
     : (obj)->IsStorageDirty(tgt, lvl))

D-D5's inversion covers the client's own emission-time clear. It does not cover the fact that the server still writes into the frontend dirty model from three places, two of which are live: RequireImageBindableStorage (Managers.cpp:5127, mipmapObject->MarkStorageDirty(uploadTarget, level, true) — the very re-dirty this package planted MGPipeUnmigratedEmulation("texture-remint-pull") next to) and GenerateThreeChannelFloatMipmapOnCpu (DirectGLES.cpp:7406).

Failure scenario. First glBindImageTexture on a texture that was already uploaded: SyncTextureObjectToBackend (DirectGLES.cpp:1529) → RequireImageBindableStorage sets m_imageBindableStorageRequired, clears m_isInitialized, re-dirties every defined level in the frontend and sets m_forceTextureParamsResync; execution falls straight into SyncMipmapsToBackend in the same verb. On the handle arm the applier's pending set is empty (the client cleared and emitted those levels long ago), so levelDirty == false for every level, pData == nullptr, and the widened image-carrier storage is allocated empty. The dispatch/draw that triggered the bind reads zeroes. This is precisely the bug Managers.cpp:5091-5101's comment says "survived so long", re-introduced on the new arm.

Refutation attempted (partially successful, and it is what keeps this out of §1). TextureObjectWithOneMipmap::MarkStorageDirty in p4a/clientfb (TextureState/TextureObject.cpp:493-503) calls PipeNoteLevelDirty(uploadTarget, mipmapLevel, dirty) → MGPipeNoteTextureLevelDirty (TextureEmit.h:1012-1021) → emitter.NoteLevelDirty(...), so the server's re-dirty does reach the client's drain list and the levels are emitted at the next validate point. So the damage is bounded to the verb that triggers it and self-heals one verb later (the applier bumps Serial, the gate at Managers.cpp:6120-6123 misses, and the levels upload). It is still deterministic wrong content for that verb, and for a one-dispatch-then-readback scenario that is the whole result. GenerateThreeChannelFloatMipmapOnCpu has the same shape with a milder outcome.

Fix: on the handle arm the question is "does this level owe an upload", and the honest answer is the union of the two sources for as long as the server keeps writing the client's flag — pending != nullptr || (obj)->IsStorageDirty(tgt, lvl) — with MGB_LEVEL_UPLOAD_DONE clearing the frontend flag too only for levels it did not consume from the pending set (so the D-D5 rule "the server never clears the client's flag" keeps holding for records the client owns). Whatever the shape, the three server-side re-dirty sites must be enumerated in the code beside it.

M-2 — MGPipeResourceRecord::Desc is never read by the texture twin: the storage is still allocated entirely from the frontend

Grep across Managers.cpp: pushedStorage->Desc has zero readers (pushedStorage is used at :6047, :6055, :6097-6122, :6140, :6200, :6702, :7183-7193, and never for Desc). Inside SyncMipmapsToBackend, currentTextureInfo (Managers.cpp:6236-6244), needsRegeneration (:6251, and again at :7044), canAppendMipmaps (:6266-6277) and every glTexImage* argument still come from stateTextureObject->GetFormat()/GetBaseSize()/GetSamples()/HasFixedSampleLocations() and textureMipmapObject->GetMipmapLevelCount().

C.3's d2 is explicit — "m_prevTextureInfo probe re-keyed onto the resource record's Serial and Desc" — and the commit message says "drive texture storage, parameters and uploads from the pushed descriptors". Only the parameters and the uploads moved. The renderbuffer twin one function over does read its Desc (MGB_RBO_FORMAT/WIDTH/HEIGHT/SAMPLES, :11694-11701), so the asymmetry is not a capability gap.

Why it matters even though no lane can see it. SyncTextureParamsToBackend already answers MGB_TEXPARAM_FORMAT from Desc.InternalFormat (:7479-7481) while SyncMipmapsToBackend allocates from GetFormat(). That is two authorities for one value inside one twin — the exact coupling P4a exists to remove — and in monolith they agree, so G4/G12 cannot expose it. It is also what BackendTextureFormatAddsAlpha(MGB_TEXPARAM_FORMAT, ...) at :7651 silently depends on.

Refutation attempted. Is Serial enough? No: Serial gates whether to run, not what to allocate. Is Desc missing the fields? No: MGPResourceDesc carries InternalFormat / Width / Height / Depth / Levels / Samples / FixedSampleLocations / Immutable, and B fills them (TextureEmit.h's respecify path).

Not in §5's twelve deviations, which is the part that makes it a major rather than a scope note: D-N/D-P force a lot of shapes on this package and every one of them is documented; this one is not.

M-3 — SyncAttachmentObject is in D's file, so DV-7's hand-off to E is a mis-attribution, and §7-13's claim about G9 is wrong

SyncAttachmentObject is Managers.cpp:7947 — MG_Backend/DirectGLES/Managers.cpp, which C.7 gives to D exclusively. DV-7 says "resolving them from MGPSurface::Res instead is package E's SyncAttachmentObject work", and §7 item 13 says G9's red-before case AReadAttachmentOnlyTexturesDepthStencilModeReachesTheDriver "is closed on the E side (SyncAttachmentObject gains the parameter sync for READ-only attachments)". E cannot touch that function without violating C.7, and it did not: p4a/esprytdraw@0b00f7f0 changes DirectGLES.cpp only (git diff --stat: 1 file, +893/-38).

Refutation attempted, and it saves the deliverable but not the attribution. E closed D-E3 by a different route — a new SyncReadFramebufferTextureAttachments in DirectGLES.cpp (E's diff :208-282, :356-358) that walks MGPipeApplier().ReadFramebuffer and calls SyncTextureParamsToBackend / SyncBuiltinSamplerToBackend for the read attachments. So G9's case does get closed. But the consequence for the rework stands: with ID-12 minting MGPSurface::TextureTarget, the attachment-walk re-key from MGPSurface::Res is D's work, not E's, and so are the four cross-object masks (below). The integrator should not schedule it on E.

M-4 — the adoption helper d1 is named for has no call site anywhere in the phase

AdoptTwinByHandle (Managers.cpp:3544-3568), the anonymous-namespace template the report calls "the release-build VOICE for the two silent refusals, shared by the five kinds", is never instantiated. StateBackendObjectRegistry::GetOrCreateByHandle (Managers.h:453) and ReleaseByHandle (Managers.h:476) likewise have no caller for any of the five re-keyed kinds. Grep over the whole tree returns only the definitions, P3a's pre-existing buffer-family copies (Managers.cpp:2157, :2472) and SanityTest.cpp. Package E adds none either: grep for AdoptTwinByHandle|GetOrCreateByHandle|ReleaseByHandle|LiveGenAt over p4a/esprytdraw:DirectGLES.cpp returns nothing.

So in this package the five twins are still minted through GetOrCreate(StatePtr) off the frontend lifetime id, and every d2-d5 site resolves with HandleOf(stateObject.get()) — a lookup, not an adoption. DV-1 records half of this honestly (the resolution sites are E's) but not that the helper itself is dead on arrival on both branches.

Consequence, and it is not cosmetic: that helper holds the only release-build diagnostic for the two refusals SlotTables.h performs under a compiled-out MOBILEGL_ASSERT. Dead code cannot be wrong-and-noticed; its bound (Registry::SlotTable::kMaxHandleSlot) and its wording will first be exercised at P5. Either give it its first caller in D's rework (the five HandleOf sites are where an adoption would go once the handle arrives in a payload) or move it, with its comment, to the package that does — and say which in the report.


3. Minor

# site what
m-1 Managers.cpp:6761-6765, :6724 MGPSubRegion::SrcOffset and MGPSubData::SourceIsVerbatimLevelShadow are never read (zero grep hits). regionPtr re-derives the byte offset from dirtyRegion.lo and the strides, and subRectEligible is still the pre-P4a uploadData == mipData pointer comparison rather than D-D6's SourceIsVerbatimLevelShadow test. Correct in monolith, both are carried contract fields the server is supposed to consume, and D-D3's "carried, never inferred" applies to SrcOffset in the same sentence as the strides.
m-2 Managers.cpp:6742-6755 only Regions.front()'s SrcRowStride/SrcSliceStride are consulted; a record whose regions disagree silently uses the first. D-D3 says the pitch is the level's, so add the assert rather than the loop.
m-3 Managers.cpp:7718 const auto borderColorForm = MGB_TEXPARAM_BORDER_FORM; is evaluated unconditionally and, when pushedBorder == nullptr, reads stateTextureObject->GetBorderColorForm() on the handle arm. The value is unused (borderColorReadable, declared :7541, gates the block at :7721), so this is not a silent fall-back — but it is a live frontend read on a switched-over path and a future edit will use it.
m-4 Managers.cpp:8277-8299 the read-buffer decode takes the FIRST Color[i] whose {Res, Level, Layer} equals ReadSurface. The same image legally attached to two colour points resolves to the lower index; Kind and Layered are not compared. The refusal branch says "refusing to guess", which the match itself partly does.
m-5 report §5 DV-9 the claim "the pull build's preprocessed text — and therefore its object code — is unchanged" is false as worded. Measured (clang++ -E -P with the pull compile_commands.json flags at both revs, diff categorised): 38 differing lines — 23 line = N constants inside ErrorLopper::Loop lambda captures shifted by the insertions, 13 pure added-parenthesis differences from the macro expansion, 2 whitespace re-flows (the border-colour if). Zero semantic differences, and symbol_report --fail-on-symbol-set-change --fail-on-added-bytes 0 is the real gate and passes — so the conclusion holds. Reword DV-9 to claim what is true.
m-6 Managers.cpp:7303, :7563, :11499, :11743 the four #if !MOBILEGL_PIPE_LEGACY_MEMOS "unreachable but loud" bodies were compiled in no build this round: build-linux and build-push both pass -DMOBILEGL_PIPE_LEGACY_MEMOS=1 (verified in both compile_commands.json), and build-verify does not exist in this tree. A syntax error in them would not have been caught. P3a's twin at :4164 has the same property, so this is inherited — but P4a quadruples it. One cmake -DMOBILEGL_PIPE_LEGACY_MEMOS=OFF compile-only configure closes it.
m-7 Managers.cpp:217 / :236 the #if MOBILEGL_PIPE_PUSH around the SamplerViewCso case (:218) sits inside the guard at :182 that already opens the whole dispatcher. Redundant; delete the inner pair.
m-8 SanityTest.cpp (the auto& stale = table.GetOrCreate(first); EXPECT_EQ(stale, nullptr) pair) the first assertion cannot go red for its stated reason: an adopted backward generation also yields a null BackendPtr&, because SlotTables.h's GetOrCreate(handle) does entry.backend.reset() before stamping. Only the following EXPECT_NE(table.FindByHandle(second), nullptr) distinguishes refusal from adoption. Keep both; fix the message so a reader does not trust the wrong one.
m-9 SanityTest.cpp ADeathNoticeForEveryP4aKindIsIdempotent the successor-acquire proof (slot really came back, generation moved) exists only for SamplerViewCso. The five object kinds get "second and third delivery is a no-op" but no ABA leg. ID-8's third case ("notice for a slot re-minted at a new generation") is therefore covered for one of six kinds.
m-10 report §6.4 "Three refusals, one per switched-over texture path" under-quotes: re-running the same standalone scenario, the default arm emits six distinct named shapes (3 texture, 2 framebuffer, 1 program). The classification claim ("no case fails for any other reason") is what matters and it holds — but grep -c 'no applier record' counts only the texture wording, so the number 3 is an artefact of the grep, not of the run.

4. What I verified mechanically (and it all passes)

check result
G5 — the four D-N functions in this package's files Recomputed with my own mask-first extractor (comments and string/char literals blanked, definition = the one name ( whose closing paren is followed by {, brace-matched in the masked text, hashed from the original text, exactly one definition per name). 08192d72 and 9bb95335 give byte-identical shas and they equal §4's four values: d75537bc… StageBlocksIntoUnpackRing, a0c9994d… UnpackRingAvailable, f56d432f… UnpackRingAllocate, 39a37249… RecomputeBackendColorSlots.
ShouldUseCaveatTextureFormat / BackendTextureFormatAddsAlpha untouched Both are in Utils.cpp:245 / :270; git diff --stat 08192d72 HEAD touches three files and Utils.cpp is not one of them.
DV-9 macro hygiene All fourteen macros are #undef'd immediately after their function (:7212-7213, :7776-7783, :11830-11833). grep -rn 'MGB_LEVEL_|MGB_TEXPARAM|MGB_RBO_' MobileGL --include=*.h → no hits: nothing leaks into Managers.h or any other header.
DV-9 pull-text identity See m-5: 38 differing lines, all provably non-semantic.
Purity (G13) grep -rc pGLContext MobileGL/MG_Backend → only MG_Backend/MGPipe/PipeInputs.h:1. awk '/struct MGPipeResourceOps \{/,/^ \};/' MG_Pipe/PipeApply.h | grep -c MG_State → 0.
Logging discipline Diff adds 22 MGLOG_E_ONCE, 2 MGLOG_E (both arm-resolver refusals, once per process by construction), 12 MGLOG_D, and zero MGLOG_I. No leftover debug, no printf, no commented-out code.
Exit order (ID-8) The only new namespace-scope object is SamplerViewImpl::g_backendSamplerViews, a BackendSlotTable whose Entry::stateRef is a weak_ptr and is never written on the handle overload (nothing instantiates GetOrCreate(StatePtr) for it), so it is not a holder of frontend SharedPtrs. No new std::atexit; EnsureProcessTeardownSentinel() is still armed by the first insertion of a driver-id-owning table. The four arm latches are function-local static const Bool in inline functions — trivially destructible, one guard variable, no exit registration.
Death-notice idempotence Argument checked against the mechanism, not the prose: MGPipeSlotAllocator::Free erases the lifetimeId→slot map, BackendSlotTable::OnFrontendObjectDestroyed returns false on the null handle, and ReleaseTwinAt refuses a Gen mismatch. The SamplerViewCso arm (Managers.cpp:228) is a plain OnFrontendObjectDestroyed and cannot free another kind's slot because the allocator resolves (kind, lifetimeId). ADeathNoticeForEveryP4aKindIsIdempotent drives the real GetStateObjectDeathOps()->OnDestroyed, not a stub, which is the right call.
The legacy arm is unchanged Ran the full MOBILEGL_PIPE_PUSH=0 ctest -L integration-gpu -j 8 -R DirectGLES: 99% passed, 6 failed out of 491, and the six are exactly the DirectGLES.HandleRecycle.Handles.* aborts — §6.3's central safety claim reproduced independently.
The default arm Ran the full default-arm lane: 189 failed out of 491, 62% passed — the report's number reproduced exactly. -R HandleRecycle on the default arm gives exactly the same six aborts and nothing else. Standalone repro of the two shapes confirmed verbatim: at 0x1ff+LEGACY_MEMOS=0, exit=134 and Fatal{PipeLegacyMemosDisabled, "MOBILEGL_PIPE_PUSH leaves kMGPipeSubsystemTextureResources (bit 10) clear (or refuses it) and MOBILEGL_PIPE_LEGACY_MEMOS=0 disables the pre-handle texture cheap-gate trio, so there is no arm to run"}; at 0x1fff the abort is gone and only named refusals remain. The ~/w7/p4a-esprytobj-lanes*.log files no longer exist (deleted per ID-5), so §6.3/§6.4's failure sets could not be diffed against their logs — see §6.
No silent fall-back Walked every #if MOBILEGL_PIPE_PUSH arm's decline path: SyncMipmapsToBackend :6102-6108, ResolvePushedBuiltinSampler :7225/:7237/:7249, SyncTextureParamsToBackend :7439, SyncToBackend(fbo) :8452/:8466, SyncReadBufferToBackend :8271/:8290, SamplerObject::SyncToBackend :11486, RBO::SyncToBackend :11730, program :11237. Every one names the handle and returns (the program one deliberately leaves its memo rather than stamping 0, which is the right direction). The only frontend read left under a handle arm that I could not justify is m-3's dead one — and M-2's, which is a design gap rather than a fall-back.

5. The twelve deviations, judged against ID-12

DV verdict
DV-1 Accepted as the C.7 boundary note ID-12 rules, with M-4's correction: the note explains why the resolution sites are E's, but not that the adoption helper and the two new registry methods end up with no caller on either branch.
DV-2 As ruled. c0c mints kMGPipeDepthStencilModeDepth/Stencil; D's rework replaces the bare != 0 in MGB_TEXPARAM_DS_MODE (Managers.cpp:7498-7500) with the named constant. The chosen direction (zero decodes to GL_DEPTH_COMPONENT) is right for the reason given and I could not fault it.
DV-3 KNOWN rework per ID-12; not re-found. I verified the scope: the packed field is compared in exactly five places (listed in §7) and nothing else in D compares MGPSubData::Target (Desc.Target is never read anywhere in Managers.cpp; MGPFramebufferState::Target at :8463-8473 is a different field). Wire confirms the hazard: PipeApply.cpp:756 stores entry.UploadTarget = record.Target — the whole packed field — while D matches static_cast<Uint16>(TextureUploadTarget), so today every texture upload would be dropped, silently, on the handle arm.
DV-4 As ruled and the cheapest of the four: D never reads Kind, and SyncReadBufferToBackend's emptiness test is MGPipeHandleIsNull(record->ReadSurface.Res) (:8277), which D-C1 fixes independently of the enum. c0c's constants make the code clearer but no rework is required here.
DV-5 As ruled, but the ownership in the report is wrong (M-3). All four masks are in D's file — IsSnormFallbackAttachment Managers.cpp:8051, IsUnormFallbackAttachment :8067, IsAlphaWidenedColorAttachment :8098, IsIntegerColorAttachment :8149 — so moving them onto MGPSurface::TextureTarget is D's rework, not "contract + integrator, until then D leaves them alone". The analysis behind the deviation (no TextureUploadTarget → TextureTarget inverse exists; inventing one would feed a D-N-pinned function a guessed input) is correct and is why the field is the right answer.
DV-6 Accepted as argued, and I confirmed both halves: DecodePushedDrawBuffers (:8237-8247) is total for Color0..7 and -1 → None, and the D-O row survives — the apply is still gated on asTarget == FramebufferTarget::Draw (:8499), as is the snorm/unorm/widened/integer mask block (:8535), so a Target = Both record synced as READ still cannot land glDrawBuffers on the wrong framebuffer.
DV-7 Accepted as a boundary note, with M-3's correction to who owns it.
DV-8 Accepted; D-H3 is unambiguous and the code matches it (:11582 stamps identity + serial only). The step message does read the other way and the deviation says so.
DV-9 Accepted as G1-forced, with m-5's rewording and m-6's gap. The measurement behind it (lambda $_N renumbering; +9 / -2 bytes) is the right kind of evidence and I did not try to re-derive it.
DV-10 Fine.
DV-11 Fine structurally — every #if !MOBILEGL_PIPE_LEGACY_MEMOS body is inside a push arm — with m-6 (never compiled) and one asymmetry worth a line in the rework: SyncMipmapsToBackend and the framebuffer pair express the arm choice as if (pushedStorage == nullptr) / if (FramebufferSubsystemEnabled()) rather than #if/#else, so their pre-handle text is not removed under LEGACY_MEMOS=0 and gets no "loud unreachable" body. Unreachability still holds (all four resolvers pass legacyArmSurvivesLegacyMemos=false), so this is a consistency note, not a defect.
DV-12 Fine; §4's one-off equivalent copies the parent script's shape faithfully and I reproduced its four shas with an independently written extractor.

6. What I could not check, and why

  • §6.3/§6.4's failure sets. ~/w7/p4a-esprytobj-lanes*.log are gone (ID-5 says the owner deletes them at the end of the round, so this is compliant, not a lapse). I reproduced the default arm's count (189/491) and the six aborts exactly, and I confirmed on a representative scenario that the only [ERROR]: MGPipe lines are named refusals — but the per-case classification of all 183 rests on the report's own log, which no longer exists. Keep the logs until the review closes in future rounds; §6.4's whole argument is a log-line attribution.
  • The 0x1ff lane. Only the 0 lane was re-run in full (6/491, the six aborts and nothing else). §6.3 says both outer lanes see the identical set because the ctest ENVIRONMENT property replaces the job env, which the 0 run confirms as far as it goes; the 0x1ff run would prove the same property from the other side and costs four minutes.
  • build-verify does not exist in this tree, so G4's retain-mode comparison — the only gate that can check a consume-and-clear set (D-D5) — has not been run anywhere in the phase yet.

7. Rework list for D's verification round

Blocking (must be done before the real-path round):

  1. C-1 — decide and implement the not-currently-bound framebuffer case. Sites: Managers.cpp:8213-8225 and :8459-8479; the five callers are DirectGLES.cpp:6474, :6475, :7960, :7980, :7997, :8017 via SyncAndBindFramebufferObject. Coordinate with A/B if the answer is a new record; raise it as a contract deviation if it is not.
  2. M-1 — make the handle arm's per-level dirty question cover the server's own re-dirty (Managers.cpp:6046-6049 and :6053-6060), and enumerate the three server-side MarkStorageDirty sites in the comment beside it (Managers.cpp:5127, DirectGLES.cpp:7406, DirectGLES.cpp:6735).
  3. ID-12 DV-3 — decode the HIGH BYTE. The cheapest correct patch is two lines, in the two helpers rather than at the three call sites, so the static_cast<Uint16>(TextureUploadTarget) spelling stays where it reads naturally:
    • Managers.cpp:3752 (in FindPipeTextureUpload, :3745): pending.UploadTarget == uploadTarget → MGPipeSubDataUploadTargetOf(pending.UploadTarget) == uploadTarget;
    • Managers.cpp:3768 (in ConsumePipeTextureUpload, :3757): pending.UploadTarget != uploadTarget → the same decode. The three call sites that pass the bare enumerator are Managers.cpp:6047-6048 (MGB_LEVEL_NEEDS_UPLOAD), :6056 (MGB_LEVEL_UPLOAD_DONE) and :6702-6705 (the staging block's pendingUpload) and need no edit under that patch — but they must be re-read against c0c's final helper signature (Uint32 arguments). Nothing else in D compares MGPSubData::Target — verified by grep; Desc.Target is never read and MGPFramebufferState::Target is a different field.
  4. ID-12 DV-5 — move the four cross-object masks onto MGPSurface::TextureTarget: Managers.cpp:8051 IsSnormFallbackAttachment, :8067 IsUnormFallbackAttachment, :8098 IsAlphaWidenedColorAttachment, :8149 IsIntegerColorAttachment. All four are D's file (M-3); ShouldUseCaveatTextureFormat / BackendTextureFormatAddsAlpha stay byte-identical and only their inputs change. Consult TextureTarget only when Kind == Texture, treat 0xFFFF as "unknown" and decline rather than guess.
  5. ID-12 DV-2/DV-4 — swap MGB_TEXPARAM_DS_MODE's != 0 (:7498-7500) for kMGPipeDepthStencilModeStencil; optionally tighten SyncReadBufferToBackend's emptiness test with kMGPipeSurfaceKindNone.
  6. M-2 — either drive SyncMipmapsToBackend's shape from pushedStorage->Desc (the brief's d2), or record it as an explicit, argued deviation with an owner. Silence is the one option that is not available, because no monolith lane can expose it.

Non-blocking but owed in the same round:

  1. M-3 — correct DV-7 and §7-13 in esprytobj-v1.md; tell the integrator that the attachment-walk re-key is D's, not E's, and that E closed D-E3 through SyncReadFramebufferTextureAttachments.
  2. M-4 — give AdoptTwinByHandle / GetOrCreateByHandle / ReleaseByHandle a first caller, or move them to the package that will have one, and say which in the report.
  3. m-1, m-2 — consume SrcOffset; assert the per-region stride invariant.
  4. m-3 — hoist MGB_TEXPARAM_BORDER_FORM inside the borderColorReadable guard.
  5. m-5 — reword DV-9 to the measured truth (23 __LINE__ constants + 13 parenthesis-only + 2 re-flows; symbol-set and byte-size unchanged).
  6. m-6 — add one cmake -DMOBILEGL_PIPE_LEGACY_MEMOS=OFF -DMOBILEGL_PIPE_PUSH=... compile-only configure to the package's verification block so the four "loud unreachable" bodies are at least compiled once.
  7. m-7 — drop the redundant nested #if.
  8. m-8, m-9 — fix the over-claiming assertion message; add the successor-acquire leg to the five object kinds in ADeathNoticeForEveryP4aKindIsIdempotent.
  9. m-10 — restate §6.4's refusal census with all six shapes.
  10. Keep ~/w7/p4a-esprytobj-lanes*.log until the review of the round closes.

8. What the integrator must re-run on the integrated tree

Beyond §7 of esprytobj-v1.md, which is otherwise sound:

  1. The DSA / named-framebuffer set, explicitly, because C-1 is the one failure that will look like a B-side seam defect: ctest --test-dir build-push -L integration-gpu -R 'ClearThenReadPixels|Orientation|FramebufferChurn|DepthStencilReadback' plus ctest --test-dir build-push -R 'FramebufferTest.NamedFramebuffer'. If C-1 is fixed, these go green with the rest; if the fix is a decline-with-a-name, they will still be red and the integrator needs to know that before reading the number.
  2. The image-bindable remint set, for M-1, one dispatch and one readback apiece: ctest --test-dir build-push -L integration-gpu -R 'ImageLoadStoreSso|FormatlessImageBake|ImageSizeAfterRespec|ImageTargetKind|SampledSetStaleness', and confirm TextureParamsWithoutASamplerViewScenario.AnImageUnitOnlyTexturesSwizzleSurvivesARequireImageBindableStorageRemint is green and that a content assertion exists beside the swizzle one — today's case checks the swizzle, which M-1 does not break.
  3. G4's retain-mode comparison (build-verify, -L integration-verify) — it has not run anywhere in this phase and it is the only mechanism that can check a consume-and-clear set. D-D5's whole safety argument is unverified until it does.
  4. The residual-refusal check, per shape, not per count. With MOBILEGL_LOG_FILE_PATH set, the integrated tree must show zero of all six shapes, not three: no applier record on the handle arm, so its {parameters,built-in sampler,storage and uploads}, has no {draw,read}-target applier record, and has no shader-CSO applier record. A residual of any one of them is a seam defect (P3a's lesson), and the framebuffer two are the ones C-1 will masquerade as.
  5. MOBILEGL_PIPE_PUSH=0x9ff once F's ObjectSubsystemControlScenario exists — D's half (the bit-11-requires-bit-10 MGLOG_E and the legacy fall-back, ResolveSamplerSubsystemArm, Managers.cpp:3647-3665) is in and correct.
  6. The six itest phase pins 0x1ff → 0x1fff (MG_IntegrationTest/CMakeLists.txt:949, 1065, 1075, 1149, 1183, 1188, 1219) and 0x80000000000001ff → 0x8000000000001fff (:1070, 1080) — F's, and until they move the six .Handles aborts are red on the integrated tree. I reproduced them and their Fatal verbatim; the attribution in §6.3 is correct and needs no re-argument.
  7. GLIBC_TUNABLES=glibc.malloc.tcache_count=0 on the unit and integration runs (ID-18/21), and the ID-8 leak/idempotence half on the DirectVulkan lane — which lives in F's HandleRecycleScenario …ReturnTheirSlots cases (G8b), not in D's SanityTest.cpp. Confirm F wrote one for SamplerViewCso, the kind with no frontend object: nothing in D or E can test it there.