perf: trusted-edit path skips strategy parse on editor edits

- Editors expose GetModel() so the aggregate can take their parsed
  state directly. ClipViewModel.HandleEditorContentChanged routes
  through Clip.FromEditor which wraps the model in ParseSuccess
  without running the strategy or the round-trip diff. Per-keystroke
  cost on a 1000-step script drops from ~500ms-2.5s of XML work to
  the editor's own re-render.
- FmScript.ToElement / FmTable.ToElement skip the parse-and-prettify
  round-trip strategies were doing on the diff path.
- ClipDataExtensions routes through the registry instead of calling
  FmScript.FromXml / FmTable.FromXml directly so plugin-side parsing
  shares the host's dispatch.
- ClipTypeRegistry collapses to an immutable static array. No
  Register, RegisterBuiltIns, Reset, no _initialized flag, no test
  isolation collection — clip strategies are fully owned by SharpFM
  and known at compile time.

Author: fuzzzerd

src/SharpFM.Model/Clip.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading;
@@ -113,6 +114,38 @@ public static Clip FromWireBytes(string name, string formatId, byte[] bytes)
         return FromXml(name, formatId, xml);
     }
 
+    /// <summary>
+    /// Construct a clip from a model the editor already holds. Skips the
+    /// strategy parse + round-trip diff entirely — the editor's domain model
+    /// is the source of truth, the XML it emits is lossless to that model
+    /// by definition. Only kind-specific diagnostics that aren't structural
+    /// (e.g. <see cref="ParseDiagnosticKind.UnknownStep"/> for <c>RawStep</c>)
+    /// are derived from the model directly.
+    /// </summary>
+    /// <remarks>
+    /// This is the typing hot path for large scripts. Going through
+    /// <see cref="FromXml"/> on every debounced edit re-parses the XML
+    /// (~ N steps) plus serialises and structurally diffs (~ N more) on
+    /// the UI thread. <c>FromEditor</c> drops all of that.
+    /// </remarks>
+    public static Clip FromEditor(string name, string formatId, string xml, ClipModel model)
+    {
+        var report = ReportForEditorModel(model);
+        return new Clip(name, formatId, xml, new ParseSuccess(model, report));
+    }
+
+    private static ClipParseReport ReportForEditorModel(ClipModel model)
+    {
+        if (model is ScriptClipModel script)
+        {
+            var diagnostics = ClipStrategyHelpers.RawStepDiagnostics(script.Script).ToList();
+            return diagnostics.Count == 0
+                ? ClipParseReport.Empty
+                : new ClipParseReport(diagnostics);
+        }
+        return ClipParseReport.Empty;
+    }
+
     /// <summary>
     /// Return a fresh clip with replacement XML. The parse runs lazily on
     /// the new instance. Returns <c>this</c> when <paramref name="newXml"/>

src/SharpFM.Model/ClipDataExtensions.cs

@@ -1,12 +1,16 @@
 using System.Collections.Generic;
+using SharpFM.Model.ClipTypes;
+using SharpFM.Model.Parsing;
 using SharpFM.Model.Schema;
 using SharpFM.Model.Scripting;
 
 namespace SharpFM.Model;
 
 /// <summary>
 /// Convenience extensions on <see cref="ClipData"/> for parsing into the
-/// appropriate domain model based on the clip's format.
+/// appropriate domain model based on the clip's format. Typed accessors
+/// dispatch through <see cref="ClipTypeRegistry"/> so adding a new format
+/// with a registered strategy automatically lights up the helpers.
 /// </summary>
 public static class ClipDataExtensions
 {
@@ -16,27 +20,23 @@ public static bool IsScript(this ClipData clip) =>
     public static bool IsTable(this ClipData clip) =>
         clip.ClipType is "Mac-XMTB" or "Mac-XMFD";
 
-    /// <summary>
-    /// Parse this clip as a script. Returns null if the clip is not a script type.
-    /// </summary>
+    /// <summary>Parse this clip as a script; null if the clip is not a script type.</summary>
     public static FmScript? AsScript(this ClipData clip) =>
-        clip.IsScript() ? FmScript.FromXml(clip.Xml) : null;
+        ClipTypeRegistry.For(clip.ClipType).Parse(clip.Xml) is ParseSuccess { Model: ScriptClipModel s }
+            ? s.Script
+            : null;
 
-    /// <summary>
-    /// Parse this clip as a table. Returns null if the clip is not a table type.
-    /// </summary>
+    /// <summary>Parse this clip as a table; null if the clip is not a table type.</summary>
     public static FmTable? AsTable(this ClipData clip) =>
-        clip.IsTable() ? FmTable.FromXml(clip.Xml) : null;
+        ClipTypeRegistry.For(clip.ClipType).Parse(clip.Xml) is ParseSuccess { Model: TableClipModel t }
+            ? t.Table
+            : null;
 
-    /// <summary>
-    /// Get the script's steps as a snapshot list. Returns null if the clip is not a script type.
-    /// </summary>
+    /// <summary>Get the script's steps as a snapshot list; null if the clip is not a script type.</summary>
     public static IReadOnlyList<ScriptStep>? GetScriptSteps(this ClipData clip) =>
         clip.AsScript()?.Steps;
 
-    /// <summary>
-    /// Get the table's fields as a snapshot list. Returns null if the clip is not a table type.
-    /// </summary>
+    /// <summary>Get the table's fields as a snapshot list; null if the clip is not a table type.</summary>
     public static IReadOnlyList<FmField>? GetTableFields(this ClipData clip) =>
         clip.AsTable()?.Fields;
 }

src/SharpFM.Model/ClipTypes/ClipStrategyHelpers.cs

@@ -1,6 +1,9 @@
+using System.Collections.Generic;
 using System.Xml;
 using System.Xml.Linq;
 using SharpFM.Model.Parsing;
+using SharpFM.Model.Scripting;
+using SharpFM.Model.Scripting.Steps;
 
 namespace SharpFM.Model.ClipTypes;
 
@@ -59,4 +62,27 @@ public static bool TryParseFmxmlsnippet(string xml, out XElement root, out Parse
 
         return true;
     }
+
+    /// <summary>
+    /// Walk a script's steps and emit one Info-severity <see cref="ParseDiagnosticKind.UnknownStep"/>
+    /// diagnostic per <see cref="RawStep"/>. Used by both the script strategy
+    /// (after a fresh parse) and the trusted-edit path (after a model-only
+    /// reuse) so the same UI signal surfaces regardless of source.
+    /// </summary>
+    public static IEnumerable<ClipParseDiagnostic> RawStepDiagnostics(FmScript script)
+    {
+        var index = 0;
+        foreach (var step in script.Steps)
+        {
+            index++;
+            if (step is RawStep raw)
+            {
+                yield return new ClipParseDiagnostic(
+                    ParseDiagnosticKind.UnknownStep,
+                    ParseDiagnosticSeverity.Info,
+                    $"/fmxmlsnippet/Step[{index}]",
+                    $"step '{raw.Name}' is not modeled by the host; preserved verbatim as RawStep");
+            }
+        }
+    }
 }

src/SharpFM.Model/ClipTypes/ClipTypeRegistry.cs

@@ -4,87 +4,41 @@
 namespace SharpFM.Model.ClipTypes;
 
 /// <summary>
-/// Static, explicitly-populated registry of <see cref="IClipTypeStrategy"/>
-/// implementations keyed by <c>Mac-XM*</c> format id. Built-in strategies are
-/// registered once at startup via <see cref="RegisterBuiltIns"/>; tests
-/// reset and re-register through <see cref="Reset"/>.
+/// Compile-time registry of <see cref="IClipTypeStrategy"/> implementations
+/// keyed by <c>Mac-XM*</c> format id. Strategies are fully owned by SharpFM
+/// (no plugin extension point), so the table is built once from a static
+/// list and is read-only thereafter — no locks, no bootstrap, no reset.
+/// Adding a new clip type means writing the strategy and adding it to
+/// <see cref="BuiltIns"/>.
 /// </summary>
-/// <remarks>
-/// Reflection-based auto-discovery (the pattern used by <c>StepRegistry</c>)
-/// is deliberately not used here — clip types are few, low-cardinality, and
-/// explicit registration makes the bootstrapping order obvious.
-/// </remarks>
 public static class ClipTypeRegistry
 {
-    private static readonly object _gate = new();
-    private static readonly Dictionary<string, IClipTypeStrategy> _strategies = new();
+    public static IReadOnlyList<IClipTypeStrategy> BuiltIns { get; } =
+    [
+        ScriptClipStrategy.Steps,
+        ScriptClipStrategy.Script,
+        TableClipStrategy.Table,
+        TableClipStrategy.Field,
+        LayoutClipStrategy.Instance,
+    ];
 
-    /// <summary>Register a strategy. A duplicate <see cref="IClipTypeStrategy.FormatId"/> overwrites the prior entry.</summary>
-    public static void Register(IClipTypeStrategy strategy)
-    {
-        lock (_gate)
-        {
-            _strategies[strategy.FormatId] = strategy;
-        }
-    }
+    private static readonly Dictionary<string, IClipTypeStrategy> _byFormatId =
+        BuiltIns.ToDictionary(s => s.FormatId);
+
+    /// <summary>All built-in strategies (excludes the opaque fallback).</summary>
+    public static IReadOnlyList<IClipTypeStrategy> All => BuiltIns;
 
     /// <summary>
     /// Resolve a strategy for the given format id. Unknown ids fall back to
     /// <see cref="OpaqueClipStrategy.Instance"/> so callers always receive a
     /// usable strategy.
     /// </summary>
-    public static IClipTypeStrategy For(string formatId)
-    {
-        lock (_gate)
-        {
-            return _strategies.TryGetValue(formatId, out var strategy)
-                ? strategy
-                : OpaqueClipStrategy.Instance;
-        }
-    }
-
-    /// <summary>True if the given format id has a dedicated strategy registered.</summary>
-    public static bool IsRegistered(string formatId)
-    {
-        lock (_gate)
-        {
-            return _strategies.ContainsKey(formatId);
-        }
-    }
-
-    /// <summary>All explicitly-registered strategies, in registration order.</summary>
-    public static IReadOnlyList<IClipTypeStrategy> All
-    {
-        get
-        {
-            lock (_gate)
-            {
-                return _strategies.Values.ToList();
-            }
-        }
-    }
-
-    /// <summary>
-    /// Register every built-in clip-type strategy. Called once at host startup;
-    /// idempotent thanks to <see cref="Register"/>'s overwrite semantics. Adding
-    /// a new <c>Mac-XM*</c> format is a single additional <see cref="Register"/>
-    /// call here. Opaque is the implicit fallback and is not registered.
-    /// </summary>
-    public static void RegisterBuiltIns()
-    {
-        Register(ScriptClipStrategy.Steps);
-        Register(ScriptClipStrategy.Script);
-        Register(TableClipStrategy.Table);
-        Register(TableClipStrategy.Field);
-        Register(LayoutClipStrategy.Instance);
-    }
-
-    /// <summary>Clear the registry. Tests use this to isolate from production registrations.</summary>
-    internal static void Reset()
-    {
-        lock (_gate)
-        {
-            _strategies.Clear();
-        }
-    }
+    public static IClipTypeStrategy For(string formatId) =>
+        _byFormatId.TryGetValue(formatId, out var strategy)
+            ? strategy
+            : OpaqueClipStrategy.Instance;
+
+    /// <summary>True if the given format id has a dedicated built-in strategy.</summary>
+    public static bool IsRegistered(string formatId) =>
+        _byFormatId.ContainsKey(formatId);
 }

src/SharpFM.Model/ClipTypes/ScriptClipStrategy.cs

@@ -1,9 +1,7 @@
 using System;
 using System.Collections.Generic;
-using System.Xml.Linq;
 using SharpFM.Model.Parsing;
 using SharpFM.Model.Scripting;
-using SharpFM.Model.Scripting.Steps;
 
 namespace SharpFM.Model.ClipTypes;
 
@@ -52,22 +50,9 @@ public ClipParseResult Parse(string xml)
                 ParseDiagnosticKind.XmlMalformed, "/", ex.Message, "failed to parse script");
         }
 
-        var output = XElement.Parse(script.ToXml());
-        var diagnostics = new List<ClipParseDiagnostic>(XmlRoundTripDiff.Compute(input, output));
-
-        var rawStepIndex = 0;
-        foreach (var step in script.Steps)
-        {
-            rawStepIndex++;
-            if (step is RawStep raw)
-            {
-                diagnostics.Add(new ClipParseDiagnostic(
-                    ParseDiagnosticKind.UnknownStep,
-                    ParseDiagnosticSeverity.Info,
-                    $"/fmxmlsnippet/Step[{rawStepIndex}]",
-                    $"step '{raw.Name}' is not modeled by the host; preserved verbatim as RawStep"));
-            }
-        }
+        var diagnostics = new List<ClipParseDiagnostic>(
+            XmlRoundTripDiff.Compute(input, script.ToElement()));
+        diagnostics.AddRange(ClipStrategyHelpers.RawStepDiagnostics(script));
 
         var report = diagnostics.Count == 0
             ? ClipParseReport.Empty

src/SharpFM.Model/ClipTypes/TableClipStrategy.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Xml.Linq;
 using SharpFM.Model.Parsing;
 using SharpFM.Model.Schema;
 
@@ -52,8 +51,8 @@ public ClipParseResult Parse(string xml)
                 ParseDiagnosticKind.XmlMalformed, "/", ex.Message, "failed to parse table");
         }
 
-        var output = XElement.Parse(table.ToXml());
-        var diagnostics = new List<ClipParseDiagnostic>(XmlRoundTripDiff.Compute(input, output));
+        var diagnostics = new List<ClipParseDiagnostic>(
+            XmlRoundTripDiff.Compute(input, table.ToElement()));
 
         var report = diagnostics.Count == 0
             ? ClipParseReport.Empty

src/SharpFM.Model/Schema/FmTable.cs

@@ -39,7 +39,11 @@ public static FmTable FromXml(string xml)
         return new FmTable(tableName, fields) { Id = tableId };
     }
 
-    public string ToXml()
+    /// <summary>
+    /// Build the table's XML as an <see cref="XElement"/> directly, skipping
+    /// the <c>ToString</c> + pretty-print round-trip <see cref="ToXml"/> does.
+    /// </summary>
+    public XElement ToElement()
     {
         var root = new XElement("fmxmlsnippet", new XAttribute("type", "FMObjectList"));
         var baseTable = new XElement("BaseTable", new XAttribute("name", Name));
@@ -51,9 +55,11 @@ public string ToXml()
 
         root.Add(baseTable);
 
-        return XmlHelpers.PrettyPrint(root.ToString());
+        return root;
     }
 
+    public string ToXml() => XmlHelpers.PrettyPrint(ToElement().ToString());
+
     public void AddField(FmField field)
     {
         Fields.Add(field);

src/SharpFM.Model/Scripting/FmScript.cs

@@ -60,7 +60,13 @@ public static FmScript FromXml(string xml)
 
     // --- Serialize to FM XML ---
 
-    public string ToXml()
+    /// <summary>
+    /// Build the script's XML as an <see cref="XElement"/> directly, skipping
+    /// the <c>ToString</c> + pretty-print round-trip <see cref="ToXml"/> does.
+    /// Use this when the caller needs an element to walk (e.g. round-trip
+    /// diffing) rather than a serialised string.
+    /// </summary>
+    public XElement ToElement()
     {
         var root = new XElement("fmxmlsnippet", new XAttribute("type", "FMObjectList"));
 
@@ -77,9 +83,11 @@ public string ToXml()
                 root.Add(step.ToXml());
         }
 
-        return XmlHelpers.PrettyPrint(root.ToString());
+        return root;
     }
 
+    public string ToXml() => XmlHelpers.PrettyPrint(ToElement().ToString());
+
     // --- Render to display text ---
 
     public string ToDisplayText()

src/SharpFM/App.axaml.cs

@@ -4,7 +4,6 @@
 using Avalonia;
 using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Markup.Xaml;
-using SharpFM.Model.ClipTypes;
 using SharpFM.Model.Scripting.Registry;
 using SharpFM.Models;
 using SharpFM.Plugin;
@@ -33,11 +32,6 @@ public override void OnFrameworkInitializationCompleted()
         // same initialization runs lazily on first registry access.
         StepRegistry.Initialize();
 
-        // Clip-type strategies are explicitly registered (no reflection); do
-        // it once at startup so paste / file load / plugin push all see the
-        // built-in formats from the first request onward.
-        ClipTypeRegistry.RegisterBuiltIns();
-
         if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
         {
             desktop.MainWindow = new MainWindow();

src/SharpFM/Editors/FallbackXmlEditor.cs

@@ -1,5 +1,6 @@
 using System;
 using AvaloniaEdit.Document;
+using SharpFM.Model.Parsing;
 
 namespace SharpFM.Editors;
 
@@ -27,4 +28,6 @@ public FallbackXmlEditor(string? xml)
     }
 
     public string ToXml() => Document.Text;
+
+    public ClipModel GetModel() => new OpaqueClipModel(Document.Text);
 }