.

Author: SimonCropp

src/Verify.Tests/Converters/ExtensionConverterTests.WithInfo_AndRootInfo#00.verified.txt

@@ -0,0 +1,3 @@
+{
+  RootProperty: RootValue
+}

src/Verify.Tests/Converters/ExtensionConverterTests.WithInfo_AndRootInfo#01.verified.txt

@@ -0,0 +1,3 @@
+{
+  Property: Value
+}

src/Verify.Tests/Converters/ExtensionConverterTests.WithInfo_AndRootInfo#02.verified.txt

@@ -0,0 +1 @@
+Foo

src/Verify.Tests/Converters/ExtensionConverterTests.cs

@@ -210,6 +210,12 @@ public Task WithInfo_AndRecording()
         return Verify(new MemoryStream([1]), "WithInfo");
     }
 
+    // Test: Explicit root info + converter that returns its own info
+    // Expected order: root info, converter info, converter text
+    [Fact]
+    public Task WithInfo_AndRootInfo() =>
+        Verify(new MemoryStream([1]), "WithInfo", null, new { RootProperty = "RootValue" });
+
     [ModuleInitializer]
     public static void WithInfoAndBinaryInit() =>
         VerifierSettings.RegisterStreamConverter(

src/Verify/Verifier/InnerVerifier_Inner.cs

@@ -39,22 +39,15 @@ async Task<VerifyResult> VerifyInner(object? root, Func<Task>? cleanup, IEnumera
 
         List<Target> list = [..targets, ..VerifierSettings.GetFileAppenders(settings)];
 
-        // Process root via TryGetRootTarget when root is NOT already in the targets list
-        // This handles:
-        // - VerifyStream with converter: root (info) is separate from targets → process both
-        // - Verify(object, IEnumerable<Target>): root is separate from targets → process both
-        // - Verify(): root is null, targets is empty → TryGetRootTarget handles null appropriately
-        // Skip when:
-        // - Verify(object): root is in targets list → avoid duplicate processing
+        // Check if root is in targets list (to avoid duplicate processing)
         var rootInTargets = root != null && list.Any(t => ReferenceEquals(t.Data, root));
-        if (!rootInTargets && TryGetRootTarget(root, ignoreNullRoot, out var rootTarget))
-        {
-            resultTargets.Add(rootTarget.Value);
-        }
 
+        // Process extension conversions first (may produce converter info that becomes root)
+        List<object>? converterInfos = null;
         if (doExtensionConversion)
         {
             var result = new List<Target>();
+            converterInfos = [];
             foreach (var target in list)
             {
                 if (!target.PerformConversion ||
@@ -69,21 +62,43 @@ target.Extension is null ||
                 cleanup += itemCleanup;
                 if (info != null)
                 {
-                    result.Add(
-                        new(
-                            settings.TxtOrJson,
-                            JsonFormatter.AsJson(
-                                settings,
-                                counter,
-                                info)));
+                    converterInfos.Add(info);
                 }
 
                 result.AddRange(converted);
             }
 
+            // If root is null and converters returned info, use converter info as root (for appenders)
+            if (!rootInTargets && root == null && converterInfos.Count > 0)
+            {
+                root = converterInfos.Count == 1 ? converterInfos[0] : converterInfos;
+                converterInfos = null; // Already used as root, don't add again
+            }
+
             list = result;
         }
 
+        // Process root via TryGetRootTarget (after extension conversion so converter info can become root)
+        if (!rootInTargets && TryGetRootTarget(root, ignoreNullRoot, out var rootTarget))
+        {
+            resultTargets.Add(rootTarget.Value);
+        }
+
+        // Add converter infos right after root (before other targets)
+        if (converterInfos != null)
+        {
+            foreach (var info in converterInfos)
+            {
+                resultTargets.Add(
+                    new(
+                        settings.TxtOrJson,
+                        JsonFormatter.AsJson(
+                            settings,
+                            counter,
+                            info)));
+            }
+        }
+
         // Resolve all targets (including objects) to ResolvedTargets
         var extraTargets = new List<ResolvedTarget>();
         var noScrubTargets = new List<ResolvedTarget>();
@@ -260,6 +275,15 @@ target.Extension is null ||
                     JsonFormatter.AsJson(settings, counter, conversionResult.Info)));
             }
 
+            // Add appends as first target if present (typed converters don't include appends in their output)
+            var converterAppends = VerifierSettings.GetJsonAppenders(settings);
+            if (converterAppends.Count > 0)
+            {
+                results.Insert(0, new(
+                    settings.TxtOrJson,
+                    JsonFormatter.AsJson(settings, counter, new InfoBuilder(true, null, converterAppends))));
+            }
+
             return (results, cleanup, true);
         }
 

src/Verify/Verifier/InnerVerifier_Stream.cs

@@ -86,14 +86,6 @@ public async Task<VerifyResult> VerifyStream(Stream? stream, string extension, o
 
         stream.MoveToStart();
 
-        // Check for stream converter first - converter info should be root for appenders
-        if (VerifierSettings.HasStreamConverter(extension))
-        {
-            var (newInfo, converted, cleanup) = await DoExtensionConversion(extension, stream, info, null);
-            return await VerifyInner(newInfo, cleanup, converted, false, true);
-        }
-
-        // No converter - create target directly
         Target target;
         if (FileExtensions.IsTextExtension(extension))
         {