feat(project-system): recover malformed element files without ever rewriting them

src/Beutl.AgentToolkit/Reconciliation/Reconciler.cs

@@ -681,21 +681,16 @@ private static CoreObject CloneCurrentRoot(IEditingSession session, JsonObject c
     private static HashSet<Guid> CollectFallbackIds(CoreObject root)
     {
         var ids = new HashSet<Guid>();
-        if (root is IHierarchical hierarchical)
+        var visited = new HashSet<object>(ReferenceEqualityComparer.Instance);
+        TraverseSerializedGraph(root, "$", visited, (node, _) =>
         {
-            foreach (IFallback fallback in hierarchical.EnumerateAllChildren<IFallback>())
+            if (node is IFallback)
             {
-                if (fallback is CoreObject coreObject)
-                {
-                    ids.Add(coreObject.Id);
-                }
+                ids.Add(node.Id);
             }
-        }
 
-        if (root is IFallback rootFallback)
-        {
-            ids.Add(((CoreObject)rootFallback).Id);
-        }
+            return false;
+        });
 
         return ids;
     }
@@ -705,112 +700,135 @@ private static HashSet<Guid> CollectFallbackIds(CoreObject root)
         string path,
         HashSet<Guid> existingFallbackIds)
     {
-        var visited = new HashSet<Guid>();
-        return FindFirstNewFallbackCore(root, path, existingFallbackIds, visited);
+        FallbackOccurrence? result = null;
+        var visited = new HashSet<object>(ReferenceEqualityComparer.Instance);
+        TraverseSerializedGraph(root, path, visited, (node, nodePath) =>
+        {
+            if (node is not IFallback fallback || existingFallbackIds.Contains(node.Id))
+            {
+                return false;
+            }
+
+            fallback.TryGetTypeName(out string? fallbackTypeName);
+            result = new FallbackOccurrence(
+                nodePath,
+                node.Id,
+                fallbackTypeName,
+                fallback.Reason.ToString(),
+                fallback.ErrorMessage);
+            return true;
+        });
+        return result;
     }
 
-    private static FallbackOccurrence? FindFirstNewFallbackCore(
-        CoreObject node,
+    private static bool TraverseSerializedGraph(
+        object? value,
         string path,
-        HashSet<Guid> existingFallbackIds,
-        HashSet<Guid> visited)
+        HashSet<object> visited,
+        Func<CoreObject, string, bool> visitCoreObject)
     {
-        if (!visited.Add(node.Id))
+        if (value is null or string)
         {
-            return null;
+            return false;
         }
 
-        if (node is IFallback fallback && !existingFallbackIds.Contains(node.Id))
+        if (!value.GetType().IsValueType && !visited.Add(value))
         {
-            fallback.TryGetTypeName(out string? fallbackTypeName);
-            return new FallbackOccurrence(
-                path,
-                node.Id,
-                fallbackTypeName,
-                fallback.Reason.ToString(),
-                fallback.ErrorMessage);
+            return false;
         }
 
-        switch (node)
+        if (value is CoreObject coreObject)
         {
-            case Scene scene:
-                for (int i = 0; i < scene.Children.Count; i++)
-                {
-                    if (FindFirstNewFallbackCore(
-                            scene.Children[i],
-                            $"{path}/Elements[{i}]",
-                            existingFallbackIds,
-                            visited) is { } occurrence)
-                    {
-                        return occurrence;
-                    }
-                }
-                break;
+            if (visitCoreObject(coreObject, path))
+            {
+                return true;
+            }
 
-            case Element element:
-                for (int i = 0; i < element.Objects.Count; i++)
-                {
-                    if (FindFirstNewFallbackCore(
-                            element.Objects[i],
-                            $"{path}/Objects[{i}]",
-                            existingFallbackIds,
-                            visited) is { } occurrence)
+            switch (coreObject)
+            {
+                case Scene scene:
+                    for (int i = 0; i < scene.Children.Count; i++)
                     {
-                        return occurrence;
+                        if (TraverseSerializedGraph(
+                                scene.Children[i],
+                                $"{path}/Elements[{i}]",
+                                visited,
+                                visitCoreObject))
+                        {
+                            return true;
+                        }
                     }
-                }
-                break;
+                    break;
 
-            case EngineObject engineObject:
-                foreach (IProperty property in engineObject.Properties)
-                {
-                    if (FindFirstNewFallbackInValue(
-                            property.CurrentValue,
-                            $"{path}/{property.Name}",
-                            existingFallbackIds,
-                            visited) is { } occurrence)
+                case Element element:
+                    for (int i = 0; i < element.Objects.Count; i++)
                     {
-                        return occurrence;
+                        if (TraverseSerializedGraph(
+                                element.Objects[i],
+                                $"{path}/Objects[{i}]",
+                                visited,
+                                visitCoreObject))
+                        {
+                            return true;
+                        }
                     }
-                }
-                break;
-        }
-
-        return null;
-    }
+                    break;
 
-    private static FallbackOccurrence? FindFirstNewFallbackInValue(
-        object? value,
-        string path,
-        HashSet<Guid> existingFallbackIds,
-        HashSet<Guid> visited)
-    {
-        switch (value)
-        {
-            case CoreObject coreObject:
-                return FindFirstNewFallbackCore(coreObject, path, existingFallbackIds, visited);
-            case IEnumerable enumerable when value is not string:
-                {
-                    int index = 0;
-                    foreach (object? item in enumerable)
+                case EngineObject engineObject:
+                    foreach (IProperty property in engineObject.Properties)
                     {
-                        if (FindFirstNewFallbackInValue(
-                                item,
-                                $"{path}[{index}]",
-                                existingFallbackIds,
-                                visited) is { } occurrence)
+                        if (TraverseSerializedGraph(
+                                property.CurrentValue,
+                                $"{path}/{property.Name}",
+                                visited,
+                                visitCoreObject))
                         {
-                            return occurrence;
+                            return true;
                         }
 
-                        index++;
+                        if (property.Animation is IKeyFrameAnimation animation)
+                        {
+                            int index = 0;
+                            foreach (IKeyFrame keyFrame in animation.KeyFrames)
+                            {
+                                if (TraverseSerializedGraph(
+                                        keyFrame.Value,
+                                        $"{path}/Animations/{property.Name}/KeyFrames[{index}]/Value",
+                                        visited,
+                                        visitCoreObject))
+                                {
+                                    return true;
+                                }
+
+                                index++;
+                            }
+                        }
                     }
-
                     break;
+            }
+
+            return false;
+        }
+
+        if (value is IEnumerable enumerable)
+        {
+            int index = 0;
+            foreach (object? item in enumerable)
+            {
+                if (TraverseSerializedGraph(
+                        item,
+                        $"{path}[{index}]",
+                        visited,
+                        visitCoreObject))
+                {
+                    return true;
                 }
+
+                index++;
+            }
         }
 
-        return null;
+        return false;
     }
 
     private static string CreateFallbackHint(FallbackOccurrence occurrence)

src/Beutl.AgentToolkit/Sessions/FileEditingSession.cs

@@ -153,10 +153,36 @@ private void SetProjectPathCore(string projectPath)
                 Path.Combine(projectDirectory, projectName),
                 sceneName,
                 usedDirs);
+            string? previousSceneDirectory = scene.Uri is { IsFile: true } previousSceneUri
+                ? Path.GetDirectoryName(previousSceneUri.LocalPath)
+                : null;
             scene.Uri = new Uri(scenePath);
+            string sceneDirectory = Path.GetDirectoryName(scenePath)!;
             foreach (Element element in scene.Children)
             {
-                element.Uri = null;
+                // Keep each sidecar's relative path across Save As: a recovered element's stable
+                // fallback identity is derived from its scene-relative path, so a regenerated
+                // path would change the element's Id when the copy is reopened.
+                if (element.Uri is { IsFile: true } previousUri)
+                {
+                    string relativePath = previousSceneDirectory != null
+                        ? Path.GetRelativePath(previousSceneDirectory, previousUri.LocalPath)
+                        : Path.GetFileName(previousUri.LocalPath);
+                    string sceneRoot = Path.TrimEndingDirectorySeparator(Path.GetFullPath(sceneDirectory));
+                    string resolvedPath = Path.GetFullPath(Path.Combine(sceneRoot, relativePath));
+                    if (!resolvedPath.StartsWith(
+                            sceneRoot + Path.DirectorySeparatorChar,
+                            PathComparison.ForCurrentPlatform))
+                    {
+                        resolvedPath = Path.Combine(sceneRoot, Path.GetFileName(previousUri.LocalPath));
+                    }
+
+                    element.Uri = new Uri(resolvedPath);
+                }
+                else
+                {
+                    element.Uri = null;
+                }
             }
 
             index++;

src/Beutl.AgentToolkit/Tools/SessionTools.cs

@@ -1,12 +1,16 @@
-using System.ComponentModel;
+using System.Collections;
+using System.ComponentModel;
 using System.Globalization;
 using Beutl.AgentToolkit.Common;
 using Beutl.AgentToolkit.Reconciliation;
 using Beutl.AgentToolkit.Rendering;
 using Beutl.AgentToolkit.Sessions;
 using Beutl.AgentToolkit.Workspace;
+using Beutl.Animation;
 using Beutl.Editor;
+using Beutl.Engine;
 using Beutl.ProjectSystem;
+using Beutl.Serialization;
 using ModelContextProtocol.Server;
 
 namespace Beutl.AgentToolkit.Tools;
@@ -15,7 +19,10 @@ public sealed record SceneSummary(string SceneId, string Name, int Width, int He
 
 public sealed record SessionSummary(IReadOnlyList<SceneSummary> Scenes);
 
-public sealed record OpenProjectResponse(string Session, string Source, SessionSummary Summary);
+public sealed record OpenProjectResponse(string Session, string Source, SessionSummary Summary)
+{
+    public IReadOnlyList<string> Warnings { get; init; } = [];
+}
 
 public sealed record CreateProjectResponse(string Session, string SavedPath, SessionSummary Summary);
 
@@ -71,10 +78,87 @@ public ValueTask<ToolResult<OpenProjectResponse>> OpenProject(string path, Cance
             return new OpenProjectResponse(
                 result.Session.SessionId,
                 result.Session.Source.ToString(),
-                CreateSummary(result.Session, result.Project));
+                CreateSummary(result.Session, result.Project))
+            {
+                // The traversal walks the live graph, so it must run on the session thread — a live
+                // editor may mutate the collections concurrently.
+                Warnings = result.Session.ReadOnSession(() => CollectDeserializationWarnings(result.Project))
+            };
         });
     }
 
+    private static IReadOnlyList<string> CollectDeserializationWarnings(Project project)
+    {
+        var warnings = new List<string>();
+        foreach (Scene scene in project.Items.OfType<Scene>())
+        {
+            foreach (Element element in scene.Children)
+            {
+                var fallbacks = new List<IFallback>();
+                var visited = new HashSet<object>(ReferenceEqualityComparer.Instance);
+                foreach (EngineObject obj in element.Objects)
+                {
+                    CollectFallbacks(obj, visited, fallbacks);
+                }
+
+                string elementFile = element.Uri is { IsFile: true } uri
+                    && scene.Uri is { IsFile: true } sceneUri
+                    ? Path.GetRelativePath(
+                        Path.GetDirectoryName(sceneUri.LocalPath)!,
+                        uri.LocalPath).Replace('\\', '/')
+                    : element.Name;
+                foreach (IFallback fallback in fallbacks)
+                {
+                    string error = string.IsNullOrWhiteSpace(fallback.ErrorMessage)
+                        ? fallback.Reason.ToString()
+                        : fallback.ErrorMessage;
+                    warnings.Add(
+                        $"Element file '{elementFile}' contains content that could not be deserialized: {error}");
+                }
+            }
+        }
+
+        return warnings;
+    }
+
+    private static void CollectFallbacks(
+        object? value,
+        ISet<object> visited,
+        ICollection<IFallback> fallbacks)
+    {
+        if (value is null or string || !visited.Add(value))
+            return;
+
+        if (value is IFallback fallback)
+        {
+            fallbacks.Add(fallback);
+            return;
+        }
+
+        if (value is EngineObject engineObject)
+        {
+            foreach (IProperty property in engineObject.Properties)
+            {
+                CollectFallbacks(property.CurrentValue, visited, fallbacks);
+                if (property.Animation is IKeyFrameAnimation animation)
+                {
+                    foreach (IKeyFrame keyFrame in animation.KeyFrames)
+                    {
+                        CollectFallbacks(keyFrame.Value, visited, fallbacks);
+                    }
+                }
+            }
+        }
+
+        if (value is IEnumerable enumerable)
+        {
+            foreach (object? item in enumerable)
+            {
+                CollectFallbacks(item, visited, fallbacks);
+            }
+        }
+    }
+
     [McpServerTool(Name = "create_project")]
     [Description("Creates and saves a new Beutl .bep project with one scene, then makes it the active editing session. In the in-app host the project opens in the Beutl editor (single open project, LiveEditor session); in the stdio host it becomes a file-backed session. Paths without an extension are saved as .bep; .beutl is reserved for project packages. The output path is restricted to BEUTL_WORKSPACE.")]
     public ValueTask<ToolResult<CreateProjectResponse>> CreateProject(