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>

src/AcDream.App/Streaming/GpuWorldState.cs

@@ -137,21 +137,55 @@ public sealed class GpuWorldState
     public IEnumerable<(uint LandblockId, Vector3 AabbMin, Vector3 AabbMax,
                         IReadOnlyList<WorldEntity> Entities,
                         IReadOnlyDictionary<uint, WorldEntity>? AnimatedById)> LandblockEntries
+        => EnumerateLandblockEntries(includeAnimatedIndex: true);
+
+    /// <summary>
+    /// Per-landblock render entries without the animated lookup dictionary.
+    /// Static render passes use this to avoid rebuilding an index they cannot
+    /// consume.
+    /// </summary>
+    public IEnumerable<(uint LandblockId, Vector3 AabbMin, Vector3 AabbMax,
+                        IReadOnlyList<WorldEntity> Entities,
+                        IReadOnlyDictionary<uint, WorldEntity>? AnimatedById)> LandblockEntriesWithoutAnimatedIndex
+        => EnumerateLandblockEntries(includeAnimatedIndex: false);
+
+    /// <summary>
+    /// Lightweight bounds-only enumeration for overlays and diagnostics.
+    /// Does not walk entity lists.
+    /// </summary>
+    public IEnumerable<(uint LandblockId, Vector3 AabbMin, Vector3 AabbMax)> LandblockBounds
     {
         get
         {
             foreach (var kvp in _loaded)
             {
-                // Build AnimatedById on the fly — cheap (~132 entities/LB max).
-                var byId = new Dictionary<uint, WorldEntity>(kvp.Value.Entities.Count);
+                if (_aabbs.TryGetValue(kvp.Key, out var aabb))
+                    yield return (kvp.Key, aabb.Min, aabb.Max);
+                else
+                    yield return (kvp.Key, Vector3.Zero, Vector3.Zero);
+            }
+        }
+    }
+
+    private IEnumerable<(uint LandblockId, Vector3 AabbMin, Vector3 AabbMax,
+                         IReadOnlyList<WorldEntity> Entities,
+                         IReadOnlyDictionary<uint, WorldEntity>? AnimatedById)> EnumerateLandblockEntries(
+        bool includeAnimatedIndex)
+    {
+        foreach (var kvp in _loaded)
+        {
+            Dictionary<uint, WorldEntity>? byId = null;
+            if (includeAnimatedIndex)
+            {
+                byId = new Dictionary<uint, WorldEntity>(kvp.Value.Entities.Count);
                 foreach (var e in kvp.Value.Entities)
                     byId[e.Id] = e;
-
-                if (_aabbs.TryGetValue(kvp.Key, out var aabb))
-                    yield return (kvp.Key, aabb.Min, aabb.Max, kvp.Value.Entities, byId);
-                else
-                    yield return (kvp.Key, Vector3.Zero, Vector3.Zero, kvp.Value.Entities, byId);
             }
+
+            if (_aabbs.TryGetValue(kvp.Key, out var aabb))
+                yield return (kvp.Key, aabb.Min, aabb.Max, kvp.Value.Entities, byId);
+            else
+                yield return (kvp.Key, Vector3.Zero, Vector3.Zero, kvp.Value.Entities, byId);
         }
     }
 

src/AcDream.App/Streaming/LandblockStreamJob.cs

@@ -37,15 +37,21 @@ public abstract record LandblockStreamResult(uint LandblockId)
     ) : LandblockStreamResult(LandblockId);
 
     /// <summary>
-    /// A previously-Far-resident landblock was promoted to Near. Terrain
-    /// mesh is already on the GPU; the result carries the entity layer
-    /// (stabs, buildings, scenery) to merge into the existing GpuWorldState
-    /// entry.
+    /// A previously-Far-resident landblock was promoted to Near. The result
+    /// carries the full near landblock plus mesh data so the render thread can
+    /// run the same near-tier side effects as a fresh LoadNear: cell visibility,
+    /// building registries, EnvCell finalization, lighting, and static collision.
+    /// GpuWorldState still merges only the entity layer so live entities already
+    /// attached to the landblock are preserved.
     /// </summary>
     public sealed record Promoted(
         uint LandblockId,
-        IReadOnlyList<WorldEntity> Entities
-    ) : LandblockStreamResult(LandblockId);
+        LoadedLandblock Landblock,
+        LandblockMeshData MeshData
+    ) : LandblockStreamResult(LandblockId)
+    {
+        public IReadOnlyList<WorldEntity> Entities => Landblock.Entities;
+    }
 
     public sealed record Failed(uint LandblockId, string Error) : LandblockStreamResult(LandblockId);
     public sealed record Unloaded(uint LandblockId) : LandblockStreamResult(LandblockId);

src/AcDream.App/Streaming/LandblockStreamer.cs

@@ -159,6 +159,9 @@ public sealed class LandblockStreamer : IDisposable
 
     private void WorkerLoop()
     {
+        var highPriority = new Queue<LandblockStreamJob>();
+        var lowPriority = new Queue<LandblockStreamJob>();
+
         try
         {
             // Safe to block: this is a dedicated worker thread with no
@@ -169,14 +172,24 @@ public sealed class LandblockStreamer : IDisposable
             // simple thread-start shape.
             while (!_cancel.Token.IsCancellationRequested)
             {
-                if (!_inbox.Reader.WaitToReadAsync(_cancel.Token).AsTask().GetAwaiter().GetResult())
+                if (highPriority.Count == 0 &&
+                    lowPriority.Count == 0 &&
+                    !_inbox.Reader.WaitToReadAsync(_cancel.Token).AsTask().GetAwaiter().GetResult())
+                {
                     break;
+                }
 
                 while (_inbox.Reader.TryRead(out var job))
-                {
-                    if (_cancel.Token.IsCancellationRequested) return;
-                    HandleJob(job);
-                }
+                    EnqueuePrioritized(job, highPriority, lowPriority);
+
+                if (highPriority.Count == 0 && lowPriority.Count == 0)
+                    continue;
+
+                if (_cancel.Token.IsCancellationRequested) return;
+                var next = highPriority.Count > 0
+                    ? highPriority.Dequeue()
+                    : lowPriority.Dequeue();
+                HandleJob(next);
             }
         }
         catch (OperationCanceledException) { /* graceful shutdown */ }
@@ -192,6 +205,55 @@ public sealed class LandblockStreamer : IDisposable
         }
     }
 
+    private static void EnqueuePrioritized(
+        LandblockStreamJob job,
+        Queue<LandblockStreamJob> highPriority,
+        Queue<LandblockStreamJob> lowPriority)
+    {
+        if (job is LandblockStreamJob.Load
+            {
+                Kind: LandblockStreamJobKind.LoadNear or LandblockStreamJobKind.PromoteToNear
+            } high)
+        {
+            // Near-tier jobs are visible-content critical. They supersede an
+            // older queued LoadFar for the same landblock: LoadNear obviously
+            // loads everything, and PromoteToNear now carries mesh data so the
+            // render thread can run the full near-tier apply side effects. If a
+            // LoadFar is already being processed, the single worker naturally
+            // finishes it before the promotion is dequeued.
+            RemoveLowPriorityJobsForLandblock(
+                lowPriority,
+                high.LandblockId,
+                removeLoadFar: true,
+                removeUnload: true);
+            highPriority.Enqueue(job);
+            return;
+        }
+
+        lowPriority.Enqueue(job);
+    }
+
+    private static void RemoveLowPriorityJobsForLandblock(
+        Queue<LandblockStreamJob> queue,
+        uint landblockId,
+        bool removeLoadFar,
+        bool removeUnload)
+    {
+        int count = queue.Count;
+        for (int i = 0; i < count; i++)
+        {
+            var job = queue.Dequeue();
+            bool remove = job.LandblockId == landblockId && job switch
+            {
+                LandblockStreamJob.Load { Kind: LandblockStreamJobKind.LoadFar } => removeLoadFar,
+                LandblockStreamJob.Unload => removeUnload,
+                _ => false
+            };
+            if (!remove)
+                queue.Enqueue(job);
+        }
+    }
+
     private void HandleJob(LandblockStreamJob job)
     {
         switch (job)
@@ -212,6 +274,19 @@ public sealed class LandblockStreamer : IDisposable
                             load.LandblockId, "LandblockLoader.Load returned null"));
                         break;
                     }
+                    if (load.Kind == LandblockStreamJobKind.PromoteToNear)
+                    {
+                        var promotedMesh = _buildMeshOrNull(load.LandblockId, lb);
+                        if (promotedMesh is null)
+                        {
+                            _outbox.Writer.TryWrite(new LandblockStreamResult.Failed(
+                                load.LandblockId, "buildMeshOrNull returned null"));
+                            break;
+                        }
+                        _outbox.Writer.TryWrite(new LandblockStreamResult.Promoted(
+                            load.LandblockId, lb, promotedMesh));
+                        break;
+                    }
                     var mesh = _buildMeshOrNull(load.LandblockId, lb);
                     if (mesh is null)
                     {

src/AcDream.App/Streaming/StreamingController.cs

@@ -103,16 +103,16 @@ public sealed class StreamingController
         {
             _region = new StreamingRegion(observerCx, observerCy, NearRadius, FarRadius);
             var bootstrap = _region.ComputeFirstTickDiff();
-            foreach (var id in bootstrap.ToLoadFar)  _enqueueLoad(id, LandblockStreamJobKind.LoadFar);
             foreach (var id in bootstrap.ToLoadNear) _enqueueLoad(id, LandblockStreamJobKind.LoadNear);
+            foreach (var id in bootstrap.ToLoadFar)  _enqueueLoad(id, LandblockStreamJobKind.LoadFar);
             _region.MarkResidentFromBootstrap();
         }
         else if (_region.CenterX != observerCx || _region.CenterY != observerCy)
         {
             var diff = _region.RecenterTo(observerCx, observerCy);
-            foreach (var id in diff.ToLoadFar)  _enqueueLoad(id, LandblockStreamJobKind.LoadFar);
-            foreach (var id in diff.ToLoadNear) _enqueueLoad(id, LandblockStreamJobKind.LoadNear);
             foreach (var id in diff.ToPromote)  _enqueueLoad(id, LandblockStreamJobKind.PromoteToNear);
+            foreach (var id in diff.ToLoadNear) _enqueueLoad(id, LandblockStreamJobKind.LoadNear);
+            foreach (var id in diff.ToLoadFar)  _enqueueLoad(id, LandblockStreamJobKind.LoadFar);
             foreach (var id in diff.ToDemote)   _state.RemoveEntitiesFromLandblock(id);
             foreach (var id in diff.ToUnload)   _enqueueUnload(id);
         }
@@ -129,6 +129,7 @@ public sealed class StreamingController
                     _state.AddLandblock(loaded.Landblock);
                     break;
                 case LandblockStreamResult.Promoted promoted:
+                    _applyTerrain(promoted.Landblock, promoted.MeshData);
                     _state.AddEntitiesToExistingLandblock(promoted.LandblockId, promoted.Entities);
                     break;
                 case LandblockStreamResult.Unloaded unloaded: