fix(render) #132: outdoor alpha drains follow retail walk order

Retail draws every cell's objects inside LScape::draw's far-to-near walk
(DrawSortCell @0x005A17C0) and drains the one delayed-alpha list at the
DrawCells boundary AFTER the finished walk (@0x005A4872). Our outdoor
frame drained at the landscape-stage end and then drew punches, interior
shells, cell objects, and ALL dynamics — every one of those opaque
passes overwrote the already-composited flames (the reopened #132
candle class: "the door draws over the candle", creatures at openings).
Depth and barrier A/Bs were no-ops because the eraser is opaque color
painted after the drain.

Two retail-cited ordering corrections, outdoor-node roots only:

1. The stage-boundary drain is skipped and FlushLandscapeAlpha() runs
   after DrawDynamicsLast, where the frame's opaque world depth is
   complete — the one far-to-near list composites over everything,
   exactly like retail's boundary flush relative to its finished walk.
2. Before DrawExitPortalMasks, FlushLandscapeAlphaFartherThan(
   ExitPortalMaskBarrierDistance(...)) drains everything at or beyond
   the nearest cell whose exit-portal mask is about to write far-Z —
   retail DrawBuilding @0x0059F2A0 runs FlushAlphaList(0f) BEFORE its
   portal-only pass, so in the far-to-near walk nothing already drained
   can meet a punched aperture's falsified depth. Without this, the
   first correction let exterior waterfalls z-pass across punched
   apertures whose true landscape depth the punch erased (found live at
   the cathedral gate). Nearer content stays queued and legitimately
   composites in front of punched structures.

Interior roots keep the pre-clear stage-boundary drain unchanged.

User-gated live: Holtburg sign candle whole in front of the sign and
tower door at the aligned pose; cathedral waterfalls contained at every
camera zoom, inside and outside. Register row AP-236 retired (the
walk-order outcome reconstruction is complete; AP-34 remains the
umbrella for the CYpt-sort reconstruction itself). Filed #456 for the
separate occluded-distant-building/creature admission residual this
session diagnosed.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

src/AcDream.App/Rendering/RetailPViewRenderer.cs

@@ -318,6 +318,31 @@ public sealed class RetailPViewRenderer
                 frameEntityPasses,
                 in frameView);
             passes.UseIndoorMembershipOnlyRouting();
+
+            // Retail DrawBuilding @0x0059F2A0 runs FlushAlphaList(0f) BEFORE
+            // its portal-only far-Z pass. In retail's strict far→near walk
+            // everything queued at that instant is FARTHER than the structure
+            // being punched, so no already-drained poly can meet a punched
+            // aperture's falsified depth, and everything drained later is
+            // NEARER than the punched structure and legitimately composites in
+            // front of it. The batched outdoor frame reproduces that invariant
+            // here: drain the far prefix — every entry at or beyond the
+            // nearest cell whose exit-portal mask is about to punch far-Z —
+            // against still-true landscape depth. Without this, an exterior
+            // waterfall beyond the cathedral drains after the punches and
+            // z-passes across every aperture pixel whose true depth the punch
+            // erased (#132 regression found at the 2026-08-29 cathedral gate).
+            // Interior roots keep their pre-clear stage-boundary drain.
+            if (ctx.RootCell.IsOutdoorNode)
+            {
+                passes.FlushLandscapeAlphaFartherThan(
+                    ExitPortalMaskBarrierDistance(
+                        pvFrame,
+                        drawableCells,
+                        ctx.Cells,
+                        ctx.CameraWorldPosition));
+            }
+
             DrawExitPortalMasks(ctx, passes, pvFrame, clipAssembly, drawableCells);
             DrawEnvCellShells(passes, pvFrame);
             DrawCellObjectLists(
@@ -339,6 +364,17 @@ public sealed class RetailPViewRenderer
                 frameEntityPasses,
                 in frameView);
 
+            // OUTDOOR root: the LScape-boundary alpha drain deferred from the
+            // landscape stage runs HERE, after punches, interior shells, cell
+            // objects, and the dynamics pass — the frame's complete opaque
+            // world. Retail's walk draws all of those before its boundary
+            // flush (LScape::draw includes every cell's objects,
+            // DrawSortCell 0x005A17C0), so this is the same one-list far→near
+            // composite over finished depth; draining at the stage end instead
+            // let every later opaque mesh overwrite the flames (#132).
+            if (ctx.RootCell.IsOutdoorNode)
+                passes.FlushLandscapeAlpha();
+
             // Interior-cell UNATTACHED emitters (spell ground effects and
             // swirls anchored in EnvCells) draw in this final world scope —
             // the cells' walls and the seals already own the depth buffer, so
@@ -467,6 +503,40 @@ public sealed class RetailPViewRenderer
     /// content is queued when DrawBuilding flushes (@0x0059F2A0). Returns 0
     /// (full drain, today's behavior) when no cell resolves.
     /// </summary>
+    /// <summary>
+    /// The pre-punch barrier threshold for <see cref="DrawExitPortalMasks"/>:
+    /// the nearest drawable cell whose exit-portal mask is about to write
+    /// far-Z. Every queued alpha entry at or beyond it must drain first
+    /// (retail DrawBuilding @0x0059F2A0's FlushAlphaList(0f) before the
+    /// portal-only pass), because after the punch those entries would z-pass
+    /// across aperture pixels whose true depth no longer exists. No punched
+    /// cells → MaxValue → the partial drain retains everything.
+    /// </summary>
+    internal static float ExitPortalMaskBarrierDistance(
+        PortalVisibilityFrame frame,
+        HashSet<uint> drawableCells,
+        IRetailPViewCellSource cells,
+        Vector3 viewerPosition)
+    {
+        float best = float.PositiveInfinity;
+        for (int i = 0; i < frame.OrderedVisibleCells.Count; i++)
+        {
+            uint cellId = frame.OrderedVisibleCells[i];
+            if (!drawableCells.Contains(cellId))
+                continue;
+            LoadedCell? cell = cells.Find(cellId);
+            if (cell is null)
+                continue;
+            float distance = Vector3.Distance(
+                cell.WorldTransform.Translation,
+                viewerPosition);
+            if (distance < best)
+                best = distance;
+        }
+
+        return float.IsFinite(best) ? best : float.MaxValue;
+    }
+
     internal static float LookInBarrierDrainDistance(
         PortalVisibilityFrame frame,
         IRetailPViewCellSource cells,
@@ -1102,7 +1172,22 @@ public sealed class RetailPViewRenderer
         // Retail PView::DrawCells 0x005A4872 drains the landscape alpha list
         // immediately after LScape::draw and before the optional depth clear.
         // The queue remains active for the post-clear/final-world scope.
-        passes.FlushLandscapeAlpha();
+        //
+        // Only an INTERIOR root drains here: its full depth clear follows, and
+        // a flame drained after that clear would z-pass through every interior
+        // wall. An OUTDOOR root has no depth clear (retail gates it on
+        // portalsDrawnCount, pc:432731), and retail's LScape::draw walk has
+        // already drawn every building interior and every cell object via
+        // DrawSortCell 0x005A17C0 before that boundary — while our outdoor
+        // frame draws punches, interior shells, cell objects, and ALL dynamics
+        // (doors, creatures, NPCs) after this point. Draining here painted the
+        // flames first and let each of those later opaque meshes overwrite
+        // them (#132: "the door draws over the candle"); the outdoor drain
+        // therefore runs after DrawDynamicsLast, where world depth is complete
+        // and the one far-to-near list composites over everything, exactly as
+        // retail's boundary flush does relative to its finished walk.
+        if (!ctx.RootCell.IsOutdoorNode)
+            passes.FlushLandscapeAlpha();
 
         // T1: retail clears the FULL depth buffer ONCE between the outside
         // stage and the interior stage (PView::DrawCells, Ghidra 0x005a4840 —