@alpsckr/unitycli 0.4.2 → 0.4.4

package/unitypkg/Editor/Infrastructure/UnityCliSerializer.cs

@@ -7,6 +7,7 @@ using System.Linq;
 using System.Reflection;
 using System.Security.Cryptography;
 using System.Text;
+using System.Threading;
 
 namespace UnityCli
 {
@@ -33,6 +34,25 @@ namespace UnityCli
             return builder.ToString();
         }
 
+        /// <summary>在请求的取消、主线程与实际 UTF-8 ceiling 内增量构造最终 JSON。</summary>
+        public static string Serialize(object value, UnityCliRequestBudget budget, CancellationToken cancellationToken)
+        {
+            long ignored;
+            return Serialize(value, budget, cancellationToken, out ignored);
+        }
+
+        /// <summary>返回序列化结果及同一次增量写入得到的精确 UTF-8 字节数。</summary>
+        internal static string Serialize(object value, UnityCliRequestBudget budget, CancellationToken cancellationToken, out long utf8Bytes)
+        {
+            if (budget == null) throw new ArgumentNullException("budget");
+            budget.CheckpointOrThrow();
+            var writer = new BudgetedJsonWriter(budget, cancellationToken);
+            WriteBudgetedValue(writer, value, budget, cancellationToken);
+            budget.CheckpointOrThrow();
+            utf8Bytes = writer.Utf8Bytes;
+            return writer.ToString();
+        }
+
         private static void WriteValue(StringBuilder builder, object value)
         {
             if (value == null)
@@ -104,6 +124,206 @@ namespace UnityCli
             builder.Append('}');
         }
 
+        private const int MaximumProtocolMembers = 256;
+        private const int MaximumDictionaryEntries = 4096;
+        private const int MaximumMemberMetadataUtf8Bytes = 64 * 1024;
+        private const int MaximumCachedProtocolTypes = 128;
+        private static readonly object BudgetedMemberCacheLock = new object();
+        private static readonly Dictionary<Type, MemberInfo[]> BudgetedMemberCache = new Dictionary<Type, MemberInfo[]>();
+
+        /// <summary>请求态序列化逐项处理集合和成员，任何候选都先计入同一预算。</summary>
+        private static void WriteBudgetedValue(BudgetedJsonWriter writer, object value, UnityCliRequestBudget budget, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            budget.CheckpointOrThrow();
+            if (value == null) { writer.Append("null"); return; }
+
+            var type = value.GetType();
+            if (type == typeof(string) || type == typeof(char)) { WriteBudgetedString(writer, Convert.ToString(value, CultureInfo.InvariantCulture)); return; }
+            if (type == typeof(bool)) { writer.Append((bool)value ? "true" : "false"); return; }
+            if (type.IsEnum) { WriteBudgetedString(writer, Enum.GetName(type, value)); return; }
+            if (UnityCliSchemaDeriver.IsInteger(type)) { writer.Append(Convert.ToString(value, CultureInfo.InvariantCulture)); return; }
+            if (type == typeof(decimal)) { writer.Append(((decimal)value).ToString(CultureInfo.InvariantCulture)); return; }
+            if (type == typeof(double) || type == typeof(float))
+            {
+                var number = Convert.ToDouble(value, CultureInfo.InvariantCulture);
+                if (double.IsNaN(number) || double.IsInfinity(number)) throw new FormatException("JSON does not support non-finite numbers.");
+                writer.Append(number.ToString("R", CultureInfo.InvariantCulture));
+                return;
+            }
+
+            var dictionary = value as IDictionary;
+            if (dictionary != null)
+            {
+                var entries = new List<DictionaryEntry>();
+                foreach (DictionaryEntry entry in dictionary)
+                {
+                    if (!budget.TryConsumeScannedRecord() || entries.Count >= MaximumDictionaryEntries)
+                        throw new UnityCliRequestBudgetExceededException(entries.Count >= MaximumDictionaryEntries ? "dictionaryEntries" : budget.ExhaustedDimension);
+                    entries.Add(entry);
+                }
+                entries.Sort((left, right) => string.CompareOrdinal(Convert.ToString(left.Key, CultureInfo.InvariantCulture), Convert.ToString(right.Key, CultureInfo.InvariantCulture)));
+                writer.Append("{");
+                for (var index = 0; index < entries.Count; index++)
+                {
+                    if (index > 0) writer.Append(",");
+                    WriteBudgetedString(writer, Convert.ToString(entries[index].Key, CultureInfo.InvariantCulture));
+                    writer.Append(":");
+                    WriteBudgetedValue(writer, entries[index].Value, budget, cancellationToken);
+                }
+                writer.Append("}");
+                return;
+            }
+
+            var enumerable = value as IEnumerable;
+            if (enumerable != null)
+            {
+                writer.Append("[");
+                var first = true;
+                foreach (var item in enumerable)
+                {
+                    if (!budget.TryConsumeScannedRecord()) throw new UnityCliRequestBudgetExceededException(budget.ExhaustedDimension);
+                    if (!first) writer.Append(",");
+                    first = false;
+                    WriteBudgetedValue(writer, item, budget, cancellationToken);
+                }
+                writer.Append("]");
+                return;
+            }
+
+            writer.Append("{");
+            var firstMember = true;
+            foreach (var member in BudgetedSerializableMembers(type, budget))
+            {
+                if (!budget.TryConsumeScannedRecord() || !budget.TryConsumeReflectionCall() || !budget.TryConsumeGetter())
+                    throw new UnityCliRequestBudgetExceededException(budget.ExhaustedDimension);
+                var memberValue = UnityCliSchemaDeriver.GetMemberValue(member, value);
+                if (memberValue == null) continue;
+                if (!firstMember) writer.Append(",");
+                firstMember = false;
+                WriteBudgetedString(writer, ToCamelCase(member.Name));
+                writer.Append(":");
+                WriteBudgetedValue(writer, memberValue, budget, cancellationToken);
+            }
+            writer.Append("}");
+        }
+
+        /// <summary>缓存只活在当前 domain generation，且类型数、成员数与 metadata 字节均有硬上限。</summary>
+        private static IReadOnlyList<MemberInfo> BudgetedSerializableMembers(Type type, UnityCliRequestBudget budget)
+        {
+            lock (BudgetedMemberCacheLock)
+            {
+                MemberInfo[] cached;
+                if (BudgetedMemberCache.TryGetValue(type, out cached)) return cached;
+            }
+
+            var members = new Dictionary<string, MemberInfo>(StringComparer.Ordinal);
+            var metadataBytes = 0;
+            var depth = 0;
+            for (var current = type; current != null && current != typeof(object); current = current.BaseType)
+            {
+                if (++depth > 32) throw new UnityCliRequestBudgetExceededException("nodes");
+                foreach (var property in UnityCliReflectionSnapshot.DeclaredProperties(current, budget, MaximumProtocolMembers))
+                {
+                    if (!budget.TryConsumeReflectionCall() || !budget.TryConsumeScannedRecord())
+                        throw new UnityCliRequestBudgetExceededException(budget.ExhaustedDimension);
+                    CountMemberMetadata(property, ref metadataBytes);
+                    if (property.GetMethod == null || !property.GetMethod.IsPublic || property.GetIndexParameters().Length != 0) continue;
+                    AddBudgetedMember(members, property);
+                }
+                foreach (var field in UnityCliReflectionSnapshot.DeclaredFields(current, budget, MaximumProtocolMembers))
+                {
+                    if (!budget.TryConsumeReflectionCall() || !budget.TryConsumeScannedRecord())
+                        throw new UnityCliRequestBudgetExceededException(budget.ExhaustedDimension);
+                    CountMemberMetadata(field, ref metadataBytes);
+                    if (!field.IsPublic || field.IsStatic) continue;
+                    AddBudgetedMember(members, field);
+                }
+            }
+
+            var result = members.Values.OrderBy(member => ToCamelCase(member.Name), StringComparer.Ordinal).ToArray();
+            lock (BudgetedMemberCacheLock)
+            {
+                if (BudgetedMemberCache.Count >= MaximumCachedProtocolTypes) BudgetedMemberCache.Clear();
+                BudgetedMemberCache[type] = result;
+            }
+            return result;
+        }
+
+        private static void AddBudgetedMember(IDictionary<string, MemberInfo> members, MemberInfo member)
+        {
+            var name = ToCamelCase(member.Name);
+            if (!members.ContainsKey(name)) members.Add(name, member);
+            if (members.Count > MaximumProtocolMembers) throw new UnityCliRequestBudgetExceededException("nodes");
+        }
+
+        private static void CountMemberMetadata(MemberInfo member, ref int metadataBytes)
+        {
+            var declaring = member.DeclaringType == null ? string.Empty : member.DeclaringType.FullName;
+            metadataBytes += Encoding.UTF8.GetByteCount(member.Name ?? string.Empty) + Encoding.UTF8.GetByteCount(declaring ?? string.Empty);
+            if (metadataBytes > MaximumMemberMetadataUtf8Bytes) throw new UnityCliRequestBudgetExceededException("serializedUtf8Bytes");
+        }
+
+        private static void WriteBudgetedString(BudgetedJsonWriter writer, string value)
+        {
+            writer.Append("\"");
+            if (value != null)
+            {
+                var runStart = 0;
+                for (var index = 0; index < value.Length; index++)
+                {
+                    string escaped = null;
+                    switch (value[index])
+                    {
+                        case '"': escaped = "\\\""; break;
+                        case '\\': escaped = "\\\\"; break;
+                        case '\b': escaped = "\\b"; break;
+                        case '\f': escaped = "\\f"; break;
+                        case '\n': escaped = "\\n"; break;
+                        case '\r': escaped = "\\r"; break;
+                        case '\t': escaped = "\\t"; break;
+                        default:
+                            if (value[index] < 0x20) escaped = "\\u" + ((int)value[index]).ToString("x4", CultureInfo.InvariantCulture);
+                            break;
+                    }
+                    if (escaped == null) continue;
+                    if (index > runStart) writer.Append(value.Substring(runStart, index - runStart));
+                    writer.Append(escaped);
+                    runStart = index + 1;
+                }
+                if (runStart < value.Length) writer.Append(value.Substring(runStart));
+            }
+            writer.Append("\"");
+        }
+
+        private sealed class BudgetedJsonWriter
+        {
+            private readonly StringBuilder builder = new StringBuilder();
+            private readonly UnityCliRequestBudget budget;
+            private readonly CancellationToken cancellationToken;
+            private long utf8Bytes;
+
+            internal BudgetedJsonWriter(UnityCliRequestBudget budget, CancellationToken cancellationToken)
+            {
+                this.budget = budget;
+                this.cancellationToken = cancellationToken;
+            }
+
+            internal void Append(string value)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                budget.CheckpointOrThrow();
+                var next = checked(utf8Bytes + Encoding.UTF8.GetByteCount(value ?? string.Empty));
+                budget.ValidateSerializedUtf8Bytes(next);
+                builder.Append(value);
+                utf8Bytes = next;
+            }
+
+            internal long Utf8Bytes { get { return utf8Bytes; } }
+
+            public override string ToString() { return builder.ToString(); }
+        }
+
         // PascalCase → camelCase:仅首字母小写(对生成 DTO 的标准 PascalCase 足够)。
         private static string ToCamelCase(string name)
         {

package/unitypkg/Editor/Infrastructure/UnityCliSessionMutationLease.cs

@@ -35,44 +35,84 @@ namespace UnityCli
             {
                 recoveryBlocked = false;
                 if (!RecoverStaleOwner()) { recoveryBlocked = true; return; }
-                TryFinalizeOwnedPlayModeRoot();
-                Owner current;
-                byte[] ignored;
-                if (!TryReadOwnerSnapshot(out current, out ignored)) { recoveryBlocked = true; return; }
+                try
+                {
+                    var directOutcome = ReconcileAcceptedDirectMutationBeforeLeaseRestore(ProductionQueueState, null);
+                    if (directOutcome == DirectMutationReloadOutcome.IdentityBlocked)
+                    {
+                        recoveryBlocked = true;
+                        return;
+                    }
+                    TryFinalizeOwnedPlayModeRoot();
+                    if (!RestoreValidatedActiveRootLease(ProductionQueueState)) recoveryBlocked = true;
+                }
+                catch { recoveryBlocked = true; }
+            }
+
+            /// <summary>测试只通过隔离state执行与production相同的direct reconciliation→generic restore顺序。</summary>
+            internal static string InitializeRecoveryOrderForTests(BridgeQueueState state, bool cleanupPending = false)
+            {
+                if (state == null || state.IsolatedExecution == null)
+                    throw new ArgumentException("Lease recovery order tests require isolated state.", "state");
+                var directOutcome = ReconcileAcceptedDirectMutationBeforeLeaseRestore(state, (requestId, requestDigest) => cleanupPending);
+                return directOutcome == DirectMutationReloadOutcome.IdentityBlocked || !RestoreValidatedActiveRootLease(state)
+                    ? DirectMutationReloadOutcome.IdentityBlocked.ToString()
+                    : directOutcome.ToString();
+            }
 
-                // 仅交叉读取每个 coordinator 的固定 active 文件，不扫描任何请求目录。
-                // 铁律：active 文件属上次启动（editorSessionId 不符）时不恢复，机制状态重启作废。
+            /// <summary>accepted direct root必须先冻结effect-before终态；显式依赖默认使用production cleanup identity。</summary>
+            private static DirectMutationReloadOutcome ReconcileAcceptedDirectMutationBeforeLeaseRestore(BridgeQueueState state, Func<string, string, bool> cleanupPending)
+            {
+                var root = state.LoadOperation("direct-mutation");
+                if (root == null || !string.Equals(root.ContainsKey("phase") ? root["phase"] as string : null, "accepted_before_effect", StringComparison.Ordinal))
+                    return DirectMutationReloadOutcome.NotApplicable;
+                if (!string.Equals(root.ContainsKey("editorSessionId") ? root["editorSessionId"] as string : null, EditorSessionId(), StringComparison.Ordinal))
+                {
+                    state.ClearOperation("direct-mutation");
+                    return DirectMutationReloadOutcome.NotApplicable;
+                }
+                var requestId = root.ContainsKey("requestId") ? root["requestId"] as string : null;
+                var requestDigest = root.ContainsKey("requestDigest") ? root["requestDigest"] as string : null;
+                var releaseExactOwner = cleanupPending == null
+                    ? DirectMutationCleanupPendingForIdentity(requestId, requestDigest)
+                    : cleanupPending(requestId, requestDigest);
+                return ReconcileAcceptedDirectMutationAfterReload(state, requestId, requestDigest, releaseExactOwner);
+            }
+
+            /// <summary>固定scope恢复只接受当前session唯一root；direct reconciliation已经在本方法之前完成。</summary>
+            private static bool RestoreValidatedActiveRootLease(BridgeQueueState state)
+            {
+                string currentRequestId;
+                string currentRequestDigest;
+                if (!state.TryGetCurrentLeaseOwner(out currentRequestId, out currentRequestDigest)) return false;
                 Owner recoverable = null;
                 var currentSession = EditorSessionId();
                 foreach (var scope in new[] { "compile", "package-resolve", "refresh", "asset-refresh", "package-embed", "test-run", "build", "navmesh-bake", "occlusion-bake", "direct-mutation" })
                 {
-                    if (!UnityCliActiveOperation.Exists(scope)) continue;
-                    try
+                    if (!state.OperationExists(scope)) continue;
+                    Dictionary<string, object> root;
+                    try { root = state.LoadOperation(scope); }
+                    catch { return false; }
+                    object requestId;
+                    object requestDigest;
+                    object stateSession;
+                    if (root == null || !root.TryGetValue("requestId", out requestId) || !root.TryGetValue("requestDigest", out requestDigest)
+                        || !root.TryGetValue("editorSessionId", out stateSession)) return false;
+                    if (!string.Equals(stateSession as string, currentSession, StringComparison.Ordinal))
                     {
-                        var state = UnityCliActiveOperation.Load(scope);
-                        object requestId;
-                        object requestDigest;
-                        object stateSession;
-                        if (state == null || !state.TryGetValue("requestId", out requestId) || !state.TryGetValue("requestDigest", out requestDigest)
-                            || !state.TryGetValue("editorSessionId", out stateSession)) { recoveryBlocked = true; return; }
-                        if (!string.Equals(stateSession as string, currentSession, StringComparison.Ordinal)) { UnityCliActiveOperation.Clear(scope); continue; }
-                        var candidate = new Owner { RequestId = requestId as string, RequestDigest = requestDigest as string };
-                        if (!IsSafeId(candidate.RequestId) || !IsSha256(candidate.RequestDigest)) { recoveryBlocked = true; return; }
-                        if (recoverable != null) { recoveryBlocked = true; return; }
-                        recoverable = candidate;
+                        state.ClearOperation(scope);
+                        continue;
                     }
-                    catch { recoveryBlocked = true; return; }
-                }
-                if (recoverable == null) return;
-                if (current != null)
-                {
-                    if (!OwnsCurrentProcess(current)
-                        || !string.Equals(current.RequestId, recoverable.RequestId, StringComparison.Ordinal)
-                        || !string.Equals(current.RequestDigest, recoverable.RequestDigest, StringComparison.Ordinal)) recoveryBlocked = true;
-                    return;
+                    var candidate = new Owner { RequestId = requestId as string, RequestDigest = requestDigest as string };
+                    if (!IsSafeId(candidate.RequestId) || !IsSha256(candidate.RequestDigest) || recoverable != null) return false;
+                    recoverable = candidate;
                 }
+                if (recoverable == null) return true;
+                if (!string.IsNullOrEmpty(currentRequestId) || !string.IsNullOrEmpty(currentRequestDigest))
+                    return string.Equals(currentRequestId, recoverable.RequestId, StringComparison.Ordinal)
+                        && string.Equals(currentRequestDigest, recoverable.RequestDigest, StringComparison.Ordinal);
                 bool recoveredLease;
-                if (!TryAcquireCore(recoverable.RequestId, recoverable.RequestDigest, true, out recoveredLease)) recoveryBlocked = true;
+                return state.TryRecoverLease(recoverable.RequestId, recoverable.RequestDigest, out recoveredLease);
             }
 
             /// <summary>