OpenMaidEngine/docs/phase-a-slice-plan.md

Phase A — Vertical Slice Plan (the first build step)

Concrete execution plan for Phase A of remake-architecture-and-roadmap.md. Decided over the alternative (fully decoding SCJUMP.BIN) after recon showed SCJUMP is not the gating unknown.

Why the slice, and why headless-first

SCJUMP recon (2026-07-06): SCJUMP.BIN is a 29,796-instruction progression state machine, not the call-script registry. Top level switches on global 0x3234 (mode 1–9 → big blocks); each block is nested eq/ne/and/jcc on flags, ending in movs to output globals. Almost no call-script. So it decides what scene/branch comes next via state, and does not resolve call-script id → code. Consequence: the id→code registry stays engine-level (deferred), but the slice can stub call-script — it is not gating for running one scene's dialogue.

Correctness bootstrap (roadmap §5) drives the ordering: the VM must be validated-correct before it is trustworthy. Our strongest oracle is build/text/dialogue.jsonl (the show-text lines per script). So the very first slice is headless and text-only, validated by that oracle — no Godot, no AGF, no audio, no dispatch registry. Only once the VM reproduces dialogue do we add rendering.

Phase A therefore splits:

• A0 — headless VM, dialogue-validated (Python prototype). ← immediate, executable now.
• A1 — port the validated model to C# (the runtime's VM core).
• A2 — Godot ADV backend (render one scene with visuals + voice).

---

A0 — Headless VM validated by the dialogue oracle

Goal: a Python interpreter that executes one ADV scene's bytecode and emits its show-text sequence; that sequence is a coherent, in-order subsequence of the script's static dialogue.jsonl lines. This proves the execution model — control flow, operand/pointer semantics, string handling, and the no-op-marker assumptions — before any C#/Godot investment. Reuses tools/sys4load.py for all parsing/decoding (no new parser).

Execution model to implement

• Memory: one flat global bank = dict[int,int] (globals are raw offsets into one space; global-int A ⇒ G[A], default 0). Per-call local frame with typed banks sized by header F0–F5 (local_int[F0], local_float[F1], local_string[F2], …).
• PC / control flow: build offset→instruction-index map from sys4load instructions (each has .offset = dword index; jump targets are dword indices). jmp t → pc = map[t]. jcc(cond, A, B) → cond truthy ? goto A : goto B, where 0xffffffff = fall through (confirmed model from RECOVER).
• Operand resolution by type: imm→value; global-int→G[value]; local-int→frame.int[value]; string(2)→decoded string at dword offset; float/global-string/etc. analogous.
• ⚠ Pointer/lvalue semantics — the key modeling task. RECOVER proves -ptr operands are lvalues: lookup-array(dst_ptr, base, idx) yields a reference to G[base+idx]; mov through a ptr writes to the referenced cell; reading a ptr rvalue dereferences it. Model a ptr slot as holding an address into the global bank; nail this so the RECOVER array-copy produces correct results (unit test it directly).
• Opcode handlers (~52 named ops):
  • arithmetic/bit add sub mul div mod and or sar shl → p1 = p2 ⊙ p3.
  • compares eq ne lt lte gr gre → 0/1.
  • mov (incl. through ptr), lookup-array (p1=mem[base+idx]), lookup-array-2d (p1=mem[base + i*stride + col]), copy-to-global, set-array-to, bit-set/reset, check-bit.
  • control jmp call jcc ret exit exit-script.
  • string set-string concat strlen toString.
  • ADV capture: show-text → append (arg text) to the emitted list; end-text-line, wait-for-input, set-font, comment → capture/skip (no visible state).
• Markers → no-op (this TESTS the classification): 0x1f4 0x1f5 0x1d5 0x1bc 0x1bf skip; tentative 0x21b 0x1d2 0x258 skip — if dialogue stays correct, the no-op assumption is validated.
• call-script → STUB: log (id), return immediately. (Its dialogue belongs to other scripts; stubbing keeps the emitted set = this script's own lines.)
• Effectful (draw/texture/audio/ui/input) → STUB: log and ignore.
• Unknown/other opcodes → log + no-op, so a rare op doesn't halt the run (record coverage).

Oracle & scene choice

• Oracle: with calls stubbed and default state, every emitted show-text line must be a real decoded string from the script's pool, and the sequence must be an in-order subsequence of that script's dialogue.jsonl lines (≈ equality for a linear scene). Catches: garbage strings (bad operand/ptr handling), impossible ordering (bad control flow), missing/extra lines.
• Scene pick: choose a short, mostly-linear ADV scene — high show-text count, low jcc density, few call-script. Selection step: rank SC####/SP#### by (show-text count) / (jcc + call-script count), small size. Known-good fallback: SC0030.BIN (dialogue verified). Also run a RECOVER unit test to validate pointer/array semantics independent of dialogue.

Steps

1. tools/vm0.py: load a script via sys4load, build offset→index map, frame + global bank.
2. Implement operand resolution + the arithmetic/compare/mov/lookup/control handlers; unit-test on RECOVER.BIN (array copy + both loops must produce correct global writes).
3. Add ADV capture + markers-as-noop + call/effectful stubs; add opcode-coverage logging.
4. Run on the chosen linear scene; diff emitted show-text vs dialogue.jsonl (subsequence check); eyeball the first ~15 lines for coherence.
5. Iterate until several scenes pass; record which ops/markers were exercised and any surprises (esp. whether the tentative-no-op markers hold).

Success criteria (A0 done)

• RECOVER unit test passes (pointer/array model correct).
• ≥3 ADV scenes: emitted show-text is a coherent in-order subsequence of their dialogue.jsonl, no garbage strings.
• Coverage report of which opcodes actually executed (drives A1/A2 priorities).
• The no-op-marker assumption is confirmed or corrected with evidence.

---

A0 result (2026-07-06) — execution model VALIDATED

tools/vm0.py built (reuses sys4load; ~250 lines). Results:

• RECOVER unit test PASSES — all 7 checks (block-1 3-field copy, block-2 restore + flag, both skip-guards). The pointer/lvalue model, 2D stride indexing, both loops, and two-way jcc all execute correctly. The core execution model is proven.
• Full SC/SP oracle sweep (vm0.py --sweep): 282 / 294 scenes DIALOGUE-VALID = 95.9%. Every emitted show-text line is checked (by string offset) as an in-order subsequence of the script's static dialogue.jsonl lines. Zero STRAY and zero ORDER violations across all 294 scenes — the model never emits a garbage string and never emits dialogue out of order. 279 CLEAN (valid + natural exit); 3 OK/LOOP (valid subsequence, halted by the loop-guard); 12 EMPTY; 3 skipped (no static show-text). SC0000 = 326 static / clean; SP0062 = 220/220 CLEAN.

A0-remainder work done (2026-07-06, session 2):

• Loop-guard added (EMIT_CAP=2): halt a run once any single line is re-emitted a 3rd time — a semantic guard tied to the oracle (vs. a blind step limit), and it classifies the scene LOOPED instead of spewing garbage. The 3 zero-state spinners (SC0010/SC0600/SC0200) now terminate cleanly in <12k steps and their emitted lines are all valid.
• SP0062 "stray" was a measurement artifact, not a bug — the precise offset-based oracle shows it CLEAN (220/220, natural exit). Offset-match ⟹ text-match (VM decodes each string at the same offset the extractor did), so CLEAN is trustworthy.
• 0x71 (label-def) folded into the no-op marker set — structural, no runtime effect.
• Sweep + single-scene diff harness added to vm0.py: --sweep [N] (coverage table over all SC/SP), --scene NAME (detailed diff for one script), plus load_oracle/subsequence_status.

op 0x90 investigated in depth — it is input chrome, NOT a correctness hole (full evidence: vm-map/opcodes.toml op 0x90 details). Kelebek left it "ukn"; corpus analysis resolves it: 0x90 x y w h tgt_a tgt_b tgt_c (argc 7) is a cursor/input hotspot hit-test that branches per interaction outcome and falls through to pc+1 when nothing matches (design-confirmed: enc.len 15 lands the next instr on the fall-through statement). It occurs ONLY in a shared ADV-chrome subroutine that is byte-identical in all 301 ADV scripts — exactly 8 sites each (5 immediate-rect buttons at (684..772, 572) toggling G[0x6c9..0x6cd] + 3 local-operand keyed forms), zero scene-specific use. Headless (no cursor/input) ⇒ fall through ⇒ vm0's stub is already correct, proven safe by all 279 CLEAN scenes (which contain these same 8 sites). op 0x97 (argc 5, no targets) is its companion register-hotspot call. So 0x90 stays as fall-through in A1 with confidence; it is modelled as a live hotspot test only in A2 (Godot input backend), confirming target→state mapping via Frida.

The 12 EMPTY scenes — state-gated interactive screens, not a model failure. Traced SC0830: it exits early because G[0xaba5c]==1 gates the content; past that gate the dialogue sits behind the ADV input-wait loop (the hotspot-polling chrome above), so with no seeded state and no input the scene exits or spins before reaching text. Unlocking them = seed per-scene state + supply input → Phase A2/B, not an A0 model fix.

⚠ Honest scope of the 95.9%: the subsequence oracle proves no-garbage / in-order, not a complete path — inherent to a subsequence oracle run headlessly (interactive/state-gated branches take the no-input path by design). That anti-garbage guarantee is exactly what A0 set out to prove.

Confirmed by this run: the classified no-op markers (0x1f4/0x1f5/0x1d5/0x1bc/0x1bf + tentative 0x21b/0x1d2/0x258, now + 0x71) are safe as no-ops for ADV flow; call-script is stubbable; effectful ops (draw-texture/create-texture/play-voice/0x1f7/0x202/0x203/…) stub cleanly.

✅ A0 COMPLETE. Success criteria met: RECOVER unit test green (pointer/array/control-flow model proven); 282 ADV scenes emit clean in-order subsequences with zero garbage; coverage number recorded; no-op-marker assumption confirmed at scale; op 0x90 (the last big control-flow unknown) resolved as input chrome whose fall-through stub is correct headless. Next = A1 — port the model to the C# VM core, differential-test against vm0.py. 0x90/0x97 stay stubbed (correct headless); the interactive input path + per-scene state seeding land in A2 (Godot backend) alongside the real hotspot model.

A1 — Port the validated model to C# ✅ DONE (2026-07-06)

Reimplement the A0 execution model as the runtime VM core in C# (the language decision from the roadmap; GDScript is too slow for the loop). A0 is the reference: differential-test C# against the Python prototype's traces on the same scenes. Port the container parser too (or load via a shared spec). Deliverable: headless C# VM reproducing A0's results.

Result: engine/ .NET 8 solution (Age.Engine classlib w/ Model/Vm/Sys4/Hosting seams + Age.Cli + xUnit tests). RECOVER passes; the C# trace is byte-identical to vm0.py --trace across all 297 SC/SP scenes (offsets+halt+steps). (Historical: this parity held while call-script was stubbed; once call-script execution landed [2026-07-07], vm0.py was retired from oracle duty and TraceDiffTests removed — see the call-script EXECUTION section.) Version-neutral Script contract enforced (VM core never references Sys4). Spec/plan: docs/superpowers/{specs,plans}/2026-07-06-a1-csharp-vm*.md.

A2 — Godot ADV backend (one scene, with visuals)

Wire the C# VM's effectful ops to Godot: show-text/message window (+ furigana via display-furigana), set-font, wait-for-input, choices, play-voice/play-bgm, and create-texture/set-texture/ draw-texture/draw-string for the background + sprites. Convert the scene's AGF art with the on-disk AGF2BMP2AGF.exe. Resolve just-enough call-script/state so the scene's setup runs (or hand-set the preconditions). Deliverable: the chosen scene playable in Godot — bg + dialogue + a choice + voice — matching A0's text.

A2a — Interactive dialogue loop ✅ DONE (2026-07-06)

Godot 4.7 (.NET, S:/Godot/Godot_v4.7-stable_mono_win64) project in godot/ referencing Age.Engine in-process. VM gained one hook (IHost.WaitForInput, opcode 0x72); suspend/resume via a worker thread + blocking SemaphoreSlim in GodotAdvHost, UI marshalled with CallDeferred. Plays SC0000 page-by-page, pauses at wait-for-input, resumes on click/Enter. Headless self-test (--headless -- --selftest) asserts the emitted 186-line offset sequence == build/vm0-trace.json; A1 engine tests stay 7/7. (Historical: the selftest was later rewritten [2026-07-07] to run a SYNTHESIZED scene through the plumbing and match a live headless run — full call-script handling, no vm0/frozen golden — see the call-script EXECUTION section.) Toolchain: godot --headless --path godot --import → dotnet build godot/Himegari.csproj → godot --headless --path godot [-- --selftest]. Spec/plan: docs/superpowers/{specs,plans}/2026-07-06-a2a-godot-dialogue*.md. Next = A2b: background via AGF2BMP2AGF.exe, play-voice/play-bgm, choices → VM globals, just-enough call-script/state (unlocks richer scenes).

A2b-Background — FIRST-PASS RENDER LANDED (2026-07-06)

Resolution solved (docs/asset-resolution-re.md: resId → files[section_base(scene)+resId]) and wired into a live render. Shipped: Age.Engine/Sys4/ResourceMap.cs (loads build/asset-index.json + build/asset-sections.json; Resolve(scene,resId) → AssetEntry; TexturePath → pre-converted BMP); GodotAdvHost implements create/set/draw-texture (slot → TextureRect composited behind the dialogue in a _stage layer); IHost.DrawTexture + VM dispatch extended to pass the destination x/y (draw-texture args 7/8); project.godot window = 800×600; convert_agf.py searches all archives + --scene batch. Engine 8/8, C# --selftest still byte-matches the vm0 trace (VM behaviour unchanged). Works end-to-end: the VM executes set-texture(resId) → ResourceMap resolves across archives → BMP loads → composite; the full-screen event-CG layer (EV052*) renders correctly as the opening plays.

Known first-pass limitations (all one subsystem = graphics geometry/blend, the next chunk):

1. Only the full-screen layer is correct. Sprites/effects and BG* backgrounds routed through the CG-load subroutine (label_12649) derive width/height/position from native ops we still stub — 0x208 (get-texture-size) + the sprite position/registration/animation chain — so their dst/size are garbage (backgrounds land off-center, e.g. BG030A dst=(300,300); sizes come out 0x0). Only the immediate full-screen draws ((0,0) 800×600) render right.
2. No alpha/blend. AE* full-screen fade/flash effects draw opaque and instant (a static grey/white sheet over the CG) instead of alpha-animating. No chromakey either (sprites would show green boxes — moot until they position).
3. Slot model is an approximation. We use one TextureRect per slot, replace-on-draw. (⚠ Earlier this line claimed "the game blits onto slot 0 as an immediate-mode canvas" — DISPROVEN 2026-07-08: the engine is RETAINED — draw-texture binds a retained object by handle (gfx_object_bind_draw), objects have distinct handles + per-object source slots, composited each frame. See engine-re.md "opening render path is RETAINED".)
4. AGF is pre-converted to BMP offline (convert_agf.py --scene); a runtime C# AGF decoder is deferred.

Next chunk — graphics-geometry/blend subsystem: implement 0x208 (host returns the slot's real image dims) + the sprite position/registration ops so geometry is correct; add alpha/additive blend for fades + green chromakey; likely move to a proper canvas/blit compositor. Fixes sprites, background placement, and fades together. (Superseded: the id-specific plan in docs/superpowers/plans/2026-07-06-a2b-background.md.)

A2b-Audio — WIRED, plays end-to-end (2026-07-06)

Audio wired, OGG plays natively in Godot (no Frida, no decode/geometry work). KEY FINDING — the two audio ops use DIFFERENT addressing (the initial "unified manifest" assumption was WRONG for BGM):

• play-voice → per-scene manifest files[base+id], offset 0 (same as set-texture).
• play-bgm → DIRECT LITERAL NAME id → BGM{id:03d}.OGG (DATA3), NOT the manifest.

Shipped: IHost.PlayBgm/PlayVoice; VM dispatch routes play-bgm(0xbf)/play-voice(0xc4) (both argc 1); the three non-Godot hosts (CaptureHost, test RecHost/CountHost) no-op them so --selftest + engine 8/8 stay byte-identical (audio ops still pc+1, step count unchanged); ResourceMap.BgmPathById(id) (direct name) for BGM + ResourceMap.AudioPath(AssetEntry) (manifest Resolve) for voice; Main loads via AudioStreamOggVorbis.LoadFromBuffer into two AudioStreamPlayer nodes (BGM Loop=true; voice Loop=false, interrupt-on-new). Headless run: 0 OGG-load failures, selftest byte-parity OK.

BY-EAR VALIDATED (2026-07-06, systematic-debugging). User confirmed voices play on their lines (play-voice med→HIGH). Two reports root-caused:

• BGM off-by-one → FIXED (real root cause, resolver changed for BGM only). Real game plays BGM005 for play-bgm 0x5 and BGM008 for 0x8; we mis-played BGM006/009 because we resolved BGM via the manifest (files[5]=BGM006). BGM is actually addressed by direct name BGM{id:03d}.OGG. Proof: play-bgm 0x23 → BGM035.OGG, a real standalone track (the BGM set skips 030-034) that the manifest mis-resolved to a graphics entry (files[35]=EV049AA.AGF). Voices are NOT off-by-one — the manifest interleaves graphics/ voice (files[35]=EV049AA, [36]=MAN999, [37]=EV052CA, [38]=SYL0001), so id-1 would land voices on .AGF (silent) but they play ⇒ voice offset is exactly 0. So the fix is BGM-specific; voices/textures unchanged. Corrects the earlier "Frida-confirmed play-bgm 5→BGM006" record (a mis-attribution).
• Lily silent = correct, form-gated (NOT a bug). Her lines use a 3-way dispatch on form flags G[0xa57](A)/G[0xa58](B)/G[0xa59](C): exactly one is 1 in the real game (her current form), else the line jmps past with no voice. Our harness seeds no globals → all zero → every Lily line skipped. Proven by seeding: audio SC0000.BIN 0xa57=1 → 35 LILA clips fire in order (form B→LILB, C→LILC). Left unseeded by user choice (no dummy state); Lily stays silent until real cross-scene state flow (Phase B) exists.

Diagnostic tool added: Age.Cli audio <SCENE.BIN> [0xADDR=VAL ...] — runs a scene and dumps executed play-bgm/play-voice ops in order (BGM direct-name, voice manifest), optional global seeding. Used for all of the above. Watch-items: BGM looping is whole-file for now (Eushully OGGs may carry LOOPSTART/ LOOPLENGTH Vorbis comments — refine later); play-sound-effect(0xb4, argc 2) left stubbed (arg roles unconfirmed).

A2b-Geometry — 0x208 keystone + blit compositor (2026-07-06)

Spec/plan: docs/superpowers/{specs,plans}/2026-07-06-a2b-graphics-geometry*.md. Shipped & verified: the CG-load subroutine (SC0000.asm label_12649) computes all sprite/background geometry in bytecode (add/sub/div/lookup-array); the only missing native primitive was 0x208 = get-texture-size(slot) → (out_w, out_h). Implemented as a real VM op (IHost.GetTextureSize, writes the two output globals); non-Godot hosts return (0,0) so trace/selftest parity holds (engine 11/11, --selftest byte-identical). Replaced the TextureRect-per-slot approximation with a faithful 800×600 immediate-mode blit compositor (Main.BlitSlot: _screen.BlitRect(src rect → dst) in execution order, one displayed TextureRect; source dims read from the pre-converted BMP header on the VM thread via BmpHeader.ReadDims, so the bytecode's geometry math sees real sizes synchronously). New diagnostics: Age.Cli gfx <SCENE> (headless numeric oracle — dumps per-draw resolved file + computed geometry) and godot … -- --shot <png> [--shot-page N] (page-gated screenshot capture). The opening event-CG sequence renders correctly — full-screen CG at (0,0) with dialogue over it (verified by screenshot, SC0000 pages 1/3).

Slot-0 seed (bug found & fixed via the gfx oracle + user eyeball): slot 0 is the primary/screen surface (800×600), normally created by engine-boot init the single-scene harness skips. Cold, 0x208 measured 0×0, and the anchor-preserve math (base' = center − (w_new/2, h_new)) then wrote a corrupted (−400,−600) into the persistent base globals — so the first CG was grey and CG2 inherited the corruption. Fix: seed _slotDims[0] = (800,600) (and record create-texture(w,h) dims) so the first CG's anchor stays an identity. This is the faithful stand-in for the skipped boot-time primary-surface creation.

Post-opening bg/sprite drift — ✅ RESOLVED (2026-07-07): native gfx ops + missing INIT2 boot state. ⚠ Corrects an earlier wrong "state-divergence-only" verdict here. Symptom (screenshot Screenshot 2026-07-06 211353.png): everything blits through slot 0 as an immediate-mode canvas; the anchor-preserve base globals accumulate drift across differently-sized textures (BG030A→(300,500), next→(450,100), →(800,350)… marching bottom-right; the background ends up pinned off-centre / bottom-right with the rest of the screen grey). Root cause = the stubbed native op 0x215 collapsing every draw onto slot 0 (its return drives label_12649's slot-select).

The canonical decode + verdict now lives in docs/engine-re.md (op 0x215 section) — don't duplicate it here. In brief: 0x215's real handler FUN_0042a0b0 (Ghidra) records its generic 5-dword instruction length and returns a std::map::find over the retained gfx-object registry populated by draw/geometry workers. That return is native retained-object state, not the VM global bank → seeding story-state cannot fix it. So this is (b) a genuine native op, not (a) the Phase-B state-divergence problem. The prior conclusion in this doc — grounded in a 2/s capture_gfx_objects.py poll that mistook script-context records for gfx objects — was wrong: it observed the wrong structure, not the lookup map.

Resolution had TWO halves (canonical decode in docs/engine-re.md, op 0x215 + "The render drift's SECOND half"; don't duplicate here):

1. Native gfx ops (b): the retained-object command-buffer ops (0x1f7,0x1fa,0x1ff,0x202,0x203, 0x212,0x213,0x215–0x21a) were reversed + implemented against a host-side GfxState (VM execution state; engine/Age.Engine/Model/GfxState.cs). 0x215 now returns distinct per-object slots. Correction (2026-07-20): 0x1a2 never belonged to this family; it is the shared SAVE.DAT integer-store half paired with 0x1a3, and its inert GfxState approximation has been removed. See docs/engine-re.md.
2. Missing system-boot state (a): the CG handle array G[0x62455..] is set by boot script INIT2 (via entrypoint SYSTEM4.BIN), which a cold single-scene run skips → all CGs collapsed onto object 0. Supplied via Age.Cli gfx --boot and Godot --boot (run INITCONFIG/INIT2/INIT through GameSession first). So the drift needed BOTH — not story flags, and not native-ops-alone.

Result: with --boot, the opening event CGs render correctly — screenshot-verified live in Godot (--path godot -- --boot; the CGs that were entirely missing now fill the frame). Residual (deferred, not regressions): AE* fade/flash effects draw opaque (alpha/blend deferred — a white "explosion" glow that should fade stays); some object-slot CGs start with a zero anchor (cold gfx objects vs the real game's warm ones — default object geometry is confirmed (0,0) in gfx_object_init_default, so not a missing default). Next visual chunk = alpha/blend + effect fading (0x202/0x203 already store the packed color) + per-frame compositing. NOTE the two-boot gap: our Phase-B --boot runs data *INIT scripts; this added the system boot — a "full boot" should run both.

A2b — Scene completeness gauge (opcode coverage tracker, 2026-07-07)

To stop guessing how "done" a rendered scene is, tools/scene_opcode_coverage.py histograms a scene's static opcodes and classifies each against the C# VM: impl (VM has a handler arm — real or a deliberate no-op like set-font), safe-noop (no arm, but opcodes.toml marks it noop_headless — a statement / block marker, correct to skip), or GAP (no arm and effectful → the VM silently pc+1s past it). The implemented set is parsed from VirtualMachine.cs's case arms (single source of truth, no drift); output is build/scene-opcode-coverage/<SCENE>.md. This makes a half-rendered scene legible: "N ops still stubbed", not "something's wrong and we thought everything ran."

SC0000 baseline: 129 distinct opcodes / 16257 instrs. Instruction-weighted the VM already covers ~94.8% (impl 12368 + safe-noop 3053); the holes are 68 GAP opcodes / 836 instrs (5.1%). The GAP list clusters into concrete backlog buckets (drives the rendering roadmap below):

• ADV on-screen text — draw-string(0x204)×205 + 0x7a text-param×205 (1:1 paired). Dialogue text is currently surfaced via IHost.ShowText → Godot Label; the engine's native glyph/window draw path is unmodeled (cosmetic for now, but it owns text layout/speed).
• Unmodeled gfx-range cluster — 0x21c–0x243 + 0x2bd/0x2bf (e.g. 0x220×66, 0x22f×34, 0x228×33, 0x21e×25): siblings of the 0x212–0x21a command-buffer family we implemented, not yet reversed → the biggest single rendering unknown (likely sprite/effect/blend geometry). RE these next before more compositor work.
• Timing — sleep(0xc8)×20: animation pacing; fades/effects can't animate (only snap) until this exists.
• Audio/SFX — play-sound-effect(0xb4)×24 + 0xb5/0xb6/0xc2/0xd9 (channel/volume/stop control) — stubbed.
• Scene coroutine — 0x7b×6 / 0x7c×2 / 0x140×1: the scene-coroutine framework backlog (multi-object scene setup routes through it; see the "SECOND latent gap" note in the status memory).
• Misc VM-support ops — a long tail (0x75-0x77, 0x85/0x88/0x8b, 0x93/0x94, 0x197-0x1a4, 0x1c7-0x1cf, 0x1fd, 0x20a/0x20c/0x20e, …), 1–2 sites each; mixed markers vs effectful — triage per-op as the VM reaches them.

Re-run per scene (scene_opcode_coverage.py SC0240 …) to gauge any target. The tracker also cross-checks opcodes.toml metadata against VM behavior — it already surfaced 0x259 (script-entry marker) missing its noop_headless flag (now reconciled).

A2b — Sprite transform/animation subsystem, opening slice (2026-07-07)

Spec docs/superpowers/specs/2026-07-07-gfx-animation-subsystem-design.md; plan docs/superpowers/plans/2026-07-07-gfx-animation-subsystem.md; RE in docs/engine-re.md ("0x21c–0x243 sprite transform / ANIMATION cluster"). First slice of the 0x21c–0x243 cluster the completeness gauge flagged.

Implemented (VM records, engine 50/50, full parity — sweep 284 exit/13 STEP-LIMIT unchanged): the four opening-path anim ops — 0x21e, 0x220, 0x234, and 0x238 — were first retained in the port here. Superseded by the 2026-07-10 matrix slice below: the original shared-target interpretation was wrong; 0x21e is scale, 0x220 is translation, and 0x234 is cyclic rotation.

Historical compositor: this slice temporarily used transform Z as alpha. The 2026-07-10 follow-up removes that approximation and applies the native separate scale/translation channels instead.

Tracker delta (scene_opcode_coverage.py SC0000): GAP 68→64 ops (836→741 instrs), impl 49→53, correctly-handled 60→65/129 (50.4%).

⚠ Honest scope — the opening AE* explosion does NOT visibly animate from this chunk. The opening's AE* effect (AE001D → AE002B → AE003B) is a sleep-paced sequence of RETAINED-object loads/draws — verified 2026-07-08 from native code + the raw bytecode (NOT our gfx oracle, which mis-reported these as "slot 0"; see engine-re.md "opening render path is RETAINED"). draw-texture binds a retained object by handle (gfx_object_bind_draw@0x47e870); the SC0000 CG loader supplies handle = CG_array[G[0x62450]] (the INIT2 handle array G[0x62455..]) and a per-object working slot G[0x62452], with sleep (0x64/0x3e8/0x2ee) between steps. Our VM executes the whole load/draw/sleep burst instantly (no timing, no per-frame present), so we only ever see the final retained state; the intermediate AE* frames never get a frame to display. This retained-object channel was the correct architectural seam, but the opening explosion needs frame-pacing — modeling the scene-coroutine / sleep 0xc8 timing (0x7b/0x140/0xc8, still GAP) so the burst is not collapsed. That is the clearly-scoped next chunk for the visible opening animation, and a genuinely different subsystem than the transform/alpha channel landed here. (Correction: an earlier draft of this note called it "immediate-mode slot-0 blits" — wrong; the engine is retained, per the native draw-texture → gfx_object_bind_draw bind.)

A2b — Frame-paced sleep (2026-07-08) — ⚠ did NOT make the opening animate (corrected)

The chunk the animation-subsystem note above flagged as "the clearly-scoped next chunk." Spec/plan docs/superpowers/{specs,plans}/2026-07-08-frame-paced-sleep{-design,}.md; RE docs/engine-re.md ("sleep (op 0xc8)").

⚠ CORRECTION (2026-07-08). The original heading here ("the opening animates ✅") and the "Verified visually" claim below were WRONG — a misread. The sleep op is correctly decoded + implemented and the one-shot dramatic pauses now work, but the rapid opening CG/AE* burst is NOT sleep-paced and did not start animating. Execution trace (via the new --trace-histogram) shows the back-to-back set-texture→draw-texture swaps run with no sleep/wait/present/coroutine between them; what actually paces them is still unknown. The --shot-sequence frames I read (arcane → Lily → maid → sky) were the game holding on key CGs via the sparse one-shot sleeps (slowed further by per-frame PNG-IO), which I mistook for the burst stepping. How the mistake happened: I inherited "the opening is sleep-paced" from this repo's own docs and treated it as verified instead of tracing execution first. What IS solid: the sleep seam, the one-shot pauses, the GfxState race fix, and the tooling. Related: the "493k sleeps" that confused me were a headless artifact (the name-entry poll loop), since fixed — see the "Headless divergence" note below.

Later resolution (2026-07-10): the matching native presentation trace below established that ordinary mutations run burst-fast and first become visible at 0x20c, 0x21c, sleep, or stable input boundaries.

What sleep actually is (RE-confirmed, correct): the Godot compositor (Main.Recomposite in _Process) presents live GfxState every frame; sleep (0xc8) was a GAP so the VM ran the whole burst in microseconds. Implementing it makes the explicit one-shot sleeps (1000/750/200 ms) pause correctly — but those are the dramatic holds, not the rapid burst's pacer.

RE (Ghidra): sleep_op_0xc8@0x420ec0 is non-blocking — it arms a main-loop-polled timer (sleep_timer_arm@0x44cff0; start = ms tick, duration = operand). Operand unit = milliseconds. (Also carries anti-tamper + a generic 3-dword instruction-length write, neither needed host-side.) 0x20c = gfx_op_0x20c_present_frame → host-implicit (our compositor presents continuously) → noop_headless.

Implemented: IHost.Sleep(long) + VM case "sleep" forwarding the raw operand; the 9 non-Godot hosts no-op it → headless/CLI parity held (sweep unchanged 284 exit/13 STEP-LIMIT, emitted offsets/steps identical, selftest OK). GodotAdvHost.Sleep blocks the VM background thread duration ms (capped 10s) — the WaitForInput suspend pattern, time-based — so the main-thread compositor presents each intermediate frame. Behaviorally equivalent to the native non-blocking timer given our threading model.

Race closed: once the VM runs concurrently for seconds, the main-thread SnapshotVisibleObjects truly overlaps VM-thread _objects/_registry writes. GetOrCreate/Register/Release were unlocked → serialized them on the existing (re-entrant) _lock. New GfxStateConcurrencyTests (deterministic repro of the "Destination array is not long enough" crash) + SleepDispatchTests; engine 52/52.

New tool --shot-sequence <dir> [--frames N] (one PNG per frame, auto-advancing past input waits — a time-based effect can't be captured by a single --shot). The frames it produced showed the game holding on distinct CGs (arcane AE* → Lily → maid → sky) — but per the correction above, those holds are the sparse one-shot sleeps, not the rapid burst stepping. (Residual, unrelated: intermediate frames show the cold-object anchor doubling — a geometry issue independent of timing.)

Tracker delta (scene_opcode_coverage.py SC0000): GAP 64→62 ops (741→714 instrs), impl 53→54 (sleep), safe-noop 12→13 (present-frame), correctly-handled 65→67/129 (51.9%).

Open (the real burst pacer): what advances the rapid opening CG/AE* burst frame-to-frame is unknown — not sleep, not present-frame (only 2× in the whole scene), not the coroutine ops (absent from the burst). Next: profile the real Godot run (--trace-histogram) of SC0000's 0x3958–0x3973 loop + gfx-op sequence. The scene-coroutine framework was deferred here; the bounded host model is completed below (2026-07-09).

Diagnostics framework extended (2026-07-08)

Motivated by the misread above (a --trace-steps dump was 2.5M lines → grep/awk). Added, all observe-only (parity preserved): HistogramTraceSink (op + call-site script:pc execution counts + sample operand), TraceSinkBase (per-script step attribution across call-script frames), TextTraceSink op-filter (--trace-ops), CompositeTraceSink, OpcodeTable.ByLabel; CLI --trace-histogram/--trace-ops; Godot --trace-histogram <file> (profiles the REAL run) + --sleep-scale. See docs/tools-reference.md.

Headless divergence FIXED — faithful halt-at-wait (2026-07-08)

The histogram pinned the goose-chase root cause: op 0x72 wait-for-input was a no-op headless, so a run plowed past all 166 of a scene's prompts into the name-entry poll loop (INPUTNAME.BIN) and spun sleep 1 493,182× to STEP-LIMIT — a path no real playthrough reaches. Fix = VmOptions.HaltAtWaitForInput: the VM halts (reason wait-for-input) at 0x72. run/play faithful by default (SC0000 → ~402 steps / 0 sleeps, matching the real path to the first prompt; --plow = old walk-every-page); sweep plow by default (dialogue oracle, 284/13 unchanged) with --halt-at-wait → all 297 scenes halt cleanly (0 STEP-LIMIT). Godot unaffected (really blocks on input). The corpus's 13 STEP-LIMIT scenes were all this artifact, not VM bugs. HaltAtWaitTests.

---

Risks / open questions for A0

• Pointer/lvalue semantics — the main modeling risk; RECOVER is the litmus test.
• Initial global state — a scene may assume preconditions from earlier flow (SCJUMP/prior scenes). Mitigation: default-zero globals + set the few a scene reads early; the subsequence oracle tolerates a shortened path.
• Runtime vs static dialogue order — static dialogue.jsonl is file-order (all lines); runtime is execution-order (branch taken). Hence subsequence, not equality; pick linear scenes to tighten it.
• Hidden effect in a "stub" — a stubbed effectful op that actually gates control flow could skew output. Watch for divergence; promote a stub to a real handler if a scene needs it.

Immediate next action

Build tools/vm0.py and get the RECOVER unit test green (pointer/array/control-flow correctness), then run the first linear ADV scene against the dialogue oracle. That single result tells us whether the whole VM approach executes correctly — the load-bearing question behind option 3.

---

✅ call-script EXECUTION (2026-07-07) — subroutines now run in the C# VM

Spec docs/superpowers/specs/2026-07-07-callscript-vm-execution-design.md; plan docs/superpowers/plans/2026-07-07-callscript-vm-execution.md. Enabled by the native-RE finding that call-script <id> is a raw SYS4INI file index (docs/engine-re.md).

Shipped (engine 25/25 green):

• IScriptProvider (Hosting) + Sys4ScriptProvider (Sys4): id → build/callscript-names.json → name → Paths.Scripts() → Sys4Loader.Load, cached. Injected into the VM so Vm never references Sys4.
• ExecFrame refactor of VirtualMachine: per-script state (script, pc, locals, intra-call stack, per-frame emit-guard) moved into ExecFrame, run by a recursive RunFrame. Globals/Emitted/Steps stay VM-level (shared). Emitted lines now carry their source script name.
• call-script executes: loads the child, runs it as a nested frame sharing globals, returns to the caller at pc+1. exit/exit-script and empty-stack ret return from the frame (top frame → HALT). Depth-capped (VmOptions.CallDepthCap=64; native limit 38). Shared globals are the return channel; per-call locals are discarded on return.
• Product paths (Age.Cli run/play/sweep, GameSession.RunScene) inject the provider. trace + the audio/gfx diagnostics stay provider-less (base-ISA oracle / built against stub behavior).

Design decision (refines the spec): a VM with no provider falls back to the prior stub (host.CallScript(id); pc+1), not a halt. This keeps every existing base-ISA test byte-identical (they construct provider-less VMs) and needs no golden-fixture regeneration; vm0.py retires from oracle duty gracefully — trace/TraceDiffTests/WaitForInputTests stay on the stub path as the base-ISA guard, with zero lockstep maintenance.

Validation: 6 new tests (fake-provider unit tests: return-to-caller, callee exit returns not halts, shared-global visibility, per-frame local isolation, unresolved-id halt, no-provider stub; integration: ADDILL executes ADDILLSUB+CALCREVISE and reaches its own exit; BUNKI's top-level ret returns cleanly). Corpus sweep (execution on): 284/297 exit clean, 13 STEP-LIMIT, 0 depth-cap, 0 unresolved, 0 crashes. The 13 STEP-LIMITs are input/state-gated ADV scenes (SC0000 etc.): executing subroutines makes their global-writes drive caller loops that headless can't break (no input; WaitForInput is a no-op) — the known state-divergence, not a call-script bug (loops hit STEP-LIMIT, not the depth cap → recursion is bounded correctly).

✅ Godot wired + testing approach corrected (2026-07-07, follow-up). The provider is now injected everywhere — no path runs with call-script disabled:

• Godot play path gets Sys4ScriptProvider, so subroutines execute live on screen (and the headless input-wait loops break on real player input, which is why headless-only scenes STEP-LIMIT).
• Testing principle (user-directed): synthesize test data; never disable a feature to keep a real scene matching a frozen number. New Age.Engine/Sys4/ScriptAssembler (code+strings → Script; also Phase-D modding-assembler groundwork). SyntheticSceneTests runs an assembled scene (show-text
  • wait-for-input + real nested call-script + shared-global return) with full handling and asserts its exact output. WaitForInputTests reworked onto a synthesized two-page scene. RecoverTests keeps its ISA-litmus role with call-script handling ON via a no-op subroutine double (isolates the ISA from the real subroutines' state deps). TraceDiffTests retired (it matched the C# VM to vm0.py's stubbed trace; vm0 is off oracle duty and we don't gate handling to keep it matching).
• Godot --selftest rewritten: was "run SC0000 stubbed, match vm0-trace(186)"; now runs a synthesized scene through the Godot thread/semaphore/CallDeferred plumbing and asserts it matches a live headless run of the same scene — full handling, no frozen golden, no vm0 dependency. Verified: godot --headless -- --selftest → "threaded host matches headless (3 lines, full handling)".

Verified live in Godot (2026-07-07): added --scene <NAME> to the frontend and a scene-end report of the call-scripts executed as nested frames (collected thread-safely — Godot drops GD.Print from the VM background thread). SC0240 executes 29 call-scripts (RESETLAND, SETEN, ADDEN, RENDERMAP, SETOBJ, DRAWOBJ, CALCREVISE, LOOK) live in the real runtime; SC0000 renders the opening event CG (windowed).

Remaining follow-ups: optionally give the audio/gfx CLI diagnostics a provider (they still run provider-less); engine-level diagnostics (the next pivot — the engine, not the frontend, should surface script/scene execution + call-script dispatch); decision→scene (scene chaining) rides this same loader once the SCJUMP decision→scene-id native hop is reversed.

A2b — opening speed-through: the pacing lead is ENGINE CADENCE (2026-07-08)

⛔ Correction. An earlier draft of this section claimed "there is no missing pacer — all opening pacing primitives are already shipped." That was retracted: it was inferred from headless op-counts (which cannot render) and it contradicts the direct eyes-on observation that the opening visibly speeds through. Ground truth = it speeds through; the pacer is real and the cause is still open. What survives below is only the mechanically-verified part plus the corrected hypothesis.

Verified (mechanical).

1. The "rapid burst" seen in plow traces is a headless fiction (input-plow). The real back-to-back set-texture→draw-texture swaps are the per-page compositor label_1235a (instruction indices 0x3958–0x3973 = dword 0x123e8–0x12497): a loop over ≤8 gfx object slots that per slot queries state (0x215), erases/releases (0x1f7/0x1fa), and draws with alpha (0x203).
2. Op 0xcd get-input-type is unmodeled in the VM (no case; only 0x72 wait-for-input is handled — two input mechanisms, one modeled). INPUTNAME.BIN:0x1c1 name-entry is a get-input-type→jcc→sleep 1→jmp poll that spins unfed. This is a real but separate gap (interactive blocker), not the speed-through.

The corrected hypothesis (engine cadence, not bytecode). Many opening draws are back-to-back with no sleep between them in the bytecode (e.g. resId 0x29 twice at 0xc45/0xc52; 0x34→0x35 at 0x1467/0x1479), yet the real game paces them. So the pace comes from the engine's execution cadence, not a script primitive. Corroboration: holding Ctrl fast-forwards ADV in the real game (faster, not instant) — a global engine speed governor over interpreter advancement. Suspected cause in our port: the Godot VM runs on a free-running background thread that is not synced to the 60fps compositor, so it blasts an entire page's draws in microseconds and the main-thread Recomposite only ever samples the final gfx-state → the intermediate CGs collapse. The native engine is a cooperatively-scheduled main loop where the interpreter yields per frame under vsync (consistent with sleep already being RE'd as a non-blocking, main-loop-polled timer — which only makes sense if the interpreter yields back to that loop).

Next (open). (1) Determine what actually landed re 60fps/vsync and the VM threading model in godot/. (2) RE the native engine main loop in Ghidra: how it ticks the interpreter per frame, the frame cap/vsync, and the Ctrl speed governor. (3) Frame-lock our VM to the render loop (a per-frame step budget or a per-frame yield/sync point) instead of the free-running thread. Confirm any fix against pixels (windowed --shot-sequence → real PNGs), not op-counts.

A2b — Frame-stepped VM ✅ DONE & MERGED (2026-07-08)

Historical implementation, superseded on 2026-07-10 by the native retained-presentation trace below. The validation recorded here was accurate for that slice, but the inferred native per-op cadence was not: service waits had been folded into an operand-fetch average. Commit 85fc07d removed the production opcode throttle; ordinary work now runs burst-fast to proven publication/pacing boundaries.

Executed the "Next (open)" list above (option 3: a per-frame yield/sync point). Spec docs/superpowers/specs/2026-07-08-frame-stepped-vm-design.md, plan docs/superpowers/plans/2026-07-08-frame-stepped-vm.md; merged to main (74a4221).

What landed (3 TDD tasks):

1. engine/Age.Engine/Hosting/FrameClock.cs — pure, threadless virtual clock: NowMs, Speed (field, 1.0), OpsPerFrame (30), Advance(realΔseconds), EffectiveBudget (= OpsPerFrame*Speed, min 1).
2. IHost.FrameYield() — the VM (VirtualMachine.RunFrame) calls it once per executed opcode (right after Step). No-op in all 9 headless hosts (CaptureHost, the CLI trace hosts, every test host) → headless output byte-identical. This is the parity guarantee.
3. godot/GodotAdvHost.cs + godot/Main.cs — the throttle. Main owns a FrameClock; each _Process it Advance(delta)s the clock and PulseFrame()s. GodotAdvHost.FrameYield() counts ops and, once EffectiveBudget is reached, blocks the VM background thread on an AutoResetEvent until the next _Process advances the clock — throttling the interpreter to ≈OpsPerFrame ops per rendered frame (≈30 → ≈1800 ops/sec, the native rate-limited cadence). Sleep now waits on the same clock (not Thread.Sleep), and the anim tween reads _lastDelta * _clock.Speed, so the single Speed factor scales throttle + sleep + tween coherently. Speed is the future Ctrl fast-forward hook, left unwired at 1.0 (wiring it needs ADV-mode-scope RE; the seam is ready).

Verified. Engine 62/62; sweep exit=284/STEP-LIMIT=13 (parity); Godot SELFTEST OK; windowed --boot --shot-sequence = 16 distinct paced visual states across 120 frames (event-CG → fade/transition → onward) instead of an instant jump to the final frame — the throttle demonstrably steps the opening over real time.

⚠ Residual (NOT this slice — the graphics geometry/blend subsystem). By-eye the opening is still hard to judge because the graphics are still wrong (AE* fades draw opaque with no alpha/blend; cold-object anchors double; multi-surface compositing approximate). Pacing is fixed and mechanically confirmed against pixels, but visual correctness is a separate open chunk the user has deferred. Do not conflate "pacing fixed" with "opening looks right."

Next candidates (deferred). (a) Graphics geometry/blend fidelity — AE* alpha/blend + per-frame compositing + cold-object anchors (the thing that makes the paced opening actually look right). (b) Wire the Ctrl Speed multiplier (ADV-mode-scope RE). (c) Full scene-coroutine framework (0x7b/0x7c/0x140) for interactive multi-object scenes (completed below, 2026-07-09). (d) Model 0xcd get-input-type (name-entry interactivity, the separate input gap noted above).

A2b — Blend & transparency (slice A) ✅ DONE (2026-07-08)

First of three graphics-fidelity slices (A blend/transparency, B geometry/anchors, C render-targets). Spec docs/superpowers/specs/2026-07-08-blend-transparency-design.md, plan docs/superpowers/plans/2026-07-08-blend-transparency.md, branch feat/blend-transparency (engine 69/69, sweep exit=284/STEP-LIMIT=13 parity, SELFTEST OK).

Landed (hybrid: engine resolves, host blits):

• Age.Engine/Model/BlendMath.cs — pure colorkey match + ARGB unpack (colorkey format reversed: op arg 3 <0 = none, else 0xRRGGBB exact-match, 0 = key black; baked at surface-load, see engine-re.md §Blend).
• RenderObject gains Alpha/Tint/Blend (BlendKind Opaque|Alpha|Additive); GfxObject.HasColor; GfxState.SetObjectColor; SnapshotVisibleObjects resolves them. 0x202/0x203 route through SetObjectColor (the stale "alpha deferred" trace stub is gone — alpha is now consumed).
• Godot compositor: colorkey-baked image cache (keyed by (path, colorKey)), BlitLayer applies colorkey + object alpha + RGB-tint modulate, and surfaceless colored objects fill a tint×alpha quad (the fades) instead of being skipped.

Result (pixels): page-1 event-CG composites cleanly (dialogue + prompt, no opaque boxes); the opening's mid-fade frames now alpha-blend (dark bg + light-ray burst, then a blended dark transition) instead of the pre-change full-screen opaque grey wall that ate the CG. Verified via --shot/--shot-sequence on SC0000 --boot.

Deferred (documented, NOT built — confirmed by a stalled interp RE pass, engine-re.md §Blend): smooth color-animation interpolation (the fade ramps snap to the correct end-state rather than gliding — the 0x202 color channel's blit consumer + clock coupling is a dedicated dig) and additive/glow blend (local_2c mode 2/3; its object field isn't pinned). BlendKind.Additive is an unused seam. Next graphics slices unchanged: B (geometry/anchors — sprite placement) and C (render-targets).

A2b — SC0000 anim/transform/spritesheet cluster (partial) ✅ DONE (2026-07-08)

The 0x21c–0x243 gfx cluster, scoped to a tractable subset after Task-1 RE revealed it's heterogeneous (setters + queries + matrix/scale + a movie op). Spec docs/superpowers/specs/2026-07-08-sc0000-anim-transform-cluster-design.md, plan .../plans/2026-07-08-sc0000-anim-transform-cluster.md, branch feat/anim-transform-cluster (engine 79/79, sweep exit=284/STEP-LIMIT=13 parity, SELFTEST OK, coverage SC0000 67→74/129 handled).

Key RE unlock: the dispatch table handler(op)=ctx[0x26c93+op] recovered statically from FUN_00413860 (the opcodes.toml u004xxxx labels are Kelebek drift). Full op→field map in engine-re.md §SC0000 anim cluster.

Built (hybrid: engine resolves, host blits):

• GfxObject gains src-rect (spritesheet) + animated-color channels; GfxState.SetSrcRect / SetColorAnim; BlendMath.PingPong; SnapshotVisibleObjects(long nowMs) = a port of gfx_object_anim_interpolate (looping row-major spritesheet cells + ping-pong color/glow), driven by the FrameClock (the "mach 5" pacing fix).
• Wired 7 ops: 0x22f/0x229 position (direct V24 set), 0x239/0x231 spritesheet (static cell / animate), 0x232 color glow (ping-pong), 0x228/0x23f queries (geometry back to script vars).

Deferred (own follow-ups, per scope decision): 0x21f/0x223 matrix/scale (need affine rendering), 0x236 timed/movie op, and the rare 0x21c/0x21d/0x224/0x242/0x243/0x23d/0x20a/0x20e tail. Adjacent non-cluster gaps remain: draw-string 0x204×205 (on-screen text) and play-sound-effect. Whole-scene visual validation is the user's call (they deferred confirmation until the scene is coherent).

A2b -- Scene-coroutine host model (2026-07-09) -- DONE

The native mechanism is fully reversed in docs/engine-re.md under Scene-coroutine framework. The port deliberately models its observable ADV lifecycle instead of emulating the runtime-resolved video service behind op 0x140.

Bounded model for this slice:

1. Detect only the corpus-wide ADV form 0x140 out "LABEL" "J" in. TITLE.BIN's unrelated "BIN" "SC????.BIN" use remains unmodeled and must not acquire ADV scene-entry behavior.
2. On a top-level entry at offset zero, synthesize native scheduler state G[0xaba5c]=1 for a script containing that ADV form. A captured global-write snapshot cannot supply it because the native scene loader does not set it through the script operand-write helper.
3. At each ADV labeled-yield site, force exactly one setup-body iteration, then return the terminal value encoded by the site's following mov terminal, immediate + eq terminal, out sequence. This handles a stale prior-scene out value and avoids hardcoding SC0000's 0x45e; all 138 corpus ADV sites share the same shape.
4. Record op 0x7b's two saved handler PCs as frame metadata. Consume op 0x7c as the host-scheduler resume marker: the host supplies service-boundary suspension and retained presentation, so it does not recursively execute the native render/poll/yield bytecode handlers.

Acceptance gates: a synthetic stale-terminal scene runs its setup body once and reaches content; a non-ADV 0x140 remains unchanged/stub-reported; real SC0000 executes op 0x140 twice, clears G[0xaba5c], and fills the slot-table columns (G[0x3239..0x324e] = 4..11) before content. Then run the engine suite, corpus sweep, Godot self-test, and live/pixel validation of the previously grey multi-layer page.

Result. The bounded model landed in VirtualMachine/ExecFrame with four focused tests. SC0000 now executes 0x140 twice, runs label_125bd once, clears the native entry gate, and loads resource 0x23 into assigned slot 5 rather than the broken slot 0. Static corpus validation found 138 ADV sites and zero shape mismatches; the one non-ADV TITLE.BIN site remains stub-reported.

Verified: engine 85/85; full sweep unchanged at 284 exit / 13 STEP-LIMIT; Godot threaded self-test SELFTEST OK (3 lines, full handling). The native transition timing remains host-approximated. SC0000 coverage is now 77/129 handled (59.7%), with 52 GAP ops / 613 GAP instructions.

Follow-up — magic-circle teardown fixed (2026-07-09). Ghidra caller analysis corrected op 0x215: it queries the retained gfx-object map and returns obj+4, the source surface slot written by draw-texture; it does not query op 0x1a2's shared-profile integer table. The old host model returned -1 for CG handles, so SC0000 skipped its explicit 0x1f7(handle,10) + 0x1fa(slot) cleanup and left AE001H.AGF (resource 0x37) visible. GfxState.QuerySlot now returns the bound source slot, 0x1f7 erases retained objects, and 0x1fa clears the surface. A booted SC0000 integration regression asserts no visible resource 0x37 remains; engine suite 86/86. Live clicked-path validation confirmed the fix on 2026-07-10: the magic circle now disappears at the intended transition.

A2b — native scale/translation channel split ✅ IMPLEMENTED; exact visual math provisional (2026-07-10)

Replaced the legacy shared AnimTarget / transform-Z-as-opacity approximation with the native channel split proven in Ghidra. Op 0x21e now owns normalized scale (100 = identity; current obj+0x6c, target obj+0xac, delay/duration obj+0x3c/+0x50). Op 0x220 owns absolute translation (current obj+0x16c, target obj+0x1ac, delay/duration obj+0x44/+0x58). Consumer gfx_object_apply_transform_channels (0x472f00) establishes a shared first-frame start timestamp, independent delayed linear interpolation, and target commit on completion.

GfxState samples both channels from FrameClock; Godot applies scale around V18 plus independent translation, including nearest-neighbor scaling/flips in the software blitter. Op 0x234 no longer overwrites either matrix: the completed consumer RE corrected it to a separate cyclic rotation period+axis channel (retained now; affine rendering deferred). No transform Z value contributes to opacity.

Focused validation: six matrix/rotation tests cover channel independence, VM dispatch, shared-start delay/duration sampling, target commit, and non-opacity Z values. Engine 86/86 and Godot build pass. Booted SC0000 with --shot-sequence + --gfx-log: 180/180 PNGs, 152 log lines, and zero unresolved/error/NaN/Infinity outcomes. The visible circle expands around its anchor through sampled scales 1.00 → 1.22 → 1.44 → 1.66 while remaining op=1.00, then the retained object is logged GONE. This validates removal of the transform-Z opacity shortcut and shows the scale channel affecting geometry in the capture. It does not prove the port's exact matrix calculation, anchor interpretation, multiplication order, or 2D projection: normal playback still races past these sections too quickly for a reliable visual judgment. Treat that math as provisional until the pacing slice enables slow normal playback and a native-versus-port frame comparison.

A2b — animation pacing + matrix validation ✅ (2026-07-10; pacing model superseded)

This slice initially interpreted roughly 1,788 vm_operand_fetch calls/s as evidence for a refresh-independent 200 completed-opcode/s allowance. That scheduler interpretation is superseded: the probe counted operand reads and mixed burst execution with time parked in native services. The matching presentation trace below proves ordinary work is burst-fast; --speed now scales sleeps and retained presentation clocks, not opcode throughput. Input remains ignored unless the VM is actually at wait-for-input.

Live native capture recorded the complete 0xcbc0 scale ramp (1→5 over 1,890 ms), including the exact composed matrices. The 215/s and 200/s port replays were useful historical diagnostics showing that object lifetime had been coupled incorrectly to script progress, but those rates are not native scheduler constants. Native matrix terms and the port's focused tests agree on row-vector anchor + (point-anchor)*scale + translation; for base (0,600), anchor (400,1000), scale 5, both project to (-1600,-1000). Exact axis-aligned anchor/order/projection is validated; cyclic-rotation rasterization remains the next affine-rendering slice.

Verification: engine 92/92 after the opcode-clock reset test, corpus sweep unchanged at 284 exit / 13 STEP-LIMIT, Godot build and threaded SELFTEST OK. The transform capture tool and transform-aware --gfx-log are documented in docs/tools-reference.md.

A2b — ADV transition/lifecycle diagnosis plan ✅ COMPLETED BELOW (2026-07-10)

This is the next SC0000 correctness slice. It is driven by live A/B observations, not by static opcode coverage alone. The direct SC0000 histogram is currently 80/129 distinct ops handled (62.0%) and 96.2% instruction-weighted, but a rare query, scheduler op, or render worker can still control an entire visible section. Coverage also excludes called scripts; this slice follows only callees actually entered on the failing path rather than expanding into blanket subscript completion.

Observed native ADV contract (client behavior): foreground presentation changes are transitions even when they are only in-place fades. SC0000 begins black and fades into the first CG; the message window then fades in before text reveals. During a CG swap, the window transitions out, one or more CG transitions run, then the window transitions back in. A click during an active foreground transition completes it immediately and lets the next presentation step start; a click at a stable wait-for-input advances the script. Ambient retained animation is a separate class and must not all be completed by that click.

Current port failures (2026-07-10):

• The initial black state holds and then the first CG pops in instead of fading. This is consistent with the port applying op 0x202's endpoint as a static tint while its native animated-color consumer remains unmodeled.
• The retained textbox artwork appears to begin fading in, then disappears. The Godot Label shortcut stays visible; it is deliberately out of scope for this slice because native draw-string/text presentation will replace it before SC0000 is called complete. Diagnose the box object's lifetime, not the shortcut text.
• The late animation burst before the first music change is badly wrong, then the screen becomes white and interactive play does not proceed to the music change.

Concrete failing boundary. BGM005 begins at SC0000 offset 0x7fa; the expected first change to BGM008 is play-bgm 0x8 at 0x1728. The immediately preceding block 0x133f..0x1725 exercises repeated 0x202/0x203 color operations and the implemented geometry/scale family, but also directly executes three still-stubbed gfx ops: 0x236 at 0x13c8, 0x1fd at 0x14f3, and 0x21f at 0x159a. It calls the shared animation finalizer label_1235a several times, including at 0x1725; that finalizer sets op 0x238's duration, then reads still-unimplemented 0x1c7 get-message-skip and 0x1cc get-adv-service-state to choose its present/yield path. Therefore the white stall could be an object/compositor error, an unmodeled foreground-transition gate, or wrong control flow caused by a stubbed output—not safely assumed to be “just interpolation.”

Investigation order

1. Make the failure boundary deterministic before changing semantics. Reproduce from --boot with auto-input and a long enough --shot-sequence, plus --gfx-log. Add a single synchronized diagnostic timeline if the existing logs cannot answer the boundary: frame/virtual time; active script + PC/opcode; VM state (running, sleep, transition, input wait, halt); BGM event; and every changed visible object's handle, surface slot/resId, tint/alpha, transform, and lifecycle event. Use play-bgm 0x8 @ 0x1728 as the reachability sentinel. Do not judge progress from the white pixels alone.

2. Classify before fixing. If the VM reaches/passes 0x1728 while the frame stays white, identify the topmost white/fill object and whether its handle remains visible, loses/rebinds its live surface, or has a stuck color endpoint. If the VM never reaches 0x1728, record the last PC and whether it is sleeping, input-waiting, transition-waiting, polling, halted, or still executing. If the executed path itself is suspect, capture the same native passage with trace_engine_ops.py and use diff_optrace.py to find the first engine/port offset divergence.

3. Track the textbox artwork as an AGE object. From its first visible frame, identify its retained handle and follow bind, color/animation, present, erase, release, and surface-rebind events through the first CG swap. The key result is one of: GONE (premature erase), still present but covered (z/lifecycle input), still present but transparent/tinted (color channel), or bound to a replaced slot (surface lifetime). Compare only those corresponding native object events; do not spend this slice synchronizing the Godot text overlay.

4. Recover the foreground ADV transition contract. Reverse/capture the producer behind get-adv-service-state (0x1cc), implement the already-known get-message-skip output (0x1c7), and observe what a click changes during the initial fade and the pre-0x1728 burst. Establish an explicit host-level foreground transition with start → per-frame progress → natural/forced completion → resume. Click completes and consumes the active foreground transition; only a stable input wait advances content. The wall clock remains the progress source and opcode pacing remains a guard within runnable bursts, not the mechanism that decides how long a presentation state lives.

5. Reverse only the executed missing gfx dependency that remains causal. Triage the three direct gaps in failing-order: 0x236 (timed/animated-surface worker), 0x1fd (scaled vector/animation setter), and 0x21f (affine/matrix channel). For each, capture native inputs, retained fields, and sampled output at the exact SC0000 site; implement it with a focused VM/state/compositor test. Do not declare a stub harmless merely because it is rare, and do not implement the whole remaining opcode list without evidence.

6. Validate as presentation checkpoints. Native/manual observation remains the final visual oracle, but each check should first have machine evidence (PC reached, object identity/lifetime, transition progress, and final state). Required checkpoints: black visibly ramps into the first CG; the textbox artwork survives until its intended transition-out; a CG swap orders window-out → CG transition(s) → window-in; clicking an active transition snaps to its endpoint without also advancing a stable page; the late burst has no stuck white owner; and execution reaches BGM008 @ 0x1728. Re-run engine tests, corpus sweep, Godot threaded self-test, and the SC0000 coverage report after each landed opcode or scheduler change.

Stop conditions / scope guard: this slice is complete when the port reaches 0x1728 interactively and the above foreground transitions have correct lifecycle/click behavior. Native glyph rendering, configurable text reveal speed, and unrelated subscript opcode completeness remain separate work. Any called script proven to own the first divergence becomes an explicit dependency of this slice; otherwise it stays out of scope.

Investigation 1 result — deterministic boundary classification (2026-07-10)

Added the observe-only Godot --timeline-log <jsonl> diagnostic so VM steps (real byte offsets), virtual time/frame, host state, BGM events, and changed visible-object outcomes share one ordered stream. The reproduction was SC0000 --boot, stable-wait auto-input via a long --shot-sequence, --gfx-log, and a uniform diagnostic --speed 8; speed scales VM, sleeps, and animation clocks together and does not inject input outside wait-for-input.

Classification: not a VM/control-flow stall on the deterministic path. The run executed all three direct gaps (0x236 @ 0x13c8, 0x1fd @ 0x14f3, 0x21f @ 0x159a), called the finalizer at 0x1725, then executed play-bgm 0x8 @ 0x1728 in running state at frame 818 / virtual 70,262 ms. The BGM event resolved to BGM008.OGG in the same synchronized event and execution continued through 0x172b and beyond; the full 1,800-frame run reached page 80 and five BGM events. Therefore a native offset-path diff is not warranted for this boundary unless a separately reproducible manual-input path fails to reach the sentinel.

The full-screen fill owner is retained handle 0xcf08, but it is not stuck at this boundary. It was a transparent white 800x600 fill (a=0.00) when 0x1728 executed. Later, 0x203 @ 0x1337f made it solid white for one sampled diagnostic frame (frame 911); the following label_1235a path executed 0x1c7, 0x1cc, and 0x21c, and the compositor sampled the same handle back at a=0.00 on frame 912. This is evidence of a likely incorrect flash/color presentation contract, not evidence for the reported pre-BGM infinite stall. No opcode, scheduler, or compositor semantic fix was made in this investigation step.

Validation after adding the diagnostic: engine 92/92, Godot build clean, threaded SELFTEST OK, and git diff --check clean. The headless --shot-sequence PNG capture path emits dummy-renderer GetImage errors, but the CPU compositor/timeline completed and the same path already had this limitation; use a windowed sequence when pixel files rather than object-state evidence are required.

A2b — cyclic rotation and affine rasterization ✅ DONE (2026-07-10)

This bounded slice followed the non-reproduced white-stall classification above; it did not resume that investigation and does not claim the interactive symptom is fixed.

Native contracts. Op 0x21f is a delayed one-shot axis-angle rotation, not a generic matrix row: (handle,delay,duration,axisX,axisY,axisZ,angleDegrees). It shares obj+0x34's start with scale/translation, uses delay/duration +0x40/+0x54, and linearly samples current axis/angle +0x1ec/+0x204 to target +0x1f8/+0x208. Op 0x234 is separately anchored cyclic rotation with integer-degree phase floor(((now-start)%period)*360/period). The native call order reduces to T(-anchor)*scale*oneShotRotation*translation*cyclicRotation*T(anchor), so the cycle rotates translation.

Op 0x223 was also closed out but deliberately not implemented here: it inserts a type-0 timed-alpha record in the surface command map, containing a target surface slot and two object ranges. SC0000's shared site 0x129e7 passes (handle+2, slot, handle+1,1,handle,1,delay,duration). This belongs to render-target/ foreground-transition presentation, not affine object state, and remains a visible GAP rather than receiving an uncertain approximation.

Native matrix oracle. The retained trace's handle 0xcb8e sample (anchor (700,600), scale from 0.9, axis (0,0,1), 30° target, sampled 11 ms into a 390 ms ramp after 500 ms delay) is [0.9055,0.0134;-0.0134,0.9055], translation (74.1449,47.3127); the focused port test matches it. The two executed SC0000 cycle sites use periods 9000/13000 ms and axes +Z/-Z. A windowed port capture advanced 563 ms from their first sample to phase angles 22°/15°, exactly the native integer formula.

Port result. GfxState now retains/samples the one-shot rotation and cyclic start/phase. Transform2DMath composes a row-vector 4×4 matrix and projects it to an invertible 2D affine transform. The Godot compositor uses a pure inverse-mapped nearest-neighbour RGBA8 rasterizer for both textures and solid fills, preserving the existing colorkey, tint-strength, opacity, clipping, flipping, and z-order paths. Native D3D9 filtering can still differ at subpixels; the matrix/order is oracle-backed rather than approximated.

The windowed --shot-sequence run wrote 454 PNGs with 102 pixel-state transitions; the first cyclic passage produced distinct affine frames as 0xcb8e/0xcb98 advanced. There is no corresponding native PNG sequence in the workspace, so validation is matrix/phase exact plus port-pixel coverage—not a false claim of pixel-perfect native frame equality.

Ghidra. Renamed/commented gfx_object_set_rotation_channel (0x47eb70), gfx_queue_surface_alpha_transition (0x47f440), the surface-command map helpers, and matrix4_make_axis_angle (0x48b215); corrected comments on the one-shot consumer, cyclic interpolator, and composite call order; named useful parameters; saved /v2.

Validation: engine 97/97; full sweep unchanged at 284 exit / 13 STEP-LIMIT; Godot build clean apart from the pre-existing nullable warning and threaded SELFTEST OK; opcode tooling and focused Python tests clean; transform tool compiles; SC0000 coverage 81/129 handled (62.8%), 48 GAP ops / 602 GAP instructions; windowed affine capture clean. Final whitespace/diff validation is recorded with the handoff.

A2b — ADV foreground transition/click lifecycle ✅ DONE (2026-07-10)

Native recovery and control-flow correction. 0x1c7 is the message-skip run-state query. 0x1cc reads ctx+0x6dbd4, now adv_read_skip_state; adv_refresh_read_skip_state@0x406cd0 plus the text/label/wait handlers maintain it from message_ReadTextSkip and the current-PC read-history lookup. It is not surface progress. The earlier reading of label_1235a's branch was reversed: zero OR-state (normal playback) reaches 0x21c and sets scheduler bit 0x400; nonzero skip/read state reaches 0x243 + 0x20c to present the endpoint. Synchronized execution caught and corrected this before validation.

The executed missing producer for 0x223 range A was 0x21d: gfx_object_clone@0x47e4f0 copies the full 0x2d4-byte retained-object record from the current CG handle to handle+1. SC0000 then rebinds the source handle to the new CG and queues 0x223 with old clone range A, new source range B, and target presenter handle+2. Op 0x203 mode 2 is the companion transition-source alpha/identity path; its 0xffffffff is opaque identity, not generic solid-white tint, and negative alpha/RGB preserve current static bytes.

Port lifecycle. GfxState owns explicit queue/start/wall-clock progress/natural-or-forced completion. Normal 0x21c parks only the VM thread until the foreground command completes while Godot continues per-frame compositing. A click during that wait forces only the foreground transition to progress 1, is consumed, and resumes the VM; stable wait-for-input remains a separate gate. Tests verify that forcing a transition leaves an independent cyclic retained rotation active. The 0x20c skip/read path starts and snaps a pending foreground transition to its endpoint without the normal wait.

Synchronized window evidence. At normal speed, the second-to-third CG transition produced seven successive distinct PNG hashes while progress advanced 0.133, 0.297, 0.442, 0.592, 0.742, 0.891, 1.000; the user independently observed that fade working in the live window. A timed click landed at progress 0.157, the next frame was the endpoint, and the stable page count did not advance. The accelerated windowed run reached BGM008 @ 0x1728 on frame 137 with non-white changing pixels (2,469 sampled colors at the sentinel) and continued; its earlier white interval was finite and released before that boundary. This is windowed pixel/object/timeline evidence, not the earlier headless reachability inference.

The retained dialogue-text surface 0xe678 still has no pixels because native draw-string 0x204 remains a separate GAP; the Godot Label shortcut remains outside this slice. Its create/erase events are explicit in the object timeline and are not being mistaken for foreground CG transition correctness.

Ghidra. Renamed/commented adv_refresh_read_skip_state (0x406cd0), op_0x1cc_get_adv_read_skip_state (0x427330), op_0x21d_clone_gfx_object (0x423310), and gfx_object_clone (0x47e4f0); added EngineCtx.adv_read_skip_state; saved /v2.

Validation: engine 102/102; full sweep unchanged at 284 exit / 13 STEP-LIMIT; Godot build clean apart from the pre-existing nullable warning and threaded SELFTEST OK; all six Python test scripts, opcode/ctx lint, 481-script decode validation, RECOVER, and Windows CR-aware git diff --check clean. The plain check reports only the generated reference's CRLF on its newly added row. SC0000 coverage is 85/129 handled (65.9%), 44 GAP ops / 598 GAP instructions. This slice was later committed as c9be9c5.

A2b — op 0x202 one-shot color/presentation ✅ DONE (2026-07-10)

Native contract. gfx_op_0x202_worker_set_color_anim@0x47ea00 writes target packed ARGB at obj+0x64, delay/duration at +0x38/+0x4c, and resets the one-shot family's shared start +0x34. The missing consumer is the bit-1 path in gfx_object_apply_transform_channels@0x472f00: it seeds start from frame time retained-gfx owner+0xb550 (EngineCtx+0x51b64), performs an integer bytewise current-+0x60 to target-+0x64 LERP, then commits target, clears timing, writes target -1, and clears the active bit once all sibling one-shot channels finish. This is ordinary presentation-clock coupling, not op 0x238's separate service clock. retained-gfx owner+0xb55c == 1 (EngineCtx+0x51b70) forces completion unless the object-local +0x2d0 override bit is set. /v2 comments were corrected and saved.

Port and endpoint diagnosis. GfxState now retains current/target/delay/duration separately, shares the start timestamp with scale/rotation/translation, and exposes synchronized color=current->target plus progress in the compositor/timeline log. This fixes the initial black-to-EV049AA cut: windowed frames sample the full-screen 0xcf08 black owner through 11 monotonically decreasing states from 1.00 to 0.00 instead of installing the transparent endpoint immediately. The ADV textbox backing 0xd2f0 is a real 800×227 black fill at (0,373); repeated show/hide passages now produce intermediate samples (for example 0.00, 0.26, 0.54, 0.82, 1.00 and the reverse), synchronized to the executing 0x202 sites around 0x12283..0x12342.

Predecessor diagnosis, resolved by the next subsection. The remaining full-white runs were not a stuck color clock or d2f0 endpoint: pixel windows place them after d2f0 is transparent, while object timelines show AE* handles first becoming visible in mode 0 with default 0xffffffff before their later mode-1 initializer. Native call-site disassembly proves op 0x203's obj+0x30 is passed directly as the D3D blend selector and mode 1 uses SRCALPHA/INVSRCALPHA; the port now uses ARGB alpha as opacity and RGB as multiplicative modulation for that mode. The long white intervals did not disappear, which localizes the residual to when intermediate retained state is presented/batched, not to 0x202 interpolation. Altering that scheduler boundary without a matching native present trace would exceed this bounded slice. draw-string 0x204/0x7a was not pulled in.

Windowed evidence: 340 PNGs, 107 distinct pixel states; black-to-first-CG and d2f0 ramps agree with synchronized object progress. Focused tests cover exact integer midpoint math, delay, natural completion field cleanup, negative sentinel resolution, the 0x202-then-0x203 current/target pattern, shared color/matrix clock start, mode-1 opacity/modulation, and the software rasterizer.

Validation: engine 108/108; full sweep unchanged at 284 exit / 13 STEP-LIMIT; Godot build clean apart from the pre-existing nullable warning and threaded SELFTEST OK; all seven Python test scripts, opcode/ctx lint, 481-script decode validation, and RECOVER clean. SC0000 coverage remains 85/129 handled (65.9%), 44 GAP ops / 598 GAP instructions. The differential oracle retains its prior branch-state divergence after 0x12031; it agrees through the executed 0x202/0x203 sequence and does not implicate this slice. Windows CR-aware whitespace validation is clean.

A2b — retained presentation batching / native scheduler boundary ✅ DONE (2026-07-10)

The synchronized native trace resolves the white-hold residual. At the AE001D passage, the native engine binds 0xcb8e/0xcb98, applies mode 1 at 0xd5a/0xd63, and arms 0x202 at 0xd73/0xd8a within one roughly 5 ms opcode burst. No gfx_render_frame occurs between those mutations; the first composition is the following 0x21c service loop. The preceding explicit 0x20c/0x125a6 mode-0 white frame lasts only about 10 ms. The port's 200-completed-op/s throttle had stretched that between-present burst across multiple window frames, making retained intermediate state look like a long white stall.

Godot now leaves ordinary opcode FrameYield unthrottled and publishes retained state only at proven presentation-capable boundaries: 0x20c, 0x21c, sleep, and input wait. 0x21c renders while visible finite one-shot channels or 0x223 commands remain active; hidden stale records and ambient cyclic channels cannot hold it open. The first implementation incorrectly included hidden records and parked at the first CG; the visible-only correction was re-run through 14 pages and the full AE burst.

Windowed before/after evidence at the same SC0000 sites: the old capture exposed AE001D in mode 0 for six compositor frames and held one identical white PNG state for 25 frames. The corrected capture executes bind, mode 1, and color targets in frame 64 and first publishes AE001D already in mode 1 at 0x21c; the old mode-0 AE object state is absent from the object/pixel timeline. Remaining short white flashes are explicit native present/color effects, not the prior between-op hold. Draw-string 0x204/0x7a, movie 0x236, and SFX remain separate slices.

Validation: engine 109/109; full sweep unchanged at 284 exit / 13 STEP-LIMIT; Godot build and threaded SELFTEST OK; all seven Python suites, opcode/ctx lint, 481-script decode, and RECOVER clean. Normal-speed windowed capture wrote 220 PNGs and progressed through the complete AE sequence; at the target frame, bind + mode-1 + 0x202 setup share one VM frame and the first published object state is mode 1. Ghidra /v2 comments were updated and saved. This slice was committed as 85fc07d.

A2b — native ADV retained text (0x7a / 0x204) ✅ DONE (2026-07-10)

The prerequisite input check passed before text work: the unmodified port reached page-1 wait-for-input@0x83c in about 2.0 seconds and a manual run released 14 consecutive waits through page 15. Clicks were independently healthy, so no scheduler/input workaround was folded into this slice.

Native /v2 dispatch resolves 0x7a to op_0x7a_handler@0x41eba0 and 0x204 to op_0x204_handler@0x422a60. Op 0x7a selects layout slot 1 and writes the last 20-byte record's cursor; SC0000 voiced pages compute (75,47), while narration resets to (100,47). Layout origin is (0,430), bounds are (720,147), retained glyph handles begin at 0xd6d8, and glyph source surface is 21. Op 0x204 locks a numbered D3D surface and GDI-rasterizes its CP932 string with retained font/color/effect state. SC0000 0x9b2 draws "魔王" to 400x30 surface 13 at (1,1); 0x1fb@0x9bb binds that surface to object 0xe678 at (74,444). Show-text builds all glyph records, then publishes one every 50 ms; a click completes and consumes an active reveal before the VM can reach the following stable wait.

The port now handles both opcodes and string-pointer types 8/14. Blank-surface text is retained by slot and drawn through the bound object's transform (the SC0000 speaker-name path), while ADV text retains cursor, origin, 50 ms/glyph progress, and forced completion. The prior top-left dev Label/status presentation is gone. Page-1 window pixels show the black 800x227 textbox with text at native (100,477); voiced page 7 has separate name/dialogue bands at y=447–468, 478–500, and 507–530. Final manual validation progressed 14 pages, with 11 completion clicks consumed during reveal and 14 later clicks releasing 14 waits.

Ghidra /v2 was renamed/commented throughout the handler, layout, raster, surface-lock, and publication chain and saved. The new low-frequency capture_adv_text_trace.py records matching native offsets/state; an initial experimental version combining a D3D device scan with hot per-glyph/render hooks crashed in frida-agent.dll at teardown, so those hooks were removed and the safe narrowed rerun left AGE alive.

Validation: engine 110/110; corpus sweep unchanged at 284 exit / 13 STEP-LIMIT; Godot build clean apart from the pre-existing nullable warning and threaded SELFTEST OK; all seven Python suites, opcode/ctx lint, 481-script decode, RECOVER, and git diff --check clean. SC0000 coverage rises from 85/129 to 87/129 handled (67.4%), with 42 GAP ops / 188 GAP instructions. Movie 0x236 and SFX remain separate slices. No implementation commit was made.

Foundation track — native asset VFS + ALF/AAI/AGF readers (VFS-A/B/C DONE)

This is an optional high-leverage detour before movie 0x236 or SFX. It replaces the Phase-A pre-extracted/pre-converted asset bootstrap with the native loose-override/archive-fallback model and removes the runtime dependency on extracted/ plus build/textures/. Canonical format/architecture detail and source references live in docs/asset-resolution-re.md §“Runtime asset-VFS track”; this section defines slice boundaries only.

Land it as three bounded slices, not one archive/codec rewrite:

VFS-A is the common prerequisite. VFS-B and VFS-C may be swapped afterward: choose A→C→B for the fastest SC0000 textbox/chrome payoff, or A→B→C when complete base+append archive mounting is the priority.

1. VFS-A — base SYS4 catalog + ALF byte reads. Runtime-parse SYS4INI into raw-id, scene-local, and name lookup views; preserve placeholders; expose bounded asset streams. Apply native precedence loose root/<record.name> → indexed ALF range. Convert Sys4Loader/Sys4ScriptProvider to consume bytes from this seam first, proving the existing 52 patched root BINs still shadow archive copies. Gate: sampled and corpus-size/range validation against extracted/, plus synthetic loose-override tests.
2. VFS-B — APPEND01 AAI mount. Parse S4AC422 and read APPEND01.ALF. Use Ghidra/native observation only as needed to settle pack selection/mount precedence; compare the entire parsed directory and sampled payloads with BinExtractALF.exe. Gate: no guessed name override or high-byte-id behavior reaches runtime.
3. VFS-C — in-process AGF → RGBA8. Port the MIT GARbro decode algorithm into platform-neutral engine code with a focused LZSS primitive, palette/truecolor expansion, stride/orientation handling, and optional ACIF alpha. Replace BMP-path texture loading with decoded pixel surfaces. Gate: codec sample matrix plus exact SO001 dimensions/alpha, then windowed SC0000 textbox/button pixels with extracted/ and build/textures/ unavailable to the runtime.

After those gates, move OGG/WAV consumers onto the same byte store as a small follow-up. That prepares SFX without conflating its channel/timing semantics with archive access. Movie 0x236 may likewise consume raw AGF/MPEG bytes later, but video decoding remains explicitly outside this track.

Expected authored seams (names provisional): Sys4AssetCatalog, IAssetStore/Sys4AssetStore, bounded archive stream/reader, LzssDecoder, and AgfDecoder; focused tests belong in Age.Engine.Tests. Runtime caches should key decoded assets by catalog identity plus loose-file timestamp, while tests use synthetic fixtures and installed-game integration checks rather than committing proprietary assets.

Decision point: this track is worthwhile before broadening beyond SC0000 because it establishes the modding contract and benefits scripts, UI chrome, SFX, and movies. It is not required to continue opcode coverage immediately, so choosing movie/SFX next remains valid.

VFS-A — base SYS4 catalog + ALF byte reads DONE (2026-07-11)

Sys4AssetCatalog now runtime-parses SYS4INI.BIN into all 13208 raw slots (including two @ placeholders), 13206 real/name records, bounded scene sections, and universal raw-id lookup. Sys4AssetStore applies native loose exact-basename -> ALF offset/size precedence with traversal rejection, per-open file handles, and a seek/read boundary. Sys4ScriptProvider and all CLI/Godot root-script paths use store bytes; ResourceMap consumes the live catalog instead of generated asset JSON.

Validation: 116 engine tests; every field against build/asset-index.json; all 136 generated scene views; all 13206 archive ranges; representative bytes across DATA1..5 against extracted/; synthetic precedence, range, traversal, and concurrency tests; CLI SC0000 run; Godot build/selftest. The installed root has 49 archive-backed script overrides and two root-only BIN engine files, not the historically reported 52 shadowing scripts; all 49 were byte-proven to win and differ from their archive payload. VFS-B APPEND01/AAI, VFS-C AGF, audio migration, and movie 0x236 remain separate.

VFS-C — in-process AGF to RGBA8 + SC0000 system chrome DONE (2026-07-11)

AgfDecoder now consumes IAssetStore bytes and emits a platform-neutral, tightly packed top-down RGBA8 surface. Its shared 4 KiB-ring LzssDecoder covers raw/compressed information, pixel, and optional ACIF alpha sections; expansion covers 4/8-bit palettes, 24/32-bit truecolor, DIB row padding, and bottom-up orientation. Synthetic fixtures exercise the whole format matrix. Installed AE000A, AE001A, BG030A, EV052CA, and SO001 match the existing converter's pixels exactly; SO001 is 800×300 with non-binary per-pixel alpha.

ResourceMap now resolves texture ids through the scene manifest with a universal raw-id fallback, then decodes through the loose-first VFS. Godot and the CLI no longer use BmpHeader, TexturePath, or pre-converted BMPs. SYSTEM4's inherited SO001 surface is seeded into slot 0x11 before SC0000, allowing the existing callback-window crops to render the textbox and control icons. Windowed page-1 validation passed with build/textures/ temporarily unavailable; source alpha produced the translucent upper edge and the bottom-right control row was visible.

Validation: 124/124 engine tests, CLI/Godot builds, Godot threaded selftest, pixel parity for five installed assets, and the windowed no-BMP capture. VFS-B APPEND01/AAI, OGG/WAV migration, movie 0x236, and unrelated opcode work remain separate.

VFS-B — APPEND01 AAI mount DONE (2026-07-11)

Sys4AssetCatalog.Load now discovers installed *.AAI files beside SYS4INI.BIN, parses the S4AC directory at its native offsets, and mounts each catalog by the selector stored at header offset 0x108. For Himegari, APPEND01.AAI mounts selector 1, names one APPEND01.ALF, and contains 81 records whose literal names all begin $1$. AssetEntry retains the pack id, ResolvePacked applies the evidenced high byte -> mounted catalog; low 24 bits -> record rule, and Sys4ScriptProvider routes append call ids through the existing IAssetStore. Base direct-name lookup remains base-only: append records are not guessed name replacements. The selected catalog still probes the record's exact loose basename before its ALF range.

Native /v2 now names/comments the AAI constructor/load/table/open/get chain and asset_mount_append_catalogs@0x44f120; asset_open_indexed_entry@0x44f390 documents the packed-id split. The native scan stores each successful catalog directly into its selector slot, so a later enumerated AAI with the same selector replaces the earlier pointer. Its SAR 24 selector extraction makes sign-bit high bytes negative table indexes, so the port rejects them rather than inventing 0x80..0xff behavior. Only selector 1 is installed and exercised here.

Validation: 127/127 engine tests; stable complete-directory digest; all 81 ranges fit; a disposable BinExtractALF.exe APPEND01.AAI extraction matches all 81 names, sizes, and payload bytes; real $1$SC1260.BIN loads through its packed id; CLI/Godot builds and threaded SELFTEST OK. Audio migration, movie 0x236, AGF work, and unrelated opcodes were untouched.

Phase A — native SC0000 SFX family (0xb4/0xb5/0xb6/0xc2/0xd9) DONE (2026-07-11)

Native RE and the matching trace resolve the bounded family. 0xb4(resource,channel) synchronously loads and retains a scene-manifest sound; 0xb5(channel) starts that loaded sound once; 0xb6(channel) destroys and clears it. The manager supports 13 native slots, while SC0000 uses a fixed 0..9 pool. Native playback is a notification-fed DirectSound ring: Play(...,DSBPLAY_LOOPING) keeps the ring alive, but logical mode 0 stops at decoder EOF. Mode 1 belongs to adjacent op 0xba and remains outside this slice. These five ops do not set pan or SFX volume; SC0000 inherits centered pan and configured SFX volume. The captured loads both apply DirectSound attenuation -2377; because native audio-preference import is outside this slice, the bounded extracted-WAV port uses unity gain and centered pan instead of treating that user setting as opcode semantics.

At the requested first site, 0xb4@0xc29 resolves 0x28 to E0808.WAV and loads channel 0; 0xb5@0xc2e publishes playback in the same native millisecond. 0xb4@0xc31 preloads the same WAV into engine-owned secondary channel 4. G[0x6242d] is native/profile-owned rather than script-written, so the port exposes value 4 through the new external-global seam for SC0000. The matching port timeline now records the same (load ch0, start ch0, preload ch4) sequence in one frame. Startup 0x62b..0x646 and the later 0x120d..0x1228 both release channels 0..9 in order.

0xc2(target,duration) is the adjacent blocking BGM fade: 100 linear steps for durations at least 1000 ms, 10 steps below that, with target zero releasing the source. 0xd9 only clears native service bit 0x1000; the isolated VM recognizes it with no host-visible effect. The Godot backend retains ten AudioStreamPlayer channels, loads catalog-resolved WAV bytes, separates load from start, releases buffers deterministically, and parks BGM fades on the unified virtual clock. ALF/AAI/AGF VFS work and movie 0x236 remain separate.

Ghidra /v2 now names/comments all five handlers plus the asset-open, decode, DirectSound start/refill/stop/ volume/release, and BGM fade workers; the program is saved. Evidence is build/native-sfx-trace.jsonl and godot/build/sfx-port-timeline4.jsonl (the latter is the final rebuilt channel-4 trace; earlier diagnostic reruns captured the missing external-state mismatch).

Automated validation: engine 111/111; corpus sweep unchanged at 284 exit / 13 STEP-LIMIT; Godot build and threaded SELFTEST OK; all seven Python suites, opcode/ctx lint, 481-script decode, RECOVER, and tracer bytecode compilation clean. SC0000 coverage rises from 87/129 to 92/129 handled (71.3%), leaving 37 GAP ops / 101 GAP instructions. Headless sequence capture still emits the known dummy-renderer GetImage diagnostics while completing successfully; it is not an audio failure.

Manual validation: the normal-speed windowed port advanced through wait-for-input@0x1a58 at 45.6 s, well past the first effects and dialogue pages, with no audio-related stall. The user confirmed the effects were audible and sounded good.

Audio-byte migration onto the asset VFS DONE (2026-07-11)

ResourceMap.BgmPathById and ResourceMap.AudioPath are removed. BGM direct-name resolution now returns a catalog entry, while voice and SFX retain their scene-local resolution; all three flow through ResourceMap.ReadAudio and the injected IAssetStore. GodotAdvHost passes owned byte arrays across the existing deferred main-thread boundary, and Main decodes them with AudioStreamOggVorbis.LoadFromBuffer / AudioStreamWav.LoadFromBuffer. The existing BGM loop and fade, voice interruption, ten-channel SFX load/start/release, clock pacing, and gain behavior are unchanged.

Validation: engine 128/128 and both .NET/Godot builds pass. An archive-only SC0000 regression verifies the Ogg signatures for BGM005.OGG and MAN999.OGG plus the RIFF/WAVE signature for E0808.WAV. With extracted/ physically moved aside, the CLI completed SC0000's 127-op audio trace and a windowed Godot run crossed voice at 0xa0a/0xbf6, BGM005 at 0x7fa, and the established SFX load/start/preload sequence at 0xc29/0xc2e/0xc31 on channels 0/0/4. Godot reported no OGG/WAV read, decode, or deferred-call errors; extracted/ was restored afterward. Movie 0x236, AGF work, opcode semantics, and unrelated VM behavior were untouched.

Phase A — SC0000 movie opcode 0x236 DONE (2026-07-11)

Reversed and implemented only SC0000's existing 0x236@0x13c8. Native ABI is (resource_id, surface_slot, movie_flags, sync_mask); the native site evaluates (0x33, 0, 2, 0). Native graph construction and asset open are synchronous, playback is asynchronous, and the opcode itself does not park the interpreter: execution resumes at bytecode 0x13d1. SC0000's later 0x21c presentation boundary sets run-state bit 0x400 and services the retained movie until EOF; only the following cleanup stops and detaches playback.

Resource 0x33 resolves to the 8,194,052-byte DATA1.ALF:CHAPTER.AGF MPEG-1 program stream through the catalog and IAssetStore. ResourceMap.ReadMovie owns that VFS read. The Godot Windows backend uses the system DirectShow MPEG splitter/decoder, converts its bottom-up RGB32 samples to retained RGBA frames, and presents them on the native slot-0 movie layer. The payload contains an audio stream, but its pin remains unrendered; audio, AGF still-image work, generalized video APIs, other opcodes, and unrelated VM behavior remain out of scope.

Ghidra /v2 names/comments the 0x423ee0 handler and the movie ctor, graph-interface/open/play, sound-route/volume, texture-renderer sample/media-type, stop/detach/release/destructor chain; the program is saved. Validation covers the exact real-SC0000 operands and 0x13c8 -> 0x13d1 boundary, archive-only VFS payload identity, actual 800x600 RGBA DirectShow decode, .NET/Godot builds, and the real Godot site opening the same VFS byte count. Manual testing exposed and corrected an initial same-frame teardown: pre-yield static loads no longer destroy the movie, 0x21c waits for DirectShow completion, and a real-render run records first frame 98 / stop frame 181. A follow-up compositor-only investigation found that the movie object was present at the correct retained z-position, but the static AGF image cache keyed by (assetId,colorKey) froze its first sample. A duplicate unconditional backbuffer copy of the current sample was then covered by that same retained object. Dynamic movie surfaces now bypass the static-image cache and publish only through their retained object. A windowed auto-play run recorded first frame 101 / stop frame 190, and the user manually confirmed that the video visibly played. The known lower white/textbox panel is an unrelated retained-object issue. Movie audio remains deliberately unrendered and out of scope. The decoder test asserts two delivered MPEG frames differ. The two archive/decode tests also pass with all of extracted/ physically moved aside. The real-scene trace is intentionally separate: the existing test bootstrap still finds root script fixtures through Paths.Scripts() under extracted/, and changing that unrelated bootstrap was outside this movie slice. Final validation: engine 132/132, Godot build with zero warnings, threaded SELFTEST OK, and opcode-map lint clean.

Pre-roll decode-warning follow-up (2026-07-21). SC0000 could print AGF decode failed CHAPTER.AGF: expected an ACGF image immediately before successful MPEG playback. This was a port-side compositor race, not corrupt media or bad catalog resolution: op 0x236 exposed the movie's .AGF resource binding while the VFS read/DirectShow graph setup was still synchronous, and the first-frame resolver fell through to the still-image AGF decoder. Movie surfaces are now registered before the VFS read, remain blank until their first dynamic frame, and the VM publishes the movie resource binding only after synchronous host setup returns. The same pending-frame guard also covers modal movies. A focused regression locks the blank-during-setup boundary; validation is 271/271 engine tests, a zero-warning Godot build, and threaded SELFTEST OK. The headless screenshot harness did not terminate at its requested page; the subsequent live SC0000 recheck passed with normal playback and no spurious AGF warning.

Phase A — SC0000 textbox/control-strip one-shot blend correction DONE (2026-07-11)

The lower white panel noted after movie publication and the white-outline controls had one shared cause, not a movie or AGF-alpha fault. SYSTEM4's inherited SO001 surface is cropped by ADV backing object 0xd2f0 and control-strip object 0xd2f1; both use a mode-0 0x202 one-shot color transition. The port discarded that one-shot provenance after sampling and interpreted the packed alpha as static tint strength. As a result, full-strength white replaced the controls' yellow pixels, while zero strength exposed the raw mostly-white backing crop instead of hiding it.

GfxState now distinguishes static mode-0 0x203 state from mode-0 color state which has passed through 0x202. The latter retains ARGB-opacity plus multiplicative-RGB semantics after target commit. This keeps the established 0x00ffffff static CG initializer opaque, preserves yellow under white identity modulation, and makes a committed alpha-zero ADV crop transparent. Focused model/raster tests cover the committed endpoint, identity modulation, and zero-opacity output. Validation: engine 134/134, Godot build with zero warnings, matching windowed capture, and user manual confirmation that the box disappears fully and the controls retain their normal color while visible.

Godot window jitter / compositor performance investigation (2026-07-11)

The visible window jitter is main-thread compositor pressure, not FrameClock.Speed, coroutine pacing, or GPU throughput. A bounded windowed run on the Vulkan backend (RTX 4080 SUPER, --max-fps 60 --print-fps) sustained only 23–25 FPS / 40–43 ms per frame while SC0000 approached its first ADV input wait. The retained frontend currently makes ShouldRecomposite() true throughout input waits, explicit sleeps, foreground waits, and text reveal. Each recomposite clears the 800x600 canvas, then for every visible layer calls Image.GetData(), runs the C# per-pixel inverse-affine rasterizer, calls Image.SetData(), and finally uploads the full canvas with ImageTexture.Update(). An unchanged input-wait screen therefore consumes the same expensive path every rendered frame; dragging the OS window stutters because this work runs on Godot's main thread.

Continuous presentation itself is partly load-bearing: one-shot transitions, movies, and ambient cyclic channels must continue sampling FrameClock while active. The unconditional redraw implied by IsWaiting/IsTextRevealing is not. The existing gfx-change log showed real one-shot color changes through render frame 121, then no retained-object changes, while the separate steady-state FPS probe remained near 23 FPS. A safe correction should preserve time-based presentation but distinguish dirty/static waits from active visual channels, and should avoid copying the full Godot Image out and back once per layer. Likely implementation boundaries are: (1) explicit compositor dirty generation plus an active-animation/movie query, and (2) one CPU backbuffer acquisition/update per recomposite or migration of ordinary layers to Godot/GPU-native drawing. Merely changing --speed, sleep/coroutine behavior, or the 60 FPS cap will not remove the underlying frame cost.

Quick win 1 implemented (2026-07-11). GfxState.HasActiveVisualPresentation(nowMs) now reports only retained pixels that can change without another VM mutation: finite surface/one-shot channels plus visible spritesheet, color, and cyclic-rotation channels with positive periods. Godot consumes explicit presentation dirtiness once and otherwise recomposites only while that query is true. Entering input wait or sleep requests one publish so preceding retained writes remain visible; the wait/sleep state itself and ADV text reveal no longer rebuild the background. Movie frames retain their existing per-sample dirty publication. This preserves the clock, VM suspension model, active transitions, ambient animation, and movie lifecycle.

Validation: the focused static-vs-ambient query regression brings the engine suite to 135/135; Godot builds with zero warnings and threaded SELFTEST OK. A matching hidden-window Vulkan run capped at 60 FPS, using --speed 8 only to reach the static state quickly, held 60 FPS / 16.66 ms per frame for all eight reported samples, versus the pre-change 23-25 FPS. Buffer batching/source-pixel caching and rasterizer fast paths remain independent follow-ups.

Quick win 2 implemented (2026-07-11). The Godot compositor now owns one reusable 800x600 RGBA8 managed backbuffer. Recomposite() clears it once, every image/fill/transition layer mutates that same array in z-order through the unchanged SoftwareAffineRasterizer, and only the completed frame crosses the Godot boundary via one Image.SetData() plus one ImageTexture.Update(). The former per-layer screen Image.GetData() / Image.SetData() round trip is gone. Static source images still call GetData() per draw; source-pixel caching remains the next independent optimization.

Visual validation used the same SC0000 page-1 command before and after the refactor (--speed 8 --shot-page 1 --shot-settle 3). The two PNG files are byte-identical, both SHA-256 E669355772D4D9118BE80AC93595F78BB467B088659DEA4CC2D2B7D0F05B62BE. A 12-second normal-speed windowed Vulkan probe now reported 53, 26, and 39 FPS through the initial heavier active intervals, then 59-60 FPS through lighter/static intervals; the old compositor had remained around 23-25 FPS. Validation also holds at engine 135/135, zero-warning Godot build, and threaded SELFTEST OK. The general per-pixel affine loop is now the clearest remaining active-frame cost.

The byte-identical page-1 capture is a differential compositor oracle only, not a claim that the automated --shot path has the correct interactive presentation state. Both the pre- and post-refactor captures show fallback SO013A rather than the expected first event CG. The matching gfx log proves this is not resource-load failure: EV049AA.AGF resolves and loads into slot 3, but at capture its handle 0x0 is positioned at (-400,-600) and the full-screen 0xcf08 copy has completed its fade to alpha zero. The user confirmed that ordinary manual play displays the correct CGs. Keep this shot-path state discrepancy open and do not use page 1 as an absolute scene-fidelity oracle; it predates and is pixel-identical across quick win 2.

Quick win 3 implemented (2026-07-11). Static compositor sources no longer round-trip through Godot Image.CreateFromData() / Image.GetData(). The cache now retains (width,height,RGBA) directly under (assetId,colorKey): unkeyed assets reuse their decoded RgbaImage.Pixels, while keyed variants clone and bake transparency once so the canonical decoded asset remains reusable under other keys. Dynamic movie samples never enter this cache; they use the decoder-owned newest-frame bytes directly, cloning only if a color key must be applied.

The differential page-1 PNG remains byte-identical at SHA-256 E669355772D4D9118BE80AC93595F78BB467B088659DEA4CC2D2B7D0F05B62BE (subject to the shot-path oracle caveat above). A bounded 220-frame sequence reached VFS movie publication at render frame 141 and captured multiple distinct movie-frame hashes, confirming dynamic samples still change rather than freezing in the static cache. Engine 135/135, zero-warning Godot build, and threaded SELFTEST OK remain clean.

The normal-speed FPS samples were effectively unchanged from quick win 2 (54/26/38, then 58-60, versus 53/26/39, then 59-60). Source copying was therefore no longer a material bottleneck after the shared backbuffer landed. The cleanup removes needless Godot objects/copies and helps future layer-heavy scenes, but the measured next target is the general inverse-affine per-pixel path—especially identity-transform, opaque-copy, and axis-aligned fill fast paths.

Quick win 4 initial raster fast path implemented (2026-07-11). SoftwareAffineRasterizer now detects exact identity matrices with integral translation and bypasses inverse-matrix construction, floating-point coordinate application, Floor, and per-pixel geometric rejection. Both BlitRgba and FillRgba use direct clipped integer indexing for that case while retaining the exact existing tint, multiplicative tint, source alpha, object opacity, destination blend, and alpha-accumulation arithmetic. Scale, rotation, fractional translation, singular transforms, and all other geometry retain the original affine fallback. Zero-opacity draws also return before scanning pixels.

Six new differential cases compare the fast paths byte-for-byte against a retained copy of the pre-fast-path algorithm across positive/negative clipping, existing destination pixels, ordinary and multiplicative tint, partial source/object alpha, and solid fills. The full engine suite is 141/141; Godot builds with zero warnings and threaded SELFTEST OK. The differential SC0000 page image retains SHA-256 E669355772D4D9118BE80AC93595F78BB467B088659DEA4CC2D2B7D0F05B62BE, subject to the automated-shot presentation-state caveat above.

Because the console SC0000 state does not match the user's ordinary interactive CG presentation, no whole-scene FPS claim is made for this slice. An isolated Release-mode 800x600 tinted/alpha identity-blit kernel comparison measured 2.737 ms for the new path versus 4.217 ms for the retained general loop, or 1.54x for that layer type. Manual-path fade responsiveness is validated below. A later bounded step may add a fully opaque/unmodulated row-copy path as optional incremental work.

Manual validation: the user tested the ordinary interactive path—the path whose CG state and fade cadence differ from the console capture—and reported a massive improvement. This confirms the identity blit/fill fast path materially improves real fade responsiveness, not merely the isolated kernel benchmark.

SC0000 third-CG white screen and AE001D glow fixed (2026-07-11)

The page-14 screenshot path reproduced the user's all-white EV052DA page exactly. Synchronized compositor and opcode evidence excluded the animated glow assets as the white owner: both AE001D layers load successfully, retain their AGF alpha, rotate, and render in mode 1 at 6-8% opacity. Base handle 0xcb2a was correct through the 0x223 EV052CA→EV052DA transition (mode=2, identity), then 0x203@0x12478 restores it to textured mode 0 with preserved 0xffffffff. The old port resolved that endpoint as tintStr=1.00, whitening every EV052DA pixel. Textured mode 0 now uses opaque multiplicative RGB modulation, while surfaceless mode-0 fills retain their existing strength behavior. The transition cleanup regression covers mode 2 → mode 0 (-1,-1).

The resulting non-white capture then proved the glow itself still contributed no visible pixels. Native RE closed the causal gap: 0x1fd(handle,x%,y%,z%) immediately writes the current scale matrix at obj+0x6c, distinct from 0x21e's one-shot target. SC0000 scales the two AE001D circles to 210% and 240%; the stub left them at 100%, almost entirely below the viewport. GfxState.SetCurrentScale and VM dispatch now reproduce the native matrices, with focused geometry/dispatch tests. Validation: engine 145/145, opcode build/lint, Godot build/capture, Ghidra annotations saved, and user confirmation that the CG and animated glow are both visible. This AE001D path is a retained scaled/rotating texture; the later 0x231 spritesheet-cell issue was separately resolved by preserving draw-texture's 200x200 cell and interpreting (8,4) as total frames/columns rather than a grid divisor.

SC0000 ADV wait indicator implemented (2026-07-11)

The missing post-reveal bat is SO000.AGF, a 390x27 strip of thirteen 30x27 frames. SYSTEM4 loads raw asset 0x337c into surface slot 12 and configures layout 1 through op 0x73 as a marker at layout-relative (385,140), screen (385,570), with terminal frame 12 and a 48 ms period. Native op 0x72 activates that layout descriptor after reveal completion. The Phase-A bootstrap now injects SO000 into surface 12 and forwards the exact op-0x73 configuration through IHost; WaitForInput carries the selected layout and starts the marker clock. Godot presents it as a separate 30x27 atlas overlay, advancing inclusive frames 0..12 every 48 ms only during the stable wait and hiding on release. This avoids recompositing the 800x600 software backbuffer during otherwise static waits. Validation: engine 147/147, zero-warning Godot build, threaded SELFTEST OK, and a real page-1 capture showing the transparent bat at (385,570).

A2b -- SC0000 post-movie AE001H spritesheet correction ✅ DONE (2026-07-11)

The reported missing cave spirit was the 0x231 path, independent of the earlier AE001D retained glow. Native interpolation proved (period, 8, 4) means milliseconds per frame, total frames, and columns; the existing 200x200 draw-texture rectangle is one cell and must not be divided again. The retained model now cycles the eight AE001H cells row-major and wraps. Focused tests cover the exact 800x400/4x2 layout. Validation: engine 146/146, opcode sources regenerated, Godot zero-warning build and threaded selftest, real-scene compositor trace across all eight cells, Ghidra /v2 annotations saved, and user confirmation on the normal client path. The automated-shot wrong-CG state remains the pre-existing separate gotcha.

A2b -- SC0000 post-movie AE001H travel-path correction ✅ DONE (2026-07-11)

The remaining off-screen motion is a separate 0x228 query-model bug, not part of the spritesheet crop. Native 0x228 decomposes and returns the retained object's target translation (obj+0x1ac..+0x1b4), while the C# VM currently returns its static draw/base position V24. For AE001H this changes the first 0x220 target from (40,-20) to (400,0); because the compositor also retains the (360,20) draw base, the sprite was displaced to approximately x=760 before cyclic rotation. GfxState.TryQueryTranslationTarget now exposes the retained target independently of V24; VM dispatch matches the native 0/1 status convention and preserves output operands on a miss. Bytecode-level tests cover the exact three targets (40,-20), (50,-80), (130,-100) plus missing-object behavior. Validation: engine 149/149, zero-warning Godot build, and threaded SELFTEST OK. Current static SC0000 coverage is 94/129 distinct ops handled (72.9%): 82 implemented + 12 safe no-ops, leaving 35 GAP ops / 88 GAP instructions. By instruction frequency, 16,169/16,257 are handled (99.5%); this gauge does not replace manual end-to-end fidelity.

A2b -- SC0000 AE001H white-pulse correction ✅ DONE (2026-07-11)

Manual movement confirmation exposed a separate color artifact. The sheet itself has no white frames. SC0000 later calls 0x232(handle,1200,224,-1); native treats RGB -1 as "preserve current static RGB," whereas the port masks it to white and drives mode-0 tint strength from the animated alpha. The compositor log correspondingly cycles tintStr from 0 to about 0.82 and back. This identifies the white wash as a port bug, not intended artwork. Native dataflow confirms fresh static color is 0xffffffff; 0x232 samples 0xffffffff ↔ 0xe0ffffff and passes it through unchanged blend mode 0, whose alpha is inert and whose white RGB is identity modulation. The port now resolves native default/static color and negative sentinels, samples packed ARGB, and applies it through normal mode-specific blending rather than a separate tint-strength convention. Focused tests cover exact AE001H invariance, mode-0 RGB modulation, and mode-1 alpha opacity. Validation: engine 152/152, zero-warning Godot build, and threaded SELFTEST OK; manual confirmation is the remaining visual gate.

ADV page-to-script locator implemented (2026-07-11)

Godot now turns each stable wait-for-input into a shared human/tool coordinate. A normal run recreates build/page-map-<SCENE>.jsonl and records the run-relative page number, page-start location, canonical wait script/offset, last show-text instruction and inline-string offsets, dialogue text, and nested call stack. The optional HUD uses the compact form SC0000 P014 · wait SC0000@0x… · text SC0000@0x…; F2 toggles it and F3 copies it. tools/locate_page.py SC0000 14 resolves that record and prints authoritative disassembly around the wait. Page number is deliberately only the friendly coordinate because state and branches can shift ordinals; the script/offset remains authoritative. A live SC0000 run verified page 1 as show-text@0x834, string 0x14963, and wait-for-input@0x83c. Validation: focused Python tests, engine 152/152, zero-warning Godot build, threaded SELFTEST OK, and the live lookup all pass.

SC0000 page-58 EV050EA background restored (2026-07-11)

The first user-supplied locator, SC0000 P058 / wait@0x6545 / text@0x653d, led directly to the missing full-screen CG. Resource 0x7a resolves to EV050EA.AGF and was loaded into slot 5, but retained handle 0xcb2a inherited an older (-100,0) translation, -90 degree rotation, and alpha-zero endpoint. Native RE showed why cleanup diverged: gfx_object_init_default zeroes source slot obj+4, so op 0x215 returns 0 for a created-but-unbound object; only a missing handle returns -1. The port's SourceSlot=-1 default made the sign-tested cleanup skip that object. The model now uses native slot 0, allowing erase/recreate to restore identity state. A lifecycle regression reproduces the transform-create, query-cleanup, and CG-reuse sequence. Validation: engine 153/153, zero-warning Godot build, and a synchronized real-scene compositor trace at page 58 showing EV050EA.AGF at (0,0), scale 1, translation 0, rotation 0, and opacity 1.

SC0000 page-89 BG004D background restored (2026-07-11)

Locator SC0000 P089 / wait@0x89e9 / text@0x89e1 identified BG004D.AGF as loaded but offscreen at (400,650). The prior BG001A animation intentionally leaves translation y=550; the erroneous extra (400,600) came from GodotAdvHost retaining slot 0's seeded 800x600 dimensions after op 0x1fa released the surface. Native release frees and nulls the slot. Static releases now remove the host resource and size state (while the existing in-flight movie retention remains unchanged), and the CLI graphics trace mirrors that lifecycle. The loader consequently builds base (0,-500), so the retained translation places BG004D at (0,50). Op 0x1ff was also completed as the native immediate current-translation setter at obj+0x16c. Validation: engine 155/155, zero-warning Godot and CLI builds, and a full synchronized run reaching the exact page-89 wait with BG004D.AGF drawn at (0,50) alongside the character sprite.

ADV control-strip button investigation complete (2026-07-18)

Native RE and the shared SC0000 routine now establish the implementation contract for the five visible lower-right controls: op 0x90 registers enter/leave/activation callbacks, SO001 supplies the base icons, tooltips, generic alpha-0x80 hover overlay, and persistent state overlays, and the activation callbacks map left-to-right to History, Auto message, all-message Skip, read-message Skip, and Hide window. Manual correction confirms the controls are silent on hover, matching the absence of any audio call in the path. Relevant input/state opcodes and G[0x6c9..0x6cd] are named in their canonical registries; the /v2 Ghidra image is annotated and saved. Full native evidence is in engine-re.md.

ADV control-strip pointer callbacks + Auto bridge implemented (2026-07-18)

The first bounded runtime slice is now live. ExecFrame owns the native-style hotspot registry populated by ops 0x90, 0x94, and 0x97; Godot routes 800x600 virtual pointer motion into it and consumes an armed hotspot click before the ordinary ADV page-advance path. Enter, leave, and activation targets execute as temporary local callbacks on the VM thread while the enclosing wait-for-input remains parked. A dedicated host wake channel services those callbacks without releasing the page semaphore. Inclusive bounds, direct enter/leave dispatch, activation/re-arm, nested local calls, click consumption, and registry lifetime have focused regressions. Callback completion requests one retained-frame publication, so static waits show the new tooltip/glow immediately without continuously recompositing the 800x600 canvas.

This does not introduce duplicate Godot widgets or hover assets: the callbacks already present in every ADV script redraw the retained SO001 tooltip/glow/state layers. Ops 0x1b6/0x1b7 now retain Auto-message state, so the x=706 action toggles and redraws its active overlay. Auto's timed page advance is not part of this slice; nor are keyboard/pad activation and the remaining four action services. Validation: engine 157/157, zero-warning Godot build, threaded SELFTEST OK, and SC0000 static coverage 100/129 handled (77.5%; 88 implemented + 12 safe no-ops, 29 GAP ops / 70 instructions).

Next: manually validate hover and repeated Auto clicks in a normal SC0000 run, then add Auto timing and the History/all-skip/read-skip/Hide service behavior one bounded action at a time. No hover-audio work is required.

Manual-validation correction (2026-07-18). The first build displayed the SO001 strip but did not hover. Its cold profile state took jcc@0x8d with G[0x6c1]==0, skipping the five visible registrations at 0x94..0xd0; later op 0x93@0x622 also canceled the one early registration pass before the first dialogue wait. Native SYSTEM4 supplies G[0x6c1]=1, and its ADV coroutine republishes the shared definitions at the stable wait. The single-scene bootstrap now supplies that exact inherited flag, retains canceled definitions as inactive coroutine templates, and re-arms them at wait-for-input. Called-script frame exit also restores the parent's armed registry. A real-SC0000 regression reaches the first wait, moves to History (684,572), executes label_1a0, observes G[0x6c9]=1, and verifies callback-frame publication. Validation is now engine 159/159, zero-warning Godot build, and threaded SELFTEST OK; manual recheck remains the visual gate.

ADV Auto timing implemented (2026-07-18)

The follow-up manual check confirms hover and the script-owned toggles work; Auto previously changed only its SO001 active overlay because timed release had not yet been implemented. Native RE closes that gap without a scene-specific shortcut. Auto now uses the engine's two configuration channels: unvoiced pages wait AutoMessageTime1 (CONFIG default 2000 ms), while voiced pages wait for real voice completion and then apply AutoMessageTime0 (default 500 ms). Ops 0x1b8/0x1b9 read/write those delays, op 0xc4 marks a queued voice, and op 0x1bc resets the per-message voice state. A configured zero retains the native 100-ms fallback.

The implementation keeps VM-owned settings separate from host-owned clock/audio state. The Godot wait loop polls the existing monotonic frame clock and an interrupt-safe voice generation counter; it does not enqueue a fake click or sleep the VM thread for a hard-coded duration. Focused regressions cover unvoiced and voiced deadlines, live Auto disable/re-enable, zero fallback, the time-setting ABI, and voice-state reset. Validation: engine 165/165, opcode and EngineCtx generators/tests/lints clean, Godot build has no compiler/analyzer warnings, and threaded SELFTEST OK.

Next: manually validate Auto advancing both an unvoiced page and a voiced page, then take the remaining History/all-message-skip/read-message-skip/Hide actions as separate bounded services.

ADV all-message Skip implemented (2026-07-18)

The x=728 action now enables the native persistent Skip service through op 0x88. The VM distinguishes persistent button/display state (op 0x19a) from the live skip query (op 0x1c7, persistent state OR the existing host fast-forward channel), and op 0x101 resets only transient input state. Godot completes text reveal and stable waits while Skip is active; the existing skip-aware transition branches publish their final endpoints. Voice calls follow the native latest-only queue: requests replace one deferred voice while Skip is active, and the most recent request starts when op 0x88(0) clears the service.

Native set:CancelMesSkipOnClick defaults to zero, so this slice deliberately does not turn arbitrary clicks into a port-only cancel gesture. A future settings-profile implementation can expose the native nonzero press/release policy without changing the Skip state seam. Regressions exercise the opcode lifecycle and the real SC0000 x=728 callback. Validation: engine 167/167, zero-warning Godot build, opcode and EngineCtx generators/tests/lints clean, and threaded SELFTEST OK.

Next: manually validate that x=728 fast-forwards text and transitions and that a later 0x88(0) boundary returns to normal pacing. Then implement Read-message Skip on the same service seam, adding the required per-script-offset read-history model rather than treating it as another global all-skip toggle.

Manual-validation correction (2026-07-18). The initial Skip build collapsed each formerly blocking message span into a free-running VM burst, so playback teleported to explicit sleeps and then teleported again. Native still executes one opcode per interpreter tick during Skip. Godot now waits for one rendered frame pulse at each FrameYield only while persistent message Skip is enabled, retaining normal free-running bursts outside Skip. Validation: engine 168/168, zero-warning Godot build, threaded SELFTEST OK; repeat the x=728 pacing check before starting Read-message Skip.

ADV Read-message Skip persistence investigation (2026-07-18)

Native RE confirms that this service cannot be implemented as a second all-message toggle. AGE resolves the current script code offset through its per-frame message-offset table, then tests a dword flag in an engine-owned ReadTextDB keyed by the raw packed script resource id and per-script message index. Click, Auto, and active-Skip completion queue {script_resource_id,index,count}; opcode 0x71, whose layout-reset sites are also the structural T1 targets, commits those pending records and therefore is not a pure runtime no-op.

The database is profile-wide rather than slot-local. AGE loads and writes RT.DAT beside shared SAVE.DAT, using $$RT.DAT and RT.BAK for replacement/backup; numbered game slots remain SAVE%2.2d.DAT. Successful slot/context saves and normal shutdown persist the shared database. The full native chain and file layout are recorded in engine-re.md, and /v2 is renamed/commented/saved.

Next: implement a profile-level read-history service behind the VM/host boundary, make click/Auto/Skip completion queue the native tuple, make op 0x71 commit it, and use the same resolver for op 0x1cc. Persist it in a port-owned shared format first; raw RT.DAT import/export can remain a separate compatibility slice.

ADV remaining-button difficulty inventory (2026-07-18)

The remaining action buttons beyond Read-message Skip are History (x=684) and Hide Window (x=772). They are not additional toggle services. HIDEWIN.BIN is 29/37 distinct opcodes covered (251/286 instructions) and mainly needs the real op-0x199 coroutine transition plus AGE's per-frame mouse/joy callback tables, button-state polling, and cursor-resource operations. Existing retained-object translation and presentation support covers its scene-view/pan behavior, making this a medium-sized infrastructure slice.

HISTORY.BIN is 41/78 distinct opcodes covered (761/854 instructions) and needs a separate session-level retained text-record model, navigation/render/metadata ops 0x1d0/0x1d1/0x1d3/0x1d4, stored-voice replay, the same generic input-callback layer, literal local-array initialization, and additional menu/text-surface operations. The shared ReadTextDB is not a backlog: it stores only per-message read flags. History is therefore the largest remaining control-strip action.

Recommended next slice: implement Hide Window first as the smallest clean remaining action and use it to land the generic coroutine/input-callback service that History will later reuse. Read-message Skip remains the next bounded persistence slice; History should follow after both foundations exist. Full native evidence and the difficulty table live in engine-re.md.

ADV Hide Window implemented (2026-07-18)

The real x=772 callback now yields through op 0x199, runs the shipped HIDEWIN.BIN, re-enters the second ADV coroutine handler, and resumes after the original yield via op 0x7c. The VM owns frame-local timed mouse and 32-entry input callback registrations; Godot supplies virtual coordinates, distinct left/right button bits, directional/action indices, and release callbacks. Cursor ids 0x3318..0x331f resolve from the original asset catalog, decode from Windows CUR XOR/AND masks with native hotspots, and install as Godot custom cursors.

G[0x62425] is now named adv_hide_window_enabled. It is not a temporary test seed or save-slot value: all ordinary ADV scripts read it, none writes it, and the full VM-write capture misses it because AGE's native scheduler owns the inherited state. The bounded Godot scene bootstrap mirrors the original enabled value 1. Focused tests cover real SC0000 activation and HIDEWIN return, the two-handler coroutine sequence, timed mouse callbacks, held input callbacks, cursor opcode forwarding, and decoding a real CUR asset. Validation: engine 175/175, opcode/global generator tests and lints clean, zero-warning Godot build, and threaded SELFTEST OK.

Next: manually validate x=772 hide/restore and edge cursors in a normal SC0000 run. The next development slice should be Read-message Skip's profile-wide ReadTextDB model; History can then reuse both that message-completion seam and the generic callback/input layer landed here.

Manual-validation correction (2026-07-18). The textbox faded through the shipped retained-graphics path, but the port's separate ADV text Label and wait-indicator TextureRect stayed visible. Op 0x199 now suspends those two page overlays for the lifetime of the yielded ADV coroutine, and op 0x7c restores them with the saved page. The failed restore interaction was a shared opcode error: bit-set/bit-reset take a bit index, not a literal mask, so HIDEWIN's set-index-1/test-0x2 raw right-button release never matched. Both the C# VM and the Python oracle now use indexed-bit semantics. Follow-up original-game validation corrected an over-narrow input conclusion: AGE separately maps physical left/right mouse buttons into logical callback indices 4/5, and HIDEWIN registers those actions to restore as well. Godot now queues the primary action for a left click while the ADV page is suspended and keeps that click from advancing the enclosing dialogue wait. The real-script regression restores through the left-action callback without hitting the step limit and records the overlay suspend/restore sequence. Validation: engine 177/177, opcode tests/lints and vm0 RECOVER clean, zero-warning Godot build, and threaded SELFTEST OK; /v2 bit handlers are annotated and saved.

Next: manually recheck x=772 with the original left-click restore gesture, then continue with the profile-wide ReadTextDB slice if the visual lifecycle now matches.

ADV Read-message Skip deferred pending persistence architecture (2026-07-18)

The native behavior and data model established above remain the implementation contract: read state is profile-wide, keyed by packed script resource id and per-script message index, with message completion queued and committed through the native 0x71 boundary. Implementation is deliberately deferred, however, until the port has a fuller picture of numbered saves, shared SAVE.DAT state, RT.DAT, configuration, and other engine-owned profile/global data.

In particular, the earlier suggestion to persist ReadTextDB in a port-owned format first is not an adopted storage decision. The port should not choose native RT.DAT, a port-owned replacement, or an import/export split in isolation from the broader save/profile backend, lifecycle, migration, and interoperability design. When that work resumes, the already-reversed semantic model can sit behind whichever backend that wider architecture selects.

With Auto, all-message Skip, and Hide Window implemented and Read-message Skip consciously deferred, History is the sole remaining unimplemented ADV control-strip action to investigate as a current slice.

ADV History retained-record investigation (2026-07-18)

Native RE now bounds History as an in-memory engine service rather than an unknown menu subsystem. The text manager retains 0x48-byte text/metadata/voice records plus 8-byte {layout_slot,first_record_index} logical entries. Ops 0x70/0x71 establish group boundaries, 0x6e writes styled text, 0xc4 writes voice pairs, and op 0x1d2 writes typed metadata. That last opcode was incorrectly classified as a safe marker despite 17,323 corpus uses and is now corrected. Op 0x1bb suppresses recursive recording while HISTORY runs; op 0x85 clears both vectors at ordinary ADV block boundaries.

The other large-looking gaps are generic: 0x64 copies encoded inline literal arrays; 0xa1/0xa2/0xa3 implement switch/case dispatch; 0x12e performs rectangle-array hover tests. The existing Hide Window input callbacks already supply HISTORY's actions. Font/color/layout/surface/presentation opcodes are individually bounded, while 0xd3/0xd4/0xd5 remains the smooth scrollbar callback/interpolation detail.

Native context saves can serialize/deserialize the live backlog, but that path is distinct from RT.DAT. The first implementation should deliberately stay in memory: add an engine/session-owned history service, wire the native writers and 0x1d0..0x1d4 readers, then let the host render requested groups. Save/load restoration remains a named integration seam for the later unified storage architecture rather than a new backend decision in this slice. Full layout, lifecycle, and opcode evidence lives in engine-re.md.

Recommended next implementation slice: land the history record/index model and its ordinary ADV write path first, with focused synthetic tests for grouping, metadata, voice pairs, suppression, and clear. Then add generic literal-array/switch support and the HISTORY read/render path. This orders the work around the data that must exist before clicking History can display anything.

ADV History retained writer model implemented (2026-07-18)

The recommended first slice is complete. AdvTextHistory is an engine model rather than a Godot widget: standalone VMs own it for their complete nested-script lifetime, and GameSession supplies one shared instance to successive scene VMs. It stores logical {layout_slot,first_record_index} entries and semantic text, typed-metadata, and voice-pair records with native flags, layout/cursor snapshots, and the active font/color/effect style.

The ordinary native write path is live. Ops 0x70/0x71 configure/reset layouts and establish group boundaries; 0x6e, 0xc4, and 0x1d2 append text, voice, and metadata records; 0x1bb suppresses all of those writers while HISTORY renders itself; and 0x85 clears the retained vectors at ordinary ADV block boundaries. The already-reversed font, color, mode, effect, bold, and cursor setters update the snapshots future history rendering will consume.

Five focused regressions cover grouping and first-record flags, metadata and voice fields, style/layout snapshots, suppression/re-enable, clear lifetime, session sharing, and the real SC0000 first page reaching its wait with string 0x14963 retained. Validation: engine 182/182, zero-warning Godot build, threaded SELFTEST OK. Static HISTORY coverage is now 56/78 distinct opcodes and 798/854 instructions handled or safe-noop.

Next: implement generic inline integer arrays (0x64) and value-switch dispatch (0xa1/0xa2/0xa3), then wire History navigation/query ops 0x1d0, 0x1d3, and 0x1d4 against this model. Rendering op 0x1d1 and its presentation operations can follow once those data-side script paths execute correctly.

ADV History data-side navigation implemented (2026-07-18)

The second bounded slice is complete. Script.BodyDwords retains the original SYS4 body for runtime data operands, and op 0x64 copies its plain count-prefixed footer values into consecutive global or local VM cells. The native rotate/XOR sequence reverses AGE's loader-created in-memory representation; applying it again to the file would corrupt HISTORY's visibly plain rectangle and coordinate arrays. Generic 0xa1/0xa2/0xa3 value-switch sequences now use formatted keys and branch to their registered or default PC.

The retained model now exposes native navigation and query behavior. Layout boundaries update a latest-entry anchor; op 0x1d0 resolves cumulative deltas from that anchor without mutating it, skipping duplicate first- record offsets and navigation-filtered records. Ops 0x1d3/0x1d4 scan from a supplied record through one group and return typed metadata or the voice pair with native defaults. Ghidra confirms both opcodes' third operands reach unused helper parameters despite HISTORY passing 1.

Eight new focused cases cover signed inline values, real HISTORY footer retention, matched/default value switches, cumulative group navigation, duplicate/filter skipping, metadata/voice queries, and missing-value defaults. Validation: engine 190/190, opcode generator tests/lint clean, zero-warning Godot build, threaded SELFTEST OK. HISTORY is now 63/78 distinct opcodes and 833/854 instructions handled or safe-noop; its 15 remaining effectful gaps total 21 instructions.

Next: implement History's display slice around 0x1d1, layout origin 0x198, message-window alpha 0x131, surface fill 0x20b, and retained-object presentation 0x222. After visible backlog rows render, finish rectangle hover/interaction, voice replay, and the 0xd3/0xd4/0xd5 smooth-scroll scheduler details.

ADV History visible display implemented (2026-07-18)

The third bounded slice is complete. Op 0x1d1 now selects one retained group and produces an engine-owned render batch for the requested target text layout. 0x198 updates that layout's origin, 0x71 clears stale host presentation, and the existing cursor/style setters provide the target baseline and retained font, color, outline, and effect state. The live HISTORY.BIN call passes flags/colors as zero, so the port renders its ordinary bound-text path without inventing behavior for unused native special modes.

Godot maintains per-layout History labels while the engine remains the canonical backlog owner. The surface- text path was generalized from one string per surface to clipped lists, allowing all five speaker-name rows drawn into surface 0xc1 to coexist. Op 0x20b clears each reused 600x30 name region, op 0x131 reads a host configuration seam with a backend-neutral default, and op 0x222 explicitly publishes the retained rebuild. No persistence, RT.DAT, or port-owned profile format was introduced.

Four focused regressions cover target origin/cursor/style, alpha/fill/present operand shaping, layout reset, and an end-to-end real-script path: real SC0000 page-one records are shared into unmodified HISTORY.BIN, which produces a non-empty visible row and reaches (0,60000) presentation without a step-cap halt. Validation: engine 194/194, zero-warning Godot build, threaded SELFTEST OK. HISTORY is now 68/78 distinct opcodes and 840/854 instructions handled or safe-noop; its ten remaining effectful gaps total 14 instructions.

Next: implement the basic History interaction slice around rectangle hit/hover (0x12e) and clean exit using the existing callback layer. Then add stored voice replay (0x1bd); leave 0xd3/0xd4/0xd5 smooth scroll interpolation as a separate fidelity slice.

ADV History basic interaction implemented (2026-07-19)

The fourth bounded slice is complete. Op 0x12e now performs its native forward scan over addressable VM arrays, including HISTORY's local rectangle and offset tables. It begins after the incoming index, applies per-candidate offsets, and inclusively intersects [left,right,top,bottom] candidates with the supplied reference rectangle. The shipped arrays resolve to scrollbar/control regions, bottom-right close candidate 8, and five 650x130 dialogue rows at candidates 9..13; the script's existing redraw owns hover visuals.

Raw input ownership is now frame-scoped. Registering a timed mouse callback through 0xcc marks that script frame as the input owner until return. Godot continues updating raw mouse bits and input callback indices, but does not release the enclosing ADV page semaphore while that modal loop is active. This closes a real scheduler hole without a HISTORY filename, scene offset, or synthetic button path.

Two regressions cover inclusive edges/forward scan and the complete live route. The latter reaches SC0000's first wait, activates the real x=684 History hotspot, lets unmodified HISTORY.BIN render retained text, presses/releases its real close region, and proves the script returns with recording restored while the same single ADV wait remains parked. Validation: engine 196/196, zero-warning Godot build, threaded SELFTEST OK. HISTORY is now 69/78 distinct opcodes and 841/854 instructions handled or safe-noop; its nine remaining effectful gaps total 13 instructions.

Next: implement stored History voice replay (0x1bd) against the existing voice host path. Then take 0xd3/0xd4/0xd5 smooth-scroll interpolation as a separate scheduler/fidelity slice.

ADV History manual layout corrections (2026-07-19)

Manual original/port comparison found that History's fixed rail was correct, but the lookup-driven buttons were clustered at the top-left, the hovered-row artwork disagreed with its hit region, and rendered text lost its x origin. The common VM cause was op 0x61: HISTORY.BIN uses local-int operands as the bases of its copied coordinate arrays, while the port treated the values in those cells as global addresses. Local pointers now retain their local/global address domain, with matching dereference and write-through behavior in both the C# VM and Python oracle. A real-script regression fixes the seven button coordinates at x=768/y=121..549 and confirms every visible row retains layout origin x=65.

Godot's dynamically created History/surface labels also no longer request full-rect anchors before they have a parent. They use top-left absolute placement, matching the batch's origin+cursor coordinates and removing the associated parent/layout diagnostic.

The next manual run showed that the sole bottom line was actually the enclosing ADV dialogue overlay, while the genuine retained batches were clipped to one pixel. The backlog itself is healthy: a new real SC0000 six-message regression produces multiple non-empty History rows. The missing state was the exact SYSTEM4.BIN prefix that defines nine shared text layouts before dispatching any scene; HISTORY only resets and repositions slots 2..6. The single-scene Godot bootstrap now carries forward all nine definitions, with History rows sized 650x150 at x=65 and y increments of 150, until full SYSTEM4 replay replaces this existing class of inherited-state bridges.

Godot also suppresses the parked page's ordinary dialogue Label and wait indicator while any nested timed raw-input frame owns the modal screen, then restores them on return. Root Control anchor presets are now applied after parenting, removing the remaining occurrence of the associated runtime layout diagnostic.

A follow-up exit check found that the host retained the last History render batches after the script had erased its objects and re-enabled recording. Op 0x1bb(1) at HISTORY.BIN@0x1100 is now the presentation end boundary: it clears only the host's transient layout bindings, leaving the engine-owned backlog intact for the next opening. The real interaction regression requires zero active History batches after return.

Validation: engine 198/198, zero-warning Godot build, threaded SELFTEST OK, and vm0 RECOVER clean.

Next: manually recheck the five History rows and overlay cleanup against the original. If they match, proceed with stored History voice replay (0x1bd), followed by 0xd3/0xd4/0xd5 smooth-scroll fidelity.

ADV History stored voice replay implemented (2026-07-19)

The manual row/cleanup recheck passed, and stored History voice replay now uses the existing voice resolver, message-Skip replacement queue, and Auto voice-pending service. Native RE exposed a meaningful second value that the earlier one-id host API erased: ordinary 0xc4 calls the indexed voice service and records {voice_id,0}, while 0x1bd uses and records {voice_id,1}. IHost.PlayVoice now carries this playback variant explicitly; Godot preserves it in queued requests and diagnostics while continuing to play the same resolved OGG until the native variant's audible interpretation is proven.

The generic opcode still appends {voice_id,1} when history capture is enabled, matching the native handler. During the real History menu, the existing 0x1bb(0) suppression boundary prevents that replay from becoming a new backlog record. Focused tests cover the variant, Auto state, normal recording, and suppressed replay. HISTORY is now 70/78 distinct opcodes and 842/854 instructions handled or safe-noop; its eight remaining effectful gaps total 12 instructions.

Validation: 199 non-DirectShow engine cases pass, the isolated DirectShow movie case passes, opcode tests and lint are clean, vm0 RECOVER passes, the Godot build has zero warnings, and threaded SELFTEST OK. The full suite's DirectShow case still times out only when run among the complete suite; this pre-existing multimedia test interaction is unrelated to the History voice path. The /v2 Ghidra image names/comments the shared indexed voice service and is saved.

Next: investigate and implement the 0xd3/0xd4/0xd5 smooth-scroll callback/interpolation family as a separate fidelity slice, including the remaining scheduler support it depends upon.

ADV History live voice gate correction (2026-07-19)

Manual replay remained silent, and the synchronized live trace localized the failure before the audio host: the clicked row reached HISTORY.BIN@0x9c7, found retained voice {0x24,0}, then failed its type-2 metadata query at 0x9e3/0x9ee and returned without executing 0xc4 or 0x1bd. The retained writer had reversed op 0x1d2's operands. Native handler/helper dataflow and SC0000's concrete 0x1d2(2,0x11) site prove the ABI is (metadata_type,value); the helper stores value at record +0x14 and type at +0x18.

The VM now records operand 2 as the value and operand 1 as the type. The real-script regression clears the voice request emitted by the original page, clicks the actual visible voiced History row, and requires a new request for SC0000 0x24/MAN999.OGG; this prevents a pre-History voice from producing a false positive. The /v2 handler and helper comments are corrected and saved. Manual replay of that same retained row now plays audibly, confirming the full click-to-Godot path.

ADV History smooth-scroll scheduler implemented (2026-07-19)

Native RE resolves 0xd3/0xd4/0xd5 as a generic frame-local timed local-callback sequence. Op 0xd3 initializes it, op 0xd4 appends repeated relative deadlines with separate primary and catch-up targets, and op 0xd5 starts the elapsed timer and services callbacks through the penultimate entry. The final entry is a look-ahead sentinel. The scheduler chooses the catch-up target when the next deadline is already late, which lets HISTORY advance interpolation state without performing every intermediate redraw.

HISTORY's concrete schedule is 10/20/30/40/50/51/52 ms: five scrollbar interpolation steps, a no-op terminal callback, and the look-ahead sentinel. The VM now stores this state on the active script frame, uses the host's existing clock/sleep boundary, redirects into the shipped local callbacks, and resumes the same 0xd5 after ret. Focused regressions cover on-time execution and forced catch-up behavior.

The canonical opcode and EngineCtx sources are updated and regenerated; the /v2 handlers, vector append helper, timer helper, and main-loop scheduler are named/commented, the expanded 56-field EngineCtx is reapplied, and the program is saved. HISTORY is now 73/78 distinct opcodes and 847/854 instructions handled or safe-noop. Its five remaining effectful gaps total seven instructions: 0x10d and 0x8b twice each, plus one each of 0x1ce, 0x1cb, and 0x20a.

Next: investigate the five remaining HISTORY support opcodes together, then select the smallest coherent implementation slice from their actual responsibilities rather than treating them as one feature by count.

Validation: all 203 engine tests pass, opcode and EngineCtx tests/lints are clean, vm0 RECOVER passes, the Godot build has zero warnings, and threaded SELFTEST OK.

ADV History mouse-wheel navigation implemented (2026-07-19)

The five-gap investigation separated independent responsibilities instead of grouping them by proximity. Native age_main_window_proc@0x486320 handles WM_MOUSEWHEEL by sign-extending its high-word delta and accumulating it at EngineCtx+0x1c34; op 0x10d returns that signed total and clears it. HISTORY first uses the opcode to discard stale motion, then polls it from its timed mouse callback and feeds the sign into the already implemented smooth-scroll route.

Godot now translates wheel-up/down into signed 120-unit deltas, and the VM atomically accumulates and consumes them. This extends the existing generic raw-input callback seam and introduces no script-specific offsets, seeded state, or persistence choice. A focused regression proves accumulation/read-clear behavior; a real SC0000-to-HISTORY regression opens after eight messages and proves wheel-up changes the retained row selection without releasing the enclosing ADV wait.

The canonical opcode and EngineCtx sources are regenerated, and /v2 now names/comments the recovered main window procedure and the specific 0x10d handler. HISTORY is 74/78 distinct opcodes and 849/854 instructions handled or safe-noop. Remaining: 0x8b twice, paired sprite-animation service ops 0x1ce/0x20a, and the deferred Read-message Skip setting getter 0x1cb.

Next: reverse the common text-style block around 0x8b; it is the smallest remaining non-persistence gap. Keep 0x1cb deferred, and treat 0x1ce/0x20a together as their own sprite-animation slice.

Validation: all 205 engine tests pass, opcode and EngineCtx tests/lints are clean, vm0 RECOVER passes, the Godot build has zero warnings, and threaded SELFTEST OK.

ADV History text line spacing implemented (2026-07-19)

Native RE resolves the two remaining 0x8b calls as text-manager line leading. The handler writes its single pixel count to manager offset +0x560 (EngineCtx+0x14ea0), whose initializer default is 6. Horizontal newline and History rendering add that value to the primary font's positive pixel height; the script's concrete style blocks use 8 pixels with their 22/24-pixel Mincho fonts and 9 with a 16-pixel Gothic font.

The VM now retains that current style property, Godot applies it as the Label line_spacing theme constant, and History rendering matches native ownership: line spacing comes from the text manager's current state rather than from the retained record. A focused regression distinguishes a record retained with spacing 9 from the current History spacing 8, and the real HISTORY route requires all non-empty rows to render with its setup value of 8.

The canonical opcode and EngineCtx sources are regenerated. The /v2 handler and all supporting initializer/line-advance functions are named and commented, the expanded 58-field EngineCtx is reapplied, and the program is saved. HISTORY is now 75/78 distinct opcodes and 851/854 instructions handled or safe-noop. The remaining instructions are paired sprite-animation service ops 0x1ce/0x20a and the deferred Read-message Skip setting getter 0x1cb.

Next: investigate and implement 0x1ce/0x20a together as the final non-persistence History support slice. Keep 0x1cb deferred until the global save/profile storage boundary is chosen.

Validation: all 205 engine tests pass, including four focused History presentation cases; opcode and EngineCtx tests/lints are clean, vm0 RECOVER passes, the Godot build has zero warnings, and threaded SELFTEST OK.

ADV History text publication / wait-indicator service implemented (2026-07-20)

Native RE corrects the provisional "sprite-animation service" description: 0x1ce and 0x20a are the explicit control points for ADV text publication and its animated input-wait indicator. 0x1ce(enabled) starts or stops the indicator's run-state/timer/frame service; Himegari only calls it with zero when entering modal scripts, including HISTORY. 0x20a(layout_slot) republishes the selected retained text layout and, when the service is active, binds its current indicator frame; HISTORY's shared redraw callback uses slot 1. Normal ADV wait opcode 0x72 implicitly arms the same service.

The VM now forwards both operations through generic host methods. Godot gates its existing animated marker on the explicit enabled state and requests recomposition for layout publication. Because the port keeps the parent wait blocked while a nested raw-input callback executes, it restores a previously enabled parent marker when that callback returns, matching the native path that re-enters the shared redraw/wait routine. No script offsets, boot seeds, or persistence assumptions were introduced.

A focused synthetic regression verifies the two service calls, and the real SC0000-to-HISTORY regression requires marker disable plus layout-slot-1 publication while preserving the same enclosing ADV wait and cleaning the modal rows. The canonical opcode and EngineCtx sources are regenerated; the /v2 handlers and workers are named/commented, the expanded 63-field EngineCtx is applied, and the image is saved. HISTORY is now 77/78 distinct opcodes and 853/854 instructions handled or safe-noop. The only remaining instruction is the deliberately deferred 0x1cb Read-message Skip setting getter, pending a global profile/save backend decision.

Validation: all 206 engine tests pass, opcode and EngineCtx tests/lints are clean, vm0 RECOVER passes, the Godot build has zero warnings, and threaded SELFTEST OK.

SC0000 deferred SFX start and voice/BGM duck control implemented (2026-07-20)

Native RE and the saved SFX trace resolve two high-frequency audio gaps. Opcode 0x2bf is the sound facade's SetDelay(channel,start_mode,delay_ms): SC0000's first (4,0,100) call starts the preloaded secondary E0808 channel about 109 ms later through the same worker used by 0xb5. The port now schedules that start against the presentation clock and attaches it to a per-channel generation, so a later load or release cancels an obsolete callback instead of starting replacement audio.

Opcode 0x1cf replaces a transient voice/BGM-duck control mask; bit 0 suppresses automatic ducking. The native engine registers ducking enabled with a 50-percent target, and its voice-start helper saves the current BGM level before applying that target. Godot now follows that contract and restores the saved level when voice playback completes or message Skip stops it. This is runtime audio state only: no profile/save field, boot seed, or storage-backend decision was introduced.

The canonical opcode and EngineCtx sources are regenerated, the expanded 65-field EngineCtx is applied, and the /v2 handlers/workers are named, commented, and saved. SC0000 is now 119/129 distinct opcodes and 16,238/16,257 instructions handled or safe-noop (92.2% distinct; 99.9% instruction-weighted); its ten remaining effectful gaps total 19 instructions.

Next: investigate the six-call 0x1ad cluster first. It is now the largest remaining SC0000 gap and should be classified before choosing between it and the smaller two-call support pairs.

Validation: all 206 engine tests pass; opcode and EngineCtx lints, vm0 RECOVER, the zero-warning Godot build, and threaded SELFTEST OK are clean.

Slice A2b-0x1ad investigation — numbered-save resume-frame marker (2026-07-20)

The six-call SC0000 0x1ad cluster is now classified at high confidence. The zero-operand handler 0x416b70 stores the current script-context index in ctx+0x9928c. Numbered-save serializer layouts 2/3 use that index as the inclusive high frame, copy activations 0..mark, and clear the marked activation's saved return target so it becomes the top frame after load. Opcode 0x2 clears the mark when unwinding below it. Across the corpus, 1,928 calls in 304 scripts place the marker at main-script entries and after modal script returns; SC0000's sites are startup plus HISTORY/MENU/HIDEWIN/INPUTNAME return paths.

No runtime implementation landed. The current GameSession JSON format persists global banks only and has no active ExecFrame chain or numbered-save lifecycle, so 0x1ad cannot have its native observable effect without choosing the unified save backend already being deliberately deferred. It remains an effectful gap, now explicitly grouped with persistence work rather than UI support.

The investigation also corrected a foundational native-field label: ctx+0x53d88 + curCtx*0x78 is the decoded instruction length in dwords (1 + 2*argc) used by adv_interpreter_tick to advance the PC, not a gfx command type. The canonical EngineCtx field, affected opcode prose, native RE, SCJUMP note, and legacy Frida-tool description now reflect that distinction; no completed host gfx behavior changes as a result.

Next: leave 0x1ad and 0x1cb together behind the future save/profile boundary. Investigate the paired zero-operand 0x1f6/0x20e calls next: both bracket SC0000's ADV scene setup/teardown paths and are the largest repeated non-persistence cluster still unclassified.

Validation: all 206 engine tests pass; opcode and EngineCtx tests/lints, vm0 RECOVER, and git diff --check are clean. SC0000 coverage deliberately remains 119/129 distinct opcodes handled (92.2%), with 0x1ad's six calls retained as a gap until numbered saves serialize active execution frames.

Slice A2b-0x1a2/0x1a3 investigation — shared SAVE.DAT integer cells (2026-07-20)

The foundational field correction does not invalidate completed visible graphics/animation/UI behavior, but the flagged 0x1a2 debt is now fully classified. 0x1a2 snapshots the selected global integer cell into a shared-profile hash keyed by its resolved global-bank index; 0x1a3 restores the paired value or zero. Native shared_profile_save serializes the table to shared SAVE.DAT, and shared_profile_load reconstructs it. It is neither retained graphics state, numbered-slot state, nor RT.DAT ReadTextDB state. The full native contract and provenance live in docs/engine-re.md and vm-map/opcodes.toml.

The inert GfxState approximation and its VM handler were removed. This intentionally changes coverage from a false impl classification to an explicit effectful gap; it does not change visible runtime behavior because the old set had no readers. 0x1a3 was already a default-stub gap. The port's whole-global-bank GameSession snapshot can mask some persistence effects, but it is broader than AGE's selected-cell service and cannot faithfully reproduce load-or-zero or lifecycle boundaries.

Deferred implementation boundary: add the pair only with a profile-owned cell-index→raw-int32 service shared across VM runs and an explicit decision for how port profiles persist/migrate shared SAVE.DAT state. Do not seed values, special-case script offsets, or silently fold this table into retained graphics or numbered saves. This can be implemented independently of raw native file import/export once the port-owned profile schema is chosen; RT.DAT and numbered-save frame state may share the owning profile service without sharing their native on-disk formats.

The canonical opcode and EngineCtx sources are regenerated. The /v2 handlers, shared-profile payload reader/writer, and generic table helpers are named and commented; the expanded 69-field EngineCtx is reapplied and the image is saved. Correcting the false implementation moves SC0000 from 119/129 to 118/129 distinct opcodes handled (91.5%): its 206 0x1a2 instructions now appear honestly among 225 effectful-gap instructions. This is a tracker correction, not a new runtime failure.

Next: keep 0x1a2/0x1a3, 0x1ad, and 0x1cb grouped behind the future unified profile/save ownership decision. Continue with the paired zero-operand 0x1f6/0x20e scene setup/teardown investigation as the largest repeated non-persistence SC0000 cluster.

Validation: all 206 engine tests pass; opcode and EngineCtx tests/lints, vm0 RECOVER, and git diff --check are clean.

Slice A2b retained-graphics lifecycle implemented (2026-07-20)

Native RE split the apparent 0x1f6 / 0x20e pair into two separate services. 0x1f6 clears the retained handle-to-object registry without releasing surface resources, and the commonly adjacent 0x23d stops movie bindings and releases transient surface slots 42 through 999. Independently, 0x20d(slot) selects an offscreen Direct3D render target (or the backbuffer for values at least 1000), and 0x20e clears the selected color target to black plus its depth buffer to 1.0.

The VM now models all four operations generically. GfxState owns the selected target and distinct object/surface lifecycle; the host receives target clears and fixed-range surface release. Godot removes modeled offscreen text pixels on clear, stops movies and clears slot-owned resources on the bulk release, and continues to rebuild the main retained frame from black. Focused regressions prove object clear preserves surfaces for rebinding, target selection reaches both an offscreen slot and the backbuffer, and the bulk release preserves system-owned low slots while dropping slot 42.

The trace corrected an older EngineCtx-base assumption: object registry +0x408, frame timer +0xb550, and nearby animation flags are relative to the embedded retained-gfx manager at EngineCtx+0x46614. Their actual absolute addresses are EngineCtx+0x46a1c and EngineCtx+0x51b64 onward. Existing visible graphics and animation implementations remain valid because they model the recovered worker behavior and observed timing rather than reading native process addresses.

The canonical opcode and EngineCtx sources are regenerated. /v2 names/comments the four handlers and five supporting workers, and the corrected structure is reapplied before saving. SC0000 is now 121/129 distinct opcodes handled (93.8%) and 16,037/16,257 instructions handled or safe-noop (98.6%); 206 of the 220 remaining effectful-gap instructions are the deliberately deferred 0x1a2 shared-profile writes.

Next: investigate/implement the two-call 0x242 retained-object field setter. It is already classified as an object +0x2d0 write and is the smallest coherent non-persistence gap; keep 0x1a2/0x1a3, 0x1ad, and 0x1cb behind the future profile/save ownership decision.

Validation: all 209 engine tests pass; opcode and EngineCtx tests/lints, vm0 RECOVER, the Godot build, threaded self-test, and git diff --check are clean.

Slice A2b detached finite object animation implemented (2026-07-20)

The obj+0x2d0 consumer resolves 0x242(handle,flags) as a finite-animation detachment control. Bit 0 makes that object's one-shot color/scale/rotation/translation/source-rectangle group ignore 0x243's global force-complete request and prevents it from holding native blocking-presentation dirty state, while leaving redraw dirty so it continues animating asynchronously. Native clears bit 0 after the finite group finishes. SC0000's two CG loaders pass zero; 302 of 303 corpus calls do the same. The only value-one use is an animated battle object in BTL.BIN.

GfxState now retains and clones the control word, excludes detached channels from blocking waits without excluding them from visual recomposition, protects them from 0x243, and clears bit 0 on natural completion. The 0x243 model is correspondingly completed: it commits every unprotected finite channel as well as resetting the separate global animation clock. Focused regressions cover get-or-create/clone behavior and the protected-versus-ordinary completion split.

The canonical opcode source is refined and regenerated. EngineCtx adds the animation-service flags at 0x51b80 and refines the two dirty-field roles; the expanded 76-field structure is reapplied to /v2. The 0x242 handler/worker, 0x243, and the shared channel consumer are named/commented and saved. SC0000 is now 122/129 distinct opcodes handled (94.6%) and 16,039/16,257 instructions handled or safe-noop (98.7%). Its remaining seven gaps total 218 instructions, 206 of them the deferred shared-profile write.

Next: investigate the four adjacent one-call unknowns 0x19b, 0x19c, 0x1ca, and 0xae together before choosing an implementation. Their low frequency makes a shared native-service relationship more important than any one opcode's count; persistence-bound 0x1a2, 0x1ad, and 0x1cb remain deferred.

Validation: all 211 engine tests pass; opcode and EngineCtx tests/lints, vm0 RECOVER, the zero-warning Godot build, threaded self-test, and git diff --check are clean.

Slice A2b ADV skip lifecycle implemented; adjacent persistence gaps classified (2026-07-20)

Native RE resolves script savemesskip/loadmesskip opcodes 0x19b/0x19c as an ADV presentation lifecycle pair. Suspend clears active fast-forward and the service gate while preserving the persistent all-message Skip toggle. Resume re-enables the gate and recomputes active fast-forward from that toggle or the live read-skip channel. The VM now models persistent and active skip state separately, and focused tests prove both persistent-toggle preservation and read-skip-only reactivation.

The same investigation classified the two adjacent one-call gaps without papering them over. Opcode 0x1ca is the already-known message:ReadTextSkip settings write and remains deferred with 0x1cb, RT.DAT, and the profile-owned read-state decision. Opcode 0xae is normally inert but becomes the serialized save-stack restoration rendezvous: it restores frame PCs and walks saved contexts while a flag set by the save-data deserializer is active. Because the port has no numbered-save ExecFrame backend, an unconditional no-op would be a false implementation; it remains grouped with 0x1ad.

The canonical opcode source and expanded 78-field EngineCtx source are regenerated. /v2 names/comments the three handlers and save deserializer, applies adv_skip_service_enabled and save_load_stack_restore_active, and is saved. SC0000 is now 124/129 distinct opcodes handled (96.1%) and 16,041/16,257 instructions handled or safe-noop (98.7%). Its five remaining gaps total 216 instructions: 0x1a2×206, 0x1ad×6, 0x1cb×2, 0x1ca×1, and 0xae×1.

Next: keep all five remaining gaps behind the unified profile/read-state/numbered-save ownership work. Choose the next implementation slice from a different scene or runtime subsystem rather than claiming normal-path no-ops for 0xae or a transient-only ReadTextSkip setting.

Validation: 213 engine tests pass; opcode and EngineCtx generators/tests/lints, SC0000 coverage, vm0 RECOVER, the zero-warning Godot build, threaded self-test, and git diff --check are clean.

Slice A2b opcode 0x1fe immediate rotation classified (2026-07-20)

Native RE resolves 0x1fe(handle, axis_x, axis_y, axis_z, angle_degrees) as the retained-object immediate-current axis-angle rotation setter. The handler converts its four numeric operands to floats; the worker stores the current axis and degree angle, rebuilds the current rotation matrix, and raises the ordinary retained-gfx redraw flag. It neither creates a timed transition nor writes 0x21f's target fields: it is rotation's direct-current companion to the implemented 0x1fd current-scale setter.

Corpus use reinforces the decode: 186 of 187 calls use Z axis (0,0,1), with only a DEBUG call using Y axis (0,1,0). SC0010's five sites include immediate 5, -5, and 0 degree Z rotations in a wobble sequence; SC0020 and SC0030 add six and three sites respectively. The port already retains RotationCurrent and composes it in native matrix order, so implementation should be a narrow generic GfxState current-rotation setter plus VM dispatch and focused tests. No runtime implementation is claimed by this investigation.

Next: implement 0x1fe through the existing retained-transform model. It requires no new host API, storage backend, seed, or script-specific behavior.

Validation: opcode source regenerated; opcode tests/lint and git diff --check are clean.

Slice B1 SYSTEM4 logical input bindings investigated (2026-07-21)

Native RE resolves SYSTEM4's adjacent 0xfe/0x107/0x10b/0x10c block as the configuration layer for the logical action mask consumed by 0xff/0x100. 0xfe sets a ten-action dispatch bound. Native default arrows use 0=up, 1=right, 2=down, 3=left; keyboard mappings then assign Z/Enter, Space, C/LeftCtrl, X, PageUp, and PageDown to actions 4 through 9. Joystick axes use the same directional actions, six physical buttons map to actions 4 through 9, left mouse defaults to action 4, and SYSTEM4 remaps right mouse to 7.

The port presently sends six Godot UI actions directly to logical indices in a different directional order and lets 0x100 scan all 32 slots. The next implementation should therefore be one generic, engine-owned physical-to-logical binding service: model native defaults, implement all four setters, bound callback polling/dispatch by the configured count, and route Godot key/mouse/joy events through the model. It requires no save/profile decision, seed, or Himegari-specific branch. No runtime implementation is claimed by this investigation.

Next: implement that input-binding service as one coherent slice with focused mapping, bounds, and simultaneous-input regressions, then manually exercise TITLE/ROOM/ADV keyboard and mouse paths.

Slice B1 SYSTEM4 logical input bindings implemented (2026-07-21)

InputBindings now owns AGE's process-wide physical-to-logical map. Its constructor reproduces native count 7 and the retained defaults Up/Right/Down/Left, Enter, Space, and Backspace. Opcodes 0xfe/0x107/0x10b/0x10c mutate the action bound, joystick slots, mouse slots, and DIK-translated Win32-VK map. Godot supplies physical key, left/right mouse, standardized joy-button, and primary-axis state instead of hardcoded ui_* indices; direct-scene diagnostics replay SYSTEM4's 16 immediate mapping calls through a bounded bootstrap while natural boot executes them normally.

The implementation also corrects 0x100's release boundary after a final native trace: set bits dispatch only below input_action_count and resume at 0x100 for simultaneous inputs, while an empty mask dispatches callback slot input_action_count and resumes after the opcode. SYSTEM4's value 10 therefore reserves slot 10 as the no-input/release callback rather than exposing action bit 10. The old synthetic release-bit queue is no longer used by Godot. Focused tests cover native defaults, all four setters, the real SYSTEM4 block, empty-mask dispatch, simultaneous/bounded actions, and native range failures.

Next: manually exercise TITLE, ROOM, and ADV with keyboard, left/right mouse, and—if available—a controller. A clean check should confirm native direction order, Z/Enter/Space behavior, right-click action 7, and release re-arming before selecting another reached Phase-B cluster.

Slice B1 ADV held fast-forward implemented (2026-07-21)

Manual validation found the general input bindings sound but LeftCtrl did not accelerate ADV. Native tracing resolves the missing consumer: adv_interpreter_tick@0x410fb0 polls the configured logical mask and uses action 6's bit 0x40 for transient fast-forward. It does not test Ctrl directly, so SYSTEM4's C/LeftCtrl bindings and the engine's retained Backspace default intentionally share the behavior.

The VM now forwards held action 6 through an ADV-lifecycle-gated physical skip channel. Godot combines it with, but stores it separately from, persistent op-0x88 Skip; release therefore restores normal playback only when the persistent channel is also off. The combined state reuses text completion, wait advance, voice deferral/release, and skip pacing. Focused tests cover Backspace/C/Ctrl, activation on ADV resume, and persistent-toggle survival across a physical press/release.

Next: manually hold LeftCtrl through text reveal and multiple waits in SC0000, then confirm release returns to normal cadence and that the on-screen Skip toggle remains active if enabled during the test.

Slice B1 ADV right-click system-menu path investigated (2026-07-21)

The native and corpus paths agree end to end. SYSTEM4 maps right mouse and X to logical action 7; every one of the 136 SC-family scripts binds action 7 through op 0x97 to a dummy hotspot whose activation branch calls MENU.BIN. Native adv_input_service_poll resolves these bindings against the live logical-action mask before ordinary page advance. The port already stores the binding in HotspotRegistry.Entry.InputBit, but nothing reads it, so action 7 stops after registration even though the physical input layer is correct.

MENU.BIN is 48/49 handled, and its INFO selector is 30/30. The only MENU gap, op 0x80, is a default retained graphics-object-slot selector consumed by op 0x1d9; it is straightforward state but not the launch blocker. Larger character/info detail screens are about 91.5–95% handled and should be treated as follow-up discrepancies reached through manual use. SAVE/CONFIG remain separate, storage-sensitive work.

Next: implement one generic bound-action hotspot activation API, route pressed keyboard/mouse/controller action masks through it before page advance, and implement op 0x80's engine-owned selector. Add a focused synthetic bound-action test plus an SC0000 action-7 regression that proves the real MENU.BIN frame is entered and the parent ADV wait is restored after return.

Implemented: the armed hotspot registry now scans op-0x97 bindings in native registration order and feeds matches through the existing activation callback lifecycle. Godot sends pressed keyboard, mouse, and joystick action masks through that bridge before ADV page advance, so right mouse and X both reach the script-owned MENU callback without a game-specific shortcut. Op 0x80 retains the selected default graphics object slot. Focused coverage proves single-consumption/rearm behavior, the selector contract, and actual SC0000 action-7 entry into release MENU.BIN followed by restoration of the parent ADV hotspots. Validation: 255 engine tests, zero-warning Godot build, and threaded selftest.

Next: manually exercise right-click and X from an SC0000 ADV wait, verify the MENU shell can be navigated and closed without losing the underlying page, then classify only the secondary submenu gaps actually reached.

Manual validation: passed on 2026-07-21. The system menu opens from ADV and returns successfully through the implemented script-owned action path; no underlying-page restoration discrepancy was reported.

Slice B1 movie-surface stop-time query implemented (2026-07-21)

Native RE corrected op 0x23f from the port's former retained-object existence test to query-surface-stop-time-ms(out, surface_slot). It calls IMediaPosition::get_StopTime, multiplies seconds by 1000, truncates toward zero, and returns -1 only for an empty movie slot. All 23 Himegari sites are associated with a preceding non-modal 0x236; FIELD consumes the result as an effect lifetime.

The Windows decoder now obtains the stop time inside 0x236's synchronous graph-construction boundary and hands it into engine-owned per-surface movie state before the VM advances. The already initialized decoder is staged for main-thread adoption, so frame delivery remains asynchronous without reopening the graph. 0x23f returns the retained value. If a movie exists but its decoder supplies no finite signed-32-bit timing value, the host reports a warning containing script/offset/surface context and returns -1; a genuinely empty movie slot returns -1 silently. Focused tests cover all three outcomes and the real SC0000 DirectShow payload exposes a positive stop time. Validation: 270 engine tests, zero-warning Godot build, and threaded Godot selftest.

Manual validation: passed on 2026-07-21. A normal Game Start through SC0000's movie-backed opening produced no movie stop-time unavailable warning, confirming the ordinary DirectShow timing handoff.

Next: continue with the next concrete discrepancy reached by manual testing.

Performance tuning sidebar (started 2026-07-22)

This bounded effort addresses frame-time collapse during simultaneous retained effects (first observed in SC0000 immediately before the CHAPTER movie) and in unit-heavy dungeon presentation. Earlier work already removed redraws during static waits, batched the CPU backbuffer, cached decoded source pixels, and added an integer-translation raster path. The remaining architecture still rebuilds an 800x600 RGBA backbuffer in C# and uploads the complete image whenever any visual channel is active. Effect bursts multiply full-screen and general-affine pixel work; a single ambient spritesheet channel also keeps that path active every Godot frame even when its discrete source cell has not changed.

The effort will keep GfxState as the backend-neutral AGE truth and retain the current software renderer as a fidelity oracle. Optimization claims require repeatable frame-time evidence from the real interactive path, not screenshot-sequence runs whose PNG I/O dominates timing.

Target workloads and success measures

Use three fixed workloads: a static ADV wait (control), the SC0000 pre-CHAPTER burst, and the DEBUGMAP/FIELD camera-pan stress case as the current dungeon proxy. Save loading is not yet available, so reaching a reproducibly unit-heavy story dungeon is disproportionate to this sidebar; add that validation later when save loading or progression makes it practical. Capture the exact script/offset alongside each frame. Compare equivalent Release/windowed runs by median, p95, and p99 frame time, recomposition time, raster time, upload time, allocation rate, visible/time-varying object count, raster path, and candidate pixel count. Track both presentation cadence and the cost of each recomposed frame: reducing how often an unchanged discrete animation is drawn must not disguise an over-budget frame when it does change. The immediate target is sustained 60 FPS where the native presentation has no intentional lower cadence; p95 must remain under 16.67 ms on the development machine, with no screenshot or behavioral regression at the sampled coordinates.

Execution slices

• P0 - frame/compositor performance log. Add an opt-in --perf-log <csv> diagnostic. Record bounded, buffered per-frame phase timings, compositor workload counters, managed allocations/GC deltas, and the current VM script/offset/opcode. Document the schema and validate the writer independently of Godot.
• P1 - capture and attribution. Record the static ADV control, SC0000 burst, and DEBUGMAP/FIELD dungeon proxy without --gfx-log, --timeline-log, or frame PNG capture. Use controlled compose/upload ablations only if the phase timings do not isolate the cost. Commit the baseline percentiles and exact canonical runtime coordinates here. A real unit-heavy story dungeon is deferred until it is practical to reach reproducibly.
• P2 - fidelity-neutral CPU wins. P2a-P2f are implemented and measured. DEBUGMAP now meets its p95 frame budget with near-zero steady allocation; the SC0000 exit capture remains 65.18/71.76 ms p50/p95 in the severe full-screen/additive band, so P2 closes and triggers P3 rather than more CPU special cases.
• P3 - GPU retained-renderer prototype. Upload decoded/color-key texture variants once and mirror ordinary retained objects into GPU-native Godot drawing while preserving handle z-order, atlas regions, transforms, opacity/tint, and blend mode. Begin with dungeon sprites and ordinary translated textures; compare selected frames against the software oracle behind a backend switch.
• P4 - GPU special paths and backend decision. Extend the prototype through affine effects, additive/tint channels, created surfaces, transitions, and movie surfaces. Adopt it as the default only after target-workload frame evidence and visual equivalence; otherwise retain documented CPU fallbacks for unsupported paths.

Do not optimize VM dispatch or investigate GPU stalls without evidence from P0/P1. --trace-histogram remains the opcode-frequency tool; it is not a frame profiler. Godot's generic frame monitor is useful corroboration, but the project log owns the AGE-object and raster-work attribution required by these slices.

P0 frame/compositor performance log implemented (2026-07-22)

Godot now accepts --perf-log <csv>. The buffered writer records one row per _Process frame with the VM script/offset/opcode at frame entry and the actual presentation boundary, Godot delta, measured main-loop phases, managed allocations/GC deltas, and the retained compositor's clear/snapshot/resolve/source-prep/raster/SetData/texture-upload split. Its workload counters include actual object/layer visits, sampled time-varying objects, transition and blend categories, integer versus affine paths, dynamic sources, source-pixel area, and clipped destination bounding-box candidates. The writer and affine clipping calculation are Godot-independent and directly unit tested. RenderObject now exposes whether its sampled object still has an active finite, spritesheet, color, rotation, surface, or range-transform channel; this is observation only and does not alter scheduling.

The threaded selftest wrote 101 coordinate-bearing rows and remained SELFTEST OK. A five-frame headless SC0000 schema smoke used isolated output paths and exercised one real recomposition, producing populated snapshot/resolve/object/skip counters; its dummy-renderer viewport warnings are why headless numbers are not performance evidence. Validation: 337 engine tests pass, including the new CSV/clipping and time-varying object regressions, and the Godot build has zero warnings/errors. Next: P1 must capture windowed, speed-1 control/pre-CHAPTER/quiet-dungeon/unit-heavy-dungeon runs without the high-volume diagnostics, then record their exact coordinates and percentile attribution here before selecting P2 changes.

For the duration of P1/P2 collection, run-godot.cmd now opts into timestamped performance capture on every windowed run. The launcher creates build/perf/run-yyyyMMdd-HHmmss-fff.csv and prints its path, allowing a normal play session to cover multiple reported passages without restarting solely for instrumentation. Direct PowerShell launches remain opt-in through -PerfLog, and selftests remain unprofiled. Remove this temporary batch-file default when the performance effort closes.

P1 capture 1 - SC0000 through the pre-CHAPTER burst (2026-07-22)

build/perf/run-20260722-105708-610.csv is the first controlled interactive capture: 3,307 frames over 55.1 seconds, including 2,836 SC0000 frames and 1,273 SC0000 recompositions. Static SC0000 frames establish the control inside the same run: across 1,563 non-recomposited frames, measured main-loop p50/p95/p99 was 0.014/0.024/0.032 ms. The active renderer is the problem: SC0000 recompositions measured main-loop p50/p95/p99 21.80/55.35/82.69 ms; raster p95 was 54.57 ms, while snapshot p95 was 0.017 ms, Image.SetData p95 0.456 ms, and texture upload p95 0.215 ms.

The reported simultaneous-effect lag is one contiguous 83-frame plateau (frames 1618-1700, virtual time 20,727-26,306 ms) parked at presentation boundary SC0000@0x123de (0x21c). Its main-loop p50/p95/max was 64.28/87.82/91.54 ms, equivalent to roughly 15.6 FPS at the median and 11.4 FPS at p95. Rasterization was 98.4% of mean main-loop time. The workload grows from 8 to 12 drawn layers and averages 3.85 million clipped candidate pixels per frame (4.98 million maximum), with as many as three general-affine layers, five additive layers, and ten viewport-covering layers. The worst frame spent 90.82 of 91.54 ms rasterizing 11 layers; snapshot, resolution, source prep, SetData, and upload together remained below one millisecond.

A secondary lead appears outside the severe plateau: recomposited allocation p95 is 1,961,448 bytes and source-prep p95 is 2.81 ms, with 0.991 correlation between the two. The size closely matches one 800x600 RGBA clone, and the affected rows have three dynamic layers; this is strong evidence for the existing dynamic-color-key clone path, but it is not the cause of the 80-90 ms plateau (whose source prep is about 0.003 ms). Treat clone removal as a later independent P2 win.

This capture confirms the CPU rasterizer as the SC0000 bottleneck and makes upload/snapshot optimization a low priority. P1 remains open until quiet- and unit-heavy-dungeon captures establish whether discrete spritesheet scheduling is enough for dungeons or whether their pixel workload independently requires the GPU retained-renderer path.

P1 capture 2 - DEBUGMAP/FIELD camera pan (2026-07-22)

build/perf/run-20260722-112100-189.csv is a 1,381-frame interactive DEBUGMAP stress run. The map portion contains 800 recomposited frames over 39.8 seconds. It measured main-loop p50/p95/p99 49.17/64.59/68.39 ms and raster p50/p95 45.58/59.36 ms. Snapshot, resolution, source preparation, Image.SetData, and texture upload again remain small in steady state; raster time correlates 0.987 with main-loop time. The dominant idle/pan boundary is FIELD.BIN@0x1029 (0xc8): 438 samples average roughly 962 visited objects, 961 submitted layers, 51 time-varying objects, and 2.16 million clipped candidate pixels. Its main-loop p50/p95 is 49.05/59.03 ms.

Camera position materially changes work rather than eliminating the bottleneck. Across representative 50-frame windows, candidate pixels range from 1.12 to 3.10 million and average main-loop time from 28.1 to 63.8 ms; candidate count correlates 0.858 with main time. Object count alone is not enough to explain the range. At the same approximately 962-object FIELD boundary, unusually light frames with 953 integer and only seven affine layers render 1.20 million candidates in about 10.3 ms, while typical frames with roughly 432 integer and 526 affine layers render 1.6-2.5 million candidates in about 26-60 ms. General-affine pixel sampling is therefore a major dungeon cost in addition to the persistent layer traversal.

The run exposes two independent secondary issues. Recomposited FIELD frames allocate about 3.59 MB at the median and trigger 32 gen-0, ten gen-1, and five gen-2 collections. The compositor currently formats a verbose outcome string for every visited object even when neither --gfx-log nor --timeline-log created the decisions dictionary; gating that diagnostic formatting is the first low-risk P2 allocation fix. One outlier (frame 1065) spends 37.99 ms resolving a resource and 48.69 ms rasterizing for a 90.53 ms total; the following steady frames return to raster dominance, so resource-resolution/GC stalls should be tracked separately from the continuous map cost.

DEBUGMAP is sufficient as an intentionally heavy retained-map stress case: it confirms that discrete-cell scheduling can remove unnecessary frames from the 51 animated objects, but cannot make a recomposed frame with hundreds of mostly affine layers fit a 16.67 ms budget by itself. P2 should gate unused diagnostic strings, add discrete-cell scheduling, and benchmark affine/opaque fast paths. A representative real unit-heavy dungeon remains a later validation workload once save loading or progression makes it practical; DEBUGMAP is the accepted P1/P3 stress proxy for now.

Evidence-driven performance action plan (2026-07-22)

The save-loading limitation makes DEBUGMAP/FIELD the accepted dungeon proxy for this effort, so P1 is closed. The SC0000 plateau and DEBUGMAP steady map load exercise complementary failure modes: SC0000 has few layers but extreme full-screen/additive pixel work, while DEBUGMAP has hundreds of retained layers, many sampled through the affine path, and discrete animation that currently requests a recomposition every Godot frame. Execute the following in order, retaining the software compositor as the pixel oracle.

1. P2a - remove diagnostic-only allocation from normal rendering. Construct per-object outcome strings and final z decision strings only when --gfx-log or --timeline-log actually supplied a decisions dictionary. Preserve byte-for-byte diagnostic output when enabled. Re-run DEBUGMAP and require a large reduction from its approximately 3.59 MB median allocation per recomposition without worsening raster time; if less than 70% disappears, use an allocation trace to identify the remaining owners before doing speculative collection tuning.
2. P2b - measure the two ambiguous dirty/raster categories. Extend the low-overhead counters only as needed to distinguish VM-requested, continuous-channel, and discrete-cell presentation, and to split pure fractional translation from scale/rotation/general affine work. The current log proves that the broad categories matter but cannot tell whether DEBUGMAP's roughly 526 apparent affine layers are camera-induced fractional translations or genuine scale/rotation. Do not change sampling semantics on that assumption alone.
3. P2c - reproduce the native shared dirty/cell cadence. Native does not give each visible sprite a host-frame redraw timer. One shared current/previous millisecond frame-time pair feeds every channel; op 0x231 compares the source cell selected at those two samples and raises graphics dirty only when it changes. Retained mutations and genuinely continuous channels still redraw as required, while an opcode-0xc8 poll iteration alone does not. Track retained mutation publication so FIELD's sleep(1) input loop stops forcing unchanged compositions, and replace “any spritesheet is active” with shared cell-change detection. FIELD's prototype 0x9c40 is configured once at 200 ms/four cells and cloned before first presentation, so the unit family is phase-locked at 5 Hz rather than 51 independent deadlines. Cover clone-before/after-first-sample, reconfiguration, differing periods, wraparound, and exact boundary cases. The DEBUGMAP acceptance metric is recompositions per second and total delivered frame time; the separately reported p50/p95 cost of frames that do recompose must remain visible.
4. P2d - specialize the measured axis-aligned scale work. P2b disproved the fractional-translation hypothesis: the new DEBUGMAP capture reports zero fractional and zero general-affine layers, with every non-integer layer classified as axis-aligned scale. Implement the nearest-neighbor-equivalent scale path and prove it byte-for-byte against the existing inverse-mapped oracle across positive/negative coordinates, half-pixel boundaries, clipping, opacity/tint, and every blend mode. This is the highest-potential DEBUGMAP per-compose CPU win because the existing translated loop is much cheaper than a general matrix inverse and transform per destination pixel.
5. P2e - specialize the remaining hot pixel loops. The measured axis-aligned scale specialization is complete. Benchmark opaque/full-opacity/unmodulated translated and scaled pixel loops next, using direct copies for fully opaque source texels and the existing blend arithmetic at transparent edges. General incremental inverse coordinates are low priority because the measured FIELD workload has no general- affine layers. Use randomized differential raster tests against the current implementation plus the SC0000 and DEBUGMAP captures. Address the dynamic color-key full-frame clone separately because it explains an allocation/source-prep spike but neither primary raster plateau. Do not spend time on snapshot, clear, Image.SetData, texture upload, VM dispatch, or parallel rasterization while their measured contribution is small or a retained GPU renderer is the cleaner boundary.
6. P2f - remove the measured per-frame collection owners. Replace Transform2DMath.Build's heap 4x4 matrices with an equivalent value-type affine-3D representation, and let the compositor reuse a caller-owned, handle-sorted RenderObject snapshot buffer. Preserve the allocating snapshot overload for callers which retain independent samples. Require exact matrix/sort differential coverage and direct zero-allocation assertions after warm-up; confirm the real path with the allocation-phase CSV columns.
7. P2 exit gate and P3 trigger. After the safe CPU batch, repeat equivalent SC0000 and DEBUGMAP runs. Report both end-to-end cadence and recomposed-frame p50/p95/p99. If either workload's required recompositions remain above 16.67 ms p95, begin P3 rather than accumulating increasingly complex CPU special cases. The expected P3 prototype mirrors ordinary translated/atlas dungeon objects into Godot canvas items behind a backend switch, uploads decoded/color-key variants once, and updates retained items only when their state changes. It must preserve handle order, transforms, tint/opacity, and blend behavior and compare selected output against the software oracle before expanding to SC0000's affine, additive, transition, created-surface, and movie special paths in P4.

Each landed optimization gets a before/after row in this document with capture path, canonical runtime coordinate, p50/p95/p99, allocation, recomposition rate, and raster-work counters. Revert or leave behind a disabled experiment when it does not produce a repeatable real-path improvement. The next capture validates P2a-P2c together and uses P2b's new categories to choose P2d without another story-progression dependency.

P2a-P2c implementation checkpoint (2026-07-22)

Normal runs no longer construct per-object compositor outcome or final z-decision strings unless --gfx-log or --timeline-log requested that evidence. This removes the known DEBUGMAP diagnostic-only allocation source while preserving the diagnostic path. The performance CSV now records five independent presentation reasons (host request, legacy screen transition, retained mutation, continuous channel, and discrete source-cell change) and separates fractional translation, axis-aligned scale, and general affine layers while retaining the original aggregate affine count.

GfxState now publishes retained mutation generations once and samples one shared current/previous frame time pair on every host tick. Continuously varying channels remain frame-driven. Visible op-0x231 spritesheets request composition only when their selected cells differ between the shared samples, and clone-before-first-sample records seed together. VM object writes that previously escaped the model lock are now applied through synchronized setters so publication cannot race ahead of the retained write. Opcode 0xc8 sleep completion no longer requests presentation by itself; preceding graphics writes are covered by the mutation generation instead.

Focused coverage includes single-publication mutation behavior, exact cell boundaries and wrap, differing object-local periods, reconfiguration, clones made before and after the first sample, continuous-channel behavior, and a 51-object phase-locked family producing five—not 255—source-cell publication events per second. The complete engine suite, Godot build/selftest, and a new comparable windowed DEBUGMAP capture are the closeout gates. Until that capture is analyzed, the allocation and recomposition improvements are implemented expectations rather than measured before/after results.

P2 capture 3 - DEBUGMAP after allocation/cadence changes (2026-07-22)

build/perf/run-20260722-121910-248.csv is the first post-P2a-P2c windowed DEBUGMAP run. Its FIELD interval contains 1,028 frames over 53.5 seconds and 1,023 recompositions (19.12/s), so discrete-cell scheduling did not reduce end-to-end cadence in this workload. The reason columns explain why rather than invalidating the shared-cell implementation: 1,014 FIELD rows have a continuous-channel reason. FIELD creates one visible op-0x232 color pulse at FIELD@0x9691 (handle 0xc802, period 2,000 ms), which legitimately changes the composed output between spritesheet boundaries. The 50 ms hover callback also produced 712 host-publication requests, including idle callbacks; callback completion is now no longer treated as dirty, while actual retained and host-surface mutations continue to publish themselves.

P2a was useful but missed its stated allocation gate. Recomposition allocation p50 fell from 3,593,400 to 3,172,128 bytes (-421,272, 11.7%); p95 fell from 3,629,816 to 3,178,544 bytes (-451,272, 12.4%). Raster p50 was effectively unchanged (45.43 versus 45.52 ms), as expected for an allocation-only edit. The next logger schema splits remaining allocation among snapshot, composition, source preparation, Image.SetData, and UI so the next capture supplies bounded allocation attribution rather than prompting collection tuning.

The new transform counters decisively redirect P2d. Recomposed FIELD frames average 447.7 integer layers and 506.3 axis-aligned-scale layers; fractional-translation and general-affine maxima are both zero. The busy 28-34 second interval averages about 2.35-2.39 million candidates and 54 ms main time, while the final off-map idle interval falls to about 1.58 million and 26 ms. P2d therefore adds an axis-aligned inverse-map path which caches the source column once per layer and computes the source row once per scanline, retaining the existing center-sample/floor and blend arithmetic. Pooled lookup storage avoids per-layer garbage. Five hundred deterministic randomized blit/fill cases compare byte-for-byte with the previous general inverse-mapped oracle across positive/negative scales, fractional placement, clipping, opacity, tint, multiplicative modulation, and alpha/additive/opaque modes. A repeat DEBUGMAP capture is still required to measure the real-path raster win and the new allocation phases. All 345 engine tests pass and the Godot project builds with zero warnings/errors.

An environment audit after this capture found four Godot game/console pairs still alive from July 11 and July 21. Each game process consumed about 0.41 CPU-seconds during a two-second sample (roughly 80% of one logical core in aggregate). They predate both P1 and this capture, so workload attribution, allocation deltas, and the transform-category correction remain actionable, but its absolute frame-time acceptance numbers are provisional. The eight processes were terminated with user authorization before the following capture.

P2 capture 4 - DEBUGMAP after axis-aligned scale specialization (2026-07-22)

build/perf/run-20260722-130024-542.csv is the clean post-P2d windowed comparison, captured after the stale Godot processes above were closed. The stable FIELD workload still visits about 962 objects and draws about 961 layers: approximately 433 integer translations, 526 axis-aligned scales, zero fractional translations, and zero general affine layers. Around 900 layers are classified opaque. Camera position changes clipped candidate pixels, but it does not materially reduce retained traversal, layer count, source pixels, or the continuous-channel presentation cadence.

For equivalent 2.2-2.5 million candidate-pixel frames, recomposition p50/p95/p99 fell from 53.71/60.50/62.72 ms in capture 3 to 21.52/22.26/22.75 ms. Raster p50/p95 fell from 50.77/57.27 ms to 19.07/19.52 ms: a 62.4% median raster reduction with the same workload band. The final 1.5-1.9 million candidate-pixel off-map band fell from 27.34/32.34 ms recomposition p50/p95 to 14.73/15.89 ms. Delivered steady cadence consequently rises from about 19 recompositions/s to 44-48/s over the busy map and about 64/s off-map. P2d is a large, repeatable real-path win; busy-map p95 nevertheless remains above the 16.67 ms P2 exit target.

The new allocation phases attribute the remaining steady busy-map p50/p95 almost exactly: total 3,178,544/3,178,544 bytes, retained snapshot 961,600/961,600, compositor 2,216,664/2,216,664, source preparation zero, Image.SetData zero, and UI 88/88. Camera position barely changes that total because the snapshot and compositor collections still cover the full retained set. Allocation is now a clear GC/long-run stability target, but raster remains the direct busy-frame budget blocker. P2e therefore starts with the full-opacity/unmodulated hot pixel loops used by the roughly 900 opaque layers; after that measured capture, reduce the two identified per-frame collection owners rather than tuning the GC.

P2e unmodulated source-over specialization implemented (2026-07-22)

The translated and axis-aligned-scale raster loops now detect full object opacity, zero effective tint, non-multiplicative color, and non-additive blending once per layer. In that common mode, alpha-zero texels remain skipped, alpha-255 texels become exact four-byte copies, and partially transparent edge texels retain the previous integer source-over arithmetic. The general tinted, faded, multiplicative, and additive paths are unchanged. This targets the approximately 900 opaque FIELD layers measured in capture 4 without assuming that their color-keyed source rectangles contain no transparent pixels.

Four hundred focused translated/scaled cases cover both opaque and alpha blend classifications with source alpha values 0, 1, 254, and 255 against the retained pre-fast-path oracle. The complete engine suite passes at 346 tests, the Godot build has zero warnings/errors, and threaded SELFTEST OK. Next: repeat the same DEBUGMAP camera/idle/off-map workload. Retain P2e only if the busy 2.2-2.5 million candidate-pixel band shows a repeatable win; then address the measured snapshot/compositor allocation owners before the P2 exit capture.

P2 capture 5 - DEBUGMAP after unmodulated source-over specialization (2026-07-22)

build/perf/run-20260722-132318-886.csv is the comparable post-P2e windowed run. In the matched 2.2-2.5 million candidate-pixel band, recomposition p50/p95/p99 fell from 21.52/22.26/22.75 ms to 15.35/16.18/19.26 ms, while raster p50/p95 fell from 19.07/19.52 ms to 12.66/13.23 ms. That is a 28.7% median recomposition reduction and a 33.6% median raster reduction; steady busy-map delivery rises from about 44-48 to 61-66 recompositions/s. The 1.5-1.9 million candidate off-map band falls from 14.73/15.89 ms recomposition p50/p95 to 9.45/11.21 ms. P2e is retained: busy-map p95 now fits the 16.67 ms target, although allocation/GC outliers leave p99 above it.

Allocation remains unchanged at 3,178,544 bytes p50/p95 in the busy band. Capture-wide gen-0/gen-1/gen-2 counts are 184/52/34 over 3,111 FIELD recompositions, versus 147/49/34 over only 2,274 recompositions in capture 4; normalized collection rates therefore do not regress, but short-lived garbage remains the clear tail-latency and long-run-stability target.

P2f measured allocation owners removed (2026-07-22)

The compositor allocation phase was dominated by Transform2DMath.Build: it created about eleven double[16] matrices for every rendered object. It now composes the same row-vector operations through a twelve-double value-type affine-3D matrix and projects to Affine2D only at the boundary. Five hundred randomized scale/translation/anchor/one-shot/cyclic-rotation cases match every output double bit-for-bit against the former array implementation, and 10,000 warmed builds allocate zero bytes.

The retained snapshot phase no longer uses Dictionary.OrderBy or returns a newly grown list to the Godot hot path. GfxState maintains a sorted handle index alongside its O(1) object dictionary, and fills a compositor-owned reusable List<RenderObject> under the existing lock. The returning overload remains for callers needing an independent snapshot. Ten warmed 1,000-object samples allocate zero bytes and preserve ascending handle order. The complete engine suite passes at 349 tests, the Godot build has zero warnings/errors, and threaded SELFTEST OK. Next: repeat the comparable DEBUGMAP run and verify the snapshot/compositor allocation columns collapse without changing the capture-5 frame-time distribution; then repeat SC0000 for the P2 exit/P3 decision.

P2 capture 6 - DEBUGMAP after primary allocation removal (2026-07-22)

build/perf/run-20260722-133412-146.csv confirms P2f's primary allocation changes on the real path. In the matched busy band, total allocation p50/p95 falls from 3,178,544/3,178,544 to 262,160/262,160 bytes (-91.8%). Retained snapshot allocation is exactly zero; compositor allocation falls from 2,216,664 to 261,880 bytes. Capture-wide gen-0/gen-1/gen-2 collections fall from 184/52/34 to 21/8/5 despite broadly similar duration and 2,709 FIELD recompositions. Snapshot p50/p95 falls from 0.165/0.328 ms to 0.097/0.141 ms.

Raster remains stable at 12.70/13.36 ms p50/p95 versus capture 5's 12.66/13.23 ms. End-to-end busy recomposition improves slightly from 15.35/16.18/19.26 ms p50/p95/p99 to 15.10/15.87/16.25 ms; the much tighter p99 is consistent with the measured GC reduction. Matched off-map recomposition improves from 9.45/11.21/13.20 ms to 9.04/10.02/11.35 ms. P2f therefore preserves the raster win while removing the large short-lived collection owners.

The stable 261,880-byte compositor remainder scales almost exactly with FIELD's approximately 961 retained objects. The first hypothesis was the per-object SnapshotSurfaceText array copy, so the compositor was changed to reuse a caller-owned List<SurfaceTextDraw> under the existing text lock; the returning overload remains available to callers needing an independent snapshot. Capture 7 below disproves that attribution.

P2 capture 7 - residual allocation probe (2026-07-22)

build/perf/run-20260722-134322-530.csv is the requested short steady DEBUGMAP idle probe. Across 1,208 full FIELD recompositions, total allocation remains 259,952/261,728 bytes p50/p95, with snapshot allocation zero and compositor allocation 259,672/261,448 bytes. The surface-text buffer therefore has no material effect in this workload and is only a harmless general cleanup. Recomposition remains in the expected camera-dependent range at 14.19/16.46 ms p50/p95 for an average 2.38 million candidate pixels.

The exact remaining owner is MovieSurfaceRegistry.TryResolveResource: every ordinary still-texture fallback constructed a LINQ Where plus descending sort pipeline to look for a live movie frame, including when the movie registry was empty. This occurred once per retained object and explains the stable roughly 270 bytes/object remainder. The registry now scans its live bindings directly while retaining the rule that the newest published playback of a resource wins. A focused test covers matching/missing lookups and newest- playback selection; 10,000 pairs allocate zero bytes after warm-up. All 350 engine tests, the zero-warning Godot build, and threaded SELFTEST OK pass. Next: one final short DEBUGMAP idle probe confirms the compositor remainder is gone, then SC0000 through the pre-CHAPTER burst supplies the P2 exit/P3 decision.

P2 capture 8 - DEBUGMAP allocation closeout (2026-07-22)

build/perf/run-20260722-140820-530.csv confirms the movie-registry correction. Across 820 full steady FIELD recompositions, total allocation is 4,416 bytes p50/p95/p99 and compositor allocation is 4,136 bytes; snapshot, source preparation, and Image.SetData remain zero, while UI accounts for 88 bytes. This is a 99.86% reduction from capture 4's 3,178,544-byte steady total and a 98.3% reduction from capture 7's 259,952-byte residual. FIELD itself performs zero gen-0, gen-1, or gen-2 collections in this probe; every capture-wide collection occurred during boot/map setup.

One FIELD row allocates 1,415,744 bytes during composition at FIELD.BIN@0x1029 as a one-time reusable- capacity/cache warm-up. It triggers no collection and completes in 14.78 ms, so it is neither a steady owner nor a visible stall. At an average 2.32 million candidate pixels, recomposition p50/p95/p99 is 13.90/15.86/18.89 ms and raster p50/p95 is 11.32/13.22 ms, consistent with the post-P2e/P2f distribution. DEBUGMAP therefore closes with busy p95 inside 16.67 ms and effectively allocation-free steady rendering. Next: repeat SC0000 through the original pre-CHAPTER burst and compare against capture 1's exact SC0000@0x123de plateau before deciding whether P2 exits or the full-screen/additive case triggers P3.

P2 exit capture 9 - SC0000 pre-CHAPTER and post-movie text (2026-07-22)

build/perf/run-20260722-141200-995.csv repeats capture 1 through the CHAPTER movie and the following text. Across every recomposition parked at SC0000.BIN@0x123de, recomposition p50/p95/p99 improves from 21.85/57.40/82.70 ms to 15.39/31.71/66.38 ms. Movie sampling itself remains small: twelve active rows have movie_ms p50/p95/max 0.20/0.99/1.06 ms, so decoding/presentation is not the reported burst bottleneck.

The acceptance decision uses equivalent severe rows rather than the mixed coordinate aggregate. For frames with at least 3.5 million candidate pixels, recomposition p50/p95/p99 falls from 76.43/88.42/90.11 ms to 65.15/71.74/72.03 ms; raster p50/p95 remains 64.11/71.15 ms. These 52 rows average 4.29 million candidate pixels, 10.7 layers, 4.6 additive layers, 8.3 viewport-covering layers, two general-affine layers, and less than 0.9 KB managed allocation. The worst comparable frame is 72.21 ms. P2's CPU fast paths therefore save roughly 15-19% in this burst but leave it around 14-15 delivered frames/s, more than four times the 16.67 ms budget. No allocation or scheduler optimization can close that gap.

A separate later interval still clones about 1.92 MB per recomposition while applying a color key to a dynamic frame. It is an independent GC issue already anticipated by the action plan, but it does not occur in the severe additive plateau and cannot change the exit decision. Treat it as part of the GPU texture/ shader ownership work rather than delaying P3 for another software-raster special case.

P2 exit decision: close the fidelity-neutral CPU batch and begin P3. The prototype mirrors ordinary retained texture/fill objects into GPU-native Godot drawing behind a backend switch, preserves handle z-order, atlas source rectangles, colorkey, tint/opacity, additive blending, and the exact affine transform, and keeps the software compositor as the pixel-parity oracle/fallback. First acceptance is the same SC0000@0x123de severe band below 16.67 ms p95 without regressing DEBUGMAP presentation or movie/text composition; only then make GPU rendering the default.

P3 retained-GPU prototype implemented; workload acceptance pending (2026-07-22)

--render-backend gpu now mirrors the synchronized GfxState snapshot into a pooled Godot Sprite2D stage. Static decoded/color-key variants upload once; mutable created surfaces and movie frames update a surface-keyed dynamic texture, so concurrent playbacks of the same resource cannot overwrite each other. Each retained item preserves handle/child order, atlas source rectangle, nearest filtering, the exact sampled affine matrix, opacity, multiplicative tint, source/tint LERP, and source-alpha/additive canvas blending. Surfaceless affine fills use a shared one-pixel texture. The software compositor remains the default for direct launches and is selected whole-frame for legacy whole-screen transitions or the still-unobserved additive LERP-tint combination; diagnostics which depend on software decision strings also stay on the oracle.

The performance CSV now records backend, GPU draw-item count, texture uploads, and upload CPU time while retaining the common object/layer/transform/candidate-pixel workload columns. A real Vulkan smoke exercised 54 GPU recompositions without Godot errors after startup; warmed three-item frames required about 0.02-0.10 ms of main-thread synchronization, while the first texture publications took about 2-3 ms. This is not the target burst and is only a plumbing measurement.

The first visual comparison initially produced a false black result because the direct SC0000 validation command omitted its required --boot SYSTEM4/INIT state. Repeating with --boot restored the opening event CG in both backends. At the settled first narration page, the GPU and software 800x450 retained-art regions match in geometry/content; every differing channel is at most one RGB value and the differences are confined to the soft lower fade, consistent with Godot floating-point versus software integer blend rounding. The automated --shot harness forces pre-page transition waits, so its abrupt fade is not cadence evidence.

For this effort run-godot.cmd temporarily enabled both timestamped perf capture and the GPU prototype; that temporary launch behavior was removed at P4 closeout. Next: use the natural SYSTEM4 route at speed 1 for the SC0000 pre-CHAPTER burst and DEBUGMAP camera/unit workload. Accept P3 only if the original SC0000@0x123de severe band reaches less than 16.67 ms p95 and manual viewing finds no texture, ordering, movie, text, fade-cadence, or dungeon-sprite regression. Then take P4's screen/range-transition GPU path and backend-default decision.

P3 capture 10 - SC0000 GPU target and P4 range-transition trigger (2026-07-22)

build/perf/run-20260722-145338-127.csv covers the natural SYSTEM4 route through the CHAPTER movie and following text. The user reports the original burst is “much, much smoother.” The log confirms that the GPU path removes the pixel-throughput wall: 199 matched SC0000@0x123de rows with at least 3.5 million candidate pixels have main-thread p50/p95/p99/max 0.068/0.117/0.119/0.124 ms and recomposition 0.048/0.083/0.085/0.093 ms, versus the P2 software baseline's 65.15/71.74 ms p50/p95. All of those frames arrive at the capture's 10.0 ms presentation cadence. Across 3,048 GPU recompositions, p95/p99/max is 3.23/4.43/13.14 ms; static reuse avoids texture uploads, while dynamic/movie publication remains bounded.

The mixed hotspot still contained 67 intentional software fallbacks (2.2% of recompositions), all for one type-0 retained range-transition object rather than a legacy whole-screen transition. Fifty-one ordinary eight-layer rows cost about 17-18 ms, twelve ten-layer affine/additive rows cost about 53-55 ms, and the final four twelve-layer rows reached 64-66 ms. These sparse fallbacks dominate the aggregate p95 even though the ordinary GPU frames are far below budget, so they trigger the narrow P4 range-transition slice.

P4 type-0 retained range transition moved to GPU; recapture pending (2026-07-22)

The GPU compositor now handles the exact existing software-oracle rule: range A remains in normal retained order, and when the transition placeholder is visited, range B is republished there with the sampled transition progress multiplying each source object's opacity. Texture/fill resolution, affine transforms, color key, tint, additive blend, dynamic-surface identity, and common perf counters use the same GPU paths as ordinary objects. Whole-screen host transitions and additive LERP-tint remain bounded software fallbacks.

A bootstrapped SC0000 page-1 capture exercises the GPU range path and matches the saved software reference: the complete 800x600 frame differs only by at most one RGB value, with 46,468 changed pixels confined to the soft y=376..449 fade and 121 independently animated chrome pixels. The Godot build has zero warnings/errors, the capture log has no runtime warning/error, threaded SELFTEST OK, and git diff --check passes. Next: repeat the natural SC0000 pre-CHAPTER run once to prove render_backend=0 disappears from this coordinate and the mixed severe-band p95 is below 16.67 ms, then run the DEBUGMAP camera/unit acceptance case.

P4 capture 11 - SC0000 range-transition closeout passes (2026-07-22)

build/perf/run-20260722-150316-085.csv repeats the natural SYSTEM4-to-CHAPTER route after the GPU range implementation. All 3,111 recompositions use render_backend=1; there are zero software fallbacks anywhere in the run. Across the original SC0000@0x123de severe band (215 rows with at least 3.5 million candidate pixels), main-thread p50/p95/p99/max is 0.075/0.132/0.175/0.562 ms and recomposition is 0.051/0.091/0.124/0.533 ms. Every severe frame arrives in 10.0-10.42 ms and none exceeds the 16.67 ms budget. The whole run's recomposition p95/p99/max is 3.10/3.57/9.03 ms; dynamic/movie upload p95 is 0.192 ms and movie sampling p95 is 0.005 ms.

This closes the original SC0000 performance defect: equivalent severe software frames were 65.15/71.74 ms p50/p95 after P2 and are now 0.075/0.132 ms on the GPU submission path, with the user's manual run already reporting the burst as much smoother. The P4 range-transition fallback is accepted for SC0000. Next: run DEBUGMAP with the established pan/idle/unit-group/off-map sequence. If its sprites, camera, pulse effects, and frame delivery remain correct, accept P3 as the retained backend and decide the small remaining whole-screen fallback/default-switch cleanup.

P3 capture 12 - DEBUGMAP passes; performance effort accepted (2026-07-22)

build/perf/run-20260722-152956-766.csv follows the established slight-pan/idle/unit-group/pan/off-map sequence. The user reports the result looks good visually. All 6,247 recompositions use the GPU, including 5,496 FIELD frames; there are zero software fallbacks. FIELD averages 962 visited objects, 961 actual draw items, 51 time-varying objects, 434 integer layers, and 525 axis-aligned-scale layers per composition.

In the matched 2.2-2.5 million candidate-pixel band, main-thread p50/p95/p99 falls from the final software baseline's 13.90/15.86/18.89 ms to 2.14/2.33/2.78 ms; recomposition is 2.03/2.19/2.66 ms. The >=2.5M band remains 2.14/2.90/5.40 ms main-thread p50/p95/p99 with a 10.99 ms max. Off-map frames with no visible draws fall to about 0.02 ms. The normal FIELD path allocates only a few KB of diagnostic/accounting state and the matched band performs no collections.

One ordinary 961-item FIELD frame measured 22.04 ms without texture uploads, allocation growth, snapshot, or resource-resolution cost; adjacent frames immediately returned to the normal distribution. It is one scheduler/driver-like outlier among 5,496 FIELD recompositions, while FIELD p99 is 2.79 ms, so it does not represent a recurring retained-renderer bottleneck. A separate first-capacity growth row uploads seven textures, allocates 3.06 MB, and still completes in 10.99 ms.

Acceptance: P3/P4 close successfully. GPU retained rendering is now the ordinary backend; the software compositor remains available via --render-backend software, owns high-volume decision diagnostics, and is the bounded fallback for legacy whole-screen host transitions or an unobserved additive-LERP combination. run-godot.cmd no longer forces -PerfLog or a renderer switch, fulfilling the temporary-launch cleanup; run-godot.ps1 -PerfLog remains available for future targeted captures. The original SC0000 burst and DEBUGMAP animated-unit workload are both visually accepted and comfortably within frame budget.

Data-semantics sidebar: MAINIT/MAMES and message infrastructure (2026-07-23)

The current static-decoding slice closes the three remaining small MES-named targets. extract_init.py now models MAINIT as eleven one-based magic/research/growth actions in a reserved 30-cell layout and joins nine untitled MAMES descriptions; growth ritual ids 10 and 11 are explicitly unmatched. INFOMES is classified as a text-free 32-by-4, first-handler-wins INFO extension registry initialized with CIMES/EIMES/VIMES. MES is classified as the shared non-selecting modal renderer over caller-populated line and optional annotation buffers. Their stable globals are curated in vm-map/globals.toml, and structural regressions protect the registry initialization, indirect dispatch, buffer reads, and cleanup.

Next: return to reader-proven 2D tables, beginning with RECOVER's 30-wide status/recovery structures.

Data-semantics sidebar: ILINIT condition matrix and RECOVER ABI (2026-07-23)

ILINIT is now a dedicated thirteen-record condition-definition schema inside the engine's reserved 30-condition by five-level layout. The generated JSON preserves every one of its 228 integer writes and 61 authored level-name strings, while adding a nested level view over duration, eleven-stat deltas, and HP/SP/FS deltas. Condition ids 1..11, 13, and 14 are defined; id 12 and ids 15..29 remain explicit reserved slots. Scalar metadata now identifies the effectiveness element, boss-immunity override, RECOVER policy, and display icon for each condition. All raw address/stride/column keys remain beside their canonical semantic joins.

The runtime side is one coherent four-table ABI. entity_condition_levels[50][30] holds current levels, entity_condition_baseline_levels[50][30] is the equipment/passive minimum, and entity_condition_remaining_turns[50][30] uses -1 for permanent/baseline, zero for inactive, and positive turns for expiring effects. RECOVER first copies max HP/SP/FS from effective-stat columns 11..13 to the three current resources. It then scans all 30 condition ids; for the six ILINIT-policy conditions (charm, confusion, paralysis, poison, water-flow, and fear), it restores the current level to the passive baseline and writes -1 when that baseline remains or zero when fully cleared. The extractor validates those table bases, strides, loop bounds, and post-recovery CALCREVISE/DRAWCHP calls before publishing the join.

Validation covers every ILINIT write, representative stat/resource matrices, the complete reserved id space, level-aware semantic projection, the resource restore mapping, and the four-table reset protocol. The global registry and generated reference now carry the condition id columns and all definition/runtime table meanings.

Next: profile CNINIT as the next unresolved high-density name-mode table. Its current generic output has 32 records but 242 address-derived fields, making it the clearest candidate for another dedicated schema driven by reader-proven row/column ownership.

Data-semantics sidebar: CNINIT unit names and voice families (2026-07-23)

CNINIT's former 32-record/242-field output was an ownership error, not a complex record. It is exactly two parallel sparse arrays with a reserved span of 1,000, both keyed by EBINIT unit id. The string array holds story/display names used throughout scene scripts, HISTORY, and DEBUGADV; INPUTNAME also scans it when rejecting a player-entered familiar name that collides with an existing name. The integer array maps a unit variant to a representative voice-family unit id before the shared voice-suppression lookup. All 277 integer ids join exactly to EBINIT, 274 carry authored names, and Lily's form ids 2..4 are the three intentional unnamed rows.

The dedicated schema now emits 277 records with one raw string field and one raw integer field, their canonical semantic names, the source unit's EBINIT definition name, the representative voice-family definition name, and an explicit alias flag. Of the 277 rows, 175 normalize to another unit id; this captures brainwashed, concealed-name, allied, boss, EX, corrupted, and trial variants without conflating their story label with EBINIT's authoring label. Every CNINIT instruction is structurally accounted for, and the generated profile has collapsed from 242 pseudo-fields to the two true consumer-visible arrays.

Next: audit CGINIT's large numeric output. Determine whether its apparent 1,304-field surface is a legitimate gallery/resource matrix or another ownership artifact before assigning any new semantics.

Data-semantics sidebar: CGINIT gallery registry (2026-07-23)

CGINIT's former 379-record/1,304-field numeric output was an ownership error. The script contains 3,941 static writes forming 851 sparse gallery-image rows, ids 1..855 with four gaps, inside a reserved 2,000-row layout. Every row has a full-size gallery image, a thumbnail sheet id, a thumbnail slot id, and a variant ordinal; 537 rows additionally carry the optional preview used by SAVE and SELSTAGE. The dedicated schema classifies every write and reduces the generated profile to these five real fields.

CGMODE proves the presentation model. INIT2 configures four sheets with SO026A.AGF through SO026D.AGF; each resource is a 6-by-5 atlas of thirty 126-by-95 thumbnail cells. CGMODE compacts the enabled sheets, groups gallery records by their one-based sheet and slot, and orders the full-size images behind a slot by the one-based variant ordinal (1..23 in shipped data). It tests each primary image's unlock state, reports unlocked and total variants per thumbnail, and displays the selected full-size asset. SAVE and SELSTAGE independently scan the same primary image column and use the optional second asset when it is a 112-by-84 preview, otherwise falling back to a captured frame.

The generated rows join all primary, preview, and sheet asset ids to SYS4INI-derived filenames while retaining the raw 0x62cd1/2/{0,1}, 0x63c71, 0x64441, and 0x64c11 keys. The curated global registry names those arrays plus CGMODE's ten-cell configured sheet-resource vector. Regressions cover the complete write accounting, sparse id range, four atlases, optional previews, representative image joins, and raw-to-semantic field projection.

Data-semantics sidebar: ALINIT alchemy recipe registry (2026-07-23)

ALINIT's former generic output—18 records and 853 address-derived fields—was another ownership error. Its 914 writes form seven parallel structures indexed by sparse recipe id: three 1,000-cell arrays for output item, minimum alchemy level, and point cost; two 1000 × 2 required/forbidden story-flag tables; and two 1000 × 4 ingredient-item/quantity tables. There are 107 populated recipe ids from 1 through 467. The dedicated extractor classifies every write and exposes only the thirteen actually populated columns.

ALCHEMY establishes the complete consumer contract. A nonzero output item marks a populated recipe. Availability requires the current alchemy level, required and forbidden story flags, a point-capacity condition, and sufficient quantities for each of four possible ingredient slots. Synthesis consumes the paired ingredient quantities, adds one output item, deducts the recipe cost from the shared spendable-point balance, and advances alchemy-level progress. All 107 output ids and all 286 ingredient references resolve through ITINIT.

The generated records retain the raw addresses, add output and ingredient names plus a compact nested ingredient view, and project all seven table bases through vm-map/globals.toml. The same semantic map now names the shared spendable-point balance, alchemy level, and alchemy-level progress. Regressions protect the full write accounting, sparse layout, item joins, story gates, paired ingredient cells, and raw-to-semantic projection.

Data-semantics sidebar: AFINIT affinity/tuning tables and CTINIT name palette (2026-07-23)

AFINIT and CTINIT were not malformed record tables; both were vocabulary/table initializers that the generic name heuristic could not segment. AFINIT contains 27 Japanese element labels and 54 length-prefixed integer rows. Its affinity section is a reserved 20 × 20 defense-by-attack matrix with thirteen authored defense rows and eighteen authored columns. The dedicated extractor converts the footer's unsigned representations back to signed values, preserving the -100 immunity cases, and joins rows 1..12 to the physical/universal/elemental/divinity/demon/spirit/undead defense names.

AFINIT's remaining rows are two paired 20 × 11 item-tuning tables and one 3 × 7 facility progression table. Curve ids 1..18 provide ten tuning-level stat bonuses and matching point costs; row 19 is explicitly zero/reserved and the eleventh column remains reserved. TUNE, IMPROVE, DRAWTIP, and CALCREVISE establish the bonus/cost contract. The three facility rows belong to equipment tuning, alchemy, and magic/research respectively, each with six thresholds leading to the level-6 cap. The registry now also names the equipment-tuning and magic facility level/progress counters.

CTINIT is INPUTNAME's complete 5 × 70 character palette. Its rows are hiragana, katakana, full-width Latin letters, four numeral styles, and symbols; their populated counts are 56, 56, 52, 40, and 69, for 273 authored cells total. INPUTNAME uses cursor slots 70..74 to select a page, rejects an empty cell, and copies a selected character into its seven-character name buffer. The generated JSON keeps all 350 positions so layout gaps remain explicit rather than collapsing into a flat character list.

Regressions account for every instruction in both scripts, signed affinity values, all tuning and facility curves, representative characters and gaps, and raw-to-semantic projection.

Data-semantics sidebar: CVINIT character-voice configuration (2026-07-23)

CVINIT's generic thirteen-row shape was close but incomplete: it grouped 35 of the script's 37 writes and presented a twelve-entry inverse map as eight unrelated address-derived fields. The dedicated schema accounts for all 38 instructions (37 static writes plus exit) as three coordinated arrays: thirteen CONFIG preview-voice assets at 0x62cad, twelve setting-slot-to-EBINIT-unit ids at 0x62c8f + slot, and twelve inverse unit-to-setting ids at 0x628a7 + unit.

CONFIG proves the presentation contract. Slot 0 is a non-unit system voice preview; slots 1..12 map to Lily, Sylphine, Sasune, Vidal, Estelle, Nelly, Tiofania, Colette, Bridget, Octavia, Fam, and Deirdre. CONFIG resolves those unit ids through the shared story-display-name table, reloads each unit's persisted speaker-seen flag to decide whether the row is available, plays the slot's preview OGG, and edits the matching cell in the thirteen-entry character_voice_suppressed settings array. All thirteen preview ids resolve to shipped audio assets.

The inverse map closes the runtime voice-filter chain rather than duplicating the CONFIG row map. Story, history, field, and battle paths first normalize the active EBINIT unit through CNINIT's voice-family unit table, then map that representative unit through CVINIT's inverse table and test the selected suppression cell. The twelve forward and inverse entries round-trip exactly. Scene scripts independently set and persist the unit-keyed speaker-seen flags when each speaker first appears, explaining CONFIG's unlock gate.

Regressions protect complete instruction accounting, all asset and EBINIT joins, the system slot, all twelve round trips, speaker-seen addresses, and raw-to-semantic projection.

Data-semantics sidebar: MPINIT stage-terrain atlas (2026-07-23)

MPINIT's 1,472 footer copies are not independent map records. Every destination is column 1 of one row in a single sparse table rooted at 0xccc93: the row pitch is 53 cells, while each footer owns the fifty authored columns 1..50. Destination arithmetic recovers grid Y directly, from the first authored row at Y=2 through the last at Y=1600; 127 all-zero rows inside that range are omitted. All 1,473 instructions are now classified as terrain-row copies plus exit.

FIELD proves the coordinate contract. STINIT2 supplies inclusive tile bounds in four 1,000-cell arrays; FIELD multiplies each bound by two, clears a reserved 2000 × 53 current-stage grid at 0x341ab, and copies the selected rectangle from the immutable MPINIT atlas. DRAWMAP, CALCOCC, MVSEEK, battle, occupancy, and movement providers consume the mutable grid. DRAWMINIMAP reads the mutable grid inside the active rectangle but falls back to the source atlas outside it for border context, while RESETLAND restores changed cells from the atlas.

The dedicated schema joins 66 named STINIT2 stage definitions to 53 unique atlas rectangles. Eight rectangles are intentionally shared by 21 stage variants, including the chapter-3 three-route map and repeated late-game arenas. The joined rectangles contain 17,079 of the atlas's 17,126 nonzero cells; the remaining 47 are preserved as border-context provenance rather than mislabeled as dead data. Every stage exposes tile/grid bounds, dimensions, terrain rows, and value populations.

LAINIT supplies the terrain vocabulary and the three fields needed to interpret the atlas: terrain-to-texture-slot indices, room/area fill flags, and layout classes (0=blocked/boundary, 1=open area, 2=passage, 3=hidden). MPINIT uses ids 0..19; all named ids join to passages, rooms, hidden spaces, bases, water, openings, altars, lava, and themed room variants. The generated registry retains every raw row address/footer offset, the omitted-zero-row list, all stage slices, LAINIT joins, and the FIELD/DRAWMINIMAP/RESETLAND consumer contract.

Regressions protect complete instruction accounting, row geometry, doubled coordinates, all 66 stage joins, shared rectangles, terrain definitions, and the exact nonzero/border-cell totals.

Next: finish LAINIT's remaining small terrain-definition surface by its FIELD/MVSEEK/DRAWMAP consumers; MPINIT already proves its name, texture-slot, area-fill, and layout-class columns.

Data-semantics sidebar: LAINIT terrain definitions (2026-07-23)

LAINIT is now a dedicated twenty-terrain definition registry inside a reserved thirty-row layout. Its 98 instructions divide exactly into seventeen terrain names, five player-facing effect descriptions, 75 numeric writes, and exit. Terrain ids 0, 5, and 6 are meaningful implicit-default rows used by MPINIT; the other shipped ids 1..19 are authored sparsely. The schema retains raw addresses while projecting all defaults explicitly.

The remaining row-major table at 0xe6afe is a 30 × 10 signed combat-stat matrix with the same column ABI as SKINIT's combat deltas: accuracy, evasion, physical attack/defense, magic attack/defense, speed, luck, critical chance, and capture power. CALCBTPARAM reads the acting unit's terrain from the doubled-coordinate current map and adds the selected row to its battle parameters. INFOAF displays the rows. All thirteen populated cells agree exactly with LAINIT's five summaries: the base raises accuracy/evasion/defenses, water and shallows lower accuracy/evasion/speed, the altar raises accuracy/evasion, and the hall raises evasion.

The sparse array at 0xe6c2a is a required traversal/reveal skill id. MVSEEK and FIELD reject ordinary terrain unless the moving unit owns the referenced SKINIT skill; the dedicated hidden terrain path enforces the same exploration requirement for hidden passages and rooms. All five requirements resolve: flight for the open shaft, diving for the underground lake, exploration for both hidden terrain types, and heat resistance for lava.

The final array at 0xe6c48 is indexed by the twenty stage texture slots rather than terrain id. When STINIT's per-stage texture override is positive, FIELD loads it directly; zero disables the slot; -1 selects LAINIT's shared fallback. All ten authored fallbacks resolve through SYS4INI to MP000A/B/C/E/H/I/J/K/L/N.AGF, and the terrain-to-slot table joins each terrain definition to the applicable default.

Regressions protect all 98 instructions, the 20-of-30 row contract, every sparse string and numeric population, all thirteen combat-stat cells, all five SKINIT skill joins, and all ten texture assets.

Next: audit SPINIT's 118 populated cells as the stride-15 HMODE resource matrix; the generic numeric view currently fragments its eight logical rows into individual address-derived records.

Data-semantics sidebar: SPINIT H-scene gallery (2026-07-23)

SPINIT's 118 numeric writes are a single 8 × 15 row-major registry at 0x6638b, not 118 independent records. Each row is one HMODE gallery page and each column is one thumbnail slot. The first seven rows are full; the eighth authors slots 0..12 and leaves slots 13..14 as meaningful zero/default cells. The dedicated schema classifies all 119 instructions including exit and preserves both complete rows and authored raw-cell provenance.

INIT2 supplies the parallel eight-page thumbnail-sheet registry at 0x66421. All eight assets resolve through SYS4INI as SO027A.AGF through SO027H.AGF; visual conversion confirms each is a fifteen-thumbnail page matching SPINIT's row geometry. Every one of SPINIT's 118 nonzero values resolves to an SP*.BIN script resource.

HMODE compacts the configured thumbnail sheets into its visible page list, iterates all fifteen SPINIT slots for each page, passes every populated resource through still-unnamed opcode 0x19d, and marks rejected cells unavailable. Selecting an available thumbnail retrieves the same matrix cell and executes it with indirect call-script. This proves the page, slot, resource, and dispatch semantics without inventing a stronger name for opcode 0x19d.

Regressions protect the 8-by-15 geometry, 118/120 population, exact two-cell gap, all eight INIT2 thumbnail joins, all 118 SYS4INI script joins, and complete instruction accounting.

Next: audit TRINIT's 365-instruction training-action registry by its direct consumers; it is the next compact mixed string/numeric INIT surface.

Data-semantics sidebar: TRINIT training actions (2026-07-23)

TRINIT is TRAIN's complete 21-row training/sexual-magic action registry. Its 75 string writes form six slots per row at 0x453b: three available-description/cost/reward lines followed by three locked-condition hint lines. The numeric storage is one contiguous block from 0x155bbc through 0x1560e6, divided into nineteen parallel or row-major families. The dedicated schema classifies all 365 instructions exactly: 75 strings, 289 static integer writes, and exit.

TRAIN proves the eligibility half of the schema. Each action can require up to three story flags, minimum/maximum unit level, signed familiar alignment thresholds encoded with a +100 bias, minimum/maximum training progress, ten minimum/maximum combat stats, one inventory item, and one acquired skill. The shipped data uses thirteen story-flag cells, one minimum-level gate, five minimum and five maximum alignment gates, fourteen minimum-progress gates, and eight required items; the forbidden-flag, maximum-level, maximum-progress, stat-bound, and required-skill families are reserved but empty. All item gates resolve to ITINIT.

The effect half stores a negative 精気 delta, fourteen unit-stat deltas, signed alignment and training-progress changes in hundredths, optional skill/item awards, and ten event ids. TRAIN checks and deducts the spirit cost, applies the unit-stat growth ABI, carries fractional alignment/progress, and grants the selected reward. All eight skill awards resolve to SKINIT and all three item awards resolve to ITINIT. The new global names also identify current/maximum spirit, familiar alignment and its fraction, training progress and its fraction, total execution count, and the 21 per-action counts.

The 75 populated event cells resolve through SCINIT to SC0800, SC0810, SC0820, SC0830, SC0840, or SC0850 paths. TRAIN indexes the row by the prior per-action execution count, copies the selected value to the SCJUMP decision output, increments the count, and treats the first zero as the execution cap. GAMESTART independently confirms the dual story-flag role: after restoring each saved count it marks every preceding event id complete. Repeated ids intentionally reuse a scene.

Regressions protect the complete write accounting, all text/gate/effect populations, representative signed thresholds and stat rows, every ITINIT/SKINIT join, all 75 SCINIT joins, and the observed one/three/four/six-execution limit distribution.

Data-semantics sidebar: CDINIT card-generation lists (2026-07-23)

CDINIT is not a 1,149-row numeric table. It is a nine-way dispatch on current_card_generation_list_id (0x152485) that repopulates two parallel runtime buffers: 100 card-id slots at 0x1525b2 and 100 three-column weight rows at 0x152486. The dedicated extractor classifies all 1,565 instructions exactly: a three-instruction clear prelude, nine selector tests and branches, 383 four-write candidate entries, nine terminal jumps, the missing-list comment/marker, and exit. The selector ids are 1, 11, 31, 41, 55, 61, 71, 94, and 160, containing 11, 36, 38, 51, 26, 52, 64, 30, and 75 entries respectively.

FIELD supplies the selector from the active STINIT type-28 card object's primary payload. Seven selectors are referenced by 246 such objects across 50 stage definitions; selectors 55 and 94 are authored but unreferenced by the shipped STINIT corpus. All 383 candidate references resolve to the 81 CDINIT2 card definitions, including their display names and result text.

The three per-entry values are base_weight, growth_interval_turns, and growth_weight. For every card that passes its CDINIT2 story-flag gates, FIELD computes base_weight + floor(current_stage_turn / growth_interval_turns) * growth_weight; a zero interval would select the fixed base path, although all shipped entries use a nonzero interval. It then chooses one card by cumulative weighted random selection. FIELD tests only required-flag columns zero and one: CDINIT2 authors a third required flag on eighteen cards, producing 54 occurrences across the generation lists, but that column is engine-dead in the shipped eligibility loop and remains separately labeled.

Two runtime geometry facts are intentionally not normalized away. FIELD scans 100 candidate slots, while CDINIT's prelude clears only the first 50 card ids and first 50 weight rows. Selector 160 then authors 75 slots. The extracted schema records the scan capacity, clear prefix, and complete authored extent so a reimplementation can reproduce or deliberately resolve that native stale-tail risk.

Regressions protect every selector and entry count, exact instruction accounting, CDINIT2 names and effective/ignored flag joins, STINIT object joins, raw parallel addresses, the 100/50 scan-clear asymmetry, and the original missing-list warning.

Data-semantics sidebar: CDINIT2 card definitions and effects (2026-07-23)

CDINIT2 is FIELD's complete 81-card definition registry inside one reserved 100-row block. The dedicated extractor classifies all 558 instructions exactly: 162 name/result-message strings, 395 numeric writes, and exit. Its numeric block is contiguous from 0x1519f9 through 0x152484 and preserves the raw arrays for card type, required and forbidden story flags, awarded item, event story flag, stage-clear point bonus, ranged HP/SP/FS recovery and damage, spirit recovery, condition id/level, and visual asset.

The shipped type distribution is forty story events, twenty-four item awards, six resource recoveries, three stage-clear point bonuses, seven traps, and one random warp. FIELD filters each candidate through two required and three forbidden story-flag cells before selection. CDINIT2 also authors eighteen values in a third required-flag column, but FIELD's eligibility loop never reads that column; these remain explicit as engine-dead authoring data rather than being promoted into the effective gate. All 81 visual ids resolve through SYS4INI to MVS*.AGF assets, all 24 item rewards join through ITINIT, all 40 event ids join through SCINIT, and all three condition-bearing traps join through ILINIT.

After selection, FIELD renders the card's visual and result message, then applies the type-specific effect. Resource and spirit ranges use an authored minimum plus random(maximum - minimum) when the maximum exceeds the minimum, so the stored maximum is exclusive for a non-fixed range and equality means a fixed value. Resource recovery and trap damage address HP, SP, and FS independently; spirit recovery clamps the current value into its valid range; condition traps call ADDILL with the authored condition level; and the random-warp card chooses a valid destination tile. Story-event cards dispatch their joined SCINIT event after the result message. Item cards call ADDITEM. Point cards accumulate their award in stage_card_spendable_point_bonus; STAGECLEAR adds that accumulator to the stage award before updating shared_spendable_points.

Representative definitions protect each path: card 1 restores HP/SP/FS by 2--4, card 4 restores spirit by 2--4, card 7 awards five stage-clear points, card 10 dispatches SC0490, card 50 performs ranged resource damage, card 52 applies level-one paralysis, card 55 inflicts fixed ten SP damage, card 57 is the random warp, card 58 awards a bronze coin, and card 81 renders MVS107.AGF. Regressions protect every string and numeric write, the 81-of-100 geometry, type distribution, effective/ignored gate split, all four external joins, representative effect projections, and the FIELD/STAGECLEAR consumer contract.

Next: audit BTANINIT and BTANINIT2 together. Their current generic outputs fragment the battle-animation registry across address-derived fields, making the consumer-side row geometry the next data-structure target.

Data-semantics sidebar: BTANINIT/BTANINIT2 battle animations (2026-07-23)

BTANINIT2 is three parallel reserved 1,000-row arrays, not 28 records with 387 unrelated fields. Its 1,017 writes define 122 sparse battle-animation ids: six effect slots at 0x15288e, six paired start-delay slots at 0x153ffe, and one total-duration cell at 0x15576e. The dedicated extractor classifies all 1,018 instructions exactly and resolves all 573 populated effect references across 186 distinct BTANINIT definitions.

The shipped slot geometry is deliberate. Slots zero and one have 114 effect references each and are actor-side when an effect requests combatant anchoring; slots two and three have 113 each and are target-side; slot five has 119; slot four is never populated. Only slots two, three, and five carry authored start delays. One hundred eleven rows are complete attack timelines with a 500--1,700 ms total duration. Eleven are auxiliary rows: two incomplete/unjoined authored attacks and passive/defeat rows 801--809, which are invoked for isolated overlays and intentionally omit the main duration.

CALCDMG selects rows 1--21 from the equipped item's item_weapon_class for normal attacks or reads skill_battle_animation_id for skills. The join accounts for 101 populated skill references across 98 animation rows, including passive reactions 801--808. BTL selects hardcoded row 809 for defeat. Four authored animation rows—205, 221, 222, and 224—have no shipped item, skill, or hardcoded consumer and remain explicit rather than being discarded.

BTANINIT is the paired effect catalog and runtime materializer. It clears fourteen six-cell work arrays plus one 6 × 3 hit-pulse table, reads the selected BTANINIT2 row, and dispatches each slot's effect id through 203 cases: zero as the empty sentinel and 202 populated definitions. The dedicated extractor classifies all 4,472 instructions, including 1,917 definition writes. The catalog contains 186 nonblocking MPEG-in-AGF movie effects, one green-colorkey sprite sheet, and fifteen opaque sprite sheets. All 202 visual resources resolve to MVB*.AGF or AM*.AGF; all 199 populated sound ids resolve to WAV files.

BTL proves the complete materialized work ABI: playback mode, additive blend, destination width and height, actor/target or battlefield-center anchor, pixel offsets, sprite atlas columns/frame count and finite duration, delayed sound, and up to three hit-pulse offsets. Shipped data populates only the first hit-pulse column, always at 100 ms, on 26 effects. The sixteen authored sprite-atlas row counts agree with the explicit frame/column values, but BTL never reads them. Sixteen complete BTANINIT effect definitions are unreferenced by BTANINIT2 and remain preserved.

Regressions protect both scripts' complete instruction accounting, reserved geometry, every effect/delay/duration population, all 573 definition joins, the SKINIT and ITINIT selections, passive/defeat rows, visual/audio resolution, movie/sprite behavior, hit-pulse timing, and the unreferenced authored surfaces.

Next: audit STINIT2's remaining generic 321-row stage-definition surface. MPINIT already proves its tile-bound columns; the next pass should join the rest of its stage metadata to FIELD and the stage-selection/initialization consumers.

Data-semantics sidebar: STINIT2 stage definitions (2026-07-23)

STINIT2's former generic 321-record view was structurally wrong: 247 of those “records” were description strings. The dedicated schema classifies all 1,634 instructions into 74 sparse stage names, 296 strings in a reserved 1000 × 6 description matrix, 1,263 numeric writes, and one exit. SELSTAGE indexes the text matrix as three uncleared lines followed by three cleared lines.

The 74 real rows divide into 66 mapped stages and eight event-only stages. The schema preserves numbered, EVENT, and EX presentation; 49 main-progression flags; the eight EX flags; four multi-stage unlock groups; and seven-column required/forbidden story-flag rows. FORT proves the availability checks and descending main-stage auto-selection, while FIELD proves unlock-group propagation.

Map rows join the four already-proven tile bounds to doubled terrain-atlas coordinates and the minimap atlas Y origin. Clear rewards expose the performance-scaled base spendable-point award and the three item-quantity columns for bronze, silver, and gold coins. Every populated entry, clear, and failure transition resolves through SCINIT (174/174), and every stage-loader resource resolves to the shared STINIT.BIN selector (74/74).

Regressions protect the corrected record geometry, complete instruction accounting, all six text slots, display kinds, story gates, unlock groups, map/minimap coordinates, rewards, SCJUMP joins, and loader joins. The 66 populated values at 0xedc4d have no script consumer. Their ordinal 1..8 distribution tracks authored challenge/reward progression: late story maps are tier 6, EX maps use tiers 5 and 7, and the final EX map alone is tier 8. Because the native engine can reach VM globals only through script operands, the array is now named stage_authoring_difficulty_tiers at medium confidence and explicitly classified as engine-dead authoring metadata.

Next: continue consumer-led naming of the remaining two-dimensional tables; STINIT2 is closed.

Data-semantics sidebar: ADV layer surface-slot registry (2026-07-23)

The highest-use unnamed row table, G[0x3239], is now closed as adv_layer_surface_slots. Its eight rows contain three graphics surface banks: primary_surface_slot 4..11, alternate_surface_slot 43..50, and transition_surface_slot 51..58. The corpus contains 2,657 table-base accesses across 309 scripts, and 143 scene scripts repeat the same initializer.

The shared CG loader proves the ABI. adv_gfx_layer_index selects a row and the corresponding adv_gfx_object_handles cell. A fresh object loads into the primary slot; an already-bound layer swaps between the primary and alternate slots; the third slot stages and cleans up transitions. adv_gfx_surface_slot_work carries the op-0x215 query result or fallback slot, while adv_gfx_resource_id carries the transient SYS4INI resource id into set-texture. INIT2 seeds the first nine cells of the 20-cell retained-object handle array; the first eight participate in the row registry.

Registry tests protect all 24 initialized slot cells, use of all three columns in SC0000, the nine INIT2 handle constants, and the canonical global/column names.

Next: rank the next unnamed row table by shipped-reader evidence.