@mflrevan/ucp 0.6.1 → 0.6.3

package/README.md

@@ -1,6 +1,6 @@
 # @mflrevan/ucp
 
-Version `0.6.1` of the Unity Control Protocol CLI.
+Version `0.6.3` of the Unity Control Protocol CLI.
 
 This package installs the `ucp` command, downloads the matching published binary for your platform during `postinstall`, and ships the matching Unity bridge payload inside the npm package.
 

package/bridge/com.ucp.bridge/CHANGELOG.md

@@ -1,5 +1,115 @@
 # Changelog
 
+## [0.6.3] - 2026-09-07
+
+### Added
+
+- Every response produced on the main thread carries an `editor` summary next to `result` or
+  `error` (`EditorStateSummary`): mode, active scene dirtiness, Console badge counts read
+  through `LogEntries.GetCountsByType`, entries logged since the request was dispatched, and
+  conditional flags for compile errors, compiling, importing, building, prefab stage, and
+  recording. The handshake, which is answered off the main thread, reports
+  `mainThreadTickAgeMs` and `compiling` so a client can recognise a blocked main thread or a
+  pending domain reload before sending a request. Added `editor/state`
+  to fetch the summary on its own.
+- Added the `ui/list`, `ui/lint`, `ui/inspect`, `ui/screenshot`, `ui/check`, and `ui/status`
+  RPCs plus the `ui/result` completion notification for UI Toolkit authoring on Unity 6 and
+  newer. On older editors the methods are registered but return an explicit unsupported error.
+- Lint runs the synchronous UXML/USS/TSS importers, reads their import logs and
+  `importedWithErrors`/`importedWithWarnings` flags, follows UI dependencies, and clone-probes
+  each `VisualTreeAsset` under a scoped log capture. Immutable package assets are inspected from
+  their existing import artifacts without a forced reimport.
+- Render operations (`inspect`, `screenshot`, `check`) are queued and ticked on
+  `EditorApplication.update` in a transient `HideAndDontSave` utility window, wait for stable
+  finite geometry and stable pixels, capture through `InternalEditorUtility.CaptureEditorWindow`
+  with DPI compensation, write PNGs under `Library/UCP/UiCaptures`, and restore the previously
+  focused window. A 300-second overall ceiling and per-state settle timeouts bound every run;
+  `BridgeServer.Shutdown` fails in-flight operations with `editor_shutdown` before a reload.
+- Scenario support: strict `.ucp-ui.json` parsing with unknown-field rejection, deep data
+  overlays, an allowlisted `set` block, `repeat` and virtualized `list-view` collections driven
+  by JSON pointers, and automatic rewriting of `DataBinding` paths to dictionary keys through
+  `Unity.Properties`.
+
+### Changed
+
+- Object ids are 64-bit end to end. `UnityObjectCompat.GetId()` returns a `long`
+  (`EntityId.ToULong` on 6000.5+, the instance id below that), `ResolveByInstanceId` takes a
+  `long`, and every controller reads `instanceId` parameters with `Convert.ToInt64`. On
+  6000.5 an `EntityId` carries a per-session upper word, so the previous `int` truncation
+  produced ids that could not be resolved back.
+
+### Fixed
+
+- Fixed the `tests/run` console guard counting log lines emitted inside a test's
+  `LogAssert.ignoreFailingMessages` window; the `IgnoreFailingMessages:true/false` markers the
+  test runner writes now delimit an exclusion range.
+- Fixed the edit-mode test assembly failing to compile on Unity 6000.5 (`GetInstanceID()` is
+  obsolete-as-error there); tests use the `EntityId`-aware `GetId()` helper throughout.
+- Removed the empty `UCP.Bridge.Runtime` assembly definition that logged an "will not be
+  compiled, because it has no scripts associated with it" warning on every import (#4).
+
+## [0.6.2] - 2026-08-31
+
+### Added
+
+- Added native, scene-object-free `record/start`, `record/stop`, `record/status`, `record/arm`, and
+  `record/signal` RPCs for Game and Scene view video capture.
+- Added aspect-preserving longest-edge sizing and explicit width/height canvases with letterboxing,
+  even-dimension normalization, configurable FPS/bitrate/duration, H.264/MP4 and VP8/WebM encoding,
+  and platform-aware format selection.
+- Added play-enter, play-exit, bounded log-regex, and named-signal triggers. Armed play triggers use
+  `SessionState` to survive domain reloads, and `record/stop` also cancels a pending trigger.
+- Added a `slowdown` parameter to `record/start` and `record/arm`. Frames are still captured at the
+  requested cadence in real time; only the encoder's declared frame rate is divided by the factor, so
+  playback is stretched without duplicating frames or re-encoding. `record/status` reports both
+  `slowdown` and the resulting `playbackFps`. Values outside 1-20 are rejected. This raises effective
+  temporal resolution for consumers that sample a clip at a fixed low rate rather than playing it.
+- Documented that `record/start --view game` resolves `Camera.main`, not the Game view's composited
+  camera stack. Projects rendering through several enabled cameras record only the `MainCamera`-tagged
+  one, and camera depth does not change the selection; `--view scene` captures the Scene view camera,
+  which is unaffected by gameplay.
+
+### Fixed
+
+- Fixed `tests/run` counting an empty root suite as a passed test. When a filter matched nothing,
+  the run finished with a childless root whose result was collected as a leaf, so the summary
+  reported one passed test named after the project. Suite results are now skipped, so a run that
+  executed nothing reports a total of zero.
+- Changed `tests/run` filtering from `Filter.testNames` to `Filter.groupNames`. `testNames` requires
+  an exact fully-qualified match, which silently selected nothing for a class or method name;
+  `groupNames` is matched as a regular expression against each test's full name, so partial names
+  select what a caller expects and fully-qualified names still match.
+- Fixed `object/get-property` double-converting values that `SerializedPropertyToValue` had already
+  shaped for JSON. `GetPropertyValue` resolves a name through `SerializedObject.FindProperty` first
+  and returns a ready `List`/`Dictionary`; `ConvertToJson` then ran over that result, matched none
+  of its cases, and fell through to `value.ToString()`. A `Vector3` field came back as
+  ``"System.Collections.Generic.List`1[System.Object]"`` with
+  ``"type": "List`1"``. Every serialized Vector2/3/4, Quaternion, Color, Rect, Bounds and
+  object-reference field was affected, and float fields reported a `Double` type name.
+  `get-property` now takes its type name from the `SerializedProperty` so it agrees with
+  `get-fields`, converts only values read through the reflection fallback, and `ConvertToJson` is
+  idempotent for already-shaped `IList`/`IDictionary` values.
+
+### Performance
+
+- Frames render through a hidden reusable `RenderTexture` and reusable CPU readback texture into
+  Unity's native `MediaEncoder`; recording creates no scene objects or scripts and avoids per-frame
+  managed texture allocation.
+
+### Reliability
+
+- Added sibling `.partial` output and final rename, explicit overwrite handling, extension/format
+  validation, encoder and temporary-file cleanup on failure, detached safety deadlines, trigger wait
+  deadlines, dropped-frame accounting, and structured completed/failed status metadata.
+- Active encoders finalize during assembly reload or editor shutdown. Play-boundary capture is
+  handled by the persisted `play-enter`/`play-exit` arm flow rather than attempting to retain a
+  native encoder across a domain reload.
+
+### Tests
+
+- Added editor smoke tests for recording RPC registration and idle status, aspect-preserving even
+  dimensions, signal matching, and cancellation of armed recordings.
+
 ## [0.4.1] - 2026-03-21
 
 ### Added

package/bridge/com.ucp.bridge/Editor/Bridge/BridgeServer.cs

@@ -26,7 +26,7 @@ namespace UCP.Bridge
         private const int DefaultPort = 21342;
         private const int MaxPort = 21352;
         private const int MaxConnections = 4;
-        private const string ProtocolVersion = "0.6.1";
+        private const string ProtocolVersion = "0.6.3";
 
         private static TcpListener s_listener;
         private static CancellationTokenSource s_cts;
@@ -45,6 +45,14 @@ namespace UCP.Bridge
 
         // Main-thread action queue
         private static readonly ConcurrentQueue<Action> s_mainThreadQueue = new();
+        // UTC ticks of the last EditorApplication.update we saw. Written by the main thread,
+        // read by the socket thread in the handshake so a client can tell "the editor's main
+        // thread is stalled" (modal dialog, synchronous import, domain reload) apart from "busy".
+        private static long s_lastMainThreadTick;
+        // EditorApplication.isCompiling as of the last pump, so the off-thread handshake can warn
+        // a client that a domain reload is imminent instead of letting its request race it.
+        private static int s_compiling;
+        private static bool s_summaryFailureLogged;
 
         // Command router
         private static readonly CommandRouter s_router = new();
@@ -120,7 +128,9 @@ namespace UCP.Bridge
                     protocolVersion = ProtocolVersion,
                     unityVersion = s_unityVersion,
                     projectName = s_projectName,
-                    projectPath = s_projectPath
+                    projectPath = s_projectPath,
+                    mainThreadTickAgeMs = MainThreadTickAgeMs(),
+                    compiling = System.Threading.Volatile.Read(ref s_compiling) == 1
                 };
             });
 
@@ -142,6 +152,12 @@ namespace UCP.Bridge
             // Screenshots
             ScreenshotController.Register(s_router);
 
+            // Lightweight video recording
+            RecordingController.Register(s_router);
+
+            // UI Toolkit authoring, inspection, linting, and capture
+            UiController.Register(s_router);
+
             // Logs
             LogsController.Register(s_router);
 
@@ -432,16 +448,25 @@ namespace UCP.Bridge
             // Dispatch on main thread
             s_mainThreadQueue.Enqueue(() =>
             {
+                var logCursor = LogsController.GetLatestId();
                 var response = s_router.Dispatch(capturedMethod, capturedId, capturedParams);
-                SendResponse(capturedWs, response);
+                SendResponse(capturedWs, response, logCursor);
             });
         }
 
-        private static void SendResponse(WebSocket ws, JsonRpcResponse response)
+        /// <summary>Milliseconds since the main thread last pumped; -1 before the first pump.</summary>
+        internal static long MainThreadTickAgeMs()
+        {
+            var last = System.Threading.Volatile.Read(ref s_lastMainThreadTick);
+            if (last == 0) return -1;
+            return (DateTime.UtcNow.Ticks - last) / TimeSpan.TicksPerMillisecond;
+        }
+
+        private static void SendResponse(WebSocket ws, JsonRpcResponse response, long? logCursor = null)
         {
             try
             {
-                var json = MiniJson.Serialize(ResponseToDict(response));
+                var json = MiniJson.Serialize(ResponseToDict(response, logCursor));
                 var bytes = Encoding.UTF8.GetBytes(json);
                 _ = ws.SendAsync(new ArraySegment<byte>(bytes),
                     WebSocketMessageType.Text, true, CancellationToken.None);
@@ -509,6 +534,7 @@ namespace UCP.Bridge
 
         private static void OnLogMessage(string message, string stackTrace, LogType type)
         {
+            RecordingController.NotifyLog(message);
             // Don't forward our own log messages to avoid infinite recursion
             if (message.StartsWith("[UCP]")) return;
 
@@ -517,6 +543,8 @@ namespace UCP.Bridge
 
         private static void PumpMainThread()
         {
+            System.Threading.Volatile.Write(ref s_lastMainThreadTick, DateTime.UtcNow.Ticks);
+            System.Threading.Volatile.Write(ref s_compiling, EditorApplication.isCompiling ? 1 : 0);
             int processed = 0;
             while (s_mainThreadQueue.TryDequeue(out var action) && processed < 50)
             {
@@ -570,11 +598,16 @@ namespace UCP.Bridge
 
         private static void Shutdown()
         {
+#if UNITY_6000_0_OR_NEWER
+            UiOperationManager.Shutdown();
+#endif
             if (!s_running) return;
             s_running = false;
 
             Debug.Log("[UCP] Bridge server shutting down");
 
+            RecordingController.Shutdown();
+
             s_cts?.Cancel();
 
             // Stop listener first to release port immediately
@@ -602,7 +635,12 @@ namespace UCP.Bridge
             Application.logMessageReceivedThreaded -= OnLogMessage;
         }
 
-        private static Dictionary<string, object> ResponseToDict(JsonRpcResponse r)
+        /// <param name="logCursor">
+        /// Present for responses produced on the main thread: the log id captured before dispatch.
+        /// The editor-state summary is attached as a sibling of result/error, and only then --
+        /// the handshake is answered off-thread where none of the editor APIs may be touched.
+        /// </param>
+        internal static Dictionary<string, object> ResponseToDict(JsonRpcResponse r, long? logCursor = null)
         {
             var dict = new Dictionary<string, object>
             {
@@ -610,6 +648,23 @@ namespace UCP.Bridge
                 ["id"] = r.id
             };
 
+            if (logCursor.HasValue)
+            {
+                try
+                {
+                    dict["editor"] = EditorStateSummary.Capture(logCursor.Value);
+                }
+                catch (Exception ex)
+                {
+                    // Never let awareness break a response; note the failure once per domain.
+                    if (!s_summaryFailureLogged)
+                    {
+                        s_summaryFailureLogged = true;
+                        Debug.LogWarning($"[UCP] editor state summary unavailable: {ex.Message}");
+                    }
+                }
+            }
+
             if (r.error != null)
             {
                 dict["error"] = new Dictionary<string, object>

package/bridge/com.ucp.bridge/Editor/Bridge/EditorStateSummary.cs

@@ -0,0 +1,165 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace UCP.Bridge
+{
+    /// <summary>
+    /// The compact editor state that rides on every main-thread response, so an agent is told
+    /// whether the console is red, whether the editor is playing or compiling, and whether the
+    /// scene is dirty without spending a request on it.
+    ///
+    /// Budget: this runs once per response on the main thread, so it may only use O(1) editor
+    /// queries and cached reflection. It must never allocate more than a few small dictionaries,
+    /// never touch the asset database, and never throw -- a summary failure is swallowed by the
+    /// caller so it can never break a response.
+    /// </summary>
+    public static class EditorStateSummary
+    {
+        private delegate void GetCountsByType(ref int errors, ref int warnings, ref int logs);
+
+        private static GetCountsByType s_getCountsByType;
+        private static bool s_countsLookedUp;
+
+        /// <param name="logsSinceId">
+        /// The log history cursor captured before the request was dispatched; entries after it
+        /// were produced by this request and are reported as "new".
+        /// </param>
+        public static Dictionary<string, object> Capture(long logsSinceId)
+        {
+            var summary = new Dictionary<string, object>(8);
+
+            var playing = EditorApplication.isPlaying;
+            summary["mode"] = playing
+                ? (EditorApplication.isPaused ? "paused" : "play")
+                : "edit";
+            if (EditorApplication.isPlayingOrWillChangePlaymode != playing)
+                summary["modeChanging"] = true;
+            if (EditorApplication.isCompiling)
+                summary["compiling"] = true;
+            if (EditorApplication.isUpdating)
+                summary["importing"] = true;
+            if (EditorUtility.scriptCompilationFailed)
+                summary["compileErrors"] = true;
+            if (BuildPipeline.isBuildingPlayer)
+                summary["building"] = true;
+
+            summary["scene"] = DescribeScenes();
+
+            var stage = PrefabStageUtility.GetCurrentPrefabStage();
+            if (stage != null)
+                summary["prefabStage"] = stage.assetPath;
+
+            summary["console"] = DescribeConsole(logsSinceId);
+
+            var recording = RecordingController.StateForSummary();
+            if (recording != null)
+                summary["recording"] = recording;
+
+            return summary;
+        }
+
+        private static Dictionary<string, object> DescribeScenes()
+        {
+            var active = SceneManager.GetActiveScene();
+            var scene = new Dictionary<string, object>(4)
+            {
+                ["name"] = active.name,
+                ["dirty"] = active.isDirty
+            };
+            if (string.IsNullOrEmpty(active.path))
+                scene["untitled"] = true;
+
+            var count = SceneManager.sceneCount;
+            if (count > 1)
+            {
+                var otherDirty = 0;
+                for (var index = 0; index < count; index++)
+                {
+                    var candidate = SceneManager.GetSceneAt(index);
+                    if (candidate != active && candidate.isDirty)
+                        otherDirty++;
+                }
+                scene["loaded"] = count;
+                if (otherDirty > 0)
+                    scene["otherDirty"] = otherDirty;
+            }
+
+            return scene;
+        }
+
+        private static Dictionary<string, object> DescribeConsole(long logsSinceId)
+        {
+            var console = new Dictionary<string, object>(4);
+            if (TryReadConsoleCounts(out var errors, out var warnings))
+            {
+                console["errors"] = errors;
+                console["warnings"] = warnings;
+            }
+            else
+            {
+                // Reflection into UnityEditor.LogEntries failed on this editor build; fall back to
+                // the bridge's own history, which at least covers everything since the bridge loaded.
+                LogsController.CountLevels(0, out errors, out warnings);
+                console["errors"] = errors;
+                console["warnings"] = warnings;
+                console["source"] = "bridge";
+            }
+
+            LogsController.CountLevels(logsSinceId, out var newErrors, out var newWarnings);
+            if (newErrors > 0)
+                console["newErrors"] = newErrors;
+            if (newWarnings > 0)
+                console["newWarnings"] = newWarnings;
+            return console;
+        }
+
+        /// <summary>
+        /// The counts the Console window's toolbar badges show, read through the same internal
+        /// API the window uses. Cached after the first lookup; the call itself is native and cheap.
+        /// </summary>
+        internal static bool TryReadConsoleCounts(out int errors, out int warnings)
+        {
+            errors = 0;
+            warnings = 0;
+            if (!s_countsLookedUp)
+            {
+                s_countsLookedUp = true;
+                try
+                {
+                    var type = typeof(Editor).Assembly.GetType("UnityEditor.LogEntries");
+                    var method = type?.GetMethod(
+                        "GetCountsByType",
+                        BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
+                    if (method != null)
+                    {
+                        s_getCountsByType = (GetCountsByType)Delegate.CreateDelegate(
+                            typeof(GetCountsByType), method, false);
+                    }
+                }
+                catch
+                {
+                    s_getCountsByType = null;
+                }
+            }
+
+            if (s_getCountsByType == null)
+                return false;
+
+            try
+            {
+                var logs = 0;
+                s_getCountsByType(ref errors, ref warnings, ref logs);
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+    }
+}

package/bridge/com.ucp.bridge/Editor/Bridge/EditorStateSummary.cs.meta

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

package/bridge/com.ucp.bridge/Editor/Compatibility/UnityObjectCompat.cs

@@ -4,17 +4,30 @@ using UnityEngine.SceneManagement;
 
 namespace UCP.Bridge
 {
+    /// <summary>
+    /// Object identity across the Unity 6 line. Up to 6000.4 an object is identified by a 32-bit
+    /// instance id; from 6000.5 it is a 64-bit <c>EntityId</c> whose upper word is a session
+    /// stamp and whose lower word is the classic id, and neither sign- nor zero-extending the
+    /// lower word resolves the object again. The wire protocol therefore carries ids as 64-bit
+    /// integers everywhere. On older editors the values are the same numbers they always were.
+    /// </summary>
     internal static class UnityObjectCompat
     {
-        public static int GetId(this Object obj)
+        public static long GetId(this Object obj)
         {
 #if UNITY_6000_5_OR_NEWER
-            return unchecked((int)EntityId.ToULong(obj.GetEntityId()));
+            return unchecked((long)EntityId.ToULong(obj.GetEntityId()));
 #else
             return obj.GetInstanceID();
 #endif
         }
 
+        /// <summary>Reads an id parameter from a parsed JSON payload (int, long, or numeric string).</summary>
+        public static long ReadId(object value)
+        {
+            return System.Convert.ToInt64(value);
+        }
+
         public static long GetSceneHandle(Scene scene)
         {
 #if UNITY_6000_5_OR_NEWER
@@ -27,16 +40,20 @@ namespace UCP.Bridge
 #endif
         }
 
-        public static Object ResolveByInstanceId(int instanceId)
+        public static Object ResolveByInstanceId(long instanceId)
         {
 #if UNITY_6000_5_OR_NEWER
             return EditorUtility.EntityIdToObject(EntityId.FromULong(unchecked((ulong)instanceId)));
 #else
-            return EditorUtility.InstanceIDToObject(instanceId);
+            // 32-bit editors cannot have handed out anything wider; treat an out-of-range id as
+            // "no such object" rather than truncating it into a different object's id.
+            if (instanceId < int.MinValue || instanceId > int.MaxValue)
+                return null;
+            return EditorUtility.InstanceIDToObject((int)instanceId);
 #endif
         }
 
-        public static T ResolveByInstanceId<T>(int instanceId) where T : Object
+        public static T ResolveByInstanceId<T>(long instanceId) where T : Object
         {
             return ResolveByInstanceId(instanceId) as T;
         }

package/bridge/com.ucp.bridge/Editor/Controllers/EditorController.cs

@@ -7,6 +7,7 @@ namespace UCP.Bridge
         public static void Register(CommandRouter router)
         {
             router.Register("editor/status", HandleStatus);
+            router.Register("editor/state", _ => EditorStateSummary.Capture(LogsController.GetLatestId()));
             router.Register("editor/quit", HandleQuit);
         }
 

package/bridge/com.ucp.bridge/Editor/Controllers/HierarchyController.cs

@@ -44,7 +44,7 @@ namespace UCP.Bridge
             // Optional parent
             if (p != null && p.TryGetValue("parent", out var parentObj))
             {
-                int parentId = Convert.ToInt32(parentObj);
+                long parentId = Convert.ToInt64(parentObj);
                 var parent = FindGameObject(parentId);
                 go.transform.SetParent(parent.transform, false);
             }
@@ -84,7 +84,7 @@ namespace UCP.Bridge
             if (p == null || !p.TryGetValue("instanceId", out var idObj))
                 throw new ArgumentException("Missing 'instanceId' parameter");
 
-            int instanceId = Convert.ToInt32(idObj);
+            long instanceId = Convert.ToInt64(idObj);
             var go = FindGameObject(instanceId);
             string name = go.name;
             var scene = go.scene;
@@ -107,14 +107,14 @@ namespace UCP.Bridge
             if (p == null || !p.TryGetValue("instanceId", out var idObj))
                 throw new ArgumentException("Missing 'instanceId' parameter");
 
-            int instanceId = Convert.ToInt32(idObj);
+            long instanceId = Convert.ToInt64(idObj);
             var go = FindGameObject(instanceId);
 
             Undo.SetTransformParent(go.transform, null, "UCP Reparent");
 
             if (p.TryGetValue("parent", out var parentObj) && parentObj != null)
             {
-                int parentId = Convert.ToInt32(parentObj);
+                long parentId = Convert.ToInt64(parentObj);
                 var parent = FindGameObject(parentId);
                 Undo.SetTransformParent(go.transform, parent.transform, "UCP Reparent");
             }
@@ -163,7 +163,7 @@ namespace UCP.Bridge
             // Instantiate from existing scene object (clone)
             else if (p.TryGetValue("sourceId", out var srcObj))
             {
-                int srcId = Convert.ToInt32(srcObj);
+                long srcId = Convert.ToInt64(srcObj);
                 source = FindGameObject(srcId);
             }
             else
@@ -183,7 +183,7 @@ namespace UCP.Bridge
             // Optional parent
             if (p.TryGetValue("parent", out var parentObj) && parentObj != null)
             {
-                int parentId = Convert.ToInt32(parentObj);
+                long parentId = Convert.ToInt64(parentObj);
                 var parent = FindGameObject(parentId);
                 instance.transform.SetParent(parent.transform, false);
             }
@@ -222,7 +222,7 @@ namespace UCP.Bridge
             if (!p.TryGetValue("type", out var typeObj) || typeObj == null)
                 throw new ArgumentException("Missing 'type' parameter");
 
-            int instanceId = Convert.ToInt32(idObj);
+            long instanceId = Convert.ToInt64(idObj);
             var go = FindGameObject(instanceId);
             string typeName = typeObj.ToString();
 
@@ -252,7 +252,7 @@ namespace UCP.Bridge
             if (!p.TryGetValue("type", out var typeObj) || typeObj == null)
                 throw new ArgumentException("Missing 'type' parameter");
 
-            int instanceId = Convert.ToInt32(idObj);
+            long instanceId = Convert.ToInt64(idObj);
             var go = FindGameObject(instanceId);
             string typeName = typeObj.ToString();
 
@@ -344,7 +344,7 @@ namespace UCP.Bridge
             return null;
         }
 
-        private static GameObject FindGameObject(int instanceId)
+        private static GameObject FindGameObject(long instanceId)
         {
             var obj = UnityObjectCompat.ResolveByInstanceId<GameObject>(instanceId);
             if (obj != null) return obj;
@@ -363,7 +363,7 @@ namespace UCP.Bridge
             throw new ArgumentException($"GameObject not found: {instanceId}");
         }
 
-        private static GameObject FindInHierarchy(GameObject go, int instanceId)
+        private static GameObject FindInHierarchy(GameObject go, long instanceId)
         {
             if (go.GetId() == instanceId) return go;
             for (int i = 0; i < go.transform.childCount; i++)