using AcDream.App.Rendering.Wb;
using AcDream.App.Rendering.Scene;
using AcDream.Core.Terrain;
using AcDream.Core.World;

namespace AcDream.App.Streaming;

/// <summary>
/// Read-only presentation state needed by render traversal and diagnostics.
/// Keeping this projection on the pipeline prevents the composition root from
/// retaining each concrete publication owner independently.
/// </summary>
public readonly record struct LandblockPresentationDiagnostics(
    LandblockRenderPublisherDiagnostics Render,
    LandblockPhysicsPublisherDiagnostics Physics,
    LandblockStaticPresentationDiagnostics Statics);

internal readonly record struct LandblockPublicationAdvance(
    bool Completed,
    bool Progressed);

/// <summary>
/// Render-thread transaction coordinator for one accepted landblock streaming
/// result. Streaming policy (desired tier, generation, priority, and apply
/// budget) remains in <see cref="StreamingController"/>; spatial buckets remain
/// in <see cref="GpuWorldState"/>. This owner fixes the presentation ordering
/// independently of those policies. The concrete render, physics, and static
/// publishers remain private implementation participants behind this boundary.
/// </summary>
/// <remarks>
/// Retail establishes cells/buildings before static objects in
/// <c>LScape::grab_visible_cells @ 0x00504EC0</c>. Its release path separates
/// <c>CLandBlock::release_all @ 0x0052FCF0</c> (objects and visible cells) from
/// later destruction in <c>CLandBlock::Destroy @ 0x0052FAA0</c> (static objects
/// and buildings). Acdream's detach-first retry ledger is the existing
/// asynchronous lifetime adaptation. Production always uses the focused owner
/// graph; the internal delegate constructor exists only for hermetic policy and
/// retry characterization tests.
/// </remarks>
public sealed class LandblockPresentationPipeline
{
    private enum PublicationKind : byte
    {
        Loaded,
        PromoteExisting,
        PromoteSelfContained,
        Far,
    }

    private sealed class PublicationTransaction
    {
        public required PublicationKind Kind;
        public required LandblockBuild Build;
        public required LandblockMeshData MeshData;
        public required uint LandblockId;
        public required LandblockStreamCostEstimate Cost;
        public LandblockStreamTier Tier;
        public bool PresentationCommitted;
        public LandblockRenderPublication? RenderPublication;
        public LandblockPhysicsPublication? PhysicsPublication;
        public LandblockStaticPresentationPublication? StaticPublication;
        public bool SpatialCommitted;
        public GpuLandblockSpatialPublication? SpatialPublication;
        public bool SpatialPresentationCommitted;
        public bool EnvCellReplayCommitted;
        public bool LiveRecoveryCommitted;
    }

    private readonly Action<LandblockBuild, LandblockMeshData>?
        _publishBeforeSpatialCommit;
    private readonly LandblockRenderPublisher? _renderPublisher;
    private readonly LandblockPhysicsPublisher? _physicsPublisher;
    private readonly LandblockStaticPresentationPublisher? _staticPublisher;
    private readonly GpuWorldState _state;
    private readonly Action<uint>? _onLandblockLoaded;
    private readonly Action<EnvCellLandblockBuild>? _ensureEnvCellMeshes;
    private readonly IRenderStaticProjectionJournalSink? _staticProjectionSink;
    private readonly LandblockRetirementCoordinator _retirements;
    private readonly Dictionary<LandblockStreamResult, PublicationTransaction> _publications =
        new(ReferenceEqualityComparer.Instance);

    internal LandblockPresentationPipeline(
        Action<LandblockBuild, LandblockMeshData> publishBeforeSpatialCommit,
        GpuWorldState state,
        Action<uint>? onLandblockLoaded = null,
        Action<EnvCellLandblockBuild>? ensureEnvCellMeshes = null,
        LandblockRetirementCoordinator? retirementCoordinator = null,
        Action<uint>? removeTerrain = null,
        Action<uint>? demoteNearLayer = null,
        IRenderStaticProjectionJournalSink? staticProjectionSink = null)
    {
        ArgumentNullException.ThrowIfNull(publishBeforeSpatialCommit);
        ArgumentNullException.ThrowIfNull(state);

        _publishBeforeSpatialCommit = publishBeforeSpatialCommit;
        _state = state;
        _onLandblockLoaded = onLandblockLoaded;
        _ensureEnvCellMeshes = ensureEnvCellMeshes;
        _staticProjectionSink = staticProjectionSink;
        if (retirementCoordinator is not null
            && !retirementCoordinator.MatchesState(_state))
        {
            throw new ArgumentException(
                "The retirement coordinator must own the pipeline's world state.",
                nameof(retirementCoordinator));
        }
        _retirements = retirementCoordinator
            ?? LandblockRetirementCoordinator.CreateLegacy(
                state,
                removeTerrain,
                demoteNearLayer);
    }

    /// <summary>
    /// Production constructor. The pipeline retains each concrete owner
    /// receipt before mutation and resumes only the unfinished exact stage
    /// after a failure.
    /// </summary>
    public LandblockPresentationPipeline(
        LandblockRenderPublisher renderPublisher,
        LandblockPhysicsPublisher physicsPublisher,
        LandblockStaticPresentationPublisher staticPublisher,
        GpuWorldState state,
        LandblockPresentationRetirementOwner retirementOwner,
        Action<uint>? onLandblockLoaded = null,
        Action<EnvCellLandblockBuild>? ensureEnvCellMeshes = null)
        : this(
            renderPublisher,
            physicsPublisher,
            staticPublisher,
            state,
            retirementOwner,
            onLandblockLoaded,
            ensureEnvCellMeshes,
            staticProjectionSink: null)
    {
    }

    internal LandblockPresentationPipeline(
        LandblockRenderPublisher renderPublisher,
        LandblockPhysicsPublisher physicsPublisher,
        LandblockStaticPresentationPublisher staticPublisher,
        GpuWorldState state,
        LandblockPresentationRetirementOwner retirementOwner,
        Action<uint>? onLandblockLoaded,
        Action<EnvCellLandblockBuild>? ensureEnvCellMeshes,
        IRenderStaticProjectionJournalSink? staticProjectionSink)
    {
        _renderPublisher = renderPublisher
            ?? throw new ArgumentNullException(nameof(renderPublisher));
        _physicsPublisher = physicsPublisher
            ?? throw new ArgumentNullException(nameof(physicsPublisher));
        _staticPublisher = staticPublisher
            ?? throw new ArgumentNullException(nameof(staticPublisher));
        _state = state ?? throw new ArgumentNullException(nameof(state));
        if (!_renderPublisher.MatchesState(_state))
        {
            throw new ArgumentException(
                "The render publisher must own the pipeline's world state.",
                nameof(state));
        }
        ArgumentNullException.ThrowIfNull(retirementOwner);
        if (!retirementOwner.Matches(
                _renderPublisher,
                _physicsPublisher,
                _staticPublisher))
        {
            throw new ArgumentException(
                "The retirement owner must reference the pipeline's concrete publishers.",
                nameof(retirementOwner));
        }
        _onLandblockLoaded = onLandblockLoaded;
        _ensureEnvCellMeshes = ensureEnvCellMeshes;
        _staticProjectionSink = staticProjectionSink;
        _retirements = LandblockRetirementCoordinator.CreateBudgeted(
            state,
            retirementOwner.AdvanceOne,
            retirementOwner.Advance,
            staticProjectionSink is null
                ? null
                : staticProjectionSink.Retire);
    }

    /// <summary>
    /// Building visibility registries published by the render owner. Legacy
    /// test pipelines have no render owner and therefore expose an empty view.
    /// </summary>
    public IReadOnlyCollection<BuildingRegistry> BuildingRegistries =>
        _renderPublisher?.BuildingRegistries ?? Array.Empty<BuildingRegistry>();

    /// <summary>
    /// Cumulative diagnostics from the three concrete presentation owners.
    /// </summary>
    public LandblockPresentationDiagnostics Diagnostics => new(
        _renderPublisher?.Diagnostics ?? default,
        _physicsPublisher?.Diagnostics ?? default,
        _staticPublisher?.Diagnostics ?? default);

    public int PendingRetirementCount => _retirements.PendingCount;
    internal bool UsesBudgetedRetirementSteps => _retirements.UsesBudgetedSteps;
    public int PendingPublicationCount => _publications.Count;

    internal bool MatchesState(GpuWorldState state) =>
        ReferenceEquals(_state, state);

    public bool IsRetirementPending(uint landblockId) =>
        _retirements.IsPending(landblockId);

    public bool HasPendingPublication(LandblockStreamResult result)
    {
        ArgumentNullException.ThrowIfNull(result);
        return _publications.ContainsKey(result);
    }

    public IReadOnlyList<LandblockStreamResult> GetPendingPublicationResults() =>
        _publications.Keys.ToArray();

    public void ResumePublication(LandblockStreamResult result)
    {
        ArgumentNullException.ThrowIfNull(result);
        if (!_publications.TryGetValue(result, out PublicationTransaction? transaction))
            return;
        Advance(result, transaction, meter: null, ensureProgress: false);
    }

    internal LandblockPublicationAdvance ResumePublication(
        LandblockStreamResult result,
        StreamingWorkMeter meter,
        bool ensureProgress)
    {
        ArgumentNullException.ThrowIfNull(result);
        ArgumentNullException.ThrowIfNull(meter);
        if (!_publications.TryGetValue(result, out PublicationTransaction? transaction))
            return new LandblockPublicationAdvance(Completed: true, Progressed: false);
        return Advance(result, transaction, meter, ensureProgress);
    }

    public void AdvanceRetirements() => _retirements.Advance();

    public void AdvanceRetirements(StreamingWorkMeter meter) =>
        _retirements.Advance(meter);

    internal void AdvancePriorityRetirement(
        uint landblockId,
        StreamingWorkMeter meter) =>
        _retirements.AdvancePriority(landblockId, meter);

    public void BeginFullRetirement(uint landblockId)
    {
        _retirements.BeginFull(landblockId);
        if (_retirements.UsesBudgetedSteps)
            _retirements.Advance();
    }

    public void BeginNearLayerRetirement(uint landblockId)
    {
        _retirements.BeginNearLayer(landblockId);
        if (_retirements.UsesBudgetedSteps)
            _retirements.Advance();
    }

    internal void EnqueueFullRetirement(uint landblockId) =>
        _retirements.BeginFull(landblockId);

    internal void EnqueueNearLayerRetirement(uint landblockId) =>
        _retirements.BeginNearLayer(landblockId);

    /// <summary>
    /// Withdraws the complete old spatial generation in one transaction, then
    /// transfers its exact receipts to the ordinary budgeted retirement FIFO.
    /// </summary>
    internal GpuWorldRecenterRetirement DetachAllForOriginRecenter()
    {
        GpuWorldRecenterRetirement detached =
            _state.DetachAllForOriginRecenter();
        Exception? adoptionFailure =
            _retirements.AdoptDetachedFull(detached.Landblocks);
        Exception? failure = (detached.ObserverFailure, adoptionFailure) switch
        {
            (null, null) => null,
            ({ } observer, null) => observer,
            (null, { } adoption) => adoption,
            ({ } observer, { } adoption) => new AggregateException(
                "Origin-recenter spatial observers and retirement adoption failed.",
                observer,
                adoption),
        };
        return detached with { ObserverFailure = failure };
    }

    public void PublishLoaded(LandblockStreamResult.Loaded loaded)
    {
        ArgumentNullException.ThrowIfNull(loaded);
        PublicationTransaction transaction = GetOrCreate(
            loaded,
            PublicationKind.Loaded,
            loaded.Build,
            loaded.MeshData,
            loaded.LandblockId,
            loaded.Tier,
            estimate: null);
        Advance(loaded, transaction, meter: null, ensureProgress: false);
    }

    internal LandblockPublicationAdvance PublishLoaded(
        LandblockStreamResult.Loaded loaded,
        LandblockStreamCostEstimate estimate,
        StreamingWorkMeter meter,
        bool ensureProgress)
    {
        ArgumentNullException.ThrowIfNull(loaded);
        ArgumentNullException.ThrowIfNull(meter);
        PublicationTransaction transaction = GetOrCreate(
            loaded,
            PublicationKind.Loaded,
            loaded.Build,
            loaded.MeshData,
            loaded.LandblockId,
            loaded.Tier,
            estimate);
        return Advance(loaded, transaction, meter, ensureProgress);
    }

    public void PublishPromoted(
        LandblockStreamResult.Promoted promoted,
        bool mergeIntoExistingLandblock)
    {
        ArgumentNullException.ThrowIfNull(promoted);
        PublicationKind kind = mergeIntoExistingLandblock
            ? PublicationKind.PromoteExisting
            : PublicationKind.PromoteSelfContained;
        PublicationTransaction transaction = GetOrCreate(
            promoted,
            kind,
            promoted.Build,
            promoted.MeshData,
            promoted.LandblockId,
            LandblockStreamTier.Near,
            estimate: null);
        Advance(promoted, transaction, meter: null, ensureProgress: false);
    }

    internal LandblockPublicationAdvance PublishPromoted(
        LandblockStreamResult.Promoted promoted,
        bool mergeIntoExistingLandblock,
        LandblockStreamCostEstimate estimate,
        StreamingWorkMeter meter,
        bool ensureProgress)
    {
        ArgumentNullException.ThrowIfNull(promoted);
        ArgumentNullException.ThrowIfNull(meter);
        PublicationKind kind = mergeIntoExistingLandblock
            ? PublicationKind.PromoteExisting
            : PublicationKind.PromoteSelfContained;
        PublicationTransaction transaction = GetOrCreate(
            promoted,
            kind,
            promoted.Build,
            promoted.MeshData,
            promoted.LandblockId,
            LandblockStreamTier.Near,
            estimate);
        return Advance(promoted, transaction, meter, ensureProgress);
    }

    public void PublishAsFar(
        LandblockStreamResult acceptedResult,
        LandblockBuild completedBuild,
        LandblockMeshData meshData)
    {
        ArgumentNullException.ThrowIfNull(acceptedResult);
        ArgumentNullException.ThrowIfNull(completedBuild);
        ArgumentNullException.ThrowIfNull(meshData);

        if (!_publications.TryGetValue(acceptedResult, out PublicationTransaction? transaction))
        {
            LoadedLandblock completed = completedBuild.Landblock;
            var farLandblock = new LoadedLandblock(
                completed.LandblockId,
                completed.Heightmap,
                Array.Empty<WorldEntity>(),
                PhysicsDatBundle.Empty);
            transaction = new PublicationTransaction
            {
                Kind = PublicationKind.Far,
                Build = new LandblockBuild(
                    farLandblock,
                    Origin: completedBuild.Origin),
                MeshData = meshData,
                LandblockId = farLandblock.LandblockId,
                Cost = LandblockStreamResultCost.Estimate(
                    new LandblockBuild(
                        farLandblock,
                        Origin: completedBuild.Origin),
                    meshData),
                Tier = LandblockStreamTier.Far,
            };
            _publications.Add(acceptedResult, transaction);
        }
        else if (transaction.Kind != PublicationKind.Far)
        {
            throw new InvalidOperationException(
                $"Landblock publication 0x{transaction.LandblockId:X8} changed kind while pending.");
        }

        Advance(
            acceptedResult,
            transaction,
            meter: null,
            ensureProgress: false);
    }

    internal LandblockPublicationAdvance PublishAsFar(
        LandblockStreamResult acceptedResult,
        LandblockBuild completedBuild,
        LandblockMeshData meshData,
        StreamingWorkMeter meter,
        bool ensureProgress)
    {
        ArgumentNullException.ThrowIfNull(acceptedResult);
        ArgumentNullException.ThrowIfNull(completedBuild);
        ArgumentNullException.ThrowIfNull(meshData);
        ArgumentNullException.ThrowIfNull(meter);

        if (!_publications.TryGetValue(
                acceptedResult,
                out PublicationTransaction? transaction))
        {
            LoadedLandblock completed = completedBuild.Landblock;
            var farLandblock = new LoadedLandblock(
                completed.LandblockId,
                completed.Heightmap,
                Array.Empty<WorldEntity>(),
                PhysicsDatBundle.Empty);
            LandblockBuild farBuild = new(
                farLandblock,
                Origin: completedBuild.Origin);
            transaction = new PublicationTransaction
            {
                Kind = PublicationKind.Far,
                Build = farBuild,
                MeshData = meshData,
                LandblockId = farLandblock.LandblockId,
                Cost = LandblockStreamResultCost.Estimate(farBuild, meshData),
                Tier = LandblockStreamTier.Far,
            };
            _publications.Add(acceptedResult, transaction);
        }
        else if (transaction.Kind != PublicationKind.Far)
        {
            throw new InvalidOperationException(
                $"Landblock publication 0x{transaction.LandblockId:X8} changed kind while pending.");
        }

        return Advance(acceptedResult, transaction, meter, ensureProgress);
    }

    private PublicationTransaction GetOrCreate(
        LandblockStreamResult result,
        PublicationKind kind,
        LandblockBuild build,
        LandblockMeshData meshData,
        uint landblockId,
        LandblockStreamTier tier,
        LandblockStreamCostEstimate? estimate)
    {
        if (_publications.TryGetValue(result, out PublicationTransaction? existing))
        {
            if (existing.Kind != kind
                && !(existing.Kind is PublicationKind.PromoteExisting
                    or PublicationKind.PromoteSelfContained
                    && kind is PublicationKind.PromoteExisting
                        or PublicationKind.PromoteSelfContained))
            {
                throw new InvalidOperationException(
                    $"Landblock publication 0x{existing.LandblockId:X8} changed kind while pending.");
            }
            return existing;
        }

        var created = new PublicationTransaction
        {
            Kind = kind,
            Build = build,
            MeshData = meshData,
            LandblockId = landblockId,
            Cost = estimate
                ?? LandblockStreamResultCost.Estimate(build, meshData),
            Tier = tier,
        };
        _publications.Add(result, created);
        return created;
    }

    private LandblockPublicationAdvance Advance(
        LandblockStreamResult result,
        PublicationTransaction transaction,
        StreamingWorkMeter? meter,
        bool ensureProgress)
    {
        bool progressed = false;
        bool TryRun(
            StreamingWorkCost cost,
            string stage,
            Action operation)
        {
            if (meter is null)
            {
                operation();
                progressed = true;
                return true;
            }

            StreamingWorkAdmission admission = meter.TryReserve(
                cost,
                stage,
                ensureProgress && !progressed);
            if (admission == StreamingWorkAdmission.Yielded)
                return false;
            try
            {
                operation();
                meter.Complete();
                progressed = true;
                return true;
            }
            catch
            {
                meter.Fail();
                throw;
            }
        }

        if (!transaction.PresentationCommitted)
        {
            if (_renderPublisher is not null
                && _physicsPublisher is not null
                && _staticPublisher is not null)
            {
                while (transaction.RenderPublication is null)
                {
                    if (!TryRun(
                            new StreamingWorkCost(EntityOperations: 1),
                            "publication-prepare-render",
                            () => transaction.RenderPublication =
                                _renderPublisher.PreparePublication(
                                    transaction.Build,
                                    transaction.MeshData)))
                    {
                        return new LandblockPublicationAdvance(false, progressed);
                    }
                }
                while (transaction.PhysicsPublication is null)
                {
                    if (!TryRun(
                            default,
                            "publication-prepare-physics",
                            () => transaction.PhysicsPublication =
                                _physicsPublisher.CreatePublication(
                                    transaction.RenderPublication)))
                    {
                        return new LandblockPublicationAdvance(false, progressed);
                    }
                }
                while (!transaction.PhysicsPublication.PreparationCommitted)
                {
                    int entityOperations =
                        transaction.PhysicsPublication.PreparationCursor
                        < transaction.Build.Landblock.Entities.Count
                            ? 1
                            : 0;
                    if (!TryRun(
                            new StreamingWorkCost(
                                EntityOperations: entityOperations),
                            "publication-index-physics",
                            () => _physicsPublisher.AdvancePreparationOne(
                                transaction.PhysicsPublication)))
                    {
                        return new LandblockPublicationAdvance(false, progressed);
                    }
                }
                while (transaction.StaticPublication is null)
                {
                    if (!TryRun(
                            default,
                            "publication-prepare-statics",
                            () => transaction.StaticPublication =
                                _staticPublisher.CreatePublication(
                                    transaction.PhysicsPublication)))
                    {
                        return new LandblockPublicationAdvance(false, progressed);
                    }
                }
                while (!transaction.StaticPublication.PreparationCommitted)
                {
                    int entityOperations =
                        transaction.StaticPublication.PreparationCursor
                        < transaction.Build.Landblock.Entities.Count
                            ? 1
                            : 0;
                    if (!TryRun(
                            new StreamingWorkCost(
                                EntityOperations: entityOperations),
                            "publication-validate-statics",
                            () => _staticPublisher.AdvancePreparationOne(
                                transaction.StaticPublication)))
                    {
                        return new LandblockPublicationAdvance(false, progressed);
                    }
                }

                // Prepare every immutable receipt before the first external
                // mutation. Cross-owner identity/data errors therefore block
                // the publication without leaving a committed prefix.
                while (!transaction.RenderPublication.BeginCommitted)
                {
                    StreamingWorkCost cost =
                        !transaction.RenderPublication.TerrainCommitted
                            ? new StreamingWorkCost(
                                GpuUploadBytes:
                                    transaction.Cost.TerrainPayloadBytes)
                            : !transaction.RenderPublication.VisibilityCommitted
                                ? new StreamingWorkCost(
                                    EntityOperations:
                                        transaction.Cost.VisibilityCells)
                                : default;
                    if (!TryRun(
                            cost,
                            "publication-render-prefix",
                            () => _renderPublisher.AdvanceBeginOne(
                                transaction.RenderPublication)))
                    {
                        return new LandblockPublicationAdvance(false, progressed);
                    }
                }
                while (!transaction.PhysicsPublication.BeginCommitted)
                {
                    int entityOperations =
                        transaction.PhysicsPublication.TerrainSurface is not null
                        && transaction.PhysicsPublication.Build.Landblock.PhysicsDats?
                            .Info is { } info
                        && transaction.PhysicsPublication.CellCursor < info.NumCells
                            ? 1
                            : transaction.PhysicsPublication.BuildingCursor
                                < transaction.PhysicsPublication.Buildings.Length
                                ? 1
                                : 0;
                    if (!TryRun(
                            new StreamingWorkCost(
                                EntityOperations: entityOperations),
                            "publication-physics-prefix",
                            () => _physicsPublisher.AdvanceBeginOne(
                                transaction.PhysicsPublication)))
                    {
                        return new LandblockPublicationAdvance(false, progressed);
                    }
                }

                // Retail establishes the building/visible-cell suffix before
                // each static object publishes lights, collision, and scripts.
                while (!transaction.RenderPublication.CompletionCommitted)
                {
                    int entityOperations =
                        transaction.RenderPublication.BuildingPublication is
                            { PreparationCommitted: false } buildingPublication
                        && buildingPublication.BuildingCursor
                            < buildingPublication.Buildings.Length
                            ? 1
                            : transaction.RenderPublication.EnvCellPublication is
                                { PreparationCommitted: false } envCellPublication
                            && envCellPublication.ShellCursor
                                < envCellPublication.Build.Shells.Length
                                ? 1
                            : !transaction.RenderPublication.EnvCellsCommitted
                                && transaction.RenderPublication
                                    .EnvCellPublication is null
                                    ? transaction.Cost.EnvCellShells
                                : 0;
                    if (!TryRun(
                            new StreamingWorkCost(
                                EntityOperations: entityOperations),
                            "publication-render-suffix",
                            () => _renderPublisher.AdvanceCompleteOne(
                                transaction.RenderPublication)))
                    {
                        return new LandblockPublicationAdvance(false, progressed);
                    }
                }

                while (!transaction.StaticPublication.BeginCommitted)
                {
                    int entityOperations =
                        transaction.StaticPublication.PriorCleanupCursor
                        < transaction.StaticPublication
                            .OrderedPreviouslyActiveIds.Count
                            ? 1
                            : 0;
                    if (!TryRun(
                            new StreamingWorkCost(
                                EntityOperations: entityOperations),
                            "publication-static-cleanup",
                            () => _staticPublisher.AdvanceBeginOne(
                                transaction.StaticPublication)))
                    {
                        return new LandblockPublicationAdvance(false, progressed);
                    }
                }
                while (!transaction.PhysicsPublication.CompletionCommitted)
                {
                    int entityOperations =
                        transaction.PhysicsPublication.GfxCursor
                            < transaction.PhysicsPublication.GfxObjectIds.Length
                            ? 1
                            : transaction.PhysicsPublication.PriorStaticCursor
                                < transaction.PhysicsPublication
                                    .PriorStaticOwnerIds.Length
                                ? 1
                                : transaction.PhysicsPublication.StaticCursor
                                    < transaction.Build.Landblock.Entities.Count
                                    ? 1
                                    : transaction.PhysicsPublication
                                        .RefloodOwnerIds is not null
                                    && transaction.PhysicsPublication
                                        .RefloodCursor
                                        < transaction.PhysicsPublication
                                            .RefloodOwnerIds.Length
                                            ? 1
                                            : 0;
                    if (!TryRun(
                            new StreamingWorkCost(
                                EntityOperations: entityOperations),
                            "publication-physics-statics",
                            () => _physicsPublisher.AdvanceCompleteOne(
                                transaction.PhysicsPublication,
                                entity =>
                                    _staticPublisher
                                        .PrepareEntityBeforeCollision(
                                            transaction.StaticPublication,
                                            entity))))
                    {
                        return new LandblockPublicationAdvance(false, progressed);
                    }
                }
                while (!transaction.StaticPublication.CompletionCommitted)
                {
                    int entityOperations =
                        transaction.StaticPublication.PluginCursor
                        < transaction.StaticPublication.OrderedSnapshots.Count
                            ? 1
                            : 0;
                    if (!TryRun(
                            new StreamingWorkCost(
                                EntityOperations: entityOperations),
                            "publication-plugin-projection",
                            () => _staticPublisher.AdvanceCompleteOne(
                                transaction.StaticPublication)))
                    {
                        return new LandblockPublicationAdvance(false, progressed);
                    }
                }
            }
            else
            {
                StreamingWorkCost legacyCost = new(
                    EntityOperations: transaction.Cost.Entities,
                    GpuUploadBytes: transaction.Cost.TerrainPayloadBytes);
                bool ran = TryRun(
                    legacyCost,
                    "publication-legacy-presentation",
                    () =>
                    {
                        try
                        {
                            (_publishBeforeSpatialCommit
                                ?? throw new InvalidOperationException(
                                    "The presentation pipeline has no publication owners."))(
                                transaction.Build,
                                transaction.MeshData);
                        }
                        catch (Exception error)
                        {
                            // Compatibility callbacks cannot report an exact retained
                            // receipt. Preserve the established fail-fast rule only
                            // for callbacks that explicitly report committed mutation.
                            if (error is StreamingMutationException
                                {
                                    MutationCommitted: true,
                                })
                            {
                                _publications.Remove(result);
                            }
                            throw;
                        }
                    });
                if (!ran)
                {
                    return new LandblockPublicationAdvance(false, progressed);
                }
            }
            transaction.PresentationCommitted = true;
        }

        if (!transaction.SpatialPresentationCommitted)
        {
            // Keep live-projection visibility publication at the shipped
            // boundary: bucket mutation, pin/script reconciliation, then the
            // outer spatial observer commit. If pinning throws, the receipt is
            // retained and only that suffix retries.
            if (!TryRun(
                    default,
                    "publication-spatial-commit",
                    () =>
                    {
                        using GpuWorldState.MutationBatch mutation =
                            _state.BeginMutationBatch();
                        if (!transaction.SpatialCommitted)
                        {
                            IEnumerable<ulong>? renderIds =
                                transaction.Build.EnvCells?.Shells.Select(
                                    static shell => shell.GeometryId);
                            transaction.SpatialPublication = transaction.Kind switch
                            {
                                PublicationKind.Loaded
                                    or PublicationKind.PromoteSelfContained
                                    or PublicationKind.Far =>
                                    _state.CommitLandblockSpatial(
                                        transaction.Build.Landblock,
                                        renderIds,
                                        transaction.Tier),
                                PublicationKind.PromoteExisting =>
                                    _state.CommitEntitiesToExistingLandblockSpatial(
                                        transaction.LandblockId,
                                        transaction.Build.Landblock.Entities,
                                        renderIds),
                                _ => throw new InvalidOperationException(
                                    $"Unknown landblock publication kind {transaction.Kind}."),
                            };
                            transaction.SpatialCommitted = true;
                        }

                        _state.ActivateLandblockPresentation(
                            transaction.SpatialPublication
                            ?? throw new InvalidOperationException(
                                "A committed spatial publication has no activation receipt."));
                        if (transaction.SpatialPublication.RequiresActivation)
                        {
                            _staticProjectionSink?.Reconcile(
                                transaction.Build,
                                transaction.SpatialPublication);
                        }
                        transaction.SpatialPresentationCommitted = true;
                    }))
            {
                return new LandblockPublicationAdvance(false, progressed);
            }
        }

        if (!transaction.EnvCellReplayCommitted)
        {
            if (!TryRun(
                    new StreamingWorkCost(
                        EntityOperations: transaction.Cost.EnvCellShells),
                    "publication-envcell-replay",
                    () =>
                    {
                        if (transaction.Kind != PublicationKind.Far
                            && transaction.Build.EnvCells is
                                {
                                    Shells.Length: > 0,
                                } envCells)
                        {
                            _ensureEnvCellMeshes?.Invoke(envCells);
                        }
                        transaction.EnvCellReplayCommitted = true;
                    }))
            {
                return new LandblockPublicationAdvance(false, progressed);
            }
        }

        if (!transaction.LiveRecoveryCommitted)
        {
            // Retained live projections can materialize only after the
            // canonical bucket exists. Landblock load never reconstructs their
            // identity or replays create-time resources.
            if (!TryRun(
                    default,
                    "publication-live-recovery",
                    () =>
                    {
                        _onLandblockLoaded?.Invoke(transaction.LandblockId);
                        transaction.LiveRecoveryCommitted = true;
                    }))
            {
                return new LandblockPublicationAdvance(false, progressed);
            }
        }

        _publications.Remove(result);
        return new LandblockPublicationAdvance(true, progressed);
    }
}