Update InnerVerifier_Inner.cs

SimonCropp · SimonCropp · commit 01615dbcac79 · 2025-12-14T14:27:08.000+11:00
diff --git a/src/Verify/Verifier/InnerVerifier_Inner.cs b/src/Verify/Verifier/InnerVerifier_Inner.cs
@@ -42,27 +42,20 @@ async Task<VerifyResult> VerifyInner(object? root, Func<Task>? cleanup, IEnumera
         // Check if root is in targets list (to avoid duplicate processing)
         var rootInTargets = root != null && list.Any(t => ReferenceEquals(t.Data, root));
 
-        // Process stream converters (may produce converter info that becomes root)
-        var converted = new List<Target>();
+        // Resolve all targets and collect converter infos
         var converterInfos = new List<object>();
+        var resolvedTargets = new List<(ResolvedTarget target, bool applyScrubbers)>();
+
         foreach (var target in list)
         {
-            if (!target.PerformConversion ||
-                target.Extension is null ||
-                !VerifierSettings.HasStreamConverter(target.Extension))
-            {
-                converted.Add(target);
-                continue;
-            }
+            var (resolvedList, resolveCleanup, applyScrubbers, infos) = await ResolveTarget(target);
+            cleanup += resolveCleanup;
+            converterInfos.AddRange(infos);
 
-            var (info, convTargets, itemCleanup) = await DoExtensionConversion(target.Extension, target.StreamData, null, target.Name);
-            cleanup += itemCleanup;
-            if (info != null)
+            foreach (var resolved in resolvedList)
             {
-                converterInfos.Add(info);
+                resolvedTargets.Add((resolved, applyScrubbers));
             }
-
-            converted.AddRange(convTargets);
         }
 
         // If root is null and converters returned info, use converter info as root (for appenders)
@@ -87,44 +80,45 @@ target.Extension is null ||
                     JsonFormatter.AsJson(settings, counter, info)));
         }
 
-        // Resolve remaining targets and apply scrubbers inline
-        foreach (var target in converted)
+        // Add resolved targets and apply scrubbers
+        foreach (var (resolved, applyScrubbers) in resolvedTargets)
         {
-            var (resolvedList, resolveCleanup, applyScrubbers) = await ResolveTarget(target);
-            cleanup += resolveCleanup;
-
-            foreach (var resolved in resolvedList)
+            if (applyScrubbers && resolved.TryGetStringBuilder(out var builder))
             {
-                if (applyScrubbers && resolved.TryGetStringBuilder(out var builder))
-                {
-                    ApplyScrubbers.ApplyForExtension(resolved.Extension, builder, settings, counter);
-                }
-
-                resultTargets.Add(resolved);
+                ApplyScrubbers.ApplyForExtension(resolved.Extension, builder, settings, counter);
             }
+
+            resultTargets.Add(resolved);
         }
 
         return (cleanup, resultTargets);
     }
 
-    async Task<(List<ResolvedTarget> targets, Func<Task> cleanup, bool applyScrubbers)> ResolveTarget(Target target)
+    async Task<(List<ResolvedTarget> targets, Func<Task> cleanup, bool applyScrubbers, List<object> converterInfos)> ResolveTarget(Target target)
     {
         var cleanup = () => Task.CompletedTask;
         var results = new List<ResolvedTarget>();
+        var converterInfos = new List<object>();
 
-        // If target has an extension, it's already resolved (Stream or StringBuilder)
-        // These come from converters or explicit targets, so apply scrubbers
+        // If target has an extension with stream data, check for stream converter
         if (target.Extension is not null)
         {
             if (target.TryGetStream(out var stream))
             {
+                if (target.PerformConversion)
+                {
+                    var (streamResults, streamCleanup, infos) = await ResolveStream(stream, target.Extension, target.Name);
+                    return (streamResults, streamCleanup, true, infos);
+                }
+
                 results.Add(new(target.Extension, stream, target.Name));
             }
             else if (target.TryGetStringBuilder(out var sb))
             {
                 results.Add(new(target.Extension, sb, target.Name));
             }
-            return (results, cleanup, true);
+
+            return (results, cleanup, true, converterInfos);
         }
 
         // Target contains an arbitrary object - resolve it using full type matching
@@ -135,15 +129,15 @@ target.Extension is null ||
             results.Add(new(
                 settings.TxtOrJson,
                 JsonFormatter.AsJson(settings, counter, new InfoBuilder(false, null, []))));
-            return (results, cleanup, false);
+            return (results, cleanup, false, converterInfos);
         }
 
         // Handle XContainer (XDocument, XElement) - apply scrubbers
         if (data is XContainer container)
         {
             var xmlString = ConvertXmlToString(container);
             results.Add(new("xml", xmlString, target.Name));
-            return (results, cleanup, true);
+            return (results, cleanup, true, converterInfos);
         }
 
         // Handle XmlNode - apply scrubbers
@@ -154,30 +148,30 @@ target.Extension is null ||
             var xdoc = XDocument.Load(reader);
             var xmlString = ConvertXmlToString(xdoc);
             results.Add(new("xml", xmlString, target.Name));
-            return (results, cleanup, true);
+            return (results, cleanup, true, converterInfos);
         }
 
         // Handle FileStream (get extension from filename) - apply scrubbers
         if (data is FileStream fileStream)
         {
             var extension = fileStream.Extension();
-            var (streamResults, streamCleanup) = await ResolveStream(fileStream, extension, target.Name);
-            return (streamResults, streamCleanup, true);
+            var (streamResults, streamCleanup, infos) = await ResolveStream(fileStream, extension, target.Name);
+            return (streamResults, streamCleanup, true, infos);
         }
 
         // Handle Stream - apply scrubbers
         if (data is Stream stream2)
         {
-            var (streamResults, streamCleanup) = await ResolveStream(stream2, "bin", target.Name);
-            return (streamResults, streamCleanup, true);
+            var (streamResults, streamCleanup, infos) = await ResolveStream(stream2, "bin", target.Name);
+            return (streamResults, streamCleanup, true, infos);
         }
 
         // Handle byte[] - apply scrubbers
         if (data is byte[] bytes)
         {
             var memStream = new MemoryStream(bytes);
-            var (streamResults, streamCleanup) = await ResolveStream(memStream, "bin", target.Name);
-            return (streamResults, streamCleanup, true);
+            var (streamResults, streamCleanup, infos) = await ResolveStream(memStream, "bin", target.Name);
+            return (streamResults, streamCleanup, true, infos);
         }
 
         // Handle IEnumerable<Stream> - throw error as in Verify(object)
@@ -190,7 +184,7 @@ target.Extension is null ||
         if (data is StringBuilder sb2)
         {
             results.Add(new("txt", sb2, target.Name));
-            return (results, cleanup, true);
+            return (results, cleanup, true, converterInfos);
         }
 
         // Handle string - check for JSON appenders first (matches TryGetRootTarget behavior)
@@ -209,12 +203,12 @@ target.Extension is null ||
                 results.Add(new(
                     settings.TxtOrJson,
                     JsonFormatter.AsJson(settings, counter, new InfoBuilder(false, str, appends))));
-                return (results, cleanup, false);
+                return (results, cleanup, false, converterInfos);
             }
 
             // Plain text - apply scrubbers
             results.Add(new("txt", str, target.Name));
-            return (results, cleanup, true);
+            return (results, cleanup, true, converterInfos);
         }
 
         // Try ToString converter (before typed converter, matching Verify(object) order) - apply scrubbers
@@ -223,7 +217,7 @@ target.Extension is null ||
             var stringResult = toString(data, settings.Context);
             var extension = stringResult.Extension ?? "txt";
             results.Add(new(extension, stringResult.Value, target.Name));
-            return (results, cleanup, true);
+            return (results, cleanup, true, converterInfos);
         }
 
         // Try typed converter - apply scrubbers
@@ -238,10 +232,10 @@ target.Extension is null ||
             // Recursively resolve the conversion result targets
             foreach (var convTarget in conversionResult.Targets)
             {
-                // Note: We ignore the applyScrubbers from recursive calls since converter output should be scrubbed
-                var (resolved, resolveCleanup, _) = await ResolveTarget(convTarget);
+                var (resolved, resolveCleanup, _, nestedInfos) = await ResolveTarget(convTarget);
                 cleanup += resolveCleanup;
                 results.AddRange(resolved);
+                converterInfos.AddRange(nestedInfos);
             }
 
             // Add info as a separate target if present
@@ -261,21 +255,22 @@ target.Extension is null ||
                     JsonFormatter.AsJson(settings, counter, new InfoBuilder(true, null, converterAppends))));
             }
 
-            return (results, cleanup, true);
+            return (results, cleanup, true, converterInfos);
         }
 
         // Fall back to JSON serialization with appenders - NO scrubbing (matches original TryGetRootTarget behavior)
         var jsonAppends = VerifierSettings.GetJsonAppenders(settings);
         results.Add(new(
             settings.TxtOrJson,
             JsonFormatter.AsJson(settings, counter, new InfoBuilder(true, data, jsonAppends))));
-        return (results, cleanup, false);
+        return (results, cleanup, false, converterInfos);
     }
 
-    async Task<(List<ResolvedTarget> targets, Func<Task> cleanup)> ResolveStream(Stream stream, string extension, string? name)
+    async Task<(List<ResolvedTarget> targets, Func<Task> cleanup, List<object> converterInfos)> ResolveStream(Stream stream, string extension, string? name)
     {
         var cleanup = () => Task.CompletedTask;
         var results = new List<ResolvedTarget>();
+        var converterInfos = new List<object>();
 
         stream.MoveToStart();
 
@@ -285,23 +280,21 @@ target.Extension is null ||
             var (info, converted, convCleanup) = await DoExtensionConversion(extension, stream, null, name);
             cleanup += convCleanup;
 
-            // Add info target if present
             if (info != null)
             {
-                results.Add(new(
-                    settings.TxtOrJson,
-                    JsonFormatter.AsJson(settings, counter, info)));
+                converterInfos.Add(info);
             }
 
             // Recursively resolve converted targets (they may contain objects)
             foreach (var convTarget in converted)
             {
-                var (resolved, resolveCleanup, _) = await ResolveTarget(convTarget);
+                var (resolved, resolveCleanup, _, nestedInfos) = await ResolveTarget(convTarget);
                 cleanup += resolveCleanup;
                 results.AddRange(resolved);
+                converterInfos.AddRange(nestedInfos);
             }
 
-            return (results, cleanup);
+            return (results, cleanup, converterInfos);
         }
 
         // No converter - convert stream directly to ResolvedTarget
@@ -314,7 +307,7 @@ target.Extension is null ||
             results.Add(new(extension, stream, name));
         }
 
-        return (results, cleanup);
+        return (results, cleanup, converterInfos);
     }
 
     string ConvertXmlToString(XContainer target)

Original file line number	Diff line number	Diff line change
`@@ -42,27 +42,20 @@ async Task<VerifyResult> VerifyInner(object? root, Func<Task>? cleanup, IEnumera`
`42`	`42`	`// Check if root is in targets list (to avoid duplicate processing)`
`43`	`43`	`var rootInTargets = root != null && list.Any(t => ReferenceEquals(t.Data, root));`
`44`	`44`
`45`		`- // Process stream converters (may produce converter info that becomes root)`
`46`		`- var converted = new List<Target>();`
	`45`	`+ // Resolve all targets and collect converter infos`
`47`	`46`	`var converterInfos = new List<object>();`
	`47`	`+ var resolvedTargets = new List<(ResolvedTarget target, bool applyScrubbers)>();`
	`48`	`+`
`48`	`49`	`foreach (var target in list)`
`49`	`50`	`{`
`50`		`- if (!target.PerformConversion \|\|`
`51`		`- target.Extension is null \|\|`
`52`		`- !VerifierSettings.HasStreamConverter(target.Extension))`
`53`		`- {`
`54`		`- converted.Add(target);`
`55`		`- continue;`
`56`		`- }`
	`51`	`+ var (resolvedList, resolveCleanup, applyScrubbers, infos) = await ResolveTarget(target);`
	`52`	`+ cleanup += resolveCleanup;`
	`53`	`+ converterInfos.AddRange(infos);`
`57`	`54`
`58`		`- var (info, convTargets, itemCleanup) = await DoExtensionConversion(target.Extension, target.StreamData, null, target.Name);`
`59`		`- cleanup += itemCleanup;`
`60`		`- if (info != null)`
	`55`	`+ foreach (var resolved in resolvedList)`
`61`	`56`	`{`
`62`		`- converterInfos.Add(info);`
	`57`	`+ resolvedTargets.Add((resolved, applyScrubbers));`
`63`	`58`	`}`
`64`		`-`
`65`		`- converted.AddRange(convTargets);`
`66`	`59`	`}`
`67`	`60`
`68`	`61`	`// If root is null and converters returned info, use converter info as root (for appenders)`
`@@ -87,44 +80,45 @@ target.Extension is null \|\|`
`87`	`80`	`JsonFormatter.AsJson(settings, counter, info)));`
`88`	`81`	`}`
`89`	`82`
`90`		`- // Resolve remaining targets and apply scrubbers inline`
`91`		`- foreach (var target in converted)`
	`83`	`+ // Add resolved targets and apply scrubbers`
	`84`	`+ foreach (var (resolved, applyScrubbers) in resolvedTargets)`
`92`	`85`	`{`
`93`		`- var (resolvedList, resolveCleanup, applyScrubbers) = await ResolveTarget(target);`
`94`		`- cleanup += resolveCleanup;`
`95`		`-`
`96`		`- foreach (var resolved in resolvedList)`
	`86`	`+ if (applyScrubbers && resolved.TryGetStringBuilder(out var builder))`
`97`	`87`	`{`
`98`		`- if (applyScrubbers && resolved.TryGetStringBuilder(out var builder))`
`99`		`- {`
`100`		`- ApplyScrubbers.ApplyForExtension(resolved.Extension, builder, settings, counter);`
`101`		`- }`
`102`		`-`
`103`		`- resultTargets.Add(resolved);`
	`88`	`+ ApplyScrubbers.ApplyForExtension(resolved.Extension, builder, settings, counter);`
`104`	`89`	`}`
	`90`	`+`
	`91`	`+ resultTargets.Add(resolved);`
`105`	`92`	`}`
`106`	`93`
`107`	`94`	`return (cleanup, resultTargets);`
`108`	`95`	`}`
`109`	`96`
`110`		`- async Task<(List<ResolvedTarget> targets, Func<Task> cleanup, bool applyScrubbers)> ResolveTarget(Target target)`
	`97`	`+ async Task<(List<ResolvedTarget> targets, Func<Task> cleanup, bool applyScrubbers, List<object> converterInfos)> ResolveTarget(Target target)`
`111`	`98`	`{`
`112`	`99`	`var cleanup = () => Task.CompletedTask;`
`113`	`100`	`var results = new List<ResolvedTarget>();`
	`101`	`+ var converterInfos = new List<object>();`
`114`	`102`
`115`		`- // If target has an extension, it's already resolved (Stream or StringBuilder)`
`116`		`- // These come from converters or explicit targets, so apply scrubbers`
	`103`	`+ // If target has an extension with stream data, check for stream converter`
`117`	`104`	`if (target.Extension is not null)`
`118`	`105`	`{`
`119`	`106`	`if (target.TryGetStream(out var stream))`
`120`	`107`	`{`
	`108`	`+ if (target.PerformConversion)`
	`109`	`+ {`
	`110`	`+ var (streamResults, streamCleanup, infos) = await ResolveStream(stream, target.Extension, target.Name);`
	`111`	`+ return (streamResults, streamCleanup, true, infos);`
	`112`	`+ }`
	`113`	`+`
`121`	`114`	`results.Add(new(target.Extension, stream, target.Name));`
`122`	`115`	`}`
`123`	`116`	`else if (target.TryGetStringBuilder(out var sb))`
`124`	`117`	`{`
`125`	`118`	`results.Add(new(target.Extension, sb, target.Name));`
`126`	`119`	`}`
`127`		`- return (results, cleanup, true);`
	`120`	`+`
	`121`	`+ return (results, cleanup, true, converterInfos);`
`128`	`122`	`}`
`129`	`123`
`130`	`124`	`// Target contains an arbitrary object - resolve it using full type matching`
`@@ -135,15 +129,15 @@ target.Extension is null \|\|`
`135`	`129`	`results.Add(new(`
`136`	`130`	`settings.TxtOrJson,`
`137`	`131`	`JsonFormatter.AsJson(settings, counter, new InfoBuilder(false, null, []))));`
`138`		`- return (results, cleanup, false);`
	`132`	`+ return (results, cleanup, false, converterInfos);`
`139`	`133`	`}`
`140`	`134`
`141`	`135`	`// Handle XContainer (XDocument, XElement) - apply scrubbers`
`142`	`136`	`if (data is XContainer container)`
`143`	`137`	`{`
`144`	`138`	`var xmlString = ConvertXmlToString(container);`
`145`	`139`	`results.Add(new("xml", xmlString, target.Name));`
`146`		`- return (results, cleanup, true);`
	`140`	`+ return (results, cleanup, true, converterInfos);`
`147`	`141`	`}`
`148`	`142`
`149`	`143`	`// Handle XmlNode - apply scrubbers`
`@@ -154,30 +148,30 @@ target.Extension is null \|\|`
`154`	`148`	`var xdoc = XDocument.Load(reader);`
`155`	`149`	`var xmlString = ConvertXmlToString(xdoc);`
`156`	`150`	`results.Add(new("xml", xmlString, target.Name));`
`157`		`- return (results, cleanup, true);`
	`151`	`+ return (results, cleanup, true, converterInfos);`
`158`	`152`	`}`
`159`	`153`
`160`	`154`	`// Handle FileStream (get extension from filename) - apply scrubbers`
`161`	`155`	`if (data is FileStream fileStream)`
`162`	`156`	`{`
`163`	`157`	`var extension = fileStream.Extension();`
`164`		`- var (streamResults, streamCleanup) = await ResolveStream(fileStream, extension, target.Name);`
`165`		`- return (streamResults, streamCleanup, true);`
	`158`	`+ var (streamResults, streamCleanup, infos) = await ResolveStream(fileStream, extension, target.Name);`
	`159`	`+ return (streamResults, streamCleanup, true, infos);`
`166`	`160`	`}`
`167`	`161`
`168`	`162`	`// Handle Stream - apply scrubbers`
`169`	`163`	`if (data is Stream stream2)`
`170`	`164`	`{`
`171`		`- var (streamResults, streamCleanup) = await ResolveStream(stream2, "bin", target.Name);`
`172`		`- return (streamResults, streamCleanup, true);`
	`165`	`+ var (streamResults, streamCleanup, infos) = await ResolveStream(stream2, "bin", target.Name);`
	`166`	`+ return (streamResults, streamCleanup, true, infos);`
`173`	`167`	`}`
`174`	`168`
`175`	`169`	`// Handle byte[] - apply scrubbers`
`176`	`170`	`if (data is byte[] bytes)`
`177`	`171`	`{`
`178`	`172`	`var memStream = new MemoryStream(bytes);`
`179`		`- var (streamResults, streamCleanup) = await ResolveStream(memStream, "bin", target.Name);`
`180`		`- return (streamResults, streamCleanup, true);`
	`173`	`+ var (streamResults, streamCleanup, infos) = await ResolveStream(memStream, "bin", target.Name);`
	`174`	`+ return (streamResults, streamCleanup, true, infos);`
`181`	`175`	`}`
`182`	`176`
`183`	`177`	`// Handle IEnumerable<Stream> - throw error as in Verify(object)`
`@@ -190,7 +184,7 @@ target.Extension is null \|\|`
`190`	`184`	`if (data is StringBuilder sb2)`
`191`	`185`	`{`
`192`	`186`	`results.Add(new("txt", sb2, target.Name));`
`193`		`- return (results, cleanup, true);`
	`187`	`+ return (results, cleanup, true, converterInfos);`
`194`	`188`	`}`
`195`	`189`
`196`	`190`	`// Handle string - check for JSON appenders first (matches TryGetRootTarget behavior)`
`@@ -209,12 +203,12 @@ target.Extension is null \|\|`
`209`	`203`	`results.Add(new(`
`210`	`204`	`settings.TxtOrJson,`
`211`	`205`	`JsonFormatter.AsJson(settings, counter, new InfoBuilder(false, str, appends))));`
`212`		`- return (results, cleanup, false);`
	`206`	`+ return (results, cleanup, false, converterInfos);`
`213`	`207`	`}`
`214`	`208`
`215`	`209`	`// Plain text - apply scrubbers`
`216`	`210`	`results.Add(new("txt", str, target.Name));`
`217`		`- return (results, cleanup, true);`
	`211`	`+ return (results, cleanup, true, converterInfos);`
`218`	`212`	`}`
`219`	`213`
`220`	`214`	`// Try ToString converter (before typed converter, matching Verify(object) order) - apply scrubbers`
`@@ -223,7 +217,7 @@ target.Extension is null \|\|`
`223`	`217`	`var stringResult = toString(data, settings.Context);`
`224`	`218`	`var extension = stringResult.Extension ?? "txt";`
`225`	`219`	`results.Add(new(extension, stringResult.Value, target.Name));`
`226`		`- return (results, cleanup, true);`
	`220`	`+ return (results, cleanup, true, converterInfos);`
`227`	`221`	`}`
`228`	`222`
`229`	`223`	`// Try typed converter - apply scrubbers`
`@@ -238,10 +232,10 @@ target.Extension is null \|\|`
`238`	`232`	`// Recursively resolve the conversion result targets`
`239`	`233`	`foreach (var convTarget in conversionResult.Targets)`
`240`	`234`	`{`
`241`		`- // Note: We ignore the applyScrubbers from recursive calls since converter output should be scrubbed`
`242`		`- var (resolved, resolveCleanup, _) = await ResolveTarget(convTarget);`
	`235`	`+ var (resolved, resolveCleanup, _, nestedInfos) = await ResolveTarget(convTarget);`
`243`	`236`	`cleanup += resolveCleanup;`
`244`	`237`	`results.AddRange(resolved);`
	`238`	`+ converterInfos.AddRange(nestedInfos);`
`245`	`239`	`}`
`246`	`240`
`247`	`241`	`// Add info as a separate target if present`
`@@ -261,21 +255,22 @@ target.Extension is null \|\|`
`261`	`255`	`JsonFormatter.AsJson(settings, counter, new InfoBuilder(true, null, converterAppends))));`
`262`	`256`	`}`
`263`	`257`
`264`		`- return (results, cleanup, true);`
	`258`	`+ return (results, cleanup, true, converterInfos);`
`265`	`259`	`}`
`266`	`260`
`267`	`261`	`// Fall back to JSON serialization with appenders - NO scrubbing (matches original TryGetRootTarget behavior)`
`268`	`262`	`var jsonAppends = VerifierSettings.GetJsonAppenders(settings);`
`269`	`263`	`results.Add(new(`
`270`	`264`	`settings.TxtOrJson,`
`271`	`265`	`JsonFormatter.AsJson(settings, counter, new InfoBuilder(true, data, jsonAppends))));`
`272`		`- return (results, cleanup, false);`
	`266`	`+ return (results, cleanup, false, converterInfos);`
`273`	`267`	`}`
`274`	`268`
`275`		`- async Task<(List<ResolvedTarget> targets, Func<Task> cleanup)> ResolveStream(Stream stream, string extension, string? name)`
	`269`	`+ async Task<(List<ResolvedTarget> targets, Func<Task> cleanup, List<object> converterInfos)> ResolveStream(Stream stream, string extension, string? name)`
`276`	`270`	`{`
`277`	`271`	`var cleanup = () => Task.CompletedTask;`
`278`	`272`	`var results = new List<ResolvedTarget>();`
	`273`	`+ var converterInfos = new List<object>();`
`279`	`274`
`280`	`275`	`stream.MoveToStart();`
`281`	`276`
`@@ -285,23 +280,21 @@ target.Extension is null \|\|`
`285`	`280`	`var (info, converted, convCleanup) = await DoExtensionConversion(extension, stream, null, name);`
`286`	`281`	`cleanup += convCleanup;`
`287`	`282`
`288`		`- // Add info target if present`
`289`	`283`	`if (info != null)`
`290`	`284`	`{`
`291`		`- results.Add(new(`
`292`		`- settings.TxtOrJson,`
`293`		`- JsonFormatter.AsJson(settings, counter, info)));`
	`285`	`+ converterInfos.Add(info);`
`294`	`286`	`}`
`295`	`287`
`296`	`288`	`// Recursively resolve converted targets (they may contain objects)`
`297`	`289`	`foreach (var convTarget in converted)`
`298`	`290`	`{`
`299`		`- var (resolved, resolveCleanup, _) = await ResolveTarget(convTarget);`
	`291`	`+ var (resolved, resolveCleanup, _, nestedInfos) = await ResolveTarget(convTarget);`
`300`	`292`	`cleanup += resolveCleanup;`
`301`	`293`	`results.AddRange(resolved);`
	`294`	`+ converterInfos.AddRange(nestedInfos);`
`302`	`295`	`}`
`303`	`296`
`304`		`- return (results, cleanup);`
	`297`	`+ return (results, cleanup, converterInfos);`
`305`	`298`	`}`
`306`	`299`
`307`	`300`	`// No converter - convert stream directly to ResolvedTarget`
`@@ -314,7 +307,7 @@ target.Extension is null \|\|`
`314`	`307`	`results.Add(new(extension, stream, name));`
`315`	`308`	`}`
`316`	`309`
`317`		`- return (results, cleanup);`
	`310`	`+ return (results, cleanup, converterInfos);`
`318`	`311`	`}`
`319`	`312`
`320`	`313`	`string ConvertXmlToString(XContainer target)`