fix(rendering): bound portal resource lifetime

Separate logical ownership, render publication, and GPU retirement across live entities, landblocks, particles, textures, mesh arenas, portal/UI teardown, and per-frame scratch storage. Add bounded DAT/texture caches, upload budgets, three-frame fence retirement, exact-incarnation appearance reconciliation, frame pacing, and extensive lifetime conformance coverage.\n\nThe seven-destination connected route now cuts peak working/private memory roughly in half, returns Caul to 125-153 FPS locally, and produces no WER or AMD reset.\n\nCo-authored-by: OpenAI Codex <codex@openai.com>

tests/AcDream.Core.Tests/Vfx/ParticleSystemTests.cs

@@ -607,6 +607,196 @@ public sealed class ParticleSystemTests
         Assert.All(sys.EnumerateEmitters(), emitter => Assert.True(emitter.ViewEligible));
     }
 
+    [Fact]
+    public void DenseSuspendedSet_IsExcludedFromSimulationViewAndRenderWorksets()
+    {
+        var sys = MakeSystem();
+        var desc = new EmitterDesc
+        {
+            DatId = 0x32000080u,
+            Type = ParticleType.Still,
+            MaxDegradeDistance = 100f,
+            MaxParticles = 1,
+            InitialParticles = 1,
+            LifetimeMin = 100f,
+            LifetimeMax = 100f,
+        };
+        var visibleCells = new HashSet<uint> { 0x01010001u };
+
+        for (int i = 0; i < 2_000; i++)
+        {
+            int handle = sys.SpawnEmitter(desc, Vector3.Zero, attachedObjectId: (uint)(i + 1));
+            sys.UpdateEmitterOwnerCell(handle, 0x01010001u);
+            if (i >= 3)
+            {
+                sys.SetEmitterPresentationVisible(handle, false);
+                sys.SetEmitterSimulationEnabled(handle, false);
+            }
+        }
+
+        sys.ApplyRetailView(Vector3.Zero, visibleCells, hasCompletedView: true);
+        sys.Tick(0.01f);
+
+        Assert.Equal(3, sys.LastRetailViewEmitterVisitCount);
+        Assert.Equal(3, sys.LastTickEmitterVisitCount);
+        Assert.Equal(3, sys.EnumerateRenderableEmitters(ParticleRenderPass.Scene).Count());
+        Assert.Equal(2_000, sys.ActiveEmitterCount);
+    }
+
+    [Fact]
+    public void OwnerRenderScope_VisitsOnlyRequestedOwnersAndUnattachedEmittersInSpawnOrder()
+    {
+        var sys = MakeSystem();
+        var desc = new EmitterDesc
+        {
+            DatId = 0x32000083u,
+            Type = ParticleType.Still,
+            MaxParticles = 1,
+        };
+        int unattached = sys.SpawnEmitter(desc, Vector3.Zero);
+        int ownerSeven = 0;
+        int ownerNine = 0;
+        for (uint owner = 1; owner <= 2_000; owner++)
+        {
+            int handle = sys.SpawnEmitter(desc, Vector3.Zero, attachedObjectId: owner);
+            if (owner == 7u)
+                ownerSeven = handle;
+            if (owner == 9u)
+                ownerNine = handle;
+        }
+
+        var destination = new List<ParticleEmitter>();
+        sys.CopyRenderableEmittersForOwners(
+            ParticleRenderPass.Scene,
+            new HashSet<uint> { 9u, 7u, 4_000u },
+            includeUnattached: true,
+            destination);
+
+        Assert.Equal(3, sys.LastRenderScopeEmitterVisitCount);
+        Assert.Equal(new[] { unattached, ownerSeven, ownerNine },
+            destination.Select(emitter => emitter.Handle));
+
+        sys.CopyRenderableEmittersForOwners(
+            ParticleRenderPass.Scene,
+            new HashSet<uint> { 7u, 9u },
+            includeUnattached: false,
+            destination,
+            excludedAttachedOwnerIds: new HashSet<uint> { 7u });
+        Assert.Equal(1, sys.LastRenderScopeEmitterVisitCount);
+        Assert.Equal(new[] { ownerNine }, destination.Select(emitter => emitter.Handle));
+    }
+
+    [Fact]
+    public void SpatialReentryWaitsForFreshRetailViewBeforeBecomingRenderable()
+    {
+        var sys = MakeSystem();
+        int handle = sys.SpawnEmitter(
+            new EmitterDesc
+            {
+                DatId = 0x32000084u,
+                Type = ParticleType.Still,
+                MaxDegradeDistance = 100f,
+                MaxParticles = 1,
+            },
+            Vector3.Zero,
+            attachedObjectId: 84u);
+        sys.UpdateEmitterOwnerCell(handle, 0x01010001u);
+        var visible = new HashSet<uint> { 0x01010001u };
+        var destination = new List<ParticleEmitter>();
+
+        sys.ApplyRetailView(Vector3.Zero, visible, hasCompletedView: true);
+        Assert.Single(sys.EnumerateRenderableEmitters(ParticleRenderPass.Scene));
+
+        sys.SetEmitterPresentationVisible(handle, false);
+        sys.SetEmitterSimulationEnabled(handle, false);
+        Assert.False(Assert.Single(sys.EnumerateEmitters()).ViewEligible);
+
+        sys.SetEmitterPresentationVisible(handle, true);
+        sys.SetEmitterSimulationEnabled(handle, true);
+        sys.CopyRenderableEmittersForOwners(
+            ParticleRenderPass.Scene,
+            new HashSet<uint> { 84u },
+            includeUnattached: false,
+            destination);
+        Assert.Empty(destination);
+
+        sys.ApplyRetailView(Vector3.Zero, visible, hasCompletedView: true);
+        sys.CopyRenderableEmittersForOwners(
+            ParticleRenderPass.Scene,
+            new HashSet<uint> { 84u },
+            includeUnattached: false,
+            destination);
+        Assert.Single(destination);
+    }
+
+    [Fact]
+    public void OrderedIndexes_PreserveSpawnOrderAcrossHardRemovalAndPassFiltering()
+    {
+        var sys = MakeSystem();
+        var desc = new EmitterDesc
+        {
+            DatId = 0x32000081u,
+            Type = ParticleType.Still,
+            MaxParticles = 1,
+        };
+        int first = sys.SpawnEmitter(desc, Vector3.Zero);
+        int removedScene = sys.SpawnEmitter(desc, Vector3.Zero);
+        int sky = sys.SpawnEmitter(
+            desc,
+            Vector3.Zero,
+            renderPass: ParticleRenderPass.SkyPreScene,
+            visibilityPolicy: ParticleVisibilityPolicy.PassOwned);
+        int removedSky = sys.SpawnEmitter(
+            desc,
+            Vector3.Zero,
+            renderPass: ParticleRenderPass.SkyPreScene,
+            visibilityPolicy: ParticleVisibilityPolicy.PassOwned);
+        int last = sys.SpawnEmitter(desc, Vector3.Zero);
+
+        sys.StopEmitter(removedScene, fadeOut: false);
+        sys.StopEmitter(removedSky, fadeOut: false);
+
+        Assert.Equal(new[] { first, sky, last },
+            sys.EnumerateEmitters().Select(emitter => emitter.Handle));
+        Assert.Equal(new[] { first, last },
+            sys.EnumerateRenderableEmitters(ParticleRenderPass.Scene)
+                .Select(emitter => emitter.Handle));
+        Assert.Equal(new[] { sky },
+            sys.EnumerateRenderableEmitters(ParticleRenderPass.SkyPreScene)
+                .Select(emitter => emitter.Handle));
+    }
+
+    [Fact]
+    public void TickSnapshot_ToleratesNestedEmitterRemovalFromDeathCallback()
+    {
+        var sys = MakeSystem();
+        var desc = new EmitterDesc
+        {
+            DatId = 0x32000082u,
+            Type = ParticleType.Still,
+            MaxParticles = 1,
+            InitialParticles = 1,
+            TotalParticles = 1,
+            LifetimeMin = 0.01f,
+            LifetimeMax = 0.01f,
+            Lifespan = 0.01f,
+        };
+        int first = sys.SpawnEmitter(desc, Vector3.Zero);
+        int second = sys.SpawnEmitter(desc, Vector3.Zero);
+        sys.EmitterDied += handle =>
+        {
+            if (handle == first)
+                sys.StopEmitter(second, fadeOut: false);
+        };
+
+        sys.Tick(0.02f);
+        sys.Tick(0.01f);
+
+        Assert.Equal(1, sys.LastTickEmitterVisitCount);
+        Assert.Equal(0, sys.ActiveEmitterCount);
+        Assert.Empty(sys.EnumerateEmitters());
+    }
+
     [Fact]
     public void FiniteEmitter_DegradedBranchExpiresAndRemovesIt()
     {
@@ -849,6 +1039,26 @@ public sealed class ParticleSystemTests
         Assert.False(sys.IsEmitterAlive(handle));
     }
 
+    [Fact]
+    public void EmitterDied_AttemptsEverySubscriberWhenOneThrows()
+    {
+        var sys = MakeSystem();
+        var delivered = new List<int>();
+        sys.EmitterDied += _ => throw new InvalidOperationException("first subscriber failed");
+        sys.EmitterDied += delivered.Add;
+
+        int handle = sys.SpawnEmitter(
+            MakeDesc(emitRate: 5f, lifetime: 0.2f, maxParticles: 4),
+            Vector3.Zero);
+
+        AggregateException failure = Assert.Throws<AggregateException>(
+            () => sys.StopEmitter(handle, fadeOut: false));
+
+        Assert.Contains("first subscriber failed", failure.ToString());
+        Assert.Equal([handle], delivered);
+        Assert.False(sys.IsEmitterAlive(handle));
+    }
+
     [Fact]
     public void Birthrate_PerSec_EmitsOnePerTickWhenIntervalElapsed()
     {