chore: initialize standalone UPM package

Runtime/Registry/ShrinkModRegistry.cs

@@ -0,0 +1,223 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace ShrinkModFramework
+{
+    public interface IReadOnlyShrinkModRegistry<T>
+    {
+        string Name { get; }
+        IReadOnlyCollection<ShrinkRegistryEntry<T>> Entries { get; }
+        IReadOnlyCollection<ShrinkRegistryEntry<T>> BaseEntries { get; }
+        bool Contains(string key);
+        bool TryGet(string key, out T value);
+        bool TryGetEntry(string key, out ShrinkRegistryEntry<T> entry);
+        IReadOnlyList<ShrinkRegistryEntry<T>> GetOverrideCandidates(string key);
+    }
+
+    internal interface IShrinkOwnedRegistry
+    {
+        void RemoveOwnedEntries(string ownerModId);
+    }
+
+    internal sealed class ShrinkModRegistry<T> : IReadOnlyShrinkModRegistry<T>, IShrinkOwnedRegistry
+    {
+        private readonly Dictionary<string, ShrinkRegistryEntry<T>> _baseEntries =
+            new(StringComparer.Ordinal);
+        private readonly Dictionary<string, List<ShrinkRegistryEntry<T>>> _overrides =
+            new(StringComparer.Ordinal);
+
+        public string Name { get; }
+
+        internal ShrinkModRegistry(string name)
+        {
+            if (string.IsNullOrWhiteSpace(name))
+                throw new ArgumentException("注册表名称不能为空。", nameof(name));
+
+            Name = name.Trim();
+        }
+
+        /// <summary>当前生效项；存在覆盖时返回最高优先级的覆盖项。</summary>
+        public IReadOnlyCollection<ShrinkRegistryEntry<T>> Entries => _baseEntries.Keys
+            .OrderBy(key => key, StringComparer.Ordinal)
+            .Select(ResolveEntry)
+            .ToArray();
+
+        /// <summary>不应用覆盖的基础注册项快照。</summary>
+        public IReadOnlyCollection<ShrinkRegistryEntry<T>> BaseEntries => _baseEntries.Values
+            .OrderBy(entry => entry.Key, StringComparer.Ordinal)
+            .ToArray();
+
+        private void RegisterBase(string ownerModId, string key, T value)
+        {
+            ownerModId = NormalizeOwner(ownerModId);
+            key = NormalizeKey(key);
+            if (_baseEntries.ContainsKey(key))
+                throw new InvalidOperationException($"注册表 '{Name}' 中已存在键 '{key}'。");
+
+            _baseEntries.Add(key, new ShrinkRegistryEntry<T>(ownerModId, key, value));
+        }
+
+        /// <summary>
+        /// 使用 owner 作为 namespace 注册内容，并返回最终键。localKey 只能是局部名称，不能包含冒号。
+        /// </summary>
+        public string RegisterNamespaced(string ownerModId, string localKey, T value)
+        {
+            ownerModId = NormalizeOwner(ownerModId);
+            if (ownerModId.IndexOf(':') >= 0)
+                throw new ArgumentException("归属模组 ID 不能包含 ':'。", nameof(ownerModId));
+            if (string.IsNullOrWhiteSpace(localKey))
+                throw new ArgumentException("局部注册键不能为空。", nameof(localKey));
+
+            localKey = localKey.Trim();
+            if (localKey.IndexOf(':') >= 0)
+                throw new ArgumentException("局部注册键不能包含 ':'。", nameof(localKey));
+
+            var key = ownerModId + ":" + localKey;
+            RegisterBase(ownerModId, key, value);
+            return key;
+        }
+
+        /// <summary>
+        /// 为已有基础项注册显式覆盖。优先级越高越先命中；同一目标的相同优先级视为硬冲突。
+        /// </summary>
+        public void RegisterOverride(string ownerModId, string targetKey, int priority, T value)
+        {
+            ownerModId = NormalizeOwner(ownerModId);
+            targetKey = NormalizeKey(targetKey);
+            if (!_baseEntries.ContainsKey(targetKey))
+                throw new InvalidOperationException(
+                    $"注册表 '{Name}' 的覆盖目标 '{targetKey}' 不存在。");
+
+            if (!_overrides.TryGetValue(targetKey, out var candidates))
+            {
+                candidates = new List<ShrinkRegistryEntry<T>>();
+                _overrides.Add(targetKey, candidates);
+            }
+
+            if (candidates.Any(candidate => candidate.Priority == priority))
+                throw new InvalidOperationException(
+                    $"注册表 '{Name}' 的键 '{targetKey}' 在优先级 {priority} 存在覆盖冲突。");
+
+            candidates.Add(ShrinkRegistryEntry<T>.CreateOverride(ownerModId, targetKey, priority, value));
+        }
+
+        public IReadOnlyList<ShrinkRegistryEntry<T>> GetOverrideCandidates(string key)
+        {
+            if (string.IsNullOrWhiteSpace(key) || !_overrides.TryGetValue(key.Trim(), out var candidates))
+                return Array.Empty<ShrinkRegistryEntry<T>>();
+
+            return candidates
+                .OrderByDescending(candidate => candidate.Priority)
+                .ThenBy(candidate => candidate.OwnerModId, StringComparer.Ordinal)
+                .ToArray();
+        }
+
+        public bool Contains(string key) =>
+            !string.IsNullOrWhiteSpace(key) && _baseEntries.ContainsKey(key.Trim());
+
+        public bool TryGet(string key, out T value)
+        {
+            if (TryGetEntry(key, out var entry))
+            {
+                value = entry.Value;
+                return true;
+            }
+
+            value = default;
+            return false;
+        }
+
+        public bool TryGetEntry(string key, out ShrinkRegistryEntry<T> entry)
+        {
+            if (!string.IsNullOrWhiteSpace(key) && _baseEntries.ContainsKey(key.Trim()))
+            {
+                entry = ResolveEntry(key.Trim());
+                return true;
+            }
+
+            entry = default;
+            return false;
+        }
+
+        void IShrinkOwnedRegistry.RemoveOwnedEntries(string ownerModId)
+        {
+            if (string.IsNullOrWhiteSpace(ownerModId))
+                return;
+
+            ownerModId = ownerModId.Trim();
+            var keys = _baseEntries
+                .Where(pair => string.Equals(pair.Value.OwnerModId, ownerModId, StringComparison.Ordinal))
+                .Select(pair => pair.Key)
+                .ToArray();
+            foreach (var key in keys)
+                _baseEntries.Remove(key);
+
+            var emptyOverrideTargets = new List<string>();
+            foreach (var pair in _overrides)
+            {
+                pair.Value.RemoveAll(candidate =>
+                    string.Equals(candidate.OwnerModId, ownerModId, StringComparison.Ordinal));
+                if (pair.Value.Count == 0)
+                    emptyOverrideTargets.Add(pair.Key);
+            }
+
+            foreach (var targetKey in emptyOverrideTargets)
+                _overrides.Remove(targetKey);
+        }
+
+        private ShrinkRegistryEntry<T> ResolveEntry(string key)
+        {
+            if (_overrides.TryGetValue(key, out var candidates) && candidates.Count > 0)
+            {
+                return candidates
+                    .OrderByDescending(candidate => candidate.Priority)
+                    .ThenBy(candidate => candidate.OwnerModId, StringComparer.Ordinal)
+                    .First();
+            }
+
+            return _baseEntries[key];
+        }
+
+        private static string NormalizeOwner(string ownerModId)
+        {
+            if (string.IsNullOrWhiteSpace(ownerModId))
+                throw new ArgumentException("归属模组 ID 不能为空。", nameof(ownerModId));
+            return ownerModId.Trim();
+        }
+
+        private static string NormalizeKey(string key)
+        {
+            if (string.IsNullOrWhiteSpace(key))
+                throw new ArgumentException("注册键不能为空。", nameof(key));
+            return key.Trim();
+        }
+    }
+
+    public readonly struct ShrinkRegistryEntry<T>
+    {
+        public string OwnerModId { get; }
+        public string Key { get; }
+        public T Value { get; }
+        public bool IsOverride { get; }
+        public int Priority { get; }
+
+        public ShrinkRegistryEntry(string ownerModId, string key, T value)
+            : this(ownerModId, key, value, false, 0)
+        {
+        }
+
+        private ShrinkRegistryEntry(string ownerModId, string key, T value, bool isOverride, int priority)
+        {
+            OwnerModId = ownerModId;
+            Key = key;
+            Value = value;
+            IsOverride = isOverride;
+            Priority = priority;
+        }
+
+        internal static ShrinkRegistryEntry<T> CreateOverride(
+            string ownerModId, string key, int priority, T value) =>
+            new(ownerModId, key, value, true, priority);
+    }
+}

Runtime/Registry/ShrinkModRegistry.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7cb75a17a6ee08f479d0be1fe145307f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Registry/ShrinkModRegistryManager.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+
+namespace ShrinkModFramework
+{
+    public sealed class ShrinkModRegistryManager
+    {
+        private readonly Dictionary<string, object> _registries = new();
+
+        public IReadOnlyShrinkModRegistry<T> GetOrCreateRegistry<T>(string name) =>
+            GetOrCreateMutableRegistry<T>(name);
+
+        internal ShrinkModRegistry<T> GetOrCreateMutableRegistry<T>(string name)
+        {
+            var compositeKey = BuildCompositeKey(typeof(T), name);
+            if (_registries.TryGetValue(compositeKey, out var existing))
+                return (ShrinkModRegistry<T>)existing;
+
+            var registry = new ShrinkModRegistry<T>(name);
+            _registries.Add(compositeKey, registry);
+            return registry;
+        }
+
+        public bool TryGetRegistry<T>(string name, out IReadOnlyShrinkModRegistry<T> registry)
+        {
+            var compositeKey = BuildCompositeKey(typeof(T), name);
+            if (_registries.TryGetValue(compositeKey, out var existing))
+            {
+                registry = (ShrinkModRegistry<T>)existing;
+                return true;
+            }
+
+            registry = null;
+            return false;
+        }
+
+        internal void Clear() => _registries.Clear();
+
+        internal void RemoveOwnedEntries(string ownerModId)
+        {
+            foreach (var registry in _registries.Values)
+            {
+                if (registry is IShrinkOwnedRegistry ownedRegistry)
+                    ownedRegistry.RemoveOwnedEntries(ownerModId);
+            }
+        }
+
+        private static string BuildCompositeKey(Type type, string name)
+        {
+            if (string.IsNullOrWhiteSpace(name))
+                throw new ArgumentException("注册表名称不能为空。", nameof(name));
+
+            return $"{type.AssemblyQualifiedName}::{name.Trim()}";
+        }
+    }
+}

Runtime/Registry/ShrinkModRegistryManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: aa8f924fbddf4e544a8531969765b217
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: