refactor(csharp): retire FileMetaDataLoader; migrate to MetaDataLoader.FromDirectory + Source polymorphism

Deletes the FileMetaDataLoader subclass. All CLI commands
(gen/migrate/verify), tests, and the conformance adapter now use the
unified MetaDataLoader.FromDirectory(...) factory. The
registry-aware overload preserves the conformance adapter's
provider-composition flow. Directory-read failure is still surfaced
as a collected MetaError on a synthetic empty root (no throw) —
mirrors the TS loadDirectory contract.

Aligns the C# port with the cross-language loader architecture
unification spec.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: dmealing

server/csharp/MetaObjects.Cli/GenCommand.cs

@@ -24,7 +24,7 @@ public static IReadOnlyList<IGenerator> DefaultGenerators() =>
 
     public static Outcome Run(string metadataDir, string outDir, string ns)
     {
-        var load = new FileMetaDataLoader().LoadDirectory(metadataDir);
+        var load = MetaDataLoader.FromDirectory(metadataDir);
         var loadErrors = load.Errors.Select(e => e.Code.ToString()).ToList();
         if (loadErrors.Count > 0)
             return new Outcome(loadErrors, null);

server/csharp/MetaObjects.Cli/MigrateCommand.cs

@@ -115,7 +115,7 @@ public static async Task<IncrementalOutcome> RunIncrementalAsync(
 
     private static (IReadOnlyList<string> Errors, MetaRoot? Root) LoadRoot(string metadataDir)
     {
-        var load = new FileMetaDataLoader().LoadDirectory(metadataDir);
+        var load = MetaDataLoader.FromDirectory(metadataDir);
         var errs = load.Errors.Select(e => e.Code.ToString()).ToList();
         return (errs, errs.Count == 0 ? load.Root : null);
     }

server/csharp/MetaObjects.Cli/VerifyCommand.cs

@@ -41,7 +41,7 @@ public sealed record Outcome(
 
     public static Outcome Run(string metadataDir, string templatesRoot)
     {
-        var load = new FileMetaDataLoader().LoadDirectory(metadataDir);
+        var load = MetaDataLoader.FromDirectory(metadataDir);
         var loadErrors = load.Errors.Select(e => e.Code.ToString()).ToList();
 
         var provider = new FilesystemProvider(templatesRoot);

server/csharp/MetaObjects.Conformance.Tests/ConformanceAdapter.cs

@@ -52,7 +52,7 @@ public static LoadOutcome LoadFixture(string inputDir, IReadOnlyList<string> pro
             .ToList();
 
         var registry = Provider.ComposeRegistry(resolved);
-        var result = new FileMetaDataLoader(registry).LoadDirectory(inputDir);
+        var result = MetaDataLoader.FromDirectory(inputDir, registry);
 
         return new LoadOutcome(
             result.Root,

server/csharp/MetaObjects.Conformance.Tests/LoaderTests.cs

@@ -34,21 +34,19 @@ public void Core_loader_consumes_MetaDataSource_units()
     }
 
     [Fact]
-    public void FileMetaDataLoader_discovers_and_merges_a_directory()
+    public void FromDirectory_discovers_and_merges_a_directory()
     {
-        var loader = new FileMetaDataLoader();
-        var result = loader.LoadDirectory(
+        var result = MetaDataLoader.FromDirectory(
             System.IO.Path.Combine(Corpus, "loader-basic-single-entity", "input"));
         Assert.Empty(result.Errors);
-        Assert.Equal("loaded", loader.State);
+        Assert.NotNull(result.Root);
     }
 
     [Fact]
-    public void FileMetaDataLoader_directory_read_failure_collects_error_and_state_is_error()
+    public void FromDirectory_read_failure_collects_error_on_synthetic_root()
     {
-        var loader = new FileMetaDataLoader();
-        var result = loader.LoadDirectory("/nonexistent/path/that/does/not/exist");
+        var result = MetaDataLoader.FromDirectory("/nonexistent/path/that/does/not/exist");
         Assert.NotEmpty(result.Errors);
-        Assert.Equal("error", loader.State);
+        Assert.NotNull(result.Root);
     }
 }

server/csharp/MetaObjects.Conformance.Tests/SuperResolveTests.cs

@@ -9,7 +9,7 @@ public class SuperResolveTests
     [Fact]
     public void Single_level_extends_resolves_and_inherits_fields()
     {
-        var result = new FileMetaDataLoader().LoadDirectory(
+        var result = MetaDataLoader.FromDirectory(
             System.IO.Path.Combine(CorpusRoot.Path, "extends-single-level", "input"));
         Assert.Empty(result.Errors);
         // the subtype's effective fields include the base's fields (inherited via the resolved super chain)
@@ -20,7 +20,7 @@ public void Single_level_extends_resolves_and_inherits_fields()
     [Fact]
     public void Nonexistent_extends_collects_ERR_UNRESOLVED_SUPER()
     {
-        var result = new FileMetaDataLoader().LoadDirectory(
+        var result = MetaDataLoader.FromDirectory(
             System.IO.Path.Combine(CorpusRoot.Path, "error-extends-nonexistent", "input"));
         Assert.Contains(result.Errors, e => e.Code == ErrorCode.ERR_UNRESOLVED_SUPER);
     }

server/csharp/MetaObjects.Conformance.Tests/ValidationTests.cs

@@ -13,7 +13,7 @@ namespace MetaObjects.Conformance.Tests;
 public class ValidationTests
 {
     private static LoadResult Load(string fixture) =>
-        new FileMetaDataLoader().LoadDirectory(
+        MetaDataLoader.FromDirectory(
             System.IO.Path.Combine(CorpusRoot.Path, fixture, "input"));
 
     [Fact]

server/csharp/MetaObjects/Loader/FileMetaDataLoader.cs

@@ -38,13 +38,6 @@ public class MetaDataLoader
     private readonly bool _strict;
 
     private string _state = "uninitialized";
-
-    /// <summary>
-    /// Protected setter so subclasses can transition state on failure paths
-    /// that bypass <see cref="Load"/> (e.g. directory-read failure in
-    /// <see cref="FileMetaDataLoader.LoadDirectory"/>).
-    /// </summary>
-    protected void SetState(string state) => _state = state;
     private MetaRoot? _root;
 
     // -------------------------------------------------------------------------
@@ -83,10 +76,35 @@ private static TypeRegistry DefaultRegistry() =>
     /// and load all discovered files in deterministic order.
     /// </summary>
     public static LoadResult FromDirectory(string directory, DirectorySource.Options? opts = null)
+        => FromDirectory(directory, DefaultRegistry(), opts);
+
+    /// <summary>
+    /// Registry-aware overload: build a <see cref="DirectorySource"/> and load
+    /// using the supplied <paramref name="registry"/>. A directory-read failure
+    /// is surfaced as a collected <see cref="MetaError"/> on a synthetic empty
+    /// root (no throw) — mirrors the TS <c>loadDirectory</c> behavior.
+    /// </summary>
+    public static LoadResult FromDirectory(string directory, TypeRegistry registry, DirectorySource.Options? opts = null)
     {
         var src = new DirectorySource(directory, opts);
-        var loader = new MetaDataLoader();
-        return loader.Load(src.Expand().Cast<IMetaDataSource>().ToList());
+        var loader = new MetaDataLoader(registry);
+        List<IMetaDataSource> sources;
+        try
+        {
+            sources = src.Expand().Cast<IMetaDataSource>().ToList();
+        }
+        catch (Exception ex)
+        {
+            // Directory-read failure: surface as a collected error on an empty load.
+            var empty = loader.Load(Array.Empty<IMetaDataSource>());
+            var errors = new List<MetaError>
+            {
+                new($"Failed to read directory \"{directory}\": {ex.Message}", ErrorCode.ERR_UNKNOWN),
+            };
+            errors.AddRange(empty.Errors);
+            return new LoadResult(empty.Root, empty.Warnings, errors.AsReadOnly());
+        }
+        return loader.Load(sources);
     }
 
     /// <summary>