Ensure native exceptions are clear and properly propagated

Audit + fixes across the whole native<->managed boundary:

- Grammar loading actually honors the native resolver now. NativeLibrary
  .Load(name, assembly, ...) does NOT invoke a SetDllImportResolver
  callback (that fires only for DllImport/LibraryImport), so grammar
  loads silently ignored TREE_SITTER_NATIVE_PATH and the repo native/<rid>
  fallback. Added internal NativeLibraryResolver.TryResolve(...) running
  the full probe sequence; LanguagePack.Load uses it (then the default
  loader), and InternalsVisibleTo exposes it. The documented contract is
  now true.
- Manifest parse errors surface as InvalidOperationException with the
  JsonException chained, instead of a bare JsonException; added a
  string/Stream test seam.

Verified the rest of the boundary already surfaces clear, typed,
chained exceptions (lib/export/null-ptr load failures, allocation
failures, ABI mismatch, query compile errors, no-language vs cancel,
dispose, the single intentional logger-thunk boundary swallow, no
throw-ex stack resets, buffers freed on throw paths).

Adds tests/ErrorPropagationTests.cs (23 cases) proving each path.
Build 0/0 (Debug+Release); 404 tests pass (incl. hermetic);
coverage 97.4% / 98.0% / 99.5% (core / codegen / languagepack).

https://claude.ai/code/session_01S3hwvd2oz6cntXmB3G6Yf1

Author: claude

src/TreeSitter.LanguagePack/LanguagePack.cs

@@ -187,12 +187,21 @@ private static unsafe Language Load(LanguageInfo info)
         nint handle;
         try
         {
-            // Load via a PUBLIC TreeSitter type so the NativeLibraryResolver — which is
-            // registered on the TreeSitter assembly only — fires for this grammar load.
-            // This makes TREE_SITTER_NATIVE_PATH and the repo native/<rid>/ dev fallback
-            // apply to grammars too (see docs/ARCHITECTURE.md and LanguageNotAvailableException).
-            handle = System.Runtime.InteropServices.NativeLibrary.Load(
-                info.NativeLibraryName, typeof(global::TreeSitter.Language).Assembly, null);
+            // Resolve through the TreeSitter NativeLibraryResolver's probe sequence so
+            // TREE_SITTER_NATIVE_PATH, the runtimes/<rid>/native layout, the assembly
+            // directory, and the repo native/<rid>/ dev fallback ALL apply to grammar
+            // loads (see docs/ARCHITECTURE.md and LanguageNotAvailableException).
+            //
+            // We must call the resolver explicitly: NativeLibrary.Load(name, assembly,
+            // searchPath) does NOT invoke the DllImport resolver registered via
+            // SetDllImportResolver — that callback only fires for DllImport/LibraryImport
+            // P/Invoke. So delegate to the resolver's probe first, then fall back to the
+            // default loader (which honours the OS search path and any embedded rpath).
+            if (!global::TreeSitter.Native.NativeLibraryResolver.TryResolve(info.NativeLibraryName, out handle))
+            {
+                handle = System.Runtime.InteropServices.NativeLibrary.Load(
+                    info.NativeLibraryName, typeof(global::TreeSitter.Language).Assembly, null);
+            }
         }
         catch (Exception ex) when (ex is DllNotFoundException or System.IO.FileNotFoundException or BadImageFormatException)
         {

src/TreeSitter.LanguagePack/Manifests.cs

@@ -53,15 +53,50 @@ internal static (FrozenDictionary<string, LanguageInfo> Manifest,
     private static Dictionary<string, ManifestEntry> DeserializeRaw()
     {
         using Stream stream = OpenManifest();
-        Dictionary<string, ManifestEntry>? raw =
-            JsonSerializer.Deserialize(stream, ManifestJsonContext.Default.DictionaryStringManifestEntry);
+        return DeserializeRaw(stream);
+    }
+
+    /// <summary>
+    /// Parses manifest JSON from an arbitrary <paramref name="stream"/> into its raw
+    /// entries, throwing <see cref="InvalidOperationException"/> with a clear message
+    /// when the document is empty, <c>null</c>, or contains no entries. This is the
+    /// single validation seam shared by the embedded-resource read and the tests; it
+    /// keeps the public <see cref="LoadAll"/> behavior identical while letting the
+    /// empty/corrupt-manifest path be exercised with synthetic input.
+    /// </summary>
+    /// <param name="stream">A UTF-8 JSON stream holding a <c>name -&gt; entry</c> object.</param>
+    internal static Dictionary<string, ManifestEntry> DeserializeRaw(Stream stream)
+    {
+        Dictionary<string, ManifestEntry>? raw;
+        try
+        {
+            raw = JsonSerializer.Deserialize(stream, ManifestJsonContext.Default.DictionaryStringManifestEntry);
+        }
+        catch (JsonException ex)
+        {
+            // A malformed manifest must surface as a clear, typed error with the parse
+            // failure chained — never a bare JsonException leaking out of the loader.
+            throw new InvalidOperationException(
+                "The embedded language manifest is empty or could not be parsed.", ex);
+        }
 
         if (raw is null || raw.Count == 0)
             throw new InvalidOperationException("The embedded language manifest is empty or could not be parsed.");
 
         return raw;
     }
 
+    /// <summary>
+    /// Parses manifest JSON from a <paramref name="json"/> string. A convenience wrapper
+    /// over <see cref="DeserializeRaw(Stream)"/> for tests; shares the same validation.
+    /// </summary>
+    /// <param name="json">The manifest JSON text.</param>
+    internal static Dictionary<string, ManifestEntry> DeserializeRaw(string json)
+    {
+        using var stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(json));
+        return DeserializeRaw(stream);
+    }
+
     /// <summary>
     /// Pure index builder, separated from the embedded-resource read so it can be unit
     /// tested with synthetic manifests and ambiguity maps. Each extension (lowercase, no

src/TreeSitter/Native/NativeLibraryResolver.cs

@@ -99,6 +99,33 @@ internal static IntPtr Resolve(string libraryName, Assembly assembly, DllImportS
         return handle;
     }
 
+    /// <summary>
+    /// Runs the binding's native-library probing sequence for <paramref name="logicalName"/>
+    /// (the same well-known locations the <see cref="DllImportResolver"/> uses: the
+    /// <c>TREE_SITTER_NATIVE_PATH</c> override, the NuGet <c>runtimes/&lt;rid&gt;/native</c>
+    /// layout, the assembly directory, and the repo <c>native/&lt;rid&gt;/</c> dev
+    /// fallback), returning the loaded handle on success.
+    /// </summary>
+    /// <remarks>
+    /// This is the explicit entry point grammar loaders (notably
+    /// <c>TreeSitter.LanguagePack</c>) must call, because
+    /// <see cref="NativeLibrary.Load(string, Assembly, DllImportSearchPath?)"/> does
+    /// <b>not</b> invoke a resolver registered via
+    /// <see cref="NativeLibrary.SetDllImportResolver"/> — that callback is wired only
+    /// into the <c>DllImport</c>/<c>LibraryImport</c> path. Routing grammar loads
+    /// through here keeps <c>TREE_SITTER_NATIVE_PATH</c> and the dev fallback working
+    /// for grammars exactly as they do for the core engine. Successful resolutions are
+    /// cached by logical name, mirroring <see cref="Resolve"/>.
+    /// </remarks>
+    /// <param name="logicalName">The logical library name (e.g. <c>tree-sitter-python</c>).</param>
+    /// <param name="handle">On success, the loaded native handle; otherwise <see cref="IntPtr.Zero"/>.</param>
+    /// <returns><see langword="true"/> if the library was resolved and loaded.</returns>
+    internal static bool TryResolve(string logicalName, out IntPtr handle)
+    {
+        handle = Resolve(logicalName, typeof(NativeLibraryResolver).Assembly, searchPath: null);
+        return handle != IntPtr.Zero;
+    }
+
     /// <summary>Runs the full probing sequence for an unresolved logical name.</summary>
     private static IntPtr ResolveCore(string libraryName, Assembly assembly)
     {

src/TreeSitter/TreeSitter.csproj

@@ -36,6 +36,11 @@
        public API is unchanged. -->
   <ItemGroup>
     <InternalsVisibleTo Include="TreeSitter.Tests" />
+    <!-- LanguagePack resolves grammar libraries through this assembly's
+         NativeLibraryResolver (so TREE_SITTER_NATIVE_PATH and the repo native/<rid>/
+         dev fallback apply to grammar loads). NativeLibrary.Load does NOT invoke the
+         DllImport resolver, so the pack must call the resolver's probe directly. -->
+    <InternalsVisibleTo Include="TreeSitter.LanguagePack" />
   </ItemGroup>
 
   <!-- NuGet package metadata. -->