@mflrevan/ucp 0.5.2 → 0.6.0

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

@@ -54,7 +54,7 @@ namespace UCP.Bridge
             }
             else
             {
-                SaveDirtyScenesIfRequested(saveDirtyScenes, discardUntitled);
+                EditorModalGuard.SaveOpenDirtyScenes(saveDirtyScenes, discardUntitled);
                 EditorSceneManager.OpenScene(path, additive ? OpenSceneMode.Additive : OpenSceneMode.Single);
             }
 
@@ -74,38 +74,6 @@ namespace UCP.Bridge
             return defaultValue;
         }
 
-        private static void SaveDirtyScenesIfRequested(bool saveDirtyScenes, bool discardUntitled)
-        {
-            if (!saveDirtyScenes)
-                return;
-
-            var requiresUntitledDiscard = false;
-
-            for (var index = 0; index < SceneManager.sceneCount; index++)
-            {
-                var scene = SceneManager.GetSceneAt(index);
-                if (!scene.isLoaded || !scene.isDirty)
-                    continue;
-
-                if (string.IsNullOrEmpty(scene.path))
-                {
-                    if (!discardUntitled)
-                        throw new System.InvalidOperationException("Dirty untitled scene cannot be auto-saved. Retry with discardUntitled=true.");
-
-                    requiresUntitledDiscard = true;
-                    continue;
-                }
-
-                if (!EditorSceneManager.SaveScene(scene))
-                    throw new System.InvalidOperationException($"Failed to auto-save dirty scene: {scene.path}");
-
-                SceneChangeTracker.ClearScene(scene);
-            }
-
-            if (requiresUntitledDiscard)
-                EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
-        }
-
         private static object HandleSaveActive(string paramsJson)
         {
             var scene = SceneManager.GetActiveScene();
@@ -302,7 +270,7 @@ namespace UCP.Bridge
 
         private static GameObject FindInHierarchy(GameObject gameObject, int instanceId)
         {
-            if (gameObject.GetInstanceID() == instanceId)
+            if (gameObject.GetId() == instanceId)
                 return gameObject;
 
             foreach (Transform child in gameObject.transform)

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

@@ -86,7 +86,7 @@ namespace UCP.Bridge
 
             var entry = new Dictionary<string, object>
             {
-                ["instanceId"] = go.GetInstanceID(),
+                ["instanceId"] = go.GetId(),
                 ["name"] = go.name,
                 ["active"] = go.activeSelf,
                 ["tag"] = go.tag,
@@ -230,7 +230,7 @@ namespace UCP.Bridge
         private static Dictionary<string, object> ProjectGameObject(GameObject go, HashSet<string> fields, int depth)
         {
             var entry = new Dictionary<string, object>();
-            AddField(entry, fields, "instanceId", go.GetInstanceID());
+            AddField(entry, fields, "instanceId", go.GetId());
             AddField(entry, fields, "name", go.name);
             AddField(entry, fields, "active", go.activeSelf);
             AddField(entry, fields, "activeInHierarchy", go.activeInHierarchy);
@@ -426,7 +426,7 @@ namespace UCP.Bridge
 
         private static GameObject FindInHierarchy(GameObject go, int instanceId)
         {
-            if (go.GetInstanceID() == instanceId)
+            if (go.GetId() == instanceId)
                 return go;
 
             for (int i = 0; i < go.transform.childCount; i++)
@@ -479,7 +479,7 @@ namespace UCP.Bridge
         {
             return new Dictionary<string, object>
             {
-                ["instanceId"] = go.GetInstanceID(),
+                ["instanceId"] = go.GetId(),
                 ["name"] = go.name,
                 ["active"] = go.activeSelf,
                 ["tag"] = go.tag,

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

@@ -0,0 +1,322 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace UCP.Bridge
+{
+    /// <summary>
+    /// Spatial reasoning primitives so an agent can answer geometric questions about a scene
+    /// instead of inferring them from raw transforms: raycast, overlap, world bounds, drop-to-
+    /// surface (ground), and nearest-object search.
+    ///
+    /// Physics queries hit colliders only — objects without a Collider are invisible to
+    /// raycast/overlap/ground. 'bounds' and 'nearest' fall back to renderer bounds and so also
+    /// see render-only objects.
+    /// </summary>
+    public static class SpatialController
+    {
+        public static void Register(CommandRouter router)
+        {
+            router.Register("physics/raycast", HandleRaycast);
+            router.Register("physics/overlap", HandleOverlap);
+            router.Register("object/bounds", HandleBounds);
+            router.Register("spatial/ground", HandleGround);
+            router.Register("spatial/nearest", HandleNearest);
+        }
+
+        private static object HandleRaycast(string paramsJson)
+        {
+            // Collider positions in the edit-mode physics scene can lag transform edits made via
+            // earlier RPCs; sync so queries see the current state.
+            Physics.SyncTransforms();
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var origin = RequireVec3(p, "origin");
+            var direction = RequireVec3(p, "direction");
+            if (direction.sqrMagnitude < 1e-8f)
+                throw new ArgumentException("'direction' must not be the zero vector");
+
+            var maxDistance = ReadFloat(p, "maxDistance", Mathf.Infinity);
+            var layerMask = ReadLayerMask(p);
+            var queryTriggers = ReadBool(p, "queryTriggers", false)
+                ? QueryTriggerInteraction.Collide
+                : QueryTriggerInteraction.Ignore;
+
+            if (Physics.Raycast(new Ray(origin, direction.normalized), out var hit, maxDistance, layerMask, queryTriggers))
+            {
+                return new Dictionary<string, object>
+                {
+                    ["status"] = "ok",
+                    ["hit"] = true,
+                    ["point"] = ObjectLocator.Vec3(hit.point),
+                    ["normal"] = ObjectLocator.Vec3(hit.normal),
+                    ["distance"] = hit.distance,
+                    ["instanceId"] = hit.collider.gameObject.GetId(),
+                    ["gameObject"] = hit.collider.gameObject.name,
+                    ["collider"] = hit.collider.GetType().Name
+                };
+            }
+
+            return new Dictionary<string, object> { ["status"] = "ok", ["hit"] = false };
+        }
+
+        private static object HandleOverlap(string paramsJson)
+        {
+            Physics.SyncTransforms();
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var shape = (ReadString(p, "shape") ?? "sphere").ToLowerInvariant();
+            var center = RequireVec3(p, "center");
+            var layerMask = ReadLayerMask(p);
+            var queryTriggers = ReadBool(p, "queryTriggers", false)
+                ? QueryTriggerInteraction.Collide
+                : QueryTriggerInteraction.Ignore;
+
+            Collider[] hits;
+            switch (shape)
+            {
+                case "sphere":
+                    hits = Physics.OverlapSphere(center, ReadFloat(p, "radius", 1f), layerMask, queryTriggers);
+                    break;
+                case "box":
+                    var half = ReadVec3Optional(p, "halfExtents") ?? Vector3.one * 0.5f;
+                    hits = Physics.OverlapBox(center, half, Quaternion.identity, layerMask, queryTriggers);
+                    break;
+                case "capsule":
+                    var end = ReadVec3Optional(p, "end") ?? center;
+                    hits = Physics.OverlapCapsule(center, end, ReadFloat(p, "radius", 1f), layerMask, queryTriggers);
+                    break;
+                default:
+                    throw new ArgumentException("'shape' must be 'sphere', 'box', or 'capsule'");
+            }
+
+            var list = new List<object>();
+            foreach (var c in hits)
+            {
+                if (c == null) continue;
+                list.Add(new Dictionary<string, object>
+                {
+                    ["instanceId"] = c.gameObject.GetId(),
+                    ["gameObject"] = c.gameObject.name,
+                    ["collider"] = c.GetType().Name,
+                    ["distance"] = Vector3.Distance(center, c.bounds.center)
+                });
+            }
+
+            return new Dictionary<string, object> { ["status"] = "ok", ["count"] = list.Count, ["hits"] = list };
+        }
+
+        private static object HandleBounds(string paramsJson)
+        {
+            // Collider bounds lag transform edits in edit mode; sync before reading them.
+            Physics.SyncTransforms();
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var go = ObjectLocator.Resolve(p);
+            var includeChildren = ReadBool(p, "includeChildren", true);
+
+            if (!ObjectLocator.TryComputeWorldBounds(go, includeChildren, out var bounds))
+            {
+                // No renderers/colliders: fall back to a zero-size box at the transform.
+                bounds = new Bounds(go.transform.position, Vector3.zero);
+                return new Dictionary<string, object>
+                {
+                    ["status"] = "ok",
+                    ["instanceId"] = go.GetId(),
+                    ["name"] = go.name,
+                    ["empty"] = true,
+                    ["center"] = ObjectLocator.Vec3(bounds.center),
+                    ["extents"] = ObjectLocator.Vec3(bounds.extents),
+                    ["size"] = ObjectLocator.Vec3(bounds.size),
+                    ["min"] = ObjectLocator.Vec3(bounds.min),
+                    ["max"] = ObjectLocator.Vec3(bounds.max)
+                };
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["instanceId"] = go.GetId(),
+                ["name"] = go.name,
+                ["empty"] = false,
+                ["center"] = ObjectLocator.Vec3(bounds.center),
+                ["extents"] = ObjectLocator.Vec3(bounds.extents),
+                ["size"] = ObjectLocator.Vec3(bounds.size),
+                ["min"] = ObjectLocator.Vec3(bounds.min),
+                ["max"] = ObjectLocator.Vec3(bounds.max)
+            };
+        }
+
+        private static object HandleGround(string paramsJson)
+        {
+            Physics.SyncTransforms();
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var direction = (ReadVec3Optional(p, "direction") ?? Vector3.down).normalized;
+            var maxDistance = ReadFloat(p, "maxDistance", 1000f);
+            var layerMask = ReadLayerMask(p);
+            var apply = ReadBool(p, "apply", true);
+
+            // Two modes: drop an object onto the surface, or just probe a point.
+            GameObject go = null;
+            Vector3 origin;
+            if (p != null && (p.ContainsKey("instanceId") || p.ContainsKey("id") || p.ContainsKey("path") || p.ContainsKey("name")))
+            {
+                go = ObjectLocator.Resolve(p);
+                origin = go.transform.position;
+            }
+            else
+            {
+                origin = RequireVec3(p, "point");
+            }
+
+            // Offset the ray start slightly against the cast direction so an object already
+            // resting on / overlapping the surface still registers a hit.
+            var start = origin - direction * 0.01f;
+            if (!Physics.Raycast(start, direction, out var hit, maxDistance, layerMask, QueryTriggerInteraction.Ignore))
+                return new Dictionary<string, object> { ["status"] = "ok", ["hit"] = false };
+
+            var result = new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["hit"] = true,
+                ["point"] = ObjectLocator.Vec3(hit.point),
+                ["normal"] = ObjectLocator.Vec3(hit.normal),
+                ["distance"] = hit.distance,
+                ["surface"] = hit.collider.gameObject.name,
+                ["surfaceId"] = hit.collider.gameObject.GetId()
+            };
+
+            if (go != null && apply)
+            {
+                // Rest the object's pivot on the surface, raised by the half-height of its
+                // bounds along the up axis so it sits on rather than through the surface.
+                var lift = 0f;
+                if (ObjectLocator.TryComputeWorldBounds(go, true, out var bounds))
+                {
+                    var pivotToBottom = go.transform.position.y - bounds.min.y;
+                    lift = Mathf.Max(pivotToBottom, 0f);
+                }
+                Undo.RecordObject(go.transform, "UCP Ground");
+                go.transform.position = hit.point + Vector3.up * lift;
+                EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
+                SceneChangeTracker.RecordGameObjectChange(go, "Transform");
+                result["movedId"] = go.GetId();
+                result["restPosition"] = ObjectLocator.Vec3(go.transform.position);
+            }
+
+            return result;
+        }
+
+        private static object HandleNearest(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+
+            Vector3 from;
+            GameObject self = null;
+            if (p != null && (p.ContainsKey("instanceId") || p.ContainsKey("id") || p.ContainsKey("path") || p.ContainsKey("name")))
+            {
+                self = ObjectLocator.Resolve(p);
+                from = self.transform.position;
+            }
+            else
+            {
+                from = RequireVec3(p, "point");
+            }
+
+            var max = (int)ReadFloat(p, "max", 5f);
+            var componentFilter = ReadString(p, "component");
+            var tagFilter = ReadString(p, "tag");
+
+            var candidates = new List<(GameObject go, float dist)>();
+            for (var i = 0; i < SceneManager.sceneCount; i++)
+            {
+                var scene = SceneManager.GetSceneAt(i);
+                if (!scene.isLoaded) continue;
+                foreach (var root in scene.GetRootGameObjects())
+                    CollectNearest(root, from, self, componentFilter, tagFilter, candidates);
+            }
+
+            candidates.Sort((a, b) => a.dist.CompareTo(b.dist));
+            var list = new List<object>();
+            for (var i = 0; i < candidates.Count && i < max; i++)
+            {
+                var (go, dist) = candidates[i];
+                list.Add(new Dictionary<string, object>
+                {
+                    ["instanceId"] = go.GetId(),
+                    ["name"] = go.name,
+                    ["distance"] = dist,
+                    ["position"] = ObjectLocator.Vec3(go.transform.position)
+                });
+            }
+
+            return new Dictionary<string, object> { ["status"] = "ok", ["count"] = list.Count, ["objects"] = list };
+        }
+
+        private static void CollectNearest(GameObject go, Vector3 from, GameObject self,
+            string componentFilter, string tagFilter, List<(GameObject, float)> outList)
+        {
+            var include = go != self;
+            if (include && !string.IsNullOrEmpty(componentFilter) && go.GetComponent(componentFilter) == null)
+                include = false;
+            if (include && !string.IsNullOrEmpty(tagFilter) && !go.CompareTag(tagFilter))
+                include = false;
+            if (include)
+                outList.Add((go, Vector3.Distance(from, go.transform.position)));
+
+            foreach (Transform child in go.transform)
+                CollectNearest(child.gameObject, from, self, componentFilter, tagFilter, outList);
+        }
+
+        // --- param helpers -------------------------------------------------
+
+        private static Vector3 RequireVec3(Dictionary<string, object> p, string key)
+        {
+            var v = ReadVec3Optional(p, key);
+            if (!v.HasValue) throw new ArgumentException($"Missing '{key}' ([x,y,z]) parameter");
+            return v.Value;
+        }
+
+        private static Vector3? ReadVec3Optional(Dictionary<string, object> p, string key)
+        {
+            if (p == null || !p.TryGetValue(key, out var v) || v == null) return null;
+            if (v is not List<object> list || list.Count < 3)
+                throw new ArgumentException($"'{key}' must be an array of three numbers");
+            return new Vector3(Convert.ToSingle(list[0]), Convert.ToSingle(list[1]), Convert.ToSingle(list[2]));
+        }
+
+        private static float ReadFloat(Dictionary<string, object> p, string key, float dflt)
+        {
+            if (p != null && p.TryGetValue(key, out var v) && v != null) return Convert.ToSingle(v);
+            return dflt;
+        }
+
+        private static bool ReadBool(Dictionary<string, object> p, string key, bool dflt)
+        {
+            if (p != null && p.TryGetValue(key, out var v) && v is bool b) return b;
+            return dflt;
+        }
+
+        private static string ReadString(Dictionary<string, object> p, string key)
+        {
+            if (p != null && p.TryGetValue(key, out var v) && v != null) return v.ToString();
+            return null;
+        }
+
+        private static int ReadLayerMask(Dictionary<string, object> p)
+        {
+            // Accept an explicit int mask, or a single layer name, else everything.
+            if (p != null && p.TryGetValue("layerMask", out var v) && v != null)
+            {
+                if (v is string s)
+                {
+                    var layer = LayerMask.NameToLayer(s);
+                    if (layer < 0) throw new ArgumentException($"Unknown layer name '{s}'");
+                    return 1 << layer;
+                }
+                return Convert.ToInt32(v);
+            }
+            return ~0;
+        }
+    }
+}

package/bridge/com.ucp.bridge/Editor/Controllers/SpatialController.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 2a3b4c5d6e7f8091a2b3c4d5e6f70819

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

@@ -0,0 +1,249 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace UCP.Bridge
+{
+    /// <summary>
+    /// First-class transform authoring: move / rotate / scale / look-at with world|local
+    /// space and absolute|relative semantics, plus a bulk transform read. Rotations are
+    /// expressed as Euler angles (degrees) on the wire — quaternions are an internal detail.
+    ///
+    /// Every mutation registers Undo, marks the scene dirty, and records a change digest,
+    /// matching the rest of the bridge. No modal APIs are touched.
+    /// </summary>
+    public static class TransformController
+    {
+        public static void Register(CommandRouter router)
+        {
+            router.Register("transform/move", HandleMove);
+            router.Register("transform/rotate", HandleRotate);
+            router.Register("transform/scale", HandleScale);
+            router.Register("transform/look-at", HandleLookAt);
+            router.Register("transform/get", HandleGet);
+        }
+
+        private static object HandleMove(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var go = ObjectLocator.Resolve(p);
+            var value = ReadVec3(p, "position", required: true).Value;
+            var space = ReadSpace(p);
+            var relative = ReadBool(p, "relative", false);
+
+            Undo.RecordObject(go.transform, "UCP Move");
+
+            if (space == Space.World)
+            {
+                go.transform.position = relative ? go.transform.position + value : value;
+            }
+            else
+            {
+                go.transform.localPosition = relative ? go.transform.localPosition + value : value;
+            }
+
+            return Commit(go, "Transform", ExtraTransform(go));
+        }
+
+        private static object HandleRotate(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var go = ObjectLocator.Resolve(p);
+            var euler = ReadVec3(p, "euler", required: true).Value;
+            var space = ReadSpace(p);
+            var relative = ReadBool(p, "relative", false);
+
+            Undo.RecordObject(go.transform, "UCP Rotate");
+
+            if (relative)
+            {
+                go.transform.Rotate(euler, space == Space.World ? Space.World : Space.Self);
+            }
+            else if (space == Space.World)
+            {
+                go.transform.eulerAngles = euler;
+            }
+            else
+            {
+                go.transform.localEulerAngles = euler;
+            }
+
+            return Commit(go, "Transform", ExtraTransform(go));
+        }
+
+        private static object HandleScale(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var go = ObjectLocator.Resolve(p);
+            var relative = ReadBool(p, "relative", false);
+
+            Vector3 scale;
+            if (p != null && p.TryGetValue("uniform", out var uniObj) && uniObj != null)
+            {
+                var u = Convert.ToSingle(uniObj);
+                scale = new Vector3(u, u, u);
+            }
+            else
+            {
+                scale = ReadVec3(p, "scale", required: true).Value;
+            }
+
+            Undo.RecordObject(go.transform, "UCP Scale");
+
+            if (relative)
+            {
+                var cur = go.transform.localScale;
+                go.transform.localScale = new Vector3(cur.x * scale.x, cur.y * scale.y, cur.z * scale.z);
+            }
+            else
+            {
+                go.transform.localScale = scale;
+            }
+
+            return Commit(go, "Transform", ExtraTransform(go));
+        }
+
+        private static object HandleLookAt(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var go = ObjectLocator.Resolve(p);
+
+            // Target is either an explicit world point or another object.
+            Vector3 targetPoint;
+            var explicitPoint = ReadVec3(p, "target", required: false);
+            if (explicitPoint.HasValue)
+            {
+                targetPoint = explicitPoint.Value;
+            }
+            else if (p != null && (p.ContainsKey("targetId") || p.ContainsKey("targetPath") || p.ContainsKey("targetName")))
+            {
+                var targetGo = ObjectLocator.Resolve(RemapTargetKeys(p));
+                targetPoint = targetGo.transform.position;
+            }
+            else
+            {
+                throw new ArgumentException("look-at requires 'target' ([x,y,z]) or 'targetId'/'targetPath'/'targetName'");
+            }
+
+            var up = ReadVec3(p, "up", required: false) ?? Vector3.up;
+
+            Undo.RecordObject(go.transform, "UCP LookAt");
+            go.transform.LookAt(targetPoint, up);
+
+            return Commit(go, "Transform", ExtraTransform(go));
+        }
+
+        private static object HandleGet(string paramsJson)
+        {
+            // Reported bounds read collider.bounds, which lag transform edits until synced.
+            Physics.SyncTransforms();
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+
+            // Bulk: 'ids' array → one entry per object, skipping unresolved ids.
+            if (p != null && p.TryGetValue("ids", out var idsObj) && idsObj is List<object> ids)
+            {
+                var list = new List<object>();
+                foreach (var idObj in ids)
+                {
+                    var go = ObjectLocator.FindByInstanceId(Convert.ToInt32(idObj));
+                    if (go == null) continue;
+                    list.Add(DescribeTransform(go));
+                }
+                return new Dictionary<string, object> { ["transforms"] = list, ["count"] = list.Count };
+            }
+
+            // Single target.
+            var single = ObjectLocator.Resolve(p);
+            return DescribeTransform(single);
+        }
+
+        private static Dictionary<string, object> DescribeTransform(GameObject go)
+        {
+            var t = go.transform;
+            var entry = new Dictionary<string, object>
+            {
+                ["instanceId"] = go.GetId(),
+                ["name"] = go.name,
+                ["position"] = ObjectLocator.Vec3(t.position),
+                ["localPosition"] = ObjectLocator.Vec3(t.localPosition),
+                ["eulerAngles"] = ObjectLocator.Vec3(t.eulerAngles),
+                ["localEulerAngles"] = ObjectLocator.Vec3(t.localEulerAngles),
+                ["localScale"] = ObjectLocator.Vec3(t.localScale),
+                ["lossyScale"] = ObjectLocator.Vec3(t.lossyScale)
+            };
+            if (ObjectLocator.TryComputeWorldBounds(go, true, out var bounds))
+            {
+                entry["boundsCenter"] = ObjectLocator.Vec3(bounds.center);
+                entry["boundsExtents"] = ObjectLocator.Vec3(bounds.extents);
+            }
+            return entry;
+        }
+
+        private static Dictionary<string, object> ExtraTransform(GameObject go)
+        {
+            var t = go.transform;
+            return new Dictionary<string, object>
+            {
+                ["instanceId"] = go.GetId(),
+                ["name"] = go.name,
+                ["position"] = ObjectLocator.Vec3(t.position),
+                ["localPosition"] = ObjectLocator.Vec3(t.localPosition),
+                ["eulerAngles"] = ObjectLocator.Vec3(t.eulerAngles),
+                ["localEulerAngles"] = ObjectLocator.Vec3(t.localEulerAngles),
+                ["localScale"] = ObjectLocator.Vec3(t.localScale)
+            };
+        }
+
+        private static object Commit(GameObject go, string label, Dictionary<string, object> extra)
+        {
+            EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
+            SceneChangeTracker.RecordGameObjectChange(go, label);
+            extra["status"] = "ok";
+            return extra;
+        }
+
+        // --- param helpers -------------------------------------------------
+
+        private static Vector3? ReadVec3(Dictionary<string, object> p, string key, bool required)
+        {
+            if (p == null || !p.TryGetValue(key, out var v) || v == null)
+            {
+                if (required) throw new ArgumentException($"Missing '{key}' ([x,y,z]) parameter");
+                return null;
+            }
+            if (v is not List<object> list || list.Count < 3)
+                throw new ArgumentException($"'{key}' must be an array of three numbers");
+            return new Vector3(Convert.ToSingle(list[0]), Convert.ToSingle(list[1]), Convert.ToSingle(list[2]));
+        }
+
+        private static Space ReadSpace(Dictionary<string, object> p)
+        {
+            if (p != null && p.TryGetValue("space", out var s) && s != null)
+            {
+                var str = s.ToString().ToLowerInvariant();
+                if (str == "local") return Space.Self;
+                if (str == "world") return Space.World;
+                throw new ArgumentException("'space' must be 'world' or 'local'");
+            }
+            return Space.World;
+        }
+
+        private static bool ReadBool(Dictionary<string, object> p, string key, bool dflt)
+        {
+            if (p != null && p.TryGetValue(key, out var v) && v is bool b) return b;
+            return dflt;
+        }
+
+        private static Dictionary<string, object> RemapTargetKeys(Dictionary<string, object> p)
+        {
+            var remapped = new Dictionary<string, object>();
+            if (p.TryGetValue("targetId", out var id)) remapped["instanceId"] = id;
+            if (p.TryGetValue("targetPath", out var path)) remapped["path"] = path;
+            if (p.TryGetValue("targetName", out var name)) remapped["name"] = name;
+            return remapped;
+        }
+    }
+}

package/bridge/com.ucp.bridge/Editor/Controllers/TransformController.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 1a2b3c4d5e6f708192a3b4c5d6e7f809