feat(cordis): 接入上下文组合与模组事务热替换

2026-08-16 23:20:40 +08:00
commit ad256f109b
676 changed files with 52168 additions and 0 deletions
@@ -0,0 +1,197 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using Cysharp.Threading.Tasks;
+
+namespace ShrinkContext
+{
+    /// <summary>
+    /// 一等上下文（论文 Γ∞ 的运行时对应物）。
+    /// - 树结构：由 <see cref="Isolate"/> 派生隔离子上下文，或由运行时为纤程派生子上下文；
+    /// - 效应：本上下文注册的可逆效应按注册逆序（LIFO）在 <see cref="DisposeAsync"/> 中回滚；
+    /// - 余效应：Set/Get 委托给运行时共享存储，键先经隔离表解析为 realm 再查表。
+    /// </summary>
+    public sealed class ShrinkCtx
+    {
+        private readonly List<ShrinkEffectHandle> _effects = new();
+        private readonly Dictionary<string, string>? _isolateOverlay;
+
+        internal ShrinkCtx(ShrinkContextRuntime runtime, ShrinkCtx? parent, ShrinkFiber? ownerFiber,
+            Dictionary<string, string>? isolateOverlay)
+        {
+            Runtime = runtime;
+            Parent = parent;
+            OwnerFiber = ownerFiber;
+            _isolateOverlay = isolateOverlay;
+        }
+
+        public ShrinkContextRuntime Runtime { get; }
+        public ShrinkCtx? Parent { get; }
+        public ShrinkFiber? OwnerFiber { get; }
+
+        // ---------------- 效应（论文 3.1 / 算法 1） ----------------
+
+        /// <summary>同步前向 + 可选同步逆操作的可逆效应；前向立即执行。</summary>
+        public ShrinkEffectHandle Effect(Action forward, Action? inverse = null)
+        {
+            if (forward == null)
+                throw new ArgumentNullException(nameof(forward));
+
+            forward();
+
+            var handle = new ShrinkEffectHandle();
+            if (inverse != null)
+                handle.AttachInverse(() =>
+                {
+                    inverse();
+                    return UniTask.CompletedTask;
+                });
+            Attach(handle);
+            return handle;
+        }
+
+        /// <summary>异步前向，完成时产出异步逆操作（论文 𝔈Γ）。DisposeAsync 会等待进行中的前向。</summary>
+        public async UniTask<ShrinkEffectHandle> EffectAsync(Func<UniTask<Func<UniTask>>> effectFn)
+        {
+            if (effectFn == null)
+                throw new ArgumentNullException(nameof(effectFn));
+
+            var handle = new ShrinkEffectHandle();
+            var gate = new UniTaskCompletionSource();
+            handle.BeginForward(gate.Task);
+            Attach(handle);
+
+            Func<UniTask>? inverse = null;
+            try
+            {
+                inverse = await effectFn();
+                handle.CompleteForward(inverse);
+            }
+            finally
+            {
+                // 先登记逆操作再放行 gate，保证等待前向的 DisposeAsync 能读到完整逆链
+                gate.TrySetResult();
+            }
+
+            return handle;
+        }
+
+        internal void Attach(ShrinkEffectHandle handle) => _effects.Add(handle);
+
+        /// <summary>
+        /// 前向已在外部执行完毕的效应：仅登记逆操作（供桥接适配器把既有 API 的"注册/注销"对包装为可逆效应）。
+        /// </summary>
+        public ShrinkEffectHandle EffectInverse(Func<UniTask> inverse)
+        {
+            if (inverse == null)
+                throw new ArgumentNullException(nameof(inverse));
+
+            var handle = new ShrinkEffectHandle();
+            handle.AttachInverse(inverse);
+            Attach(handle);
+            return handle;
+        }
+
+        /// <summary>按 LIFO 顺序执行本上下文注册的全部逆操作。</summary>
+        public async UniTask DisposeAsync()
+        {
+            for (var i = _effects.Count - 1; i >= 0; i--)
+                await _effects[i].DisposeAsync();
+            _effects.Clear();
+        }
+
+        // ---------------- 余效应（论文 3.2 / 算法 2） ----------------
+
+        /// <summary>
+        /// 提供依赖（set 是可逆效应）：立即安装绑定并通知依赖者；
+        /// 逆操作撤回绑定并再次通知。句柄同时挂在当前上下文上，随上下文卸载自动撤回。
+        /// </summary>
+        public ShrinkEffectHandle Set<T>(string key, T value) => Runtime.SetBinding(this, key, value);
+
+        /// <summary>
+        /// 代理介导的依赖访问（论文算法 6）：沿纤程链解析已提交视图；
+        /// 声明了但未激活的键抛 <see cref="ShrinkInactiveAccessException"/>，
+        /// 全链未声明的键抛 <see cref="ShrinkUndeclaredAccessException"/>。
+        /// </summary>
+        public T Get<T>(string key)
+        {
+            var fiber = OwnerFiber;
+            while (fiber != null)
+            {
+                if (fiber.Committed != null && fiber.Committed.TryGetValue(key, out var binding))
+                    return (T)binding.Value!;
+                if (fiber.InjectSet.Contains(key))
+                    throw new ShrinkInactiveAccessException(key, fiber.Name);
+                fiber = fiber.Parent;
+            }
+
+            throw new ShrinkUndeclaredAccessException(key);
+        }
+
+        /// <summary>与 <see cref="Get{T}"/> 相同的介导规则；未激活返回 false 而不抛异常。</summary>
+        public bool TryGet<T>(string key, out T value)
+        {
+            var fiber = OwnerFiber;
+            while (fiber != null)
+            {
+                if (fiber.Committed != null && fiber.Committed.TryGetValue(key, out var binding))
+                {
+                    value = (T)binding.Value!;
+                    return true;
+                }
+                if (fiber.InjectSet.Contains(key))
+                    break;
+                fiber = fiber.Parent;
+            }
+
+            value = default!;
+            return false;
+        }
+
+        /// <summary>
+        /// 派生隔离子上下文（论文定义 28/29 的派生实现）：
+        /// 覆盖 key 的 realm 解析；父上下文不受影响；丢弃子上下文即隐式恢复。
+        /// </summary>
+        public ShrinkCtx Isolate(string key, string realm)
+        {
+            if (string.IsNullOrEmpty(key))
+                throw new ArgumentException("Key must not be null or empty.", nameof(key));
+            if (string.IsNullOrEmpty(realm))
+                throw new ArgumentException("Realm must not be null or empty.", nameof(realm));
+
+            return new ShrinkCtx(Runtime, this, OwnerFiber, new Dictionary<string, string> { [key] = realm });
+        }
+
+        internal ShrinkCtx CreateChildForFiber(ShrinkFiber fiber) => new(Runtime, this, fiber, null);
+
+        /// <summary>在派生子上下文中叠加隔离覆盖（同键后者优先），供加载器为条目配置隔离域。</summary>
+        internal ShrinkCtx WithIsolate(IReadOnlyDictionary<string, string> isolate)
+        {
+            var overlay = new Dictionary<string, string>();
+            if (_isolateOverlay != null)
+            {
+                foreach (var pair in _isolateOverlay)
+                    overlay[pair.Key] = pair.Value;
+            }
+
+            foreach (var pair in isolate)
+                overlay[pair.Key] = pair.Value;
+
+            return new ShrinkCtx(Runtime, this, OwnerFiber, overlay);
+        }
+
+        /// <summary>解析 key 在本上下文中归属的 realm：沿父链找最近的隔离覆盖，默认 realm 为 key 自身。</summary>
+        internal string ResolveRealm(string key)
+        {
+            var current = this;
+            while (current != null)
+            {
+                if (current._isolateOverlay != null && current._isolateOverlay.TryGetValue(key, out var realm))
+                    return realm;
+                current = current.Parent;
+            }
+
+            return key;
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3c4e5dd3f658ca14a929dd41f2466927
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,61 @@
+#nullable enable
+using System;
+using Cysharp.Threading.Tasks;
+
+namespace ShrinkContext
+{
+    /// <summary>
+    /// 单个可逆效应的句柄（论文算法 1 的 effect 封装）。
+    /// 前向执行时产出逆操作并累积在句柄内部；DisposeAsync 至多执行一次（armed 语义），
+    /// 若前向仍在进行中则先等待其完成再运行累积的逆操作（dispose = await task; recover()）。
+    /// </summary>
+    public sealed class ShrinkEffectHandle
+    {
+        private static readonly Func<UniTask> Nop = static () => UniTask.CompletedTask;
+
+        private bool _armed = true;
+        private UniTask _forwardTask;
+        private bool _hasForwardTask;
+        private Func<UniTask> _inverseChain = Nop;
+
+        public bool IsArmed => _armed;
+
+        /// <summary>登记一个进行中的异步前向；DisposeAsync 会先等待它完成。</summary>
+        internal void BeginForward(UniTask forwardTask)
+        {
+            _forwardTask = forwardTask;
+            _hasForwardTask = true;
+        }
+
+        /// <summary>前向完成后登记其逆操作；新逆操作在链首执行（LIFO）。</summary>
+        internal void CompleteForward(Func<UniTask> inverse)
+        {
+            if (inverse == null)
+                return;
+
+            var previous = _inverseChain;
+            _inverseChain = async () =>
+            {
+                await inverse();
+                await previous();
+            };
+        }
+
+        /// <summary>直接附加逆操作（等效于前向已同步完成）。</summary>
+        internal void AttachInverse(Func<UniTask> inverse) => CompleteForward(inverse);
+
+        public async UniTask DisposeAsync()
+        {
+            if (!_armed)
+                return;
+
+            _armed = false;
+            if (_hasForwardTask && _forwardTask.Status == UniTaskStatus.Pending)
+                await _forwardTask;
+
+            var chain = _inverseChain;
+            _inverseChain = Nop;
+            await chain();
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6baa51f655b3c9a4d9dc0b1dbdce8461
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: