Experimental markdown output

Sources/SwiftDocC/Converter/DocumentationContextConverter.swift

@@ -113,4 +113,21 @@ public class DocumentationContextConverter {
         )
         return translator.visit(node.semantic) as? RenderNode
     }
+
+    /// Converts a documentation node to a markdown node.
+    /// - Parameters:
+    ///   - node: The documentation node to convert.
+    /// - Returns: The markdown node representation of the documentation node.
+    internal func markdownOutput(for node: DocumentationNode) -> CollectedMarkdownOutput? {
+        guard !node.isVirtual else {
+            return nil
+        }
+
+        var visitor = MarkdownOutputSemanticVisitor(context: context, node: node)
+
+        if let node = visitor.createOutput() {
+            return CollectedMarkdownOutput(identifier: visitor.identifier, node: node, manifest: visitor.manifest)
+        }
+        return nil
+    }
 }

Sources/SwiftDocC/Infrastructure/ConvertActionConverter.swift

@@ -80,6 +80,7 @@ package enum ConvertActionConverter {
         var assets = [RenderReferenceType : [any RenderReference]]()
         var coverageInfo = [CoverageDataEntry]()
         let coverageFilterClosure = documentationCoverageOptions.generateFilterClosure()
+        var markdownManifest = MarkdownOutputManifest(title: context.inputs.displayName, documents: [])
 
         // An inner function to gather problems for errors encountered during the conversion.
         //
@@ -131,6 +132,21 @@ package enum ConvertActionConverter {
                         return
                     }
 
+                    if FeatureFlags.current.isExperimentalMarkdownOutputEnabled,
+                       let markdownConsumer = outputConsumer as? (any ConvertOutputMarkdownConsumer),
+                       let markdownNode = converter.markdownOutput(for: entity)
+                    {
+                        try markdownConsumer.consume(markdownNode: markdownNode.writable)
+                        if FeatureFlags.current.isExperimentalMarkdownOutputManifestEnabled,
+                           let manifest = markdownNode.manifest
+                        {
+                            resultsGroup.async(queue: resultsSyncQueue) {
+                                markdownManifest.documents.formUnion(manifest.documents)
+                                markdownManifest.relationships.formUnion(manifest.relationships)
+                            }
+                        }
+                    }
+
                     try outputConsumer.consume(renderNode: renderNode)
 
                     switch documentationCoverageOptions.level {
@@ -235,6 +251,12 @@ package enum ConvertActionConverter {
                 }
             }
         }
+
+        if FeatureFlags.current.isExperimentalMarkdownOutputManifestEnabled,
+           let markdownConsumer = outputConsumer as? (any ConvertOutputMarkdownConsumer)
+        {
+            try markdownConsumer.consume(markdownManifest: markdownManifest)
+        }
 
         switch documentationCoverageOptions.level {
         case .detailed, .brief:

Sources/SwiftDocC/Infrastructure/ConvertOutputConsumer.swift

@@ -48,6 +48,15 @@ public protocol ConvertOutputConsumer {
 
     /// Consumes a file representation of the local link resolution information.
     func consume(linkResolutionInformation: SerializableLinkResolutionInformation) throws
+
+}
+
+package protocol ConvertOutputMarkdownConsumer {
+    /// Consumes a markdown output node
+    func consume(markdownNode: WritableMarkdownOutputNode) throws
+
+    /// Consumes a markdown output manifest
+    func consume(markdownManifest: MarkdownOutputManifest) throws
 }
 
 // Default implementations that discard the documentation conversion products, for consumers that don't need these