fix(csharp): address loader-unification review findings (sync HttpClient, abs-URI guard, FromDirectory state-on-failure, registry overloads)

- UriSource.Read(): replace sync-over-async (GetAwaiter().GetResult()) with
  synchronous HttpClient.Send + ReadAsStream to eliminate deadlock risk.
- UriSource ctor: reject relative URIs at construction with ArgumentException.
- MetaDataLoader.FromDirectory: on directory-read failure, synthesize the
  failure LoadResult directly with state == "error" instead of calling
  Load([]) (which left _state == "loaded" because no errors were collected
  before the synthetic load completed). LoadResult gains a State field;
  loader exposes internal SetState for static-factory pre-Load shortcuts.
- Add registry-aware overloads FromUris(uris, registry) and
  FromString(content, format, registry) for symmetry with FromDirectory.
- Tests: assert UriSource rejects relative URIs; assert
  FromDirectory_read_failure surfaces state == "error".

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

Author: dmealing

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

@@ -48,5 +48,6 @@ public void FromDirectory_read_failure_collects_error_on_synthetic_root()
         var result = MetaDataLoader.FromDirectory("/nonexistent/path/that/does/not/exist");
         Assert.NotEmpty(result.Errors);
         Assert.NotNull(result.Root);
+        Assert.Equal("error", result.State);
     }
 }

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

@@ -24,6 +24,12 @@ public void FileScheme_ReadsLocalFile()
         }
     }
 
+    [Fact]
+    public void RelativeUri_ThrowsArgumentException()
+    {
+        Assert.Throws<ArgumentException>(() => new UriSource(new Uri("foo/bar.json", UriKind.Relative)));
+    }
+
     [Fact]
     public void ExplicitFormat_OverridesExtensionInference()
     {

server/csharp/MetaObjects/Loader/MetaDataLoader.cs

@@ -23,7 +23,8 @@ namespace MetaObjects.Loader;
 public sealed record LoadResult(
     MetaRoot Root,
     IReadOnlyList<string> Warnings,
-    IReadOnlyList<MetaError> Errors);
+    IReadOnlyList<MetaError> Errors,
+    string State = "loaded");
 
 /// <summary>
 /// Core metadata loader pipeline. Consumes a list of
@@ -79,32 +80,45 @@ public static LoadResult FromDirectory(string directory, DirectorySource.Options
     public static LoadResult FromDirectory(string directory, TypeRegistry registry, DirectorySource.Options? opts = null)
     {
         var src = new DirectorySource(directory, opts);
-        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>());
+            // Directory-read failure: synthesize an error result directly so
+            // state reflects "error" (calling Load([]) would set state to
+            // "loaded" because no errors had been collected yet at that point).
+            var loader = new MetaDataLoader(registry);
+            loader.SetState("error");
+            var root = MakeSyntheticRoot();
+            if (loader.Freeze)
+            {
+                root.Freeze();
+            }
             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 new LoadResult(root, Array.Empty<string>(), errors.AsReadOnly(), "error");
         }
-        return loader.Load(sources);
+        return new MetaDataLoader(registry).Load(sources);
     }
 
     /// <summary>
     /// Convenience: wrap each URI in a <see cref="UriSource"/> and load in order.
     /// </summary>
     public static LoadResult FromUris(IReadOnlyList<Uri> uris)
+        => FromUris(uris, DefaultRegistry());
+
+    /// <summary>
+    /// Registry-aware overload: wrap each URI in a <see cref="UriSource"/> and
+    /// load using the supplied <paramref name="registry"/>.
+    /// </summary>
+    public static LoadResult FromUris(IReadOnlyList<Uri> uris, TypeRegistry registry)
     {
-        var loader = new MetaDataLoader();
+        var loader = new MetaDataLoader(registry);
         var sources = uris.Select(u => (IMetaDataSource)new UriSource(u)).ToList();
         return loader.Load(sources);
     }
@@ -113,8 +127,15 @@ public static LoadResult FromUris(IReadOnlyList<Uri> uris)
     /// Convenience: load a single in-memory string of the given format.
     /// </summary>
     public static LoadResult FromString(string content, MetaDataFormat format)
+        => FromString(content, format, DefaultRegistry());
+
+    /// <summary>
+    /// Registry-aware overload: load a single in-memory string of the given
+    /// format using the supplied <paramref name="registry"/>.
+    /// </summary>
+    public static LoadResult FromString(string content, MetaDataFormat format, TypeRegistry registry)
     {
-        var loader = new MetaDataLoader();
+        var loader = new MetaDataLoader(registry);
         return loader.Load(new IMetaDataSource[] { new InMemoryStringSource(content, format: format) });
     }
 
@@ -312,9 +333,16 @@ public LoadResult Load(IReadOnlyList<IMetaDataSource> sources)
         }
 
         _root = root;
-        return new LoadResult(root, warnings.AsReadOnly(), errors.AsReadOnly());
+        return new LoadResult(root, warnings.AsReadOnly(), errors.AsReadOnly(), _state);
     }
 
+    /// <summary>
+    /// Internal state setter — used by static factories (e.g. FromDirectory)
+    /// that need to short-circuit the pipeline on pre-Load failures and still
+    /// report state == "error".
+    /// </summary>
+    internal void SetState(string state) => _state = state;
+
     // -------------------------------------------------------------------------
     // Helpers
     // -------------------------------------------------------------------------

server/csharp/MetaObjects/Loader/UriSource.cs

@@ -30,6 +30,8 @@ public sealed class UriSource : IMetaDataSource
     public UriSource(Uri uri, MetaDataFormat? format = null)
     {
         Uri = uri ?? throw new ArgumentNullException(nameof(uri));
+        if (!uri.IsAbsoluteUri)
+            throw new ArgumentException($"UriSource requires an absolute URI; got relative '{uri}'.", nameof(uri));
         Id = uri.ToString();
         Format = format ?? MetaDataFormats.InferFromExtension(uri.AbsolutePath);
     }
@@ -43,9 +45,12 @@ public string Read()
 
         if (Uri.Scheme == "http" || Uri.Scheme == "https")
         {
-            using HttpResponseMessage resp = _http.GetAsync(Uri).GetAwaiter().GetResult();
+            using var req = new HttpRequestMessage(HttpMethod.Get, Uri);
+            using var resp = _http.Send(req);
             resp.EnsureSuccessStatusCode();
-            return resp.Content.ReadAsStringAsync().GetAwaiter().GetResult();
+            using var stream = resp.Content.ReadAsStream();
+            using var reader = new System.IO.StreamReader(stream);
+            return reader.ReadToEnd();
         }
 
         throw new NotSupportedException($"Unsupported URI scheme '{Uri.Scheme}' on {Uri}");