refactor(net): own live session composition

Extract reset, selection, entered-world, and route construction behind LiveSessionHost while preserving the sole LiveSessionController authority. Retain partial route and subscription cleanup for retry, and replace the embedded ACE-only shortcut with the exact named-retail unsigned skill formula.

Co-authored-by: Codex <codex@openai.com>

src/AcDream.App/Net/LiveSessionCommandRouter.cs

@@ -21,7 +21,7 @@ internal sealed record LiveSessionCommandBindings(
 /// itself is the published bus, so a retained reference becomes inert before
 /// the displaced transport is disposed.
 /// </summary>
-internal sealed class LiveSessionCommandRouter : ICommandBus, IDisposable
+internal sealed class LiveSessionCommandRouter : ILiveSessionCommandRouting
 {
     private readonly object _gate = new();
     private LiveCommandBus? _commands;

src/AcDream.App/Net/LiveSessionEventRouter.cs

@@ -57,12 +57,19 @@ internal sealed record LiveSocialSessionBindings(
 /// Owns every inbound subscription for one exact live session. Domain state
 /// remains in the supplied sinks; this class owns only routing and teardown.
 /// </summary>
-internal sealed class LiveSessionEventRouter : IDisposable
+internal sealed class LiveSessionEventRouter : ILiveSessionEventRouting
 {
     private readonly LiveSessionSubscriptionSet _subscriptions = new();
     private readonly Action<int>? _constructionCheckpoint;
+    private readonly WorldSession _session;
+    private readonly LiveEntitySessionSink _entities;
+    private readonly LiveEnvironmentSessionSink _environment;
+    private readonly LiveInventorySessionBindings _inventory;
+    private readonly LiveCharacterSessionBindings _character;
+    private readonly LiveSocialSessionBindings _social;
     private int _constructionStep;
-    private int _accepting = 1;
+    private int _accepting;
+    private int _lifecycleState; // 0 created, 1 attaching, 2 attached, 3 disposed
 
     public LiveSessionEventRouter(
         WorldSession session,
@@ -75,7 +82,28 @@ internal sealed class LiveSessionEventRouter : IDisposable
     {
         ArgumentNullException.ThrowIfNull(session);
         Validate(entities, environment, inventory, character, social);
+        _session = session;
+        _entities = entities;
+        _environment = environment;
+        _inventory = inventory;
+        _character = character;
+        _social = social;
         _constructionCheckpoint = constructionCheckpoint;
+    }
+
+    public void Attach()
+    {
+        if (Interlocked.CompareExchange(ref _lifecycleState, 1, 0) != 0)
+            throw new InvalidOperationException(
+                "Live-session event routing can only attach once.");
+
+        Interlocked.Exchange(ref _accepting, 1);
+        WorldSession session = _session;
+        LiveEntitySessionSink entities = _entities;
+        LiveEnvironmentSessionSink environment = _environment;
+        LiveInventorySessionBindings inventory = _inventory;
+        LiveCharacterSessionBindings character = _character;
+        LiveSocialSessionBindings social = _social;
 
         try
         {
@@ -182,22 +210,14 @@ internal sealed class LiveSessionEventRouter : IDisposable
                 h => session.VitalCurrentUpdated += h,
                 h => session.VitalCurrentUpdated -= h,
                 vital => inventory.LocalPlayer.OnVitalCurrent(vital.VitalId, vital.Current));
+
+            if (Interlocked.CompareExchange(ref _lifecycleState, 2, 1) != 1)
+                throw new ObjectDisposedException(nameof(LiveSessionEventRouter));
         }
-        catch (Exception constructionError)
+        catch
         {
             Interlocked.Exchange(ref _accepting, 0);
-            try
-            {
-                _subscriptions.Dispose();
-            }
-            catch (Exception cleanupError)
-            {
-                throw new AggregateException(
-                    "live-session event routing failed and cleanup also failed",
-                    constructionError,
-                    cleanupError);
-            }
-
+            Interlocked.Exchange(ref _lifecycleState, 3);
             throw;
         }
     }
@@ -207,6 +227,7 @@ internal sealed class LiveSessionEventRouter : IDisposable
     public void Dispose()
     {
         Interlocked.Exchange(ref _accepting, 0);
+        Interlocked.Exchange(ref _lifecycleState, 3);
         _subscriptions.Dispose();
     }
 
@@ -222,15 +243,10 @@ internal sealed class LiveSessionEventRouter : IDisposable
         };
 
         attach(handler);
-        try
-        {
-            _subscriptions.Add(() => detach(handler));
-        }
-        catch
-        {
-            detach(handler);
-            throw;
-        }
+        // Add assumes cleanup ownership before it can call an external detach.
+        // If the set is already closing, it retains/retries that exact edge;
+        // calling detach again here would replay a successful removal.
+        _subscriptions.Add(() => detach(handler));
 
         ConstructionCheckpoint();
     }
@@ -290,31 +306,48 @@ internal sealed class LiveSessionEventRouter : IDisposable
 
 internal sealed class LiveSessionSubscriptionSet : IDisposable
 {
-    private List<IDisposable>? _subscriptions = [];
+    private readonly object _gate = new();
+    private readonly List<RetryableSubscription> _subscriptions = [];
+    private bool _disposeRequested;
 
     public void Add(IDisposable subscription)
     {
         ArgumentNullException.ThrowIfNull(subscription);
-        List<IDisposable>? subscriptions = _subscriptions;
-        if (subscriptions is null)
-        {
-            subscription.Dispose();
-            throw new ObjectDisposedException(nameof(LiveSessionSubscriptionSet));
-        }
-
-        subscriptions.Add(subscription);
+        AddRetained(new RetryableSubscription(subscription.Dispose));
     }
 
-    public void Add(Action unsubscribe) => Add(new ActionSubscription(unsubscribe));
+    public void Add(Action unsubscribe)
+    {
+        ArgumentNullException.ThrowIfNull(unsubscribe);
+        AddRetained(new RetryableSubscription(unsubscribe));
+    }
+
+    private void AddRetained(RetryableSubscription retained)
+    {
+        bool disposeNow;
+        lock (_gate)
+        {
+            disposeNow = _disposeRequested;
+            _subscriptions.Add(retained);
+        }
+
+        if (!disposeNow)
+            return;
+        retained.Dispose();
+        throw new ObjectDisposedException(nameof(LiveSessionSubscriptionSet));
+    }
 
     public void Dispose()
     {
-        List<IDisposable>? subscriptions = Interlocked.Exchange(ref _subscriptions, null);
-        if (subscriptions is null)
-            return;
+        RetryableSubscription[] subscriptions;
+        lock (_gate)
+        {
+            _disposeRequested = true;
+            subscriptions = _subscriptions.ToArray();
+        }
 
         List<Exception>? errors = null;
-        for (int index = subscriptions.Count - 1; index >= 0; index--)
+        for (int index = subscriptions.Length - 1; index >= 0; index--)
         {
             try
             {
@@ -332,10 +365,59 @@ internal sealed class LiveSessionSubscriptionSet : IDisposable
                 errors);
     }
 
-    private sealed class ActionSubscription(Action unsubscribe) : IDisposable
+    private sealed class RetryableSubscription(Action dispose) : IDisposable
     {
-        private Action? _unsubscribe = unsubscribe;
+        private readonly object _gate = new();
+        private Action? _dispose = dispose;
+        private bool _executing;
+        private int _executingThreadId;
 
-        public void Dispose() => Interlocked.Exchange(ref _unsubscribe, null)?.Invoke();
+        public void Dispose()
+        {
+            Action? operation;
+            int threadId = Environment.CurrentManagedThreadId;
+            lock (_gate)
+            {
+                while (_executing)
+                {
+                    if (_executingThreadId == threadId)
+                    {
+                        throw new InvalidOperationException(
+                            "Live-session subscription cleanup cannot complete reentrantly.");
+                    }
+                    Monitor.Wait(_gate);
+                }
+
+                operation = _dispose;
+                if (operation is null)
+                    return;
+                _executing = true;
+                _executingThreadId = threadId;
+            }
+
+            try
+            {
+                operation();
+            }
+            catch
+            {
+                CompleteAttempt(succeeded: false);
+                throw;
+            }
+
+            CompleteAttempt(succeeded: true);
+        }
+
+        private void CompleteAttempt(bool succeeded)
+        {
+            lock (_gate)
+            {
+                if (succeeded)
+                    _dispose = null;
+                _executing = false;
+                _executingThreadId = 0;
+                Monitor.PulseAll(_gate);
+            }
+        }
     }
 }

src/AcDream.App/Net/LiveSessionHost.cs

@@ -0,0 +1,242 @@
+using System.Runtime.ExceptionServices;
+using AcDream.Core.Net;
+using AcDream.UI.Abstractions;
+
+namespace AcDream.App.Net;
+
+internal interface ILiveSessionEventRouting : IDisposable
+{
+    void Attach();
+}
+
+internal interface ILiveSessionCommandRouting : ICommandBus, IDisposable
+{
+    void Activate();
+}
+
+internal sealed record LiveSessionRoutingFactories(
+    Func<WorldSession, ILiveSessionEventRouting> CreateEvents,
+    Func<WorldSession, ILiveSessionCommandRouting> CreateCommands);
+
+internal sealed record LiveSessionSelectionBindings(
+    Action<uint> SetPlayerIdentity,
+    Action<uint> SetVitalsIdentity,
+    Action<uint> SetChatIdentity,
+    Action<uint> MarkPersistent,
+    Action<uint> SetVanishProbeIdentity,
+    Action ClearCombat);
+
+internal sealed record LiveSessionEnteredWorldBindings(
+    Action<string> SetActiveCharacter,
+    Action RestoreLayout,
+    Action SyncToolbar,
+    Action<string> LoadCharacterSettings,
+    Action ArmPlayerModeAutoEntry);
+
+internal sealed record LiveSessionHostBindings(
+    LiveSessionRoutingFactories Routing,
+    LiveSessionResetBindings Reset,
+    LiveSessionSelectionBindings Selection,
+    LiveSessionEnteredWorldBindings EnteredWorld,
+    Action<string, int, string> Connecting,
+    Action Connected);
+
+/// <summary>
+/// App composition owner for the one canonical <see cref="LiveSessionController"/>.
+/// It owns callback ordering and per-generation route factories, but never
+/// mirrors session, generation, identity, routing, or command state.
+/// </summary>
+internal sealed class LiveSessionHost
+{
+    private sealed class PendingRouteRollback(
+        ILiveSessionCommandRouting? commands,
+        ILiveSessionEventRouting? events)
+    {
+        private ILiveSessionCommandRouting? _commands = commands;
+        private ILiveSessionEventRouting? _events = events;
+
+        public bool IsComplete => _commands is null && _events is null;
+
+        public void Drain()
+        {
+            List<Exception>? failures = null;
+            TryDispose(ref _commands, ref failures);
+            TryDispose(ref _events, ref failures);
+            if (failures is not null)
+            {
+                throw new AggregateException(
+                    "Live-session route rollback did not converge.",
+                    failures);
+            }
+        }
+
+        private static void TryDispose<TOwner>(
+            ref TOwner? owner,
+            ref List<Exception>? failures)
+            where TOwner : class, IDisposable
+        {
+            if (owner is null)
+                return;
+            try
+            {
+                owner.Dispose();
+                owner = null;
+            }
+            catch (Exception error)
+            {
+                (failures ??= []).Add(error);
+            }
+        }
+    }
+
+    private readonly LiveSessionController _controller;
+    private readonly LiveSessionRoutingFactories _routing;
+    private readonly LiveSessionSelectionBindings _selection;
+    private readonly LiveSessionEnteredWorldBindings _enteredWorld;
+    private readonly LiveSessionResetPlan _resetPlan;
+    private readonly LiveSessionLifecycleHost _lifecycle;
+    private PendingRouteRollback? _pendingRouteRollback;
+
+    public LiveSessionHost(
+        LiveSessionController controller,
+        LiveSessionHostBindings bindings)
+    {
+        _controller = controller ?? throw new ArgumentNullException(nameof(controller));
+        ArgumentNullException.ThrowIfNull(bindings);
+        _routing = bindings.Routing ?? throw new ArgumentNullException(nameof(bindings.Routing));
+        _selection = bindings.Selection ?? throw new ArgumentNullException(nameof(bindings.Selection));
+        _enteredWorld = bindings.EnteredWorld
+            ?? throw new ArgumentNullException(nameof(bindings.EnteredWorld));
+        ArgumentNullException.ThrowIfNull(_routing.CreateEvents);
+        ArgumentNullException.ThrowIfNull(_routing.CreateCommands);
+        ArgumentNullException.ThrowIfNull(bindings.Connecting);
+        ArgumentNullException.ThrowIfNull(bindings.Connected);
+        Validate(_selection, _enteredWorld);
+
+        _resetPlan = LiveSessionResetManifest.Create(bindings.Reset);
+        _lifecycle = new LiveSessionLifecycleHost(new LiveSessionLifecycleBindings(
+            Bind: BindSession,
+            Reset: ResetSessionState,
+            Connecting: bindings.Connecting,
+            Connected: bindings.Connected,
+            Selected: ApplySelection,
+            Entered: ApplyEnteredWorld));
+    }
+
+    public WorldSession? CurrentSession => _controller.CurrentSession;
+    public ICommandBus Commands => _controller.Commands;
+    public bool IsInWorld => _controller.IsInWorld;
+
+    public LiveSessionStartResult Start(RuntimeOptions options) =>
+        _controller.Start(options, _lifecycle);
+
+    public LiveSessionStartResult Reconnect(RuntimeOptions options) =>
+        _controller.Reconnect(options, _lifecycle);
+
+    private LiveSessionBinding BindSession(WorldSession session)
+    {
+        DrainPendingRouteRollback();
+
+        ILiveSessionEventRouting? events = null;
+        ILiveSessionCommandRouting? commands = null;
+        try
+        {
+            events = _routing.CreateEvents(session)
+                ?? throw new InvalidOperationException(
+                    "The live-session event factory returned null.");
+            events.Attach();
+            commands = _routing.CreateCommands(session)
+                ?? throw new InvalidOperationException(
+                    "The live-session command factory returned null.");
+            return new LiveSessionBinding(
+                session,
+                commands,
+                activateCommands: commands.Activate,
+                deactivateCommands: commands.Dispose,
+                detachEvents: events.Dispose);
+        }
+        catch (Exception creationError)
+        {
+            RethrowWithRetryableRollback(creationError, commands, events);
+            throw;
+        }
+    }
+
+    private void ResetSessionState()
+    {
+        // An incompletely detached route can still deliver callbacks into the
+        // state below. Treat physical route convergence as the same hard
+        // barrier used by normal LiveSessionBinding teardown.
+        DrainPendingRouteRollback();
+        _resetPlan.Execute();
+    }
+
+    private void ApplySelection(LiveSessionCharacterSelection selection)
+    {
+        uint id = selection.CharacterId;
+        _selection.SetPlayerIdentity(id);
+        _selection.SetVitalsIdentity(id);
+        _selection.SetChatIdentity(id);
+        _selection.MarkPersistent(id);
+        _selection.SetVanishProbeIdentity(id);
+        _selection.ClearCombat();
+    }
+
+    private void ApplyEnteredWorld(LiveSessionCharacterSelection selection)
+    {
+        string name = selection.CharacterName;
+        _enteredWorld.SetActiveCharacter(name);
+        _enteredWorld.RestoreLayout();
+        _enteredWorld.SyncToolbar();
+        _enteredWorld.LoadCharacterSettings(name);
+        _enteredWorld.ArmPlayerModeAutoEntry();
+    }
+
+    private void RethrowWithRetryableRollback(
+        Exception creationError,
+        ILiveSessionCommandRouting? commands,
+        ILiveSessionEventRouting? events)
+    {
+        _pendingRouteRollback = new PendingRouteRollback(commands, events);
+        try
+        {
+            DrainPendingRouteRollback();
+        }
+        catch (AggregateException cleanupError)
+        {
+            var failures = new List<Exception> { creationError };
+            failures.AddRange(cleanupError.InnerExceptions);
+            throw new AggregateException(
+                "Live-session route construction and rollback both failed.",
+                failures);
+        }
+
+        ExceptionDispatchInfo.Capture(creationError).Throw();
+    }
+
+    private void DrainPendingRouteRollback()
+    {
+        if (_pendingRouteRollback is not { } rollback)
+            return;
+        rollback.Drain();
+        if (rollback.IsComplete)
+            _pendingRouteRollback = null;
+    }
+
+    private static void Validate(
+        LiveSessionSelectionBindings selection,
+        LiveSessionEnteredWorldBindings entered)
+    {
+        ArgumentNullException.ThrowIfNull(selection.SetPlayerIdentity);
+        ArgumentNullException.ThrowIfNull(selection.SetVitalsIdentity);
+        ArgumentNullException.ThrowIfNull(selection.SetChatIdentity);
+        ArgumentNullException.ThrowIfNull(selection.MarkPersistent);
+        ArgumentNullException.ThrowIfNull(selection.SetVanishProbeIdentity);
+        ArgumentNullException.ThrowIfNull(selection.ClearCombat);
+        ArgumentNullException.ThrowIfNull(entered.SetActiveCharacter);
+        ArgumentNullException.ThrowIfNull(entered.RestoreLayout);
+        ArgumentNullException.ThrowIfNull(entered.SyncToolbar);
+        ArgumentNullException.ThrowIfNull(entered.LoadCharacterSettings);
+        ArgumentNullException.ThrowIfNull(entered.ArmPlayerModeAutoEntry);
+    }
+}

src/AcDream.App/Net/RetailSkillFormula.cs

@@ -0,0 +1,72 @@
+using DatReaderWriter.DBObjs;
+using DatReaderWriter.Types;
+
+namespace AcDream.App.Net;
+
+/// <summary>
+/// Exact unsigned formula used by retail <c>SkillFormula::Calculate @
+/// 0x00591960</c>. DAT reader fields are signed storage views, so their bits
+/// are deliberately reinterpreted as retail's unsigned W/X/Y/Z words.
+/// </summary>
+internal static class RetailSkillFormula
+{
+    public static bool TryCalculate(
+        SkillFormula formula,
+        uint attribute1,
+        uint attribute2,
+        out uint result)
+    {
+        ArgumentNullException.ThrowIfNull(formula);
+
+        uint divisor = unchecked((uint)formula.Divisor);
+        if (divisor == 0u)
+        {
+            result = 0u;
+            return false;
+        }
+
+        uint x = unchecked((uint)formula.Attribute1Multiplier);
+        uint y = unchecked((uint)formula.Attribute2Multiplier);
+        uint w = unchecked((uint)formula.AdditiveBonus);
+        uint numerator = unchecked(x * attribute1 + y * attribute2 + w);
+        result = (uint)Math.Floor((double)numerator / divisor + 0.5d);
+        return true;
+    }
+}
+
+/// <summary>
+/// Named live-session resolver for the attribute contribution to one skill.
+/// Table lookup and missing-property policy stay separate from retail math.
+/// </summary>
+internal sealed class LiveSkillCreditResolver(SkillTable? skillTable)
+{
+    public uint Resolve(
+        uint skillId,
+        IReadOnlyDictionary<uint, uint> attributeCurrents)
+    {
+        ArgumentNullException.ThrowIfNull(attributeCurrents);
+
+        if (skillTable?.Skills is null
+            || !skillTable.Skills.TryGetValue(
+                (DatReaderWriter.Enums.SkillId)skillId,
+                out var skillBase))
+        {
+            return 0u;
+        }
+
+        SkillFormula formula = skillBase.Formula;
+        attributeCurrents.TryGetValue(
+            (uint)formula.Attribute1,
+            out uint attribute1);
+        attributeCurrents.TryGetValue(
+            (uint)formula.Attribute2,
+            out uint attribute2);
+        return RetailSkillFormula.TryCalculate(
+            formula,
+            attribute1,
+            attribute2,
+            out uint result)
+            ? result
+            : 0u;
+    }
+}