feat(render): Phase A8 — indoor visibility + streaming fixes batch

Lands the working A8 indoor-rendering and streaming fixes accumulated this
session. User has verified these visually to some degree (e.g. lifestone /
translucent meshes confirmed fine under the FrontFace flip; bridge / wall /
collision regressions confirmed fixed after travel); not every path has been
exhaustively gated. The cellar-flap defect remains OPEN and will be solved
the retail-faithful way via a dedicated brainstorm (see handoff docs).

Rendering core (reviewed, high confidence):
- EnvCellRenderer SSBO stride fix: upload packed Matrix4x4[] (64B) instead of
  the 80B CPU InstanceData struct the shader never expected — fixes the
  transform/texture "explosion" for any draw with >1 instance (cells that
  dedupe to a shared cellGeomId). Real root cause.
- WB-style global FrontFace(CW) + per-batch CullMode carried through the MDI
  layout (GroupKey + BuildIndirectArrays + DrawIndirectRange split into
  same-cull runs with absolute uDrawIDOffset per run).
- EntitySet partitioning (IndoorPass / OutdoorScenery / LiveDynamic) +
  WorldEntity.BuildingShellAnchorCellId so building shells scope to their
  dat-derived building cell instead of rendering everywhere.
- RenderOutsideInAcdream (look into buildings from outside) +
  CollectVisiblePortalBuildings frustum cull of portal bounds.
- Sky-when-inside-building + per-cell audit probe + GL-state probe.

Streaming / perf (test-covered; not independently code-reviewed this session):
- Near/far priority queues so near work wins over far; PromoteToNear carries
  full landblock + mesh data; LandblockEntriesWithoutAnimatedIndex avoids
  rebuilding the animated-lookup dict in the hot draw path. Fixes the
  bridge-not-appearing / missing-walls / broken-collision-after-travel
  regressions and improves post-transition FPS.

Tooling + docs:
- tools/A8CellAudit: offline dat cell/portal/building dumper (portals +
  buildings modes) — reproduces the cellar-flap investigation with no launch.
- docs/research cellar-flap root-cause + option-2 handoff (the didInsideStencil
  double-duty finding + the WB-recursive design decision + brainstorm prompt),
  entity-taxonomy, replan, issue-78 visibility investigation.

Diagnostics retained on purpose: ACDREAM_A8_DIAG_* gates, portal_stencil.vert
provisional pos.w clamp, and the probe families are kept (env-var gated, zero
cost when off) because the pending option-2 cellar-flap brainstorm needs them.
Strip in the option-2 ship commit.

Indoor branch stays behind ACDREAM_A8_INDOOR_BRANCH=1 (default off = pre-A8
visual). Build green; App tests + Core (streaming/dispatcher/loader) tests pass.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

tests/AcDream.Core.Tests/Streaming/GpuWorldStateTwoTierTests.cs

@@ -74,6 +74,36 @@ public class GpuWorldStateTwoTierTests
         Assert.Equal(2, state.Entities.Count);
     }
 
+    [Fact]
+    public void LandblockEntriesWithoutAnimatedIndex_LeavesAnimatedLookupNull()
+    {
+        var state = new GpuWorldState();
+        state.AddLandblock(MakeStubLandblock(0xAAAAFFFFu,
+            MakeStubEntity(1),
+            MakeStubEntity(2)));
+
+        var staticEntry = Assert.Single(state.LandblockEntriesWithoutAnimatedIndex);
+        Assert.Null(staticEntry.AnimatedById);
+
+        var liveEntry = Assert.Single(state.LandblockEntries);
+        Assert.NotNull(liveEntry.AnimatedById);
+        Assert.True(liveEntry.AnimatedById!.ContainsKey(1));
+        Assert.True(liveEntry.AnimatedById.ContainsKey(2));
+    }
+
+    [Fact]
+    public void LandblockBounds_EnumeratesWithoutEntityPayload()
+    {
+        var state = new GpuWorldState();
+        state.AddLandblock(MakeStubLandblock(0xAAAAFFFFu,
+            MakeStubEntity(1),
+            MakeStubEntity(2)));
+
+        var bounds = Assert.Single(state.LandblockBounds);
+
+        Assert.Equal(0xAAAAFFFFu, bounds.LandblockId);
+    }
+
     /// <summary>
     /// Phase Post-A.5 #53 (Task 12): the optional <c>onLandblockUnloaded</c>
     /// callback fires once when <see cref="GpuWorldState.RemoveEntitiesFromLandblock"/>

tests/AcDream.Core.Tests/Streaming/LandblockStreamerTests.cs

@@ -45,6 +45,97 @@ public class LandblockStreamerTests
         Assert.Same(stubLandblock, loaded.Landblock);
     }
 
+    [Fact]
+    public async Task LoadNear_OvertakesQueuedFarLoads()
+    {
+        var callOrder = new System.Collections.Generic.List<(uint Id, LandblockStreamJobKind Kind)>();
+        var stubMesh = new AcDream.Core.Terrain.LandblockMeshData(
+            System.Array.Empty<AcDream.Core.Terrain.TerrainVertex>(),
+            System.Array.Empty<uint>());
+
+        using var streamer = new LandblockStreamer(
+            loadLandblock: (id, kind) =>
+            {
+                callOrder.Add((id, kind));
+                return new LoadedLandblock(id, new LandBlock(), System.Array.Empty<WorldEntity>());
+            },
+            buildMeshOrNull: (_, _) => stubMesh);
+
+        streamer.EnqueueLoad(0xAAAAFFFFu, LandblockStreamJobKind.LoadFar);
+        streamer.EnqueueLoad(0xBBBBFFFFu, LandblockStreamJobKind.LoadFar);
+        streamer.EnqueueLoad(0xCCCCFFFFu, LandblockStreamJobKind.LoadFar);
+        streamer.EnqueueLoad(0xDDDDFFFFu, LandblockStreamJobKind.LoadNear);
+        streamer.Start();
+
+        var result = await DrainFirstAsync(streamer);
+
+        var loaded = Assert.IsType<LandblockStreamResult.Loaded>(result);
+        Assert.Equal(0xDDDDFFFFu, loaded.LandblockId);
+        Assert.Equal((0xDDDDFFFFu, LandblockStreamJobKind.LoadNear), callOrder[0]);
+    }
+
+    [Fact]
+    public async Task PromoteToNear_ProducesPromotedWithMeshData()
+    {
+        int meshBuildCalls = 0;
+        var entity = new WorldEntity
+        {
+            Id = 7,
+            SourceGfxObjOrSetupId = 0,
+            Position = System.Numerics.Vector3.Zero,
+            Rotation = System.Numerics.Quaternion.Identity,
+            MeshRefs = System.Array.Empty<MeshRef>()
+        };
+
+        using var streamer = new LandblockStreamer(
+            loadLandblock: (id, kind) => new LoadedLandblock(id, new LandBlock(), new[] { entity }),
+            buildMeshOrNull: (_, _) =>
+            {
+                meshBuildCalls++;
+                return new AcDream.Core.Terrain.LandblockMeshData(
+                    System.Array.Empty<AcDream.Core.Terrain.TerrainVertex>(),
+                    System.Array.Empty<uint>());
+            });
+
+        streamer.EnqueueLoad(0xA9B4FFFFu, LandblockStreamJobKind.PromoteToNear);
+        streamer.Start();
+
+        var result = await DrainFirstAsync(streamer);
+
+        var promoted = Assert.IsType<LandblockStreamResult.Promoted>(result);
+        Assert.Equal(0xA9B4FFFFu, promoted.LandblockId);
+        Assert.Same(entity, promoted.Entities[0]);
+        Assert.NotNull(promoted.MeshData);
+        Assert.Equal(1, meshBuildCalls);
+    }
+
+    [Fact]
+    public async Task PromoteToNear_OvertakesAndSupersedesQueuedFarLoadForSameLandblock()
+    {
+        var callOrder = new System.Collections.Generic.List<(uint Id, LandblockStreamJobKind Kind)>();
+        var stubMesh = new AcDream.Core.Terrain.LandblockMeshData(
+            System.Array.Empty<AcDream.Core.Terrain.TerrainVertex>(),
+            System.Array.Empty<uint>());
+
+        using var streamer = new LandblockStreamer(
+            loadLandblock: (id, kind) =>
+            {
+                callOrder.Add((id, kind));
+                return new LoadedLandblock(id, new LandBlock(), System.Array.Empty<WorldEntity>());
+            },
+            buildMeshOrNull: (_, _) => stubMesh);
+
+        streamer.EnqueueLoad(0xA9B4FFFFu, LandblockStreamJobKind.LoadFar);
+        streamer.EnqueueLoad(0xA9B4FFFFu, LandblockStreamJobKind.PromoteToNear);
+        streamer.Start();
+
+        var result = await DrainFirstAsync(streamer);
+
+        var promoted = Assert.IsType<LandblockStreamResult.Promoted>(result);
+        Assert.Equal(0xA9B4FFFFu, promoted.LandblockId);
+        Assert.Equal((0xA9B4FFFFu, LandblockStreamJobKind.PromoteToNear), callOrder[0]);
+    }
+
     [Fact]
     public async Task Load_WhenLoaderReturnsNull_ReportsFailed()
     {
@@ -183,4 +274,16 @@ public class LandblockStreamerTests
         Assert.NotNull(loaderThreadId);
         Assert.NotEqual(testThreadId, loaderThreadId.Value);
     }
+
+    private static async Task<LandblockStreamResult> DrainFirstAsync(LandblockStreamer streamer)
+    {
+        for (int i = 0; i < SpinMaxIterations; i++)
+        {
+            var drained = streamer.DrainCompletions(maxBatchSize: LandblockStreamer.DefaultDrainBatchSize);
+            if (drained.Count > 0) return drained[0];
+            await Task.Delay(SpinStepMs);
+        }
+
+        throw new Xunit.Sdk.XunitException("Timed out waiting for streamer completion.");
+    }
 }

tests/AcDream.Core.Tests/Streaming/StreamingControllerTwoTierTests.cs

@@ -99,16 +99,25 @@ public class StreamingControllerTwoTierTests
         state.AddLandblock(lb);
         Assert.Empty(state.Entities);
 
-        // Streamer pushes a Promoted result carrying the entity layer.
-        var promoted = new LandblockStreamResult.Promoted(
+        // Streamer pushes a Promoted result carrying the full near landblock.
+        var promotedLb = new LoadedLandblock(
             lbId,
-            new[] { new WorldEntity {
+            Heightmap: null!,
+            Entities: new[] { new WorldEntity {
                 Id = 7, SourceGfxObjOrSetupId = 0,
                 Position = System.Numerics.Vector3.Zero,
                 Rotation = System.Numerics.Quaternion.Identity,
                 MeshRefs = System.Array.Empty<MeshRef>() } });
+        var promotedMesh = new LandblockMeshData(
+            System.Array.Empty<TerrainVertex>(),
+            System.Array.Empty<uint>());
+        var promoted = new LandblockStreamResult.Promoted(
+            lbId,
+            promotedLb,
+            promotedMesh);
         var queue = new Queue<LandblockStreamResult>();
         queue.Enqueue(promoted);
+        int applyPromotedCount = 0;
 
         var ctrl = new StreamingController(
             enqueueLoad: (id, kind) => loads.Add((id, kind)),
@@ -119,7 +128,12 @@ public class StreamingControllerTwoTierTests
                 while (batch.Count < max && queue.Count > 0) batch.Add(queue.Dequeue());
                 return batch;
             },
-            applyTerrain: (_, _) => { },
+            applyTerrain: (appliedLb, appliedMesh) =>
+            {
+                applyPromotedCount++;
+                Assert.Same(promotedLb, appliedLb);
+                Assert.Same(promotedMesh, appliedMesh);
+            },
             state: state,
             nearRadius: 2,
             farRadius: 2);
@@ -128,6 +142,7 @@ public class StreamingControllerTwoTierTests
 
         // Promoted routes to AddEntitiesToExistingLandblock — the entity is now
         // merged into the existing LB record.
+        Assert.Equal(1, applyPromotedCount);
         Assert.Equal(1, state.Entities.Count);
         Assert.Equal(7u, state.Entities[0].Id);
     }