@mflrevan/ucp 0.5.0 → 0.5.2

package/README.md

@@ -1,6 +1,6 @@
 # @mflrevan/ucp
 
-Version `0.5.0` of the Unity Control Protocol CLI.
+Version `0.5.2` 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/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.5.0";
+        private const string ProtocolVersion = "0.5.2";
 
         private static TcpListener s_listener;
         private static CancellationTokenSource s_cts;
@@ -72,11 +72,12 @@ namespace UCP.Bridge
             try
             {
                 RegisterHandlers();
+                LogsController.SeedHistoryFromConsole();
 
                 EditorApplication.update += PumpMainThread;
                 EditorApplication.quitting += Shutdown;
                 AssemblyReloadEvents.beforeAssemblyReload += Shutdown;
-                Application.logMessageReceived += OnLogMessage;
+                Application.logMessageReceivedThreaded += OnLogMessage;
 
                 s_token = Guid.NewGuid().ToString("N").Substring(0, 16);
                 StartServer();
@@ -165,6 +166,9 @@ namespace UCP.Bridge
 
             // Reference search (bridge fallback)
             ReferenceController.Register(s_router);
+
+            // Shader diagnostics
+            ShaderController.Register(s_router);
         }
 
         private static void StartServer()
@@ -555,7 +559,7 @@ namespace UCP.Bridge
             CleanLockFile();
 
             EditorApplication.update -= PumpMainThread;
-            Application.logMessageReceived -= OnLogMessage;
+            Application.logMessageReceivedThreaded -= OnLogMessage;
         }
 
         private static Dictionary<string, object> ResponseToDict(JsonRpcResponse r)

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

@@ -2,8 +2,10 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
+using System.Text.RegularExpressions;
 using UnityEditor;
 using UnityEngine;
+using UnityEngine.Rendering;
 
 namespace UCP.Bridge
 {
@@ -13,6 +15,7 @@ namespace UCP.Bridge
         {
             router.Register("asset/search", HandleSearch);
             router.Register("asset/info", HandleInfo);
+            router.Register("asset/inspect", HandleInspect);
             router.Register("asset/read", HandleReadScriptableObject);
             router.Register("asset/write", HandleWriteScriptableObject);
             router.Register("asset/write-batch", HandleWriteScriptableObjectBatch);
@@ -28,6 +31,7 @@ namespace UCP.Bridge
             string typeFilter = null;
             string nameFilter = null;
             string pathFilter = null;
+            bool useRegex = false;
             int maxResults = 100;
 
             if (p != null)
@@ -38,13 +42,28 @@ namespace UCP.Bridge
                     nameFilter = nObj.ToString();
                 if (p.TryGetValue("path", out var pObj) && pObj != null)
                     pathFilter = pObj.ToString();
+                if (p.TryGetValue("regex", out var regexObj) && regexObj != null)
+                    useRegex = Convert.ToBoolean(regexObj);
                 if (p.TryGetValue("maxResults", out var mObj))
                     maxResults = Convert.ToInt32(mObj);
             }
 
+            Regex nameRegex = null;
+            if (useRegex && !string.IsNullOrEmpty(nameFilter))
+            {
+                try
+                {
+                    nameRegex = new Regex(nameFilter, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
+                }
+                catch (ArgumentException ex)
+                {
+                    throw new ArgumentException($"Invalid regex for name filter: {ex.Message}");
+                }
+            }
+
             // Build search filter
             string filter = "";
-            if (!string.IsNullOrEmpty(nameFilter))
+            if (!useRegex && !string.IsNullOrEmpty(nameFilter))
                 filter += nameFilter + " ";
             if (!string.IsNullOrEmpty(typeFilter))
                 filter += $"t:{GetSearchTypeFilter(typeFilter)}";
@@ -64,7 +83,7 @@ namespace UCP.Bridge
             for (int i = 0; i < guids.Length; i++)
             {
                 string assetPath = AssetDatabase.GUIDToAssetPath(guids[i]);
-                foreach (var asset in GetMatchingAssets(assetPath, typeFilter, nameFilter))
+                foreach (var asset in GetMatchingAssets(assetPath, typeFilter, nameFilter, nameRegex))
                 {
                     totalMatches++;
                     if (results.Count >= maxResults)
@@ -135,6 +154,47 @@ namespace UCP.Bridge
             return info;
         }
 
+        private static object HandleInspect(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("path", out var pathObj))
+                throw new ArgumentException("Missing 'path' parameter");
+
+            string assetPath = pathObj.ToString();
+            int maxFields = 80;
+            if (p.TryGetValue("maxFields", out var maxObj) && maxObj != null)
+                maxFields = Math.Max(1, Convert.ToInt32(maxObj));
+
+            var asset = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(assetPath);
+            if (asset == null)
+                throw new ArgumentException($"Asset not found: {assetPath}");
+
+            var result = HandleInfo(paramsJson) as Dictionary<string, object>;
+            result["inspectedAtUtc"] = DateTime.UtcNow.ToString("o");
+
+            var importer = AssetImporter.GetAtPath(assetPath);
+            if (importer != null)
+                result["importer"] = InspectSerializedObject(importer, maxFields);
+
+            if (asset is Material material)
+            {
+                result["shader"] = material.shader != null ? material.shader.name : string.Empty;
+                result["shaderPath"] = material.shader != null ? AssetDatabase.GetAssetPath(material.shader) : string.Empty;
+                result["keywords"] = InspectMaterialKeywords(material);
+                result["properties"] = InspectMaterialProperties(material, maxFields);
+            }
+            else if (asset is GameObject gameObject)
+            {
+                result["renderers"] = InspectPrefabRenderers(gameObject);
+            }
+            else
+            {
+                result["fields"] = InspectSerializedObject(asset, maxFields);
+            }
+
+            return result;
+        }
+
         private static object HandleReadScriptableObject(string paramsJson)
         {
             var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
@@ -194,6 +254,133 @@ namespace UCP.Bridge
             };
         }
 
+        private static List<object> InspectSerializedObject(UnityEngine.Object target, int maxFields)
+        {
+            var serializedObject = new SerializedObject(target);
+            var fields = new List<object>();
+            try
+            {
+                var iterator = serializedObject.GetIterator();
+                if (iterator.NextVisible(true))
+                {
+                    do
+                    {
+                        if (iterator.name == "m_Script") continue;
+                        fields.Add(SerializedPropertyControllerSupport.Describe(iterator));
+                    }
+                    while (fields.Count < maxFields && iterator.NextVisible(false));
+                }
+            }
+            finally
+            {
+                serializedObject.Dispose();
+            }
+
+            return fields;
+        }
+
+        private static List<object> InspectMaterialKeywords(Material material)
+        {
+            var keywords = new List<object>();
+            foreach (var keyword in material.enabledKeywords)
+                keywords.Add(keyword.name);
+            return keywords;
+        }
+
+        private static List<object> InspectMaterialProperties(Material material, int maxFields)
+        {
+            var properties = new List<object>();
+            var shader = material.shader;
+            if (shader == null)
+                return properties;
+
+            var count = Math.Min(shader.GetPropertyCount(), maxFields);
+            for (int i = 0; i < count; i++)
+            {
+                var name = shader.GetPropertyName(i);
+                var type = shader.GetPropertyType(i);
+                properties.Add(new Dictionary<string, object>
+                {
+                    ["name"] = name,
+                    ["description"] = shader.GetPropertyDescription(i),
+                    ["type"] = type.ToString(),
+                    ["value"] = ReadMaterialValue(material, name, type)
+                });
+            }
+
+            return properties;
+        }
+
+        private static object ReadMaterialValue(Material material, string name, ShaderPropertyType type)
+        {
+            switch (type)
+            {
+                case ShaderPropertyType.Color:
+                    var color = material.GetColor(name);
+                    return new List<object> { color.r, color.g, color.b, color.a };
+                case ShaderPropertyType.Vector:
+                    var vector = material.GetVector(name);
+                    return new List<object> { vector.x, vector.y, vector.z, vector.w };
+                case ShaderPropertyType.Float:
+                case ShaderPropertyType.Range:
+                    return material.GetFloat(name);
+                case ShaderPropertyType.Texture:
+                    var texture = material.GetTexture(name);
+                    return texture != null
+                        ? new Dictionary<string, object>
+                        {
+                            ["name"] = texture.name,
+                            ["path"] = AssetDatabase.GetAssetPath(texture),
+                            ["type"] = texture.GetType().Name
+                        }
+                        : null;
+                default:
+                    return null;
+            }
+        }
+
+        private static List<object> InspectPrefabRenderers(GameObject gameObject)
+        {
+            var renderers = new List<object>();
+            foreach (var renderer in gameObject.GetComponentsInChildren<Renderer>(true))
+            {
+                var materials = new List<object>();
+                foreach (var material in renderer.sharedMaterials)
+                {
+                    materials.Add(material != null
+                        ? new Dictionary<string, object>
+                        {
+                            ["name"] = material.name,
+                            ["path"] = AssetDatabase.GetAssetPath(material),
+                            ["shader"] = material.shader != null ? material.shader.name : string.Empty
+                        }
+                        : null);
+                }
+
+                renderers.Add(new Dictionary<string, object>
+                {
+                    ["path"] = GetTransformPath(renderer.transform),
+                    ["type"] = renderer.GetType().Name,
+                    ["enabled"] = renderer.enabled,
+                    ["materials"] = materials
+                });
+            }
+
+            return renderers;
+        }
+
+        private static string GetTransformPath(Transform transform)
+        {
+            var names = new List<string>();
+            var current = transform;
+            while (current != null)
+            {
+                names.Insert(0, current.name);
+                current = current.parent;
+            }
+            return string.Join("/", names);
+        }
+
         private static object HandleWriteScriptableObject(string paramsJson)
         {
             var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
@@ -354,6 +541,7 @@ namespace UCP.Bridge
                 throw new ArgumentException("Missing 'moves' parameter");
 
             var continueOnError = TryGetOptionalBool(parameters, "continueOnError");
+            var dryRun = TryGetOptionalBool(parameters, "dryRun");
             var requests = ParseMoveRequests(movesObject);
             var results = new List<object>();
             var errors = new List<object>();
@@ -361,15 +549,14 @@ namespace UCP.Bridge
             var stopped = false;
             var anyChanged = false;
 
-            AssetDatabase.StartAssetEditing();
-            try
+            if (dryRun)
             {
                 for (var index = 0; index < requests.Count; index++)
                 {
                     var request = requests[index];
                     try
                     {
-                        var moveResult = MoveAssetInternal(request.SourcePath, request.Destination, false);
+                        var moveResult = PreviewMoveInternal(request.SourcePath, request.Destination);
                         results.Add(AddMoveIndex(moveResult, index));
                         if (GetBool(moveResult, "changed"))
                         {
@@ -395,12 +582,75 @@ namespace UCP.Bridge
                     }
                 }
             }
-            finally
+            else
             {
-                AssetDatabase.StopAssetEditing();
+                var preparedMoves = new List<PreparedMove>();
+                for (var index = 0; index < requests.Count; index++)
+                {
+                    var request = requests[index];
+                    try
+                    {
+                        var preparedMove = PrepareMove(request.SourcePath, request.Destination, true);
+                        preparedMoves.Add(new PreparedMove(index, request.SourcePath, preparedMove));
+                    }
+                    catch (Exception ex)
+                    {
+                        errors.Add(new Dictionary<string, object>
+                        {
+                            ["index"] = index,
+                            ["sourcePath"] = request.SourcePath,
+                            ["destinationPath"] = request.Destination,
+                            ["message"] = ex.Message
+                        });
+
+                        if (!continueOnError)
+                        {
+                            stopped = true;
+                            break;
+                        }
+                    }
+                }
+
+                AssetDatabase.StartAssetEditing();
+                try
+                {
+                    foreach (var preparedMove in preparedMoves)
+                    {
+                        try
+                        {
+                            var moveResult = MovePreparedAsset(preparedMove.SourcePath, preparedMove.Move, false);
+                            results.Add(AddMoveIndex(moveResult, preparedMove.Index));
+                            if (GetBool(moveResult, "changed"))
+                            {
+                                movedCount++;
+                                anyChanged = true;
+                            }
+                        }
+                        catch (Exception ex)
+                        {
+                            errors.Add(new Dictionary<string, object>
+                            {
+                                ["index"] = preparedMove.Index,
+                                ["sourcePath"] = preparedMove.SourcePath,
+                                ["destinationPath"] = preparedMove.Move.ResolvedDestination,
+                                ["message"] = ex.Message
+                            });
+
+                            if (!continueOnError)
+                            {
+                                stopped = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+                finally
+                {
+                    AssetDatabase.StopAssetEditing();
+                }
             }
 
-            if (anyChanged)
+            if (!dryRun && anyChanged)
             {
                 AssetDatabase.SaveAssets();
                 AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
@@ -412,6 +662,7 @@ namespace UCP.Bridge
                 ["requested"] = requests.Count,
                 ["moved"] = movedCount,
                 ["failed"] = errors.Count,
+                ["dryRun"] = dryRun,
                 ["stopped"] = stopped,
                 ["results"] = results,
                 ["errors"] = errors
@@ -431,10 +682,19 @@ namespace UCP.Bridge
             }
         }
 
-        private static IEnumerable<UnityEngine.Object> GetMatchingAssets(string assetPath, string typeFilter, string nameFilter)
+        private static IEnumerable<UnityEngine.Object> GetMatchingAssets(
+            string assetPath,
+            string typeFilter,
+            string nameFilter,
+            Regex nameRegex)
         {
             UnityEngine.Object[] candidates;
-            if (string.IsNullOrEmpty(typeFilter) && string.IsNullOrEmpty(nameFilter))
+            if (string.IsNullOrEmpty(typeFilter) && string.IsNullOrEmpty(nameFilter) && nameRegex == null)
+            {
+                var mainAsset = AssetDatabase.LoadMainAssetAtPath(assetPath);
+                candidates = mainAsset != null ? new[] { mainAsset } : Array.Empty<UnityEngine.Object>();
+            }
+            else if (assetPath.EndsWith(".unity", StringComparison.OrdinalIgnoreCase))
             {
                 var mainAsset = AssetDatabase.LoadMainAssetAtPath(assetPath);
                 candidates = mainAsset != null ? new[] { mainAsset } : Array.Empty<UnityEngine.Object>();
@@ -447,17 +707,24 @@ namespace UCP.Bridge
             foreach (var candidate in candidates)
             {
                 if (candidate == null) continue;
-                if (!MatchesName(candidate, assetPath, nameFilter)) continue;
+                if (!MatchesName(candidate, assetPath, nameFilter, nameRegex)) continue;
                 if (!MatchesType(candidate, assetPath, typeFilter)) continue;
                 yield return candidate;
             }
         }
 
-        private static bool MatchesName(UnityEngine.Object asset, string assetPath, string nameFilter)
+        private static bool MatchesName(UnityEngine.Object asset, string assetPath, string nameFilter, Regex nameRegex)
         {
-            if (string.IsNullOrEmpty(nameFilter))
+            if (string.IsNullOrEmpty(nameFilter) && nameRegex == null)
                 return true;
 
+            if (nameRegex != null)
+            {
+                var fileStem = System.IO.Path.GetFileNameWithoutExtension(assetPath);
+                return nameRegex.IsMatch(asset.name)
+                    || (!string.IsNullOrEmpty(fileStem) && nameRegex.IsMatch(fileStem));
+            }
+
             return asset.name.Contains(nameFilter, StringComparison.OrdinalIgnoreCase)
                 || System.IO.Path.GetFileNameWithoutExtension(assetPath).Contains(nameFilter, StringComparison.OrdinalIgnoreCase);
         }
@@ -507,30 +774,29 @@ namespace UCP.Bridge
 
         private static Dictionary<string, object> MoveAssetInternal(string sourcePath, string destination, bool finalize)
         {
-            var normalizedSource = NormalizeMovePath(sourcePath);
-            var isFolder = AssetDatabase.IsValidFolder(normalizedSource);
-            if (!isFolder && !AssetDatabase.AssetPathExists(normalizedSource))
-                throw new ArgumentException($"Asset not found: {normalizedSource}");
-
-            if (!IsMovableAssetPath(normalizedSource))
-                throw new ArgumentException($"Asset moves are only supported under Assets/: {normalizedSource}");
-
-            var identity = DescribeExistingAsset(normalizedSource, isFolder);
-            var resolvedDestination = ResolveDestinationPath(normalizedSource, destination);
-            if (!IsMovableAssetPath(resolvedDestination))
-                throw new ArgumentException($"Destination must be under Assets/: {resolvedDestination}");
-
-            if (string.Equals(normalizedSource, resolvedDestination, StringComparison.OrdinalIgnoreCase))
-            {
-                return DescribeMovedAsset(normalizedSource, resolvedDestination, false, identity);
-            }
+            var move = PrepareMove(sourcePath, destination, true);
+            return MovePreparedAsset(NormalizeMovePath(sourcePath), move, finalize);
+        }
 
-            if (AssetDatabase.AssetPathExists(resolvedDestination) || AssetDatabase.IsValidFolder(resolvedDestination))
-                throw new ArgumentException($"Destination already exists: {resolvedDestination}");
+        private static Dictionary<string, object> PreviewMoveInternal(string sourcePath, string destination)
+        {
+            var normalizedSource = NormalizeMovePath(sourcePath);
+            var move = PrepareMove(normalizedSource, destination, false);
+            return DescribeMovedAsset(normalizedSource, move.ResolvedDestination, move.Changed, move.Identity);
+        }
 
-            EnsureParentFoldersExist(resolvedDestination);
+        private static ValidatedMove PrepareMove(string sourcePath, string destination, bool ensureParentFolders)
+        {
+            var normalizedSource = NormalizeMovePath(sourcePath);
+            var move = ValidateMoveRequest(normalizedSource, destination);
+            if (ensureParentFolders)
+                EnsureParentFoldersExist(move.ResolvedDestination);
+            return move;
+        }
 
-            var moveError = AssetDatabase.MoveAsset(normalizedSource, resolvedDestination);
+        private static Dictionary<string, object> MovePreparedAsset(string normalizedSource, ValidatedMove move, bool finalize)
+        {
+            var moveError = AssetDatabase.MoveAsset(normalizedSource, move.ResolvedDestination);
             if (!string.IsNullOrEmpty(moveError))
                 throw new InvalidOperationException(moveError);
 
@@ -540,7 +806,7 @@ namespace UCP.Bridge
                 AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
             }
 
-            return DescribeMovedAsset(normalizedSource, resolvedDestination, true, identity);
+            return DescribeMovedAsset(normalizedSource, move.ResolvedDestination, true, move.Identity);
         }
 
         private static Dictionary<string, object> DescribeMovedAsset(
@@ -648,6 +914,29 @@ namespace UCP.Bridge
             return path?.Trim().Replace('\\', '/');
         }
 
+        private static ValidatedMove ValidateMoveRequest(string normalizedSource, string destination)
+        {
+            var isFolder = AssetDatabase.IsValidFolder(normalizedSource);
+            if (!isFolder && !AssetDatabase.AssetPathExists(normalizedSource))
+                throw new ArgumentException(BuildAssetNotFoundMessage(normalizedSource));
+
+            if (!IsMovableAssetPath(normalizedSource))
+                throw new ArgumentException($"Asset moves are only supported under Assets/: {normalizedSource}");
+
+            var identity = DescribeExistingAsset(normalizedSource, isFolder);
+            var resolvedDestination = ResolveDestinationPath(normalizedSource, destination);
+            if (!IsMovableAssetPath(resolvedDestination))
+                throw new ArgumentException($"Destination must be under Assets/: {resolvedDestination}");
+
+            if (string.Equals(normalizedSource, resolvedDestination, StringComparison.OrdinalIgnoreCase))
+                return new ValidatedMove(identity, resolvedDestination, false);
+
+            if (AssetDatabase.AssetPathExists(resolvedDestination) || AssetDatabase.IsValidFolder(resolvedDestination))
+                throw new ArgumentException($"Destination already exists: {resolvedDestination}");
+
+            return new ValidatedMove(identity, resolvedDestination, true);
+        }
+
         private static bool IsMovableAssetPath(string path)
         {
             return !string.IsNullOrEmpty(path)
@@ -655,6 +944,60 @@ namespace UCP.Bridge
                     || path.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase));
         }
 
+        private static string BuildAssetNotFoundMessage(string normalizedSource)
+        {
+            var message = $"Asset not found: {normalizedSource}.";
+            var suggestions = FindSimilarAssetPaths(normalizedSource, 3);
+            if (suggestions.Count > 0)
+                message += " Did you mean: " + string.Join(", ", suggestions) + "?";
+            message += " If the asset was created or renamed outside Unity, refresh or reimport so AssetDatabase can pick up the latest path.";
+            return message;
+        }
+
+        private static List<string> FindSimilarAssetPaths(string normalizedSource, int maxSuggestions)
+        {
+            var targetName = Path.GetFileNameWithoutExtension(normalizedSource) ?? normalizedSource;
+            var targetFileName = Path.GetFileName(normalizedSource) ?? normalizedSource;
+            var targetExtension = Path.GetExtension(normalizedSource) ?? string.Empty;
+            var matches = new List<(string path, int score)>();
+
+            foreach (var candidate in AssetDatabase.GetAllAssetPaths())
+            {
+                if (!candidate.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase))
+                    continue;
+
+                var score = 0;
+                if (candidate.IndexOf(targetName, StringComparison.OrdinalIgnoreCase) >= 0)
+                    score += 3;
+                if (string.Equals(Path.GetFileName(candidate), targetFileName, StringComparison.OrdinalIgnoreCase))
+                    score += 4;
+                if (string.Equals(Path.GetExtension(candidate), targetExtension, StringComparison.OrdinalIgnoreCase))
+                    score += 1;
+                if (score > 0)
+                    matches.Add((candidate, score));
+            }
+
+            matches.Sort((left, right) =>
+            {
+                var scoreCompare = right.score.CompareTo(left.score);
+                return scoreCompare != 0
+                    ? scoreCompare
+                    : string.Compare(left.path, right.path, StringComparison.OrdinalIgnoreCase);
+            });
+
+            var suggestions = new List<string>();
+            foreach (var match in matches)
+            {
+                if (suggestions.Contains(match.path))
+                    continue;
+                suggestions.Add(match.path);
+                if (suggestions.Count >= maxSuggestions)
+                    break;
+            }
+
+            return suggestions;
+        }
+
         private static Dictionary<string, object> ParseParameters(string paramsJson)
         {
             return MiniJson.Deserialize(paramsJson) as Dictionary<string, object>
@@ -750,6 +1093,20 @@ namespace UCP.Bridge
             public string Destination { get; }
         }
 
+        private readonly struct PreparedMove
+        {
+            public PreparedMove(int index, string sourcePath, ValidatedMove move)
+            {
+                Index = index;
+                SourcePath = sourcePath;
+                Move = move;
+            }
+
+            public int Index { get; }
+            public string SourcePath { get; }
+            public ValidatedMove Move { get; }
+        }
+
         private readonly struct AssetIdentity
         {
             public AssetIdentity(string guid, string name, string type, bool isFolder)
@@ -766,5 +1123,19 @@ namespace UCP.Bridge
             public bool IsFolder { get; }
         }
 
+        private readonly struct ValidatedMove
+        {
+            public ValidatedMove(AssetIdentity identity, string resolvedDestination, bool changed)
+            {
+                Identity = identity;
+                ResolvedDestination = resolvedDestination;
+                Changed = changed;
+            }
+
+            public AssetIdentity Identity { get; }
+            public string ResolvedDestination { get; }
+            public bool Changed { get; }
+        }
+
     }
 }