diff --git a/Sources/SwiftDocC/Checker/Checkers/DuplicateTopicsSection.swift b/Sources/SwiftDocC/Checker/Checkers/DuplicateTopicsSection.swift
index d4ad680891..5e3662eef7 100644
--- a/Sources/SwiftDocC/Checker/Checkers/DuplicateTopicsSection.swift
+++ b/Sources/SwiftDocC/Checker/Checkers/DuplicateTopicsSection.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -11,9 +11,7 @@
 public import Foundation
 public import Markdown
 
-/**
- A `Document` may only have one level-2 "Topics" heading at the top level, since it serves as structured data for a documentation bundle's hierarchy.
- */
+/// A document only supports a single level-2 "Topics" heading at the top level, because it's used to define the documentation's hierarchy.
 public struct DuplicateTopicsSections: Checker {
     /// The list of level-2 headings with the text "Topics" found in the document.
     public var foundTopicsHeadings = [Heading]()
diff --git a/Sources/SwiftDocC/Converter/DocumentationContextConverter.swift b/Sources/SwiftDocC/Converter/DocumentationContextConverter.swift
index 72e23665bb..03bcf45d03 100644
--- a/Sources/SwiftDocC/Converter/DocumentationContextConverter.swift
+++ b/Sources/SwiftDocC/Converter/DocumentationContextConverter.swift
@@ -20,9 +20,6 @@ public class DocumentationContextConverter {
     /// The context the converter uses to resolve references it finds in the documentation node's content.
     let context: DocumentationContext
     
-    /// The bundle that contains the content from which the documentation node originated.
-    let bundle: DocumentationBundle
-    
     /// A context that contains common pre-rendered pieces of content.
     let renderContext: RenderContext
     
@@ -43,12 +40,11 @@ public class DocumentationContextConverter {
     /// The remote source control repository where the documented module's source is hosted.
     let sourceRepository: SourceRepository?
     
-    /// Creates a new node converter for the given bundle and context.
+    /// Creates a new node converter for the given context.
     ///
-    /// The converter uses bundle and context to resolve references to other documentation and describe the documentation hierarchy.
+    /// The converter uses the context to resolve references to other documentation and describe the documentation hierarchy.
     ///
     /// - Parameters:
-    ///   - bundle: The bundle that contains the content from which the documentation node originated.
     ///   - context: The context that the converter uses to to resolve references it finds in the documentation node's content.
     ///   - renderContext: A context that contains common pre-rendered pieces of content.
     ///   - emitSymbolSourceFileURIs: Whether the documentation converter should include
@@ -61,7 +57,6 @@ public class DocumentationContextConverter {
     ///   - sourceRepository: The source repository where the documentation's sources are hosted.
     ///   - symbolIdentifiersWithExpandedDocumentation: A list of symbol IDs that have version of their documentation page with more content that a renderer can link to.
     public init(
-        bundle: DocumentationBundle,
         context: DocumentationContext,
         renderContext: RenderContext,
         emitSymbolSourceFileURIs: Bool = false,
@@ -69,7 +64,6 @@ public class DocumentationContextConverter {
         sourceRepository: SourceRepository? = nil,
         symbolIdentifiersWithExpandedDocumentation: [String]? = nil
     ) {
-        self.bundle = bundle
         self.context = context
         self.renderContext = renderContext
         self.shouldEmitSymbolSourceFileURIs = emitSymbolSourceFileURIs
@@ -78,6 +72,26 @@ public class DocumentationContextConverter {
         self.symbolIdentifiersWithExpandedDocumentation = symbolIdentifiersWithExpandedDocumentation
     }
     
+    @available(*, deprecated, renamed: "init(context:renderContext:emitSymbolSourceFileURIs:emitSymbolAccessLevels:sourceRepository:symbolIdentifiersWithExpandedDocumentation:)", message: "Use 'init(context:renderContext:emitSymbolSourceFileURIs:emitSymbolAccessLevels:sourceRepository:symbolIdentifiersWithExpandedDocumentation:)' instead. This deprecated API will be removed after 6.3 is released")
+    public convenience init(
+        bundle _: DocumentationBundle,
+        context: DocumentationContext,
+        renderContext: RenderContext,
+        emitSymbolSourceFileURIs: Bool = false,
+        emitSymbolAccessLevels: Bool = false,
+        sourceRepository: SourceRepository? = nil,
+        symbolIdentifiersWithExpandedDocumentation: [String]? = nil
+    ) {
+        self.init(
+            context: context,
+            renderContext: renderContext,
+            emitSymbolSourceFileURIs: emitSymbolSourceFileURIs,
+            emitSymbolAccessLevels: emitSymbolAccessLevels,
+            sourceRepository: sourceRepository,
+            symbolIdentifiersWithExpandedDocumentation: symbolIdentifiersWithExpandedDocumentation
+        )
+    }
+    
     /// Converts a documentation node to a render node.
     ///
     /// Convert a documentation node into a render node to get a self-contained, persist-able representation of a given topic's data, so you can write it to disk, send it over a network, or otherwise process it.
@@ -91,7 +105,6 @@ public class DocumentationContextConverter {
 
         var translator = RenderNodeTranslator(
             context: context,
-            bundle: bundle,
             identifier: node.reference,
             renderContext: renderContext,
             emitSymbolSourceFileURIs: shouldEmitSymbolSourceFileURIs,
diff --git a/Sources/SwiftDocC/Converter/DocumentationNodeConverter.swift b/Sources/SwiftDocC/Converter/DocumentationNodeConverter.swift
index 77804359e8..4844e7daba 100644
--- a/Sources/SwiftDocC/Converter/DocumentationNodeConverter.swift
+++ b/Sources/SwiftDocC/Converter/DocumentationNodeConverter.swift
@@ -15,21 +15,21 @@ public struct DocumentationNodeConverter {
     /// The context the converter uses to resolve references it finds in the documentation node's content.
     let context: DocumentationContext
     
-    /// The bundle that contains the content from which the documentation node originated.
-    let bundle: DocumentationBundle
-    
-    /// Creates a new node converter for the given bundle and context.
+    /// Creates a new node converter for the given context.
     ///
-    /// The converter uses bundle and context to resolve references to other documentation and describe the documentation hierarchy.
+    /// The converter uses context to resolve references to other documentation and describe the documentation hierarchy.
     ///
     /// - Parameters:
-    ///   - bundle: The bundle that contains the content from which the documentation node originated.
     ///   - context: The context that the converter uses to to resolve references it finds in the documentation node's content.
-    public init(bundle: DocumentationBundle, context: DocumentationContext) {
-        self.bundle = bundle
+    public init(context: DocumentationContext) {
         self.context = context
     }
     
+    @available(*, deprecated, renamed: "init(context:)", message: "Use 'init(context:)' instead. This deprecated API will be removed after 6.3 is released")
+    public init(bundle _: DocumentationBundle, context: DocumentationContext) {
+        self.init(context: context)
+    }
+    
     /// Converts a documentation node to a render node.
     ///
     /// Convert a documentation node into a render node to get a self-contained, persistable representation of a given topic's data, so you can write it to disk, send it over a network, or otherwise process it.
@@ -37,7 +37,7 @@ public struct DocumentationNodeConverter {
     ///   - node: The documentation node to convert.
     /// - Returns: The render node representation of the documentation node.
     public func convert(_ node: DocumentationNode) -> RenderNode {
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         return translator.visit(node.semantic) as! RenderNode
     }
 }
diff --git a/Sources/SwiftDocC/DocumentationService/Convert/ConvertService+DataProvider.swift b/Sources/SwiftDocC/DocumentationService/Convert/ConvertService+DataProvider.swift
index 75fc4b0a72..81859f7b94 100644
--- a/Sources/SwiftDocC/DocumentationService/Convert/ConvertService+DataProvider.swift
+++ b/Sources/SwiftDocC/DocumentationService/Convert/ConvertService+DataProvider.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -12,7 +12,7 @@ import Foundation
 
 extension ConvertService {
     /// Creates a bundle and an associated in-memory data provider from the information of a given convert request
-    static func makeBundleAndInMemoryDataProvider(_ request: ConvertRequest) -> (bundle: DocumentationBundle, provider: InMemoryDataProvider) {
+    static func makeBundleAndInMemoryDataProvider(_ request: ConvertRequest) -> (inputs: DocumentationContext.Inputs, provider: InMemoryDataProvider) {
         var files: [URL: Data] = [:]
         files.reserveCapacity(
               request.symbolGraphs.count
@@ -21,10 +21,10 @@ extension ConvertService {
             + request.miscResourceURLs.count
         )
         for markupFile in request.markupFiles {
-            files[makeURL().appendingPathExtension(DocumentationBundleFileTypes.referenceFileExtension)] = markupFile
+            files[makeURL().appendingPathExtension(DocumentationInputFileTypes.referenceFileExtension)] = markupFile
         }
         for tutorialFile in request.tutorialFiles {
-            files[makeURL().appendingPathExtension(DocumentationBundleFileTypes.tutorialFileExtension)] = tutorialFile
+            files[makeURL().appendingPathExtension(DocumentationInputFileTypes.tutorialFileExtension)] = tutorialFile
         }
         let markupFileURL = Array(files.keys)
         
@@ -37,8 +37,8 @@ extension ConvertService {
         }
         
         return (
-            DocumentationBundle(
-                info: request.bundleInfo,
+            DocumentationContext.Inputs(
+                info: request.info,
                 symbolGraphURLs: symbolGraphURLs,
                 markupURLs: markupFileURL,
                 miscResourceURLs: request.miscResourceURLs
diff --git a/Sources/SwiftDocC/DocumentationService/Convert/ConvertService.swift b/Sources/SwiftDocC/DocumentationService/Convert/ConvertService.swift
index fc22a5c356..b63b083a04 100644
--- a/Sources/SwiftDocC/DocumentationService/Convert/ConvertService.swift
+++ b/Sources/SwiftDocC/DocumentationService/Convert/ConvertService.swift
@@ -128,7 +128,7 @@ public struct ConvertService: DocumentationService {
             
             if let linkResolvingServer {
                 let resolver = try OutOfProcessReferenceResolver(
-                    bundleID: request.bundleInfo.id,
+                    bundleID: request.info.id,
                     server: linkResolvingServer,
                     convertRequestIdentifier: messageIdentifier
                 )
@@ -137,28 +137,28 @@ public struct ConvertService: DocumentationService {
                 configuration.externalDocumentationConfiguration.globalSymbolResolver = resolver
             }
             
-            let bundle: DocumentationBundle
+            let inputs: DocumentationContext.Inputs
             let dataProvider: any DataProvider
             
             let inputProvider = DocumentationContext.InputsProvider()
-            if let bundleLocation = request.bundleLocation,
-               let catalogURL = try inputProvider.findCatalog(startingPoint: bundleLocation, allowArbitraryCatalogDirectories: allowArbitraryCatalogDirectories)
+            if let catalogLocation = request.catalogLocation,
+               let catalogURL = try inputProvider.findCatalog(startingPoint: catalogLocation, allowArbitraryCatalogDirectories: allowArbitraryCatalogDirectories)
             {
-                let bundleDiscoveryOptions = try BundleDiscoveryOptions(
-                    fallbackInfo: request.bundleInfo,
+                let bundleDiscoveryOptions = try CatalogDiscoveryOptions(
+                    fallbackInfo: request.info,
                     additionalSymbolGraphFiles: []
                 )
                 
-                bundle = try inputProvider.makeInputs(contentOf: catalogURL, options: bundleDiscoveryOptions)
+                inputs = try inputProvider.makeInputs(contentOf: catalogURL, options: bundleDiscoveryOptions)
                 dataProvider = FileManager.default
             } else {
-                (bundle, dataProvider) = Self.makeBundleAndInMemoryDataProvider(request)
+                (inputs, dataProvider) = Self.makeBundleAndInMemoryDataProvider(request)
             }
             
-            let context = try await DocumentationContext(bundle: bundle, dataProvider: dataProvider, configuration: configuration)
+            let context = try await DocumentationContext(inputs: inputs, dataProvider: dataProvider, configuration: configuration)
             
             // Precompute the render context
-            let renderContext = RenderContext(documentationContext: context, bundle: bundle)
+            let renderContext = RenderContext(documentationContext: context)
             
             let symbolIdentifiersMeetingRequirementsForExpandedDocumentation: [String]? = request.symbolIdentifiersWithExpandedDocumentation?.compactMap { identifier, expandedDocsRequirement in
                 guard let documentationNode = context.documentationCache[identifier] else {
@@ -168,7 +168,6 @@ public struct ConvertService: DocumentationService {
                 return documentationNode.meetsExpandedDocumentationRequirements(expandedDocsRequirement) ? identifier : nil
             }
             let converter = DocumentationContextConverter(
-                bundle: bundle,
                 context: context,
                 renderContext: renderContext,
                 emitSymbolSourceFileURIs: request.emitSymbolSourceFileURIs,
@@ -243,12 +242,12 @@ public struct ConvertService: DocumentationService {
             .compactMap { (value, isDocumentationExtensionContent) -> (ResolvedTopicReference, RenderReferenceStore.TopicContent)? in
                 let (topicReference, article) = value
                 
-                let bundle = context.bundle
-                guard bundle.id == topicReference.bundleID else { return nil }
-                let renderer = DocumentationContentRenderer(documentationContext: context, bundle: bundle)
+                let inputs = context.inputs
+                guard inputs.id == topicReference.bundleID else { return nil }
+                let renderer = DocumentationContentRenderer(documentationContext: context)
                 
                 let documentationNodeKind: DocumentationNode.Kind = isDocumentationExtensionContent ? .unknownSymbol : .article
-                let overridingDocumentationNode = DocumentationContext.documentationNodeAndTitle(for: article, kind: documentationNodeKind, in: bundle)?.node
+                let overridingDocumentationNode = DocumentationContext.documentationNodeAndTitle(for: article, kind: documentationNodeKind, in: inputs)?.node
                 var dependencies = RenderReferenceDependencies()
                 let renderReference = renderer.renderReference(for: topicReference, with: overridingDocumentationNode, dependencies: &dependencies)
                 
diff --git a/Sources/SwiftDocC/DocumentationService/Convert/Fallback Link Resolution/ConvertServiceFallbackResolver.swift b/Sources/SwiftDocC/DocumentationService/Convert/Fallback Link Resolution/ConvertServiceFallbackResolver.swift
index 8ee83c262e..d96bef0fee 100644
--- a/Sources/SwiftDocC/DocumentationService/Convert/Fallback Link Resolution/ConvertServiceFallbackResolver.swift	
+++ b/Sources/SwiftDocC/DocumentationService/Convert/Fallback Link Resolution/ConvertServiceFallbackResolver.swift	
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2024-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -26,7 +26,7 @@ protocol ConvertServiceFallbackResolver {
     /// The bundle identifier for the fallback resolver.
     ///
     /// The fallback resolver will only resolve links with this bundle identifier.
-    var bundleID: DocumentationBundle.Identifier { get }
+    var bundleID: DocumentationContext.Inputs.Identifier { get }
     
     // MARK: References
     
diff --git a/Sources/SwiftDocC/DocumentationService/Models/Services/Convert/ConvertRequest.swift b/Sources/SwiftDocC/DocumentationService/Models/Services/Convert/ConvertRequest.swift
index e09c124503..e12ea04175 100644
--- a/Sources/SwiftDocC/DocumentationService/Models/Services/Convert/ConvertRequest.swift
+++ b/Sources/SwiftDocC/DocumentationService/Models/Services/Convert/ConvertRequest.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -13,11 +13,17 @@ public import Foundation
 
 /// A request to convert in-memory documentation.
 public struct ConvertRequest: Codable {
-    /// Information about the documentation bundle to convert.
+    /// Information about the documentation catalog to convert.
     ///
     /// ## See Also
-    /// - ``DocumentationBundle/Info``
-    public var bundleInfo: DocumentationBundle.Info
+    /// - ``DocumentationContext/Inputs/Info``
+    public var info: DocumentationContext.Inputs.Info
+    
+    @available(*, deprecated, renamed: "info", message: "Use 'info' instead. This deprecated API will be removed after 6.3 is released.")
+    public var bundleInfo: URL? {
+        get { catalogLocation }
+        set { catalogLocation = newValue }
+    }
     
     /// Feature flags to enable when performing this convert request.
     public var featureFlags: FeatureFlags
@@ -51,16 +57,22 @@ public struct ConvertRequest: Codable {
     /// Whether the conversion's render reference store should be included in the response.
     ///
     /// The ``RenderReferenceStore`` contains compiled information for documentation nodes registered in a context. This
-    /// information can be used as a lightweight index of the available documentation content in the bundle that's been converted.
+    /// information can be used as a lightweight index of the available documentation content in the context that's been converted.
     public var includeRenderReferenceStore: Bool?
     
-    /// The file location of the bundle to convert, if any.
-    public var bundleLocation: URL?
+    /// The file location of the catalog to convert, if any.
+    public var catalogLocation: URL?
+    
+    @available(*, deprecated, renamed: "catalogLocation", message: "Use 'catalogLocation' instead. This deprecated API will be removed after 6.3 is released.")
+    public var bundleLocation: URL? {
+        get { catalogLocation }
+        set { catalogLocation = newValue }
+    }
     
-    /// The symbols graph data included in the documentation bundle to convert.
+    /// The symbols graph data included in the documentation catalog to convert.
     ///
     /// ## See Also
-    /// - ``DocumentationBundle/symbolGraphURLs``
+    /// - ``DocumentationContext/Inputs/symbolGraphURLs``
     public var symbolGraphs: [Data]
     
     /// The mapping of external symbol identifiers to lines of a documentation comment that overrides the value in the symbol graph.
@@ -72,20 +84,20 @@ public struct ConvertRequest: Codable {
     /// Whether the conversion's rendered documentation should include source file location metadata.
     public var emitSymbolSourceFileURIs: Bool
     
-    /// The article and documentation extension file data included in the documentation bundle to convert.
+    /// The article and documentation extension file data included in the documentation catalog to convert.
     ///
     /// ## See Also
-    /// - ``DocumentationBundle/markupURLs``
+    /// - ``DocumentationContext/Inputs/markupURLs``
     public var markupFiles: [Data]
     
     
-    /// The tutorial file data included in the documentation bundle to convert.
+    /// The tutorial file data included in the documentation catalog to convert.
     public var tutorialFiles: [Data]
     
-    /// The on-disk resources in the documentation bundle to convert.
+    /// The on-disk resources in the documentation catalog to convert.
     ///
     /// ## See Also
-    /// - ``DocumentationBundle/miscResourceURLs``
+    /// - ``DocumentationContext/Inputs/miscResourceURLs``
     public var miscResourceURLs: [URL]
     
     /// The symbol identifiers that have an expanded documentation page available if they meet the associated access level requirement.
@@ -97,31 +109,31 @@ public struct ConvertRequest: Codable {
     
     /// Creates a request to convert in-memory documentation.
     /// - Parameters:
-    ///   - bundleInfo: Information about the bundle to convert.
+    ///   - info: Information about the catalog to convert.
     ///   - featureFlags: Feature flags to enable when performing this convert request.
     ///   - externalIDsToConvert: The external IDs of the symbols to convert.
     ///   - documentPathsToConvert: The paths of the documentation nodes to convert.
     ///   - includeRenderReferenceStore: Whether the conversion's render reference store should be included in the
     ///   response.
-    ///   - bundleLocation: The file location of the documentation bundle to convert, if any.
-    ///   - symbolGraphs: The symbols graph data included in the documentation bundle to convert.
+    ///   - catalogLocation: The file location of the documentation catalog to convert, if any.
+    ///   - symbolGraphs: The symbols graph data included in the documentation catalog to convert.
     ///   - overridingDocumentationComments: The mapping of external symbol identifiers to lines of a
     ///   documentation comment that overrides the value in the symbol graph.
     ///   - emitSymbolSourceFileURIs: Whether the conversion's rendered documentation should include source file location metadata.
     ///   - knownDisambiguatedSymbolPathComponents: The mapping of external symbol identifiers to
     ///   known disambiguated symbol path components.
-    ///   - markupFiles: The article and documentation extension file data included in the documentation bundle to convert.
-    ///   - tutorialFiles: The tutorial file data included in the documentation bundle to convert.
-    ///   - miscResourceURLs: The on-disk resources in the documentation bundle to convert.
+    ///   - markupFiles: The article and documentation extension file data included in the documentation catalog to convert.
+    ///   - tutorialFiles: The tutorial file data included in the documentation catalog to convert.
+    ///   - miscResourceURLs: The on-disk resources in the documentation catalog to convert.
     ///   - symbolIdentifiersWithExpandedDocumentation: A dictionary of identifiers to requirements for these symbols to have expanded
     ///   documentation available.
     public init(
-        bundleInfo: DocumentationBundle.Info,
+        info: DocumentationContext.Inputs.Info,
         featureFlags: FeatureFlags = FeatureFlags(),
         externalIDsToConvert: [String]?,
         documentPathsToConvert: [String]? = nil,
         includeRenderReferenceStore: Bool? = nil,
-        bundleLocation: URL? = nil,
+        catalogLocation: URL? = nil,
         symbolGraphs: [Data],
         overridingDocumentationComments: [String: [Line]]? = nil,
         knownDisambiguatedSymbolPathComponents: [String: [String]]? = nil,
@@ -134,7 +146,7 @@ public struct ConvertRequest: Codable {
         self.externalIDsToConvert = externalIDsToConvert
         self.documentPathsToConvert = documentPathsToConvert
         self.includeRenderReferenceStore = includeRenderReferenceStore
-        self.bundleLocation = bundleLocation
+        self.catalogLocation = catalogLocation
         self.symbolGraphs = symbolGraphs
         self.overridingDocumentationComments = overridingDocumentationComments
         self.knownDisambiguatedSymbolPathComponents = knownDisambiguatedSymbolPathComponents
@@ -148,10 +160,45 @@ public struct ConvertRequest: Codable {
         self.markupFiles = markupFiles
         self.tutorialFiles = tutorialFiles
         self.miscResourceURLs = miscResourceURLs
-        self.bundleInfo = bundleInfo
+        self.info = info
         self.featureFlags = featureFlags
         self.symbolIdentifiersWithExpandedDocumentation = symbolIdentifiersWithExpandedDocumentation
     }
+    
+    @available(*, deprecated, renamed: "init(info:featureFlags:externalIDsToConvert:documentPathsToConvert:includeRenderReferenceStore:catalogLocation:symbolGraphs:overridingDocumentationComments:knownDisambiguatedSymbolPathComponents:emitSymbolSourceFileURIs:markupFiles:tutorialFiles:miscResourceURLs:symbolIdentifiersWithExpandedDocumentation:)", message: "Use 'init(info:featureFlags:externalIDsToConvert:documentPathsToConvert:includeRenderReferenceStore:catalogLocation:symbolGraphs:overridingDocumentationComments:knownDisambiguatedSymbolPathComponents:emitSymbolSourceFileURIs:markupFiles:tutorialFiles:miscResourceURLs:symbolIdentifiersWithExpandedDocumentation:)' instead. This deprecated API will be removed after 6.3 is released.")
+    public init(
+        bundleInfo: DocumentationContext.Inputs.Info,
+        featureFlags: FeatureFlags = FeatureFlags(),
+        externalIDsToConvert: [String]?,
+        documentPathsToConvert: [String]? = nil,
+        includeRenderReferenceStore: Bool? = nil,
+        bundleLocation: URL? = nil,
+        symbolGraphs: [Data],
+        overridingDocumentationComments: [String: [Line]]? = nil,
+        knownDisambiguatedSymbolPathComponents: [String: [String]]? = nil,
+        emitSymbolSourceFileURIs: Bool = true,
+        markupFiles: [Data],
+        tutorialFiles: [Data] = [],
+        miscResourceURLs: [URL],
+        symbolIdentifiersWithExpandedDocumentation: [String: ExpandedDocumentationRequirements]? = nil
+    ) {
+        self.init(
+            info: bundleInfo,
+            featureFlags: featureFlags,
+            externalIDsToConvert: externalIDsToConvert,
+            documentPathsToConvert: documentPathsToConvert,
+            includeRenderReferenceStore: includeRenderReferenceStore,
+            catalogLocation: bundleLocation,
+            symbolGraphs: symbolGraphs,
+            overridingDocumentationComments: overridingDocumentationComments,
+            knownDisambiguatedSymbolPathComponents: knownDisambiguatedSymbolPathComponents,
+            emitSymbolSourceFileURIs: emitSymbolSourceFileURIs,
+            markupFiles: markupFiles,
+            tutorialFiles: tutorialFiles,
+            miscResourceURLs: miscResourceURLs,
+            symbolIdentifiersWithExpandedDocumentation: symbolIdentifiersWithExpandedDocumentation
+        )
+    }
 }
 
 extension ConvertRequest {
diff --git a/Sources/SwiftDocC/DocumentationService/Models/Services/Convert/ConvertResponse.swift b/Sources/SwiftDocC/DocumentationService/Models/Services/Convert/ConvertResponse.swift
index 264432825f..27071b2f62 100644
--- a/Sources/SwiftDocC/DocumentationService/Models/Services/Convert/ConvertResponse.swift
+++ b/Sources/SwiftDocC/DocumentationService/Models/Services/Convert/ConvertResponse.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -18,10 +18,10 @@ public struct ConvertResponse: Codable {
     /// The render nodes that were created as part of the conversion, encoded as JSON.
     public var renderNodes: [Data]
     
-    /// The render reference store that was created as part of the bundle's conversion, encoded as JSON.
+    /// The render reference store that was created as part of the documentation's conversion, encoded as JSON.
     ///
     /// The ``RenderReferenceStore`` contains compiled information for documentation nodes that were registered as part of
-    /// the conversion. This information can be used as a lightweight index of the available documentation content in the bundle that's
+    /// the conversion. This information can be used as a lightweight index of the available documentation content in the context that's
     /// been converted.
     public var renderReferenceStore: Data?
     
diff --git a/Sources/SwiftDocC/Indexing/Navigator/AvailabilityIndex+Ext.swift b/Sources/SwiftDocC/Indexing/Navigator/AvailabilityIndex+Ext.swift
index 1309a484c7..3a6e8cc94d 100644
--- a/Sources/SwiftDocC/Indexing/Navigator/AvailabilityIndex+Ext.swift
+++ b/Sources/SwiftDocC/Indexing/Navigator/AvailabilityIndex+Ext.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -63,7 +63,7 @@ extension AvailabilityIndex {
 // MARK: - InterfaceLanguage
 
 /**
- Interface Language identifies a programming language used to index a content of a documentation bundle.
+ Interface Language identifies a programming language used to index a content of a documentation context.
  
  - Note: The name reflects what a render node JSON provides to identify a programming language.
  The name has been decided to avoid confusion with locale languages.
diff --git a/Sources/SwiftDocC/Indexing/Navigator/NavigatorIndex.swift b/Sources/SwiftDocC/Indexing/Navigator/NavigatorIndex.swift
index 4024bf3f93..334bfbf117 100644
--- a/Sources/SwiftDocC/Indexing/Navigator/NavigatorIndex.swift
+++ b/Sources/SwiftDocC/Indexing/Navigator/NavigatorIndex.swift
@@ -14,7 +14,7 @@ import Crypto
 /**
  A `NavigatorIndex` contains all the necessary information to display the data inside a navigator.
  The data ranges from the tree to the necessary pieces of information to filter the content and perform actions in a fast way.
- A navigator index is created per bundle and needs a bundle identifier to correctly work. Anonymous bundles are allowed, but they limit
+ A navigator index is created per context and needs a bundle identifier to correctly work. Anonymous bundles are allowed, but they limit
  the functionalities of the index.
  
  A `NavigatorIndex` is composed by two main components:
diff --git a/Sources/SwiftDocC/Infrastructure/Bundle Assets/BundleData.swift b/Sources/SwiftDocC/Infrastructure/Bundle Assets/BundleData.swift
index afbd5893e5..49110d0b58 100644
--- a/Sources/SwiftDocC/Infrastructure/Bundle Assets/BundleData.swift	
+++ b/Sources/SwiftDocC/Infrastructure/Bundle Assets/BundleData.swift	
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -20,7 +20,7 @@ public struct BundleData {
     
     /// Creates a bundle data value given its location and an associated trait collection.
     /// - Parameters:
-    ///   - url: The location of the resource in the documentation bundle.
+    ///   - url: The location of the resource in the documentation catalog.
     ///   - traitCollection: An optional trait collection associated with the resource.
     public init(url: URL, traitCollection: DataTraitCollection?) {
         self.url = url
diff --git a/Sources/SwiftDocC/Infrastructure/Bundle Assets/DataAssetManager.swift b/Sources/SwiftDocC/Infrastructure/Bundle Assets/DataAssetManager.swift
index c36f2542dc..86d2926fbc 100644
--- a/Sources/SwiftDocC/Infrastructure/Bundle Assets/DataAssetManager.swift	
+++ b/Sources/SwiftDocC/Infrastructure/Bundle Assets/DataAssetManager.swift	
@@ -348,10 +348,10 @@ public struct AssetReference: Hashable, Codable {
     public var assetName: String
     
     /// The identifier of the bundle the asset is apart of.
-    public let bundleID: DocumentationBundle.Identifier
+    public let bundleID: DocumentationContext.Inputs.Identifier
     
     /// Creates a reference from a given asset name and the bundle it is apart of.
-    public init(assetName: String, bundleID: DocumentationBundle.Identifier) {
+    public init(assetName: String, bundleID: DocumentationContext.Inputs.Identifier) {
         self.assetName = assetName
         self.bundleID = bundleID
     }
diff --git a/Sources/SwiftDocC/Infrastructure/Context/DocumentationContext+Configuration.swift b/Sources/SwiftDocC/Infrastructure/Context/DocumentationContext+Configuration.swift
index b7bcdb3293..a0ff4ddce3 100644
--- a/Sources/SwiftDocC/Infrastructure/Context/DocumentationContext+Configuration.swift
+++ b/Sources/SwiftDocC/Infrastructure/Context/DocumentationContext+Configuration.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2024-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -36,7 +36,7 @@ extension DocumentationContext {
             /// path components into the documentation context.
             var knownDisambiguatedSymbolPathComponents: [String: [String]]?
             
-            /// Controls whether bundle registration should allow registering articles when no technology root is defined.
+            /// Controls whether catalog registration should allow registering articles when no technology root is defined.
             ///
             /// Set this property to `true` to enable registering documentation for standalone articles,
             /// for example when using ``ConvertService``.
@@ -76,7 +76,7 @@ extension DocumentationContext {
         /// A collection of configuration related to external sources of documentation.
         public struct ExternalDocumentationConfiguration {
             /// The lookup of external documentation sources by their bundle identifiers.
-            public var sources: [DocumentationBundle.Identifier: any ExternalDocumentationSource] = [:]
+            public var sources: [DocumentationContext.Inputs.Identifier: any ExternalDocumentationSource] = [:]
             /// A type that resolves all symbols that are referenced in symbol graph files but can't be found in any of the locally available symbol graph files.
             public var globalSymbolResolver: (any GlobalExternalSymbolResolver)?
             /// A list of URLs to documentation archives that the local documentation depends on.
diff --git a/Sources/SwiftDocC/Infrastructure/ConvertActionConverter.swift b/Sources/SwiftDocC/Infrastructure/ConvertActionConverter.swift
index 17a5db0a70..8e4c85a19a 100644
--- a/Sources/SwiftDocC/Infrastructure/ConvertActionConverter.swift
+++ b/Sources/SwiftDocC/Infrastructure/ConvertActionConverter.swift
@@ -21,18 +21,16 @@ package enum ConvertActionConverter {
     static package let signposter = NoOpSignposterShim()
 #endif
     
-    /// Converts the documentation bundle in the given context and passes its output to a given consumer.
+    /// Converts the documentation catalog in the given context and passes its output to a given consumer.
     ///
     /// - Parameters:
-    ///   - bundle: The documentation bundle to convert.
-    ///   - context: The context that the bundle is a part of.
+    ///   - context: The context of documentation information to convert.
     ///   - outputConsumer: The consumer that the conversion passes outputs of the conversion to.
     ///   - sourceRepository: The source repository where the documentation's sources are hosted.
     ///   - emitDigest: Whether the conversion should pass additional metadata output––such as linkable entities information, indexing information, or asset references by asset type––to the consumer.
     ///   - documentationCoverageOptions: The level of experimental documentation coverage information that the conversion should pass to the consumer.
     /// - Returns: A list of problems that occurred during the conversion (excluding the problems that the context already encountered).
     package static func convert(
-        bundle: DocumentationBundle,
         context: DocumentationContext,
         outputConsumer: some ConvertOutputConsumer & ExternalNodeConsumer,
         sourceRepository: SourceRepository?,
@@ -61,15 +59,14 @@ package enum ConvertActionConverter {
         
         // Precompute the render context
         let renderContext = signposter.withIntervalSignpost("Build RenderContext", id: signposter.makeSignpostID()) {
-            RenderContext(documentationContext: context, bundle: bundle)
+            RenderContext(documentationContext: context)
         }
         try outputConsumer.consume(renderReferenceStore: renderContext.store)
 
         // Copy images, sample files, and other static assets.
-        try outputConsumer.consume(assetsInBundle: bundle)
+        try outputConsumer.consume(assetsInInputs: context.inputs)
         
         let converter = DocumentationContextConverter(
-            bundle: bundle,
             context: context,
             renderContext: renderContext,
             sourceRepository: sourceRepository
@@ -104,12 +101,14 @@ package enum ConvertActionConverter {
         let resultsSyncQueue = DispatchQueue(label: "Convert Serial Queue", qos: .unspecified, attributes: [])
         let resultsGroup = DispatchGroup()
         
+        let id = context.inputs.id
+        
         // Consume external links and add them into the sidebar.
         for externalLink in context.externalCache {
-            // Here we're associating the external node with the **current** bundle's bundle ID.
+            // Here we're associating the external node with the **current** local bundle ID.
             // This is needed because nodes are only considered children if the parent and child's bundle ID match.
             // Otherwise, the node will be considered as a separate root node and displayed separately.
-            let externalRenderNode = ExternalRenderNode(externalEntity: externalLink.value, bundleIdentifier: bundle.id)
+            let externalRenderNode = ExternalRenderNode(externalEntity: externalLink.value, bundleIdentifier: id)
             try outputConsumer.consume(externalRenderNode: externalRenderNode)
         }
         
@@ -192,7 +191,7 @@ package enum ConvertActionConverter {
         if FeatureFlags.current.isExperimentalLinkHierarchySerializationEnabled {
             signposter.withIntervalSignpost("Serialize link hierarchy", id: signposter.makeSignpostID()) {
                 do {
-                    let serializableLinkInformation = try context.linkResolver.localResolver.prepareForSerialization(bundleID: bundle.id)
+                    let serializableLinkInformation = try context.linkResolver.localResolver.prepareForSerialization(bundleID: id)
                     try outputConsumer.consume(linkResolutionInformation: serializableLinkInformation)
                     
                     if !emitDigest {
@@ -225,7 +224,7 @@ package enum ConvertActionConverter {
             break
         }
         
-        try outputConsumer.consume(buildMetadata: BuildMetadata(bundleDisplayName: bundle.displayName, bundleID: bundle.id))
+        try outputConsumer.consume(buildMetadata: BuildMetadata(bundleDisplayName: context.inputs.displayName, bundleID: id))
         
         // Log the finalized topic graph checksum.
         benchmark(add: Benchmark.TopicGraphHash(context: context))
diff --git a/Sources/SwiftDocC/Infrastructure/ConvertOutputConsumer.swift b/Sources/SwiftDocC/Infrastructure/ConvertOutputConsumer.swift
index f5e1ebd432..54d0efe4cd 100644
--- a/Sources/SwiftDocC/Infrastructure/ConvertOutputConsumer.swift
+++ b/Sources/SwiftDocC/Infrastructure/ConvertOutputConsumer.swift
@@ -23,7 +23,10 @@ public protocol ConvertOutputConsumer {
     /// > Warning: This method might be called concurrently.
     func consume(renderNode: RenderNode) throws
     
-    /// Consumes a documentation bundle with the purpose of extracting its on-disk assets.
+    /// Consumes a collection of input files with the purpose of extracting its on-disk assets.
+    func consume(assetsInInputs inputs: DocumentationContext.Inputs) throws
+    
+    @available(*, deprecated, renamed: "consume(assetsInInputs:)", message: "Use 'consume(assetsInInputs:)' instead. This deprecated API will be removed after 6.3 is released")
     func consume(assetsInBundle bundle: DocumentationBundle) throws
     
     /// Consumes the linkable element summaries produced during a conversion.
@@ -65,6 +68,16 @@ public extension ConvertOutputConsumer {
     func _deprecated_consume(problems: [Problem]) throws {}
 }
 
+@available(*, deprecated, message: "This deprecated API will be removed after 6.3 is released")
+public extension ConvertOutputConsumer {
+    func consume(assetsInBundle bundle: DocumentationBundle) throws {
+        try consume(assetsInInputs: bundle)
+    }
+    
+    // This is needed so that conforming types don't break. After 6.3 is released we can remove it.
+    func consume(assetsInInputs inputs: DocumentationContext.Inputs) throws {}
+}
+
 // A package-internal protocol that callers can cast to when they need to call `_consume(problems:)` for backwards compatibility (until `consume(problems:)` is removed).
 package protocol _DeprecatedConsumeProblemsAccess {
     func _consume(problems: [Problem]) throws
diff --git a/Sources/SwiftDocC/Infrastructure/DocumentationContext.swift b/Sources/SwiftDocC/Infrastructure/DocumentationContext.swift
index cd7fca83d7..22ff632cfd 100644
--- a/Sources/SwiftDocC/Infrastructure/DocumentationContext.swift
+++ b/Sources/SwiftDocC/Infrastructure/DocumentationContext.swift
@@ -12,13 +12,7 @@ public import Foundation
 import Markdown
 import SymbolKit
 
-/// The documentation context manages the in-memory model for the built documentation.
-///
-/// A ``DocumentationWorkspace`` discovers serialized documentation bundles from a variety of sources (files on disk, databases, or web services), provides them to the `DocumentationContext`,
-/// and notifies the context when bundles are added or removed using the ``DocumentationContextDataProviderDelegate`` protocol.
-///
-/// When a documentation bundle is registered with the context, all of its content is loaded into memory and relationships between documentation entities are built. When this is done, the context can be queried
-/// about documentation entities, resources, and relationships between entities.
+/// An in-memory model for the built documentation.
 ///
 /// ## Topics
 ///
@@ -47,7 +41,7 @@ public class DocumentationContext {
         /// but if such a declaration is found the symbol can have only one declaration.
         case unexpectedEmptyPlatformName(String)
         
-        /// The bundle registration operation is cancelled externally.
+        /// The context creation was cancelled externally.
         case registrationDisabled
         
         public var errorDescription: String {
@@ -59,7 +53,7 @@ public class DocumentationContext {
                 case .unexpectedEmptyPlatformName(let symbolIdentifier):
                     return "Declaration without operating system name for symbol \(symbolIdentifier) cannot be merged with more declarations with operating system name for the same symbol"
                 case .registrationDisabled:
-                    return "The bundle registration operation is cancelled externally."
+                    return "The context creation was cancelled externally."
             }
         }
     }
@@ -67,11 +61,11 @@ public class DocumentationContext {
     /// A class that resolves documentation links by orchestrating calls to other link resolver implementations.
     public var linkResolver: LinkResolver
 
-    /// The data provider that the context can use to read the contents of files that belong to ``bundle``.
+    /// The data provider that the context can use to read the contents of files that belong to ``inputs``.
     let dataProvider: any DataProvider
 
-    /// The documentation bundle that is registered with the context.
-    let bundle: DocumentationBundle
+    /// The collection of input files that the context was created from.
+    let inputs: DocumentationContext.Inputs
 
     /// A collection of configuration for this context.
     public let configuration: Configuration
@@ -97,9 +91,9 @@ public class DocumentationContext {
         }
     }
     
-    /// The root module nodes of the Topic Graph.
+    /// The root module nodes of the topic graph.
     ///
-    /// This property is initialized during the registration of a documentation bundle.
+    /// This property is initialized during the context's initialization.
     public private(set) var rootModules: [ResolvedTopicReference]!
         
     /// The topic reference of the root module, if it's the only registered module.
@@ -128,8 +122,8 @@ public class DocumentationContext {
     /// nodes by their symbol's ID when it builds up in-memory relationships between symbols. Later, the context adds articles and other conceptual content with only their
     /// references for lookup.
     var documentationCache = LocalCache()
-    /// The asset managers for each documentation bundle, keyed by the bundle's identifier.
-    var assetManagers = [DocumentationBundle.Identifier: DataAssetManager]()
+    /// The asset managers for each unit of documentation, keyed by their identifiers.
+    var assetManagers = [DocumentationContext.Inputs.Identifier: DataAssetManager]()
     /// A list of non-topic links that can be resolved.
     var nodeAnchorSections = [ResolvedTopicReference: AnchorSection]()
     
@@ -147,12 +141,12 @@ public class DocumentationContext {
         documentationCache.reference(symbolID: symbolID) ?? externalCache.reference(symbolID: symbolID)
     }
     
-    /// A list of all the problems that was encountered while registering and processing the documentation bundles in this context.
+    /// A list of all the problems that was encountered while initializing the documentation context.
     public var problems: [Problem] {
         return diagnosticEngine.problems
     }
 
-    /// The engine that collects problems encountered while registering and processing the documentation bundles in this context.
+    /// The engine that collects problems encountered while initializing the documentation context
     public var diagnosticEngine: DiagnosticEngine
     
     /// All the link references that have been resolved from external sources, either successfully or not.
@@ -162,8 +156,7 @@ public class DocumentationContext {
     
     /// A temporary structure to hold a semantic value that hasn't yet had its links resolved.
     ///
-    /// These temporary values are only expected to exist while the documentation is being built. Once the documentation bundles have been fully registered and the topic graph
-    /// has been built, the documentation context shouldn't hold any semantic result values anymore.
+    /// These temporary values are only expected to exist while the documentation is being initialized. Once the context has been fully initialized, it shouldn't hold any semantic result values anymore.
     struct SemanticResult<S: Semantic> {
         /// The ``Semantic`` value with unresolved links.
         var value: S
@@ -177,16 +170,14 @@ public class DocumentationContext {
     
     /// Temporary storage for articles before they are curated and moved to the documentation cache.
     ///
-    /// This storage is only used while the documentation context is being built. Once the documentation bundles have been fully registered and the topic graph
-    /// has been built, this list of uncurated articles will be empty.
+    /// This storage is only used while the documentation context is being built. Once the documentation context has been fully initialized, this list of uncurated articles will be empty.
     ///
     /// The key to lookup an article is the reference to the article itself.
     var uncuratedArticles = [ResolvedTopicReference: SemanticResult<Article>]()
     
     /// Temporary storage for documentation extension files before they are curated and moved to the documentation cache.
     ///
-    /// This storage is only used while the documentation context is being built. Once the documentation bundles have been fully registered and the topic graph
-    /// has been built, this list of uncurated documentation extensions will be empty.
+    /// This storage is only used while the documentation context is being built. Once the documentation context has been fully initialized, this list of uncurated documentation extensions will be empty.
     ///
     /// The key to lookup a documentation extension file is the symbol reference from its title (level 1 heading).
     var uncuratedDocumentationExtensions = [ResolvedTopicReference: SemanticResult<Article>]()
@@ -194,41 +185,28 @@ public class DocumentationContext {
     /// Mentions of symbols within articles.
     var articleSymbolMentions = ArticleSymbolMentions()
 
-    /// Initializes a documentation context with a given `bundle`.
+    /// Initializes a documentation context with a given collection of input files.
     ///
     /// - Parameters:
-    ///   - bundle: The bundle to register with the context.
-    ///   - fileManager: The file manager that the context uses to read files from the bundle.
+    ///   - inputs: The collection of documentation inputs files to register with the context.
+    ///   - fileManager: The file manager that the context uses to read files from the inputs.
     ///   - diagnosticEngine: The pre-configured engine that will collect problems encountered during compilation.
     ///   - configuration: A collection of configuration for the created context.
-    /// - Throws: If an error is encountered while registering a documentation bundle.
+    /// - Throws: If an error is encountered while creating the context.
     package init(
-        bundle: DocumentationBundle,
+        inputs: DocumentationContext.Inputs,
         dataProvider: any DataProvider,
         diagnosticEngine: DiagnosticEngine = .init(),
         configuration: Configuration = .init()
     ) async throws {
-        self.bundle = bundle
+        self.inputs = inputs
         self.dataProvider = dataProvider
         self.diagnosticEngine = diagnosticEngine
         self.configuration = configuration
         self.linkResolver = LinkResolver(dataProvider: dataProvider)
 
-        ResolvedTopicReference.enableReferenceCaching(for: bundle.id)
-        try register(bundle)
-    }
-    
-    // Remove these  when removing `registeredBundles` and `bundle(identifier:)`.
-    // These exist so that internal code that need to be compatible with legacy data providers can access the bundles without deprecation warnings.
-    @available(*, deprecated, renamed: "bundle", message: "REMOVE THIS")
-    var _registeredBundles: [DocumentationBundle] {
-        [bundle]
-    }
-    
-    @available(*, deprecated, renamed: "bundle", message: "REMOVE THIS")
-    func _bundle(identifier: String) -> DocumentationBundle? {
-        assert(bundle.id.rawValue == identifier, "New code shouldn't pass unknown bundle identifiers to 'DocumentationContext.bundle(identifier:)'.")
-        return bundle.id.rawValue == identifier ? bundle : nil
+        ResolvedTopicReference.enableReferenceCaching(for: inputs.id)
+        try register(inputs)
     }
         
     /// Perform semantic analysis on a given `document` at a given `source` location and append any problems found to `problems`.
@@ -236,11 +214,10 @@ public class DocumentationContext {
     /// - Parameters:
     ///   - document: The document to analyze.
     ///   - source: The location of the document.
-    ///   - bundle: The bundle that the document belongs to.
     ///   - problems: A mutable collection of problems to update with any problem encountered during the semantic analysis.
     /// - Returns: The result of the semantic analysis.
-    private func analyze(_ document: Document, at source: URL, in bundle: DocumentationBundle, engine: DiagnosticEngine) -> Semantic? {
-        var analyzer = SemanticAnalyzer(source: source, bundle: bundle)
+    private func analyze(_ document: Document, at source: URL, engine: DiagnosticEngine) -> Semantic? {
+        var analyzer = SemanticAnalyzer(source: source, inputs: inputs)
         let result = analyzer.visit(document)
         engine.emit(analyzer.problems)
         return result
@@ -281,7 +258,7 @@ public class DocumentationContext {
     
     /// Find the known plain string module name for a given module reference.
     ///
-    /// - Note: Looking up module names requires that the module names have been pre-resolved. This happens automatically at the end of bundle registration.
+    /// - Note: Looking up module names requires that the module names have been pre-resolved. This happens automatically at the end of the context's initialization.
     ///
     /// - Parameter moduleReference: The module reference to find the module name for.
     /// - Returns: The plain string name for the referenced module.
@@ -292,7 +269,7 @@ public class DocumentationContext {
         // If no name is found it's considered a programmer error; either that the names haven't been resolved yet
         // or that the passed argument isn't a reference to a known module.
         if moduleNameCache.isEmpty {
-            fatalError("Incorrect use of API: '\(#function)' requires that bundles have finished registering.")
+            fatalError("Incorrect use of API: '\(#function)' requires that the context has fully initialized.")
         }
         fatalError("Incorrect use of API: '\(#function)' can only be used with known module references")
     }
@@ -310,14 +287,14 @@ public class DocumentationContext {
         }
     }
 
-    /// Attempts to resolve links external to the given bundle.
+    /// Attempts to resolve links external to the local unit of documentation.
     ///
     /// The link resolution results are collected in ``externallyResolvedLinks``.
     ///
     /// - Parameters:
     ///   - references: A list of references to local nodes to visit to collect links.
     ///   - localBundleID: The local bundle ID, used to identify and skip absolute fully qualified local links.
-    private func preResolveExternalLinks(references: [ResolvedTopicReference], localBundleID: DocumentationBundle.Identifier) {
+    private func preResolveExternalLinks(references: [ResolvedTopicReference], localBundleID: DocumentationContext.Inputs.Identifier) {
         preResolveExternalLinks(semanticObjects: references.compactMap({ reference -> ReferencedSemanticObject? in
             guard let node = try? entity(with: reference), let semantic = node.semantic else { return nil }
             return (reference: reference, semantic: semantic)
@@ -332,18 +309,18 @@ public class DocumentationContext {
         return (reference: from.topicGraphNode.reference, semantic: from.value)
     }
     
-    /// Attempts to resolve links external to the given bundle by visiting the given list of semantic objects.
+    /// Attempts to resolve links external to the local unit of documentation by visiting the given list of semantic objects.
     ///
     /// The resolved references are collected in ``externallyResolvedLinks``.
     ///
     /// - Parameters:
     ///   - semanticObjects: A list of semantic objects to visit to collect links.
     ///   - localBundleID: The local bundle ID, used to identify and skip absolute fully qualified local links.
-    private func preResolveExternalLinks(semanticObjects: [ReferencedSemanticObject], localBundleID: DocumentationBundle.Identifier) {
+    private func preResolveExternalLinks(semanticObjects: [ReferencedSemanticObject], localBundleID: DocumentationContext.Inputs.Identifier) {
         // If there are no external resolvers added we will not resolve any links.
         guard !configuration.externalDocumentationConfiguration.sources.isEmpty else { return }
         
-        let collectedExternalLinks = Synchronized([DocumentationBundle.Identifier: Set<UnresolvedTopicReference>]())
+        let collectedExternalLinks = Synchronized([DocumentationContext.Inputs.Identifier: Set<UnresolvedTopicReference>]())
         semanticObjects.concurrentPerform { _, semantic in
             autoreleasepool {
                 // Walk the node and extract external link references.
@@ -396,7 +373,7 @@ public class DocumentationContext {
     /**
      Attempt to resolve links in curation-only documentation, converting any ``TopicReferences`` from `.unresolved` to `.resolved` where possible.
      */
-    private func resolveLinks(curatedReferences: Set<ResolvedTopicReference>, bundle: DocumentationBundle) {
+    private func resolveLinks(curatedReferences: Set<ResolvedTopicReference>, inputs: DocumentationContext.Inputs) {
         let signpostHandle = signposter.beginInterval("Resolve links", id: signposter.makeSignpostID())
         defer {
             signposter.endInterval("Resolve links", signpostHandle)
@@ -442,7 +419,7 @@ public class DocumentationContext {
                 return
             }
             
-            var resolver = ReferenceResolver(context: self, bundle: bundle, rootReference: reference, inheritanceParentReference: symbolOriginReference)
+            var resolver = ReferenceResolver(context: self, rootReference: reference, inheritanceParentReference: symbolOriginReference)
             
             // Update the node with the markup that contains resolved references instead of authored links.
             documentationNode.semantic = autoreleasepool { 
@@ -456,7 +433,7 @@ public class DocumentationContext {
                 for alternateRepresentation in alternateRepresentations {
                     let resolutionResult = resolver.resolve(
                         alternateRepresentation.reference,
-                        in: bundle.rootReference,
+                        in: inputs.rootReference,
                         range: alternateRepresentation.originalMarkup.range,
                         severity: .warning
                     )
@@ -553,12 +530,12 @@ public class DocumentationContext {
     ///   - tutorialTableOfContentsResults: The list of temporary 'tutorial table-of-contents' pages.
     ///   - tutorials: The list of temporary 'tutorial' pages.
     ///   - tutorialArticles: The list of temporary 'tutorialArticle' pages.
-    ///   - bundle: The bundle to resolve links against.
+    ///   - inputs: The collection of input files that the content for the tutorial files originate from.
     private func resolveLinks(
         tutorialTableOfContents tutorialTableOfContentsResults: [SemanticResult<TutorialTableOfContents>],
         tutorials: [SemanticResult<Tutorial>],
         tutorialArticles: [SemanticResult<TutorialArticle>],
-        bundle: DocumentationBundle
+        inputs: DocumentationContext.Inputs
     ) {
         let signpostHandle = signposter.beginInterval("Resolve links", id: signposter.makeSignpostID())
         defer {
@@ -572,7 +549,7 @@ public class DocumentationContext {
         for tableOfContentsResult in tutorialTableOfContentsResults {
             autoreleasepool {
                 let url = tableOfContentsResult.source
-                var resolver = ReferenceResolver(context: self, bundle: bundle)
+                var resolver = ReferenceResolver(context: self)
                 let tableOfContents = resolver.visit(tableOfContentsResult.value) as! TutorialTableOfContents
                 diagnosticEngine.emit(resolver.problems)
                 
@@ -644,7 +621,7 @@ public class DocumentationContext {
             autoreleasepool {
                 let url = tutorialResult.source
                 let unresolvedTutorial = tutorialResult.value
-                var resolver = ReferenceResolver(context: self, bundle: bundle)
+                var resolver = ReferenceResolver(context: self)
                 let tutorial = resolver.visit(unresolvedTutorial) as! Tutorial
                 diagnosticEngine.emit(resolver.problems)
                 
@@ -678,7 +655,7 @@ public class DocumentationContext {
             autoreleasepool {
                 let url = articleResult.source
                 let unresolvedTutorialArticle = articleResult.value
-                var resolver = ReferenceResolver(context: self, bundle: bundle)
+                var resolver = ReferenceResolver(context: self)
                 let article = resolver.visit(unresolvedTutorialArticle) as! TutorialArticle
                 diagnosticEngine.emit(resolver.problems)
                             
@@ -709,7 +686,7 @@ public class DocumentationContext {
         // Articles are resolved in a separate pass
     }
     
-    private func registerDocuments(from bundle: DocumentationBundle) throws -> (
+    private func registerDocuments(from inputs: DocumentationContext.Inputs) throws -> (
         tutorialTableOfContentsResults: [SemanticResult<TutorialTableOfContents>],
         tutorials: [SemanticResult<Tutorial>],
         tutorialArticles: [SemanticResult<TutorialArticle>],
@@ -729,7 +706,7 @@ public class DocumentationContext {
         let decodeError = Synchronized<(any Error)?>(nil)
         
         // Load and analyze documents concurrently
-        let analyzedDocuments: [(URL, Semantic)] = bundle.markupURLs.concurrentPerform { url, results in
+        let analyzedDocuments: [(URL, Semantic)] = inputs.markupURLs.concurrentPerform { url, results in
             guard decodeError.sync({ $0 == nil }) else { return }
             
             do {
@@ -744,7 +721,7 @@ public class DocumentationContext {
                     diagnosticEngine.emit(langChecker.problems)
                 }
 
-                guard let analyzed = analyze(document, at: url, in: bundle, engine: diagnosticEngine) else {
+                guard let analyzed = analyze(document, at: url, engine: diagnosticEngine) else {
                     return
                 }
                 
@@ -771,8 +748,8 @@ public class DocumentationContext {
             // Store the references we encounter to ensure they're unique. The file name is currently the only part of the URL considered for the topic reference, so collisions may occur.
             let (url, analyzed) = analyzedDocument
 
-            let path = NodeURLGenerator.pathForSemantic(analyzed, source: url, bundle: bundle)
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: path, sourceLanguage: .swift)
+            let path = NodeURLGenerator.pathForSemantic(analyzed, source: url, inputInfo: inputs.info)
+            let reference = ResolvedTopicReference(bundleID: inputs.id, path: path, sourceLanguage: .swift)
             
             // Since documentation extensions' filenames have no impact on the URL of pages, there is no need to enforce unique filenames for them.
             // At this point we consider all articles with an H1 containing link a "documentation extension."
@@ -897,7 +874,7 @@ public class DocumentationContext {
     private func nodeWithInitializedContent(
         reference: ResolvedTopicReference,
         match foundDocumentationExtension: DocumentationContext.SemanticResult<Article>?,
-        bundle: DocumentationBundle
+        inputs: DocumentationContext.Inputs
     ) -> DocumentationNode {
         guard var updatedNode = documentationCache[reference] else {
             fatalError("A topic reference that has already been resolved should always exist in the cache.")
@@ -907,7 +884,7 @@ public class DocumentationContext {
         updatedNode.initializeSymbolContent(
             documentationExtension: foundDocumentationExtension?.value,
             engine: diagnosticEngine,
-            bundle: bundle
+            inputs: inputs
         )
 
         // After merging the documentation extension into the symbol, warn about deprecation summary for non-deprecated symbols.
@@ -998,12 +975,8 @@ public class DocumentationContext {
         diagnosticEngine.emit(result.problems)
     }
     
-    /// Loads all graph files from a given `bundle` and merges them together while building the symbol relationships and loading any available markdown documentation for those symbols.
-    ///
-    /// - Parameter bundle: The bundle to load symbol graph files from.
-    /// - Returns: A pair of the references to all loaded modules and the hierarchy of all the loaded symbol's references.
+    /// Loads all symbol graph files from context's inputs and merges them together while building the symbol relationships and loading any available markdown documentation for those symbols.
     private func registerSymbols(
-        from bundle: DocumentationBundle,
         symbolGraphLoader: SymbolGraphLoader,
         documentationExtensions: [SemanticResult<Article>]
     ) throws {
@@ -1025,7 +998,7 @@ public class DocumentationContext {
             
             // Build references for all symbols in all of this module's symbol graphs.
             let symbolReferences = signposter.withIntervalSignpost("Disambiguate references") {
-                linkResolver.localResolver.referencesForSymbols(in: symbolGraphLoader.unifiedGraphs, bundle: bundle, context: self)
+                linkResolver.localResolver.referencesForSymbols(in: symbolGraphLoader.unifiedGraphs, context: self)
             }
             
             // Set the index and cache storage capacity to avoid ad-hoc storage resizing.
@@ -1078,9 +1051,9 @@ public class DocumentationContext {
                         interfaceLanguage: moduleInterfaceLanguages.first!.id
                     )
                     
-                    // Use the default module kind for this bundle if one was provided,
+                    // Use the default module kind for this catalog if one was provided,
                     // otherwise fall back to 'Framework'
-                    let moduleKindDisplayName = bundle.info.defaultModuleKind ?? "Framework"
+                    let moduleKindDisplayName = inputs.info.defaultModuleKind ?? "Framework"
                     let moduleSymbol = SymbolGraph.Symbol(
                             identifier: moduleIdentifier,
                             names: SymbolGraph.Symbol.Names(title: moduleName, navigator: nil, subHeading: nil, prose: nil),
@@ -1090,7 +1063,7 @@ public class DocumentationContext {
                             kind: SymbolGraph.Symbol.Kind(parsedIdentifier: .module, displayName: moduleKindDisplayName),
                             mixins: [:])
                     let moduleSymbolReference = SymbolReference(moduleName, interfaceLanguages: moduleInterfaceLanguages, defaultSymbol: moduleSymbol)
-                    moduleReference = ResolvedTopicReference(symbolReference: moduleSymbolReference, moduleName: moduleName, bundle: bundle)
+                    moduleReference = ResolvedTopicReference(symbolReference: moduleSymbolReference, moduleName: moduleName, inputs: inputs)
                     
                     signposter.withIntervalSignpost("Add symbols to topic graph", id: signposter.makeSignpostID()) {
                         addSymbolsToTopicGraph(symbolGraph: unifiedSymbolGraph, url: fileURL, symbolReferences: symbolReferences, moduleReference: moduleReference)
@@ -1181,7 +1154,7 @@ public class DocumentationContext {
                 
                 // FIXME: Resolve the link relative to the module https://github.com/swiftlang/swift-docc/issues/516
                 let reference = TopicReference.unresolved(.init(topicURL: url))
-                switch resolve(reference, in: bundle.rootReference, fromSymbolLink: true) {
+                switch resolve(reference, in: inputs.rootReference, fromSymbolLink: true) {
                 case .success(let resolved):
                     if let existing = uncuratedDocumentationExtensions[resolved] {
                         if symbolsWithMultipleDocumentationExtensionMatches[resolved] == nil {
@@ -1242,7 +1215,7 @@ public class DocumentationContext {
             try GeneratedDocumentationTopics.createInheritedSymbolsAPICollections(
                 relationships: uniqueRelationships,
                 context: self,
-                bundle: bundle
+                inputs: inputs
             )
 
             // Parse and prepare the nodes' content concurrently.
@@ -1253,7 +1226,7 @@ public class DocumentationContext {
                     let updatedNode = nodeWithInitializedContent(
                         reference: finalReference,
                         match: match,
-                        bundle: bundle
+                        inputs: inputs
                     )
                     
                     return ((
@@ -1285,14 +1258,14 @@ public class DocumentationContext {
             }
 
             // Resolve any external references first
-            preResolveExternalLinks(references: Array(moduleReferences.values) + combinedSymbols.keys.compactMap({ documentationCache.reference(symbolID: $0) }), localBundleID: bundle.id)
+            preResolveExternalLinks(references: Array(moduleReferences.values) + combinedSymbols.keys.compactMap({ documentationCache.reference(symbolID: $0) }), localBundleID: inputs.id)
             
             // Look up and add symbols that are _referenced_ in the symbol graph but don't exist in the symbol graph.
             try resolveExternalSymbols(in: combinedSymbols, relationships: combinedRelationshipsBySelector)
             
             for (selector, relationships) in combinedRelationshipsBySelector {
                 // Build relationships in the completed graph
-                buildRelationships(relationships, selector: selector, bundle: bundle)
+                buildRelationships(relationships, selector: selector, bundle: inputs)
                 // Merge into target symbols the member symbols that get rendered on the same page as target.
                 populateOnPageMemberRelationships(from: relationships, selector: selector)
             }
@@ -1315,7 +1288,7 @@ public class DocumentationContext {
     func buildRelationships(
         _ relationships: Set<SymbolGraph.Relationship>,
         selector: UnifiedSymbolGraph.Selector,
-        bundle: DocumentationBundle
+        bundle: DocumentationContext.Inputs
     ) {
         // Find all of the relationships which refer to an extended module.
         let extendedModuleRelationships = ExtendedTypeFormatTransformation.collapsedExtendedModuleRelationships(from: relationships)
@@ -1345,7 +1318,6 @@ public class DocumentationContext {
                 SymbolGraphRelationshipsBuilder.addImplementationRelationship(
                     edge: edge,
                     selector: selector,
-                    in: bundle,
                     context: self,
                     localCache: documentationCache,
                     engine: diagnosticEngine
@@ -1614,7 +1586,7 @@ public class DocumentationContext {
     private static let supportedImageExtensions: Set<String> = ["png", "jpg", "jpeg", "svg", "gif"]
     private static let supportedVideoExtensions: Set<String> = ["mov", "mp4"]
 
-    // TODO: Move this functionality to ``DocumentationBundleFileTypes`` (rdar://68156425).
+    // TODO: Move this functionality to ``DocumentationInputFileTypes`` (rdar://68156425).
     
     /// A type of asset.
     public enum AssetType: CustomStringConvertible {
@@ -1647,12 +1619,12 @@ public class DocumentationContext {
         }
     }
     
-    private func registerMiscResources(from bundle: DocumentationBundle) throws {
+    private func registerMiscResources(from bundle: DocumentationContext.Inputs) throws {
         let miscResources = Set(bundle.miscResourceURLs)
         try assetManagers[bundle.id, default: DataAssetManager()].register(data: miscResources)
     }
     
-    private func registeredAssets(withExtensions extensions: Set<String>? = nil, inContexts contexts: [DataAsset.Context] = DataAsset.Context.allCases, forBundleID bundleID: DocumentationBundle.Identifier) -> [DataAsset] {
+    private func registeredAssets(withExtensions extensions: Set<String>? = nil, inContexts contexts: [DataAsset.Context] = DataAsset.Context.allCases, forBundleID bundleID: DocumentationContext.Inputs.Identifier) -> [DataAsset] {
         guard let resources = assetManagers[bundleID]?.storage.values else {
             return []
         }
@@ -1673,7 +1645,7 @@ public class DocumentationContext {
     ///
     /// - Parameter bundleID: The identifier of the bundle to return image assets for.
     /// - Returns: A list of all the image assets for the given bundle.
-    public func registeredImageAssets(for bundleID: DocumentationBundle.Identifier) -> [DataAsset] {
+    public func registeredImageAssets(for bundleID: DocumentationContext.Inputs.Identifier) -> [DataAsset] {
         registeredAssets(withExtensions: DocumentationContext.supportedImageExtensions, forBundleID: bundleID)
     }
     
@@ -1681,7 +1653,7 @@ public class DocumentationContext {
     ///
     /// - Parameter bundleID: The identifier of the bundle to return video assets for.
     /// - Returns: A list of all the video assets for the given bundle.
-    public func registeredVideoAssets(for bundleID: DocumentationBundle.Identifier) -> [DataAsset] {
+    public func registeredVideoAssets(for bundleID: DocumentationContext.Inputs.Identifier) -> [DataAsset] {
         registeredAssets(withExtensions: DocumentationContext.supportedVideoExtensions, forBundleID: bundleID)
     }
     
@@ -1689,7 +1661,7 @@ public class DocumentationContext {
     ///
     /// - Parameter bundleID: The identifier of the bundle to return download assets for.
     /// - Returns: A list of all the download assets for the given bundle.
-    public func registeredDownloadsAssets(for bundleID: DocumentationBundle.Identifier) -> [DataAsset] {
+    public func registeredDownloadsAssets(for bundleID: DocumentationContext.Inputs.Identifier) -> [DataAsset] {
         registeredAssets(inContexts: [DataAsset.Context.download], forBundleID: bundleID)
     }
     
@@ -1706,7 +1678,7 @@ public class DocumentationContext {
         }
     }
     
-    private func registerRootPages(from articles: Articles, in bundle: DocumentationBundle) {
+    private func registerRootPages(from articles: Articles, in bundle: DocumentationContext.Inputs) {
         // Create a root leaf node for all root page articles
         for article in articles {
             // Create the documentation data
@@ -1743,7 +1715,7 @@ public class DocumentationContext {
     /// - Returns: The articles that were registered, with their topic graph node updated to what's been added to the topic graph.
     private func registerArticles(
         _ articles: DocumentationContext.Articles,
-        in bundle: DocumentationBundle
+        in bundle: DocumentationContext.Inputs
     ) -> DocumentationContext.Articles {
         articles.map { article in
             guard let (documentation, title) = DocumentationContext.documentationNodeAndTitle(
@@ -1784,7 +1756,7 @@ public class DocumentationContext {
     /// - Parameters:
     ///   - articles: On input, a list of articles. If an article is used as a root it is removed from this list.
     ///   - bundle: The bundle containing the articles.
-    private func synthesizeArticleOnlyRootPage(articles: inout [DocumentationContext.SemanticResult<Article>], bundle: DocumentationBundle) {
+    private func synthesizeArticleOnlyRootPage(articles: inout [DocumentationContext.SemanticResult<Article>], bundle: DocumentationContext.Inputs) {
         let title = bundle.displayName
         
         // An inner helper function to register a new root node from an article
@@ -1865,19 +1837,19 @@ public class DocumentationContext {
     /// - Parameters:
     ///   - article: The article that will be used to create the returned documentation node.
     ///   - kind: The kind that should be used to create the returned documentation node.
-    ///   - bundle: The documentation bundle this article belongs to.
+    ///   - inputs: The collection of inputs files that this article belongs to.
     /// - Returns: A documentation node and title for the given article semantic result.
     static func documentationNodeAndTitle(
         for article: DocumentationContext.SemanticResult<Article>,
         availableSourceLanguages: Set<SourceLanguage>? = nil,
         kind: DocumentationNode.Kind,
-        in bundle: DocumentationBundle
+        in inputs: DocumentationContext.Inputs
     ) -> (node: DocumentationNode, title: String)? {
         guard let articleMarkup = article.value.markup else {
             return nil
         }
         
-        let path = NodeURLGenerator.pathForSemantic(article.value, source: article.source, bundle: bundle)
+        let path = NodeURLGenerator.pathForSemantic(article.value, source: article.source, inputInfo: inputs.info)
         
         // Use the languages specified by the `@SupportedLanguage` directives if present.
         let availableSourceLanguages = article.value
@@ -1897,7 +1869,7 @@ public class DocumentationContext {
         let defaultSourceLanguage = defaultLanguage(in: availableSourceLanguages)
         
         let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: inputs.id,
             path: path,
             sourceLanguages: availableSourceLanguages
                 // FIXME: Pages in article-only catalogs should not be inferred as "Swift" as a fallback
@@ -1972,20 +1944,18 @@ public class DocumentationContext {
         return articleReferences
     }
     
-    /**
-     Register a documentation bundle with this context.
-     */
-    private func register(_ bundle: DocumentationBundle) throws {
+    /// Register a collection of documentation inputs with this context.
+    private func register(_ inputs: DocumentationContext.Inputs) throws {
         try shouldContinueRegistration()
 
         let currentFeatureFlags: FeatureFlags?
-        if let bundleFlags = bundle.info.featureFlags {
+        if let inputFileFlags = inputs.info.featureFlags {
             currentFeatureFlags = FeatureFlags.current
-            FeatureFlags.current.loadFlagsFromBundle(bundleFlags)
+            FeatureFlags.current.loadFlagsFromInputs(inputFileFlags)
 
-            for unknownFeatureFlag in bundleFlags.unknownFeatureFlags {
+            for unknownFeatureFlag in inputFileFlags.unknownFeatureFlags {
                 let suggestions = NearMiss.bestMatches(
-                    for: DocumentationBundle.Info.BundleFeatureFlags.CodingKeys.allCases.map({ $0.stringValue }),
+                    for: DocumentationContext.Inputs.Info.BundleFeatureFlags.CodingKeys.allCases.map({ $0.stringValue }),
                     against: unknownFeatureFlag)
                 var summary: String = "Unknown feature flag in Info.plist: \(unknownFeatureFlag.singleQuoted)"
                 if !suggestions.isEmpty {
@@ -2007,22 +1977,21 @@ public class DocumentationContext {
             }
         }
 
-        // Note: Each bundle is registered and processed separately.
-        // Documents and symbols may both reference each other so the bundle is registered in 4 steps
+        // Note: It's possible for both documents and symbols to reference each other so the inputs are registered in 4 steps
         
-        // In the bundle discovery phase all tasks run in parallel as they don't depend on each other.
+        // In the discovery phase all tasks run in parallel as they don't depend on each other.
         let discoveryGroup = DispatchGroup()
         let discoveryQueue = DispatchQueue(label: "org.swift.docc.Discovery", qos: .unspecified, attributes: .concurrent, autoreleaseFrequency: .workItem)
         
         let discoveryError = Synchronized<(any Error)?>(nil)
 
-        // Load all bundle symbol graphs into the loader.
+        // Load all the inputs' symbol graphs into the loader.
         var symbolGraphLoader: SymbolGraphLoader!
         var hierarchyBasedResolver: PathHierarchyBasedLinkResolver!
         
         discoveryGroup.async(queue: discoveryQueue) { [unowned self] in
             symbolGraphLoader = SymbolGraphLoader(
-                bundle: bundle,
+                inputs: inputs,
                 dataProvider: dataProvider,
                 symbolGraphTransformer: configuration.convertServiceConfiguration.symbolGraphTransformer
             )
@@ -2034,7 +2003,7 @@ public class DocumentationContext {
                 hierarchyBasedResolver = signposter.withIntervalSignpost("Build PathHierarchy", id: signposter.makeSignpostID()) {
                     PathHierarchyBasedLinkResolver(pathHierarchy: PathHierarchy(
                         symbolGraphLoader: symbolGraphLoader,
-                        bundleName: urlReadablePath(bundle.displayName),
+                        catalogName: urlReadablePath(inputs.displayName),
                         knownDisambiguatedPathComponents: configuration.convertServiceConfiguration.knownDisambiguatedSymbolPathComponents
                     ))
                 }
@@ -2050,7 +2019,7 @@ public class DocumentationContext {
         discoveryGroup.async(queue: discoveryQueue) { [unowned self] in
             do {
                 try signposter.withIntervalSignpost("Load resources", id: signposter.makeSignpostID()) {
-                    try self.registerMiscResources(from: bundle)
+                    try self.registerMiscResources(from: inputs)
                 }
             } catch {
                 // Pipe the error out of the dispatch queue.
@@ -2076,7 +2045,7 @@ public class DocumentationContext {
         discoveryGroup.async(queue: discoveryQueue) { [unowned self] in
             do {
                 result = try signposter.withIntervalSignpost("Load documents", id: signposter.makeSignpostID()) {
-                    try self.registerDocuments(from: bundle)
+                    try self.registerDocuments(from: inputs)
                 }
             } catch {
                 // Pipe the error out of the dispatch queue.
@@ -2150,7 +2119,7 @@ public class DocumentationContext {
         }
         
         self.linkResolver.localResolver = hierarchyBasedResolver
-        hierarchyBasedResolver.addMappingForRoots(bundle: bundle)
+        hierarchyBasedResolver.addMappingForRoots(inputs: inputs)
         for tutorial in tutorials {
             hierarchyBasedResolver.addTutorial(tutorial)
         }
@@ -2161,8 +2130,8 @@ public class DocumentationContext {
             hierarchyBasedResolver.addTutorialTableOfContents(tutorialTableOfContents)
         }
         
-        registerRootPages(from: rootPageArticles, in: bundle)
-        try registerSymbols(from: bundle, symbolGraphLoader: symbolGraphLoader, documentationExtensions: documentationExtensions)
+        registerRootPages(from: rootPageArticles, in: inputs)
+        try registerSymbols(symbolGraphLoader: symbolGraphLoader, documentationExtensions: documentationExtensions)
         // We don't need to keep the loader in memory after we've registered all symbols.
         symbolGraphLoader = nil
         
@@ -2172,7 +2141,7 @@ public class DocumentationContext {
            !otherArticles.isEmpty,
            !configuration.convertServiceConfiguration.allowsRegisteringArticlesWithoutTechnologyRoot
         {
-            synthesizeArticleOnlyRootPage(articles: &otherArticles, bundle: bundle)
+            synthesizeArticleOnlyRootPage(articles: &otherArticles, bundle: inputs)
         }
             
         // Keep track of the root modules registered from symbol graph files, we'll need them to automatically
@@ -2187,7 +2156,7 @@ public class DocumentationContext {
         // Articles that will be automatically curated can be resolved but they need to be pre registered before resolving links.
         let rootNodeForAutomaticCuration = soleRootModuleReference.flatMap(topicGraph.nodeWithReference(_:))
         if configuration.convertServiceConfiguration.allowsRegisteringArticlesWithoutTechnologyRoot || rootNodeForAutomaticCuration != nil {
-            otherArticles = registerArticles(otherArticles, in: bundle)
+            otherArticles = registerArticles(otherArticles, in: inputs)
             try shouldContinueRegistration()
         }
         
@@ -2196,13 +2165,13 @@ public class DocumentationContext {
             tutorialTableOfContentsResults.map(referencedSemanticObject) +
             tutorials.map(referencedSemanticObject) +
             tutorialArticles.map(referencedSemanticObject),
-                                localBundleID: bundle.id)
+                                localBundleID: inputs.id)
         
         resolveLinks(
             tutorialTableOfContents: tutorialTableOfContentsResults,
             tutorials: tutorials,
             tutorialArticles: tutorialArticles,
-            bundle: bundle
+            inputs: inputs
         )
         
         // After the resolving links in tutorial content all the local references are known and can be added to the referenceIndex for fast lookup.
@@ -2215,7 +2184,7 @@ public class DocumentationContext {
         }
         
         try shouldContinueRegistration()
-        var allCuratedReferences = try crawlSymbolCuration(in: linkResolver.localResolver.topLevelSymbols(), bundle: bundle)
+        var allCuratedReferences = try crawlSymbolCuration(in: linkResolver.localResolver.topLevelSymbols())
         
         // Store the list of manually curated references if doc coverage is on.
         if configuration.experimentalCoverageConfiguration.shouldStoreManuallyCuratedReferences {
@@ -2230,13 +2199,13 @@ public class DocumentationContext {
         }
         
         // Crawl the rest of the symbols that haven't been crawled so far in hierarchy pre-order.
-        allCuratedReferences = try crawlSymbolCuration(in: automaticallyCurated.map(\.symbol), bundle: bundle, initial: allCuratedReferences)
+        allCuratedReferences = try crawlSymbolCuration(in: automaticallyCurated.map(\.symbol), initial: allCuratedReferences)
         
         // Automatically curate articles that haven't been manually curated
         // Article curation is only done automatically if there is only one root module
         if let rootNode = rootNodeForAutomaticCuration {
             let articleReferences = try autoCurateArticles(otherArticles, startingFrom: rootNode)
-            allCuratedReferences = try crawlSymbolCuration(in: articleReferences, bundle: bundle, initial: allCuratedReferences)
+            allCuratedReferences = try crawlSymbolCuration(in: articleReferences, initial: allCuratedReferences)
         }
         
         // Remove curation paths that have been created automatically above
@@ -2254,14 +2223,14 @@ public class DocumentationContext {
         linkResolver.localResolver.addAnchorForSymbols(localCache: documentationCache)
         
         // Fifth, resolve links in nodes that are added solely via curation
-        preResolveExternalLinks(references: Array(allCuratedReferences), localBundleID: bundle.id)
-        resolveLinks(curatedReferences: allCuratedReferences, bundle: bundle)
+        preResolveExternalLinks(references: Array(allCuratedReferences), localBundleID: inputs.id)
+        resolveLinks(curatedReferences: allCuratedReferences, inputs: inputs)
 
         if configuration.convertServiceConfiguration.fallbackResolver != nil {
             // When the ``ConvertService`` builds documentation for a single page there won't be a module or root
             // reference to auto-curate the page under, so the regular local link resolution code path won't visit
             // the single page. To ensure that links are resolved, explicitly visit all pages.
-            resolveLinks(curatedReferences: Set(knownPages), bundle: bundle)
+            resolveLinks(curatedReferences: Set(knownPages), inputs: inputs)
         }
         
         // We should use a read-only context during render time (rdar://65130130).
@@ -2460,17 +2429,16 @@ public class DocumentationContext {
     /// Crawls the hierarchy of the given list of nodes, adding relationships in the topic graph for all resolvable task group references.
     /// - Parameters:
     ///   - references: A list of references to crawl.
-    ///   - bundle: A documentation bundle.
     ///   - initial: A list of references to skip when crawling.
     /// - Returns: The references of all the symbols that were curated.
     @discardableResult
-    func crawlSymbolCuration(in references: [ResolvedTopicReference], bundle: DocumentationBundle, initial: Set<ResolvedTopicReference> = []) throws -> Set<ResolvedTopicReference> {
+    func crawlSymbolCuration(in references: [ResolvedTopicReference], initial: Set<ResolvedTopicReference> = []) throws -> Set<ResolvedTopicReference> {
         let signpostHandle = signposter.beginInterval("Curate symbols", id: signposter.makeSignpostID())
         defer {
             signposter.endInterval("Curate symbols", signpostHandle)
         }
         
-        var crawler = DocumentationCurator(in: self, bundle: bundle, initial: initial)
+        var crawler = DocumentationCurator(in: self, initial: initial)
 
         for reference in references {
             try crawler.crawlChildren(
@@ -2642,7 +2610,7 @@ public class DocumentationContext {
     /**
      Unregister a documentation bundle with this context and clear any cached resources associated with it.
      */
-    private func unregister(_ bundle: DocumentationBundle) {
+    private func unregister(_ bundle: DocumentationContext.Inputs) {
         let referencesToRemove = topicGraph.nodes.keys.filter {
             $0.bundleID == bundle.id
         }
@@ -2657,7 +2625,7 @@ public class DocumentationContext {
     // MARK: - Getting documentation relationships
 
     /**
-     Look for a secondary resource among the registered bundles.
+     Look for a secondary resource among the registered assets.
 
      The context tracks resources by file name. If the documentation author specified a resource reference using a
      qualified path, instead of a file name, the context will fail to find that resource.
@@ -2698,7 +2666,7 @@ public class DocumentationContext {
     }
     
     /**
-     Look for a documentation node among the registered bundles and via any external resolvers.
+     Look for a documentation node among the registered content and via any external resolvers.
 
      - Returns: A ``DocumentationNode`` with the given identifier.
      - Throws: ``ContextError/notFound(_:)`` if a documentation node with the given identifier was not found.
@@ -2873,7 +2841,7 @@ public class DocumentationContext {
         resolveAsset(named: name, bundleID: parent.bundleID, withType: type)
     }
     
-    func resolveAsset(named name: String, bundleID: DocumentationBundle.Identifier, withType expectedType: AssetType?) -> DataAsset? {
+    func resolveAsset(named name: String, bundleID: DocumentationContext.Inputs.Identifier, withType expectedType: AssetType?) -> DataAsset? {
         if let localAsset = assetManagers[bundleID]?.allData(named: name) {
             if let expectedType {
                 guard localAsset.hasVariant(withAssetType: expectedType) else {
diff --git a/Sources/SwiftDocC/Infrastructure/DocumentationCurator.swift b/Sources/SwiftDocC/Infrastructure/DocumentationCurator.swift
index 1519965672..c93ce84c0a 100644
--- a/Sources/SwiftDocC/Infrastructure/DocumentationCurator.swift
+++ b/Sources/SwiftDocC/Infrastructure/DocumentationCurator.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -17,14 +17,10 @@ struct DocumentationCurator {
     /// The documentation context to crawl.
     private let context: DocumentationContext
     
-    /// The current bundle.
-    private let bundle: DocumentationBundle
-    
     private(set) var problems = [Problem]()
     
-    init(in context: DocumentationContext, bundle: DocumentationBundle, initial: Set<ResolvedTopicReference> = []) {
+    init(in context: DocumentationContext, initial: Set<ResolvedTopicReference> = []) {
         self.context = context
-        self.bundle = bundle
         self.curatedNodes = initial
     }
     
@@ -80,7 +76,7 @@ struct DocumentationCurator {
         }
         
         // Check if the link has been externally resolved already.
-        if let bundleID = unresolved.topicURL.components.host.map({ DocumentationBundle.Identifier(rawValue: $0) }),
+        if let bundleID = unresolved.topicURL.components.host.map({ DocumentationContext.Inputs.Identifier(rawValue: $0) }),
            context.configuration.externalDocumentationConfiguration.sources[bundleID] != nil || context.configuration.convertServiceConfiguration.fallbackResolver != nil {
             if case .success(let resolvedExternalReference) = context.externallyResolvedLinks[unresolved.topicURL] {
                 return resolvedExternalReference
@@ -99,7 +95,7 @@ struct DocumentationCurator {
             // - "documentation/CatalogName/ArticleName"
             switch path.components(separatedBy: "/").count {
             case 0,1:
-                return NodeURLGenerator.Path.article(bundleName: bundle.displayName, articleName: path).stringValue
+                return NodeURLGenerator.Path.article(bundleName: context.inputs.displayName, articleName: path).stringValue
             case 2:
                 return "\(NodeURLGenerator.Path.documentationFolder)/\(path)"
             default:
diff --git a/Sources/SwiftDocC/Infrastructure/DocumentationBundleFileTypes.swift b/Sources/SwiftDocC/Infrastructure/DocumentationInputFileTypes.swift
similarity index 91%
rename from Sources/SwiftDocC/Infrastructure/DocumentationBundleFileTypes.swift
rename to Sources/SwiftDocC/Infrastructure/DocumentationInputFileTypes.swift
index 18af82c395..f739ca23ff 100644
--- a/Sources/SwiftDocC/Infrastructure/DocumentationBundleFileTypes.swift
+++ b/Sources/SwiftDocC/Infrastructure/DocumentationInputFileTypes.swift
@@ -10,8 +10,8 @@
 
 public import Foundation
 
-/// A collection of functions to check if a file is one of the documentation bundle files types.
-public enum DocumentationBundleFileTypes {
+/// A collection of functions to check if a file is one of the documentation catalog's files types.
+public enum DocumentationInputFileTypes {
     
     static let referenceFileExtension = "md"
     /// Checks if a file is a reference documentation file.
@@ -85,3 +85,7 @@ public enum DocumentationBundleFileTypes {
         return url.lastPathComponent == themeSettingsFileName
     }
 }
+
+@available(*, deprecated, renamed: "DocumentationInputFileTypes", message: "Use 'DocumentationInputFileTypes' instead. This deprecated API will be removed after 6.3 is released")
+public typealias DocumentationBundleFileTypes = DocumentationInputFileTypes
+
diff --git a/Sources/SwiftDocC/Infrastructure/DocumentationBundle+Identifier.swift b/Sources/SwiftDocC/Infrastructure/DocumentationInputs+Identifier.swift
similarity index 78%
rename from Sources/SwiftDocC/Infrastructure/DocumentationBundle+Identifier.swift
rename to Sources/SwiftDocC/Infrastructure/DocumentationInputs+Identifier.swift
index a2afc9d699..1e978b9cd7 100644
--- a/Sources/SwiftDocC/Infrastructure/DocumentationBundle+Identifier.swift
+++ b/Sources/SwiftDocC/Infrastructure/DocumentationInputs+Identifier.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2024-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -10,7 +10,7 @@
 
 import Foundation
 
-extension DocumentationBundle {
+extension DocumentationContext.Inputs {
     /// A stable and locally unique identifier for a collection of documentation inputs.
     public struct Identifier: RawRepresentable {
         public let rawValue: String
@@ -28,32 +28,32 @@ extension DocumentationBundle {
     }
 }
 
-extension DocumentationBundle.Identifier: Hashable {}
-extension DocumentationBundle.Identifier: Sendable {}
+extension DocumentationContext.Inputs.Identifier: Hashable {}
+extension DocumentationContext.Inputs.Identifier: Sendable {}
 
 // Support creating an identifier from a string literal.
-extension DocumentationBundle.Identifier: ExpressibleByStringLiteral {
+extension DocumentationContext.Inputs.Identifier: ExpressibleByStringLiteral {
     public init(stringLiteral value: StringLiteralType) {
         self.init(rawValue: value)
     }
 }
 
 // Sort identifiers based on their raw string value.
-extension DocumentationBundle.Identifier: Comparable {
+extension DocumentationContext.Inputs.Identifier: Comparable {
     public static func < (lhs: Self, rhs: Self) -> Bool {
         lhs.rawValue < rhs.rawValue
     }
 }
 
 // Print as a single string value
-extension DocumentationBundle.Identifier: CustomStringConvertible {
+extension DocumentationContext.Inputs.Identifier: CustomStringConvertible {
     public var description: String {
         rawValue
     }
 }
 
 // Encode and decode the identifier as a single string value.
-extension DocumentationBundle.Identifier: Codable {
+extension DocumentationContext.Inputs.Identifier: Codable {
     public init(from decoder: any Decoder) throws {
         let container = try decoder.singleValueContainer()
         let rawValue = try container.decode(String.self)
diff --git a/Sources/SwiftDocC/Infrastructure/DocumentationBundle.swift b/Sources/SwiftDocC/Infrastructure/DocumentationInputs.swift
similarity index 86%
rename from Sources/SwiftDocC/Infrastructure/DocumentationBundle.swift
rename to Sources/SwiftDocC/Infrastructure/DocumentationInputs.swift
index 11cc3ef426..1363e6b222 100644
--- a/Sources/SwiftDocC/Infrastructure/DocumentationBundle.swift
+++ b/Sources/SwiftDocC/Infrastructure/DocumentationInputs.swift
@@ -10,6 +10,8 @@
 
 public import Foundation
 
+extension DocumentationContext {
+    
 /// A collection of the build inputs for a unit of documentation.
 ///
 /// A unit of documentation may for example cover a framework, library, or tool.
@@ -33,18 +35,18 @@ public import Foundation
 ///
 /// - ``info``
 /// - ``displayName``
-/// - ``identifier``
-public struct DocumentationBundle {
+/// - ``id``
+public struct Inputs {
     public enum PropertyListError: DescribedError {
         case invalidVersionString(String)
         case keyNotFound(String)
         
         public var errorDescription: String {
             switch self {
-            case .invalidVersionString(let versionString):
-                return "'\(versionString)' is not a valid version string"
-            case .keyNotFound(let name):
-                return "Expected key \(name.singleQuoted) not found"
+                case .invalidVersionString(let versionString):
+                    return "'\(versionString)' is not a valid version string"
+                case .keyNotFound(let name):
+                    return "Expected key \(name.singleQuoted) not found"
             }
         }
     }
@@ -57,8 +59,8 @@ public struct DocumentationBundle {
         info.displayName
     }
     
-    /// The documentation bundle's stable and locally unique identifier.
-    public var id: DocumentationBundle.Identifier {
+    /// The unit of documentation's stable and locally unique identifier.
+    public var id: Identifier {
         info.id
     }
     
@@ -68,7 +70,7 @@ public struct DocumentationBundle {
     ///
     /// ## See Also
     ///
-    /// - ``DocumentationBundleFileTypes/isSymbolGraphFile(_:)``
+    /// - ``DocumentationInputFileTypes/isSymbolGraphFile(_:)``
     public let symbolGraphURLs: [URL]
     
     /// Documentation markup input files for this unit of documentation.
@@ -77,7 +79,7 @@ public struct DocumentationBundle {
     ///
     /// ## See Also
     ///
-    /// - ``DocumentationBundleFileTypes/isMarkupFile(_:)``
+    /// - ``DocumentationInputFileTypes/isMarkupFile(_:)``
     public let markupURLs: [URL]
     
     /// Miscellaneous resources (for example images, videos, or downloadable assets) for this unit of documentation.
@@ -133,16 +135,21 @@ public struct DocumentationBundle {
     }
     
     public private(set) var rootReference: ResolvedTopicReference
-
+    
     /// Default path to resolve symbol links.
     public private(set) var documentationRootReference: ResolvedTopicReference
-
+    
     /// Default path to resolve tutorial table-of-contents links.
     public var tutorialTableOfContentsContainer: ResolvedTopicReference
-
+    
     /// Default path to resolve tutorial links.
     public var tutorialsContainerReference: ResolvedTopicReference
-
+    
     /// Default path to resolve articles.
     public var articlesDocumentationRootReference: ResolvedTopicReference
 }
+
+}
+
+@available(*, deprecated, renamed: "DocumentationContext.Inputs", message: "Use 'DocumentationContext.Inputs' instead. This deprecated API will be removed after 6.3 is released")
+public typealias DocumentationBundle = DocumentationContext.Inputs
diff --git a/Sources/SwiftDocC/Infrastructure/External Data/ExternalDocumentationSource.swift b/Sources/SwiftDocC/Infrastructure/External Data/ExternalDocumentationSource.swift
index b6e40e272b..3b5c08b7ac 100644
--- a/Sources/SwiftDocC/Infrastructure/External Data/ExternalDocumentationSource.swift	
+++ b/Sources/SwiftDocC/Infrastructure/External Data/ExternalDocumentationSource.swift	
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -20,7 +20,7 @@ import Foundation
 /// ``DocumentationContext/externalDocumentationSources`` for the bundle identifier of the unresolved reference. If there is, that source is asked to attempt to resolve the reference.
 ///
 /// If the referenced documentation exists in the external source, the source returns a resolved reference to the context. Later, the context uses this resolved reference to ask the source
-/// for the external entity with the documentation content for that reference. Because this content isn't part of the compiled bundle, it won't have its own page in the build output.
+/// for the external entity with the documentation content for that reference. Because this content isn't part of the compiled catalog, it won't have its own page in the build output.
 ///
 /// If the reference doesn't exist in the external source of documentation or if an error occurs while attempting to resolve the reference, the external source returns information about the error.
 ///
diff --git a/Sources/SwiftDocC/Infrastructure/External Data/ExternalMetadata.swift b/Sources/SwiftDocC/Infrastructure/External Data/ExternalMetadata.swift
index 9360fb25ce..4566150e74 100644
--- a/Sources/SwiftDocC/Infrastructure/External Data/ExternalMetadata.swift	
+++ b/Sources/SwiftDocC/Infrastructure/External Data/ExternalMetadata.swift	
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -76,8 +76,14 @@ public struct ExternalMetadata {
     /// If `true`, inherited symbols retain their original docs.
     public var inheritDocs = false
 
-    /// If `true`, there is no source bundle on disk and the inputs were passed via command line parameters.
-    public var isGeneratedBundle = false
+    /// If `true`, there is no source catalog on disk and the inputs were passed via command line parameters.
+    public var isGeneratedCatalog = false
+    
+    @available(*, deprecated, renamed: "isGeneratedCatalog", message: "Use 'isGeneratedCatalog' instead. This deprecated API will be removed after 6.3 is released.")
+    public var isGeneratedBundle: Bool {
+        get { isGeneratedCatalog }
+        set { isGeneratedCatalog = newValue }
+    }
     
     /// The granularity of diagnostics to emit via the engine.
     public var diagnosticLevel: DiagnosticSeverity = .warning
diff --git a/Sources/SwiftDocC/Infrastructure/External Data/GlobalExternalSymbolResolver.swift b/Sources/SwiftDocC/Infrastructure/External Data/GlobalExternalSymbolResolver.swift
index acf37d2f00..617b2bf7eb 100644
--- a/Sources/SwiftDocC/Infrastructure/External Data/GlobalExternalSymbolResolver.swift	
+++ b/Sources/SwiftDocC/Infrastructure/External Data/GlobalExternalSymbolResolver.swift	
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -17,10 +17,9 @@ import Foundation
 ///
 /// If a symbol in a symbol graph file references a symbol in another module---for example, when the symbol conforms to a protocol from another module, when the
 /// symbol inherits from a class in another module, or the symbol has arguments or return values that are types from other modules---then this resolver is used to
-/// look up those symbols by their unique identifier. This allows references in symbol declarations to be turned into links for external symbols, just like in-bundle
-/// symbol references.
+/// look up those symbols by their unique identifier. This allows references in symbol declarations to be turned into links for external symbols, just like local symbol references.
 ///
-/// Because symbol identifiers don't specify what bundle the symbol belongs to, a documentation context can only have one global external symbol resolver.
+/// Because symbol identifiers don't specify what module the symbol belongs to, a documentation context can only have one global external symbol resolver.
 ///
 /// ## See Also
 /// - ``DocumentationContext/globalExternalSymbolResolver``
diff --git a/Sources/SwiftDocC/Infrastructure/External Data/OutOfProcessReferenceResolver.swift b/Sources/SwiftDocC/Infrastructure/External Data/OutOfProcessReferenceResolver.swift
index 1988f8b074..07f40c4164 100644
--- a/Sources/SwiftDocC/Infrastructure/External Data/OutOfProcessReferenceResolver.swift	
+++ b/Sources/SwiftDocC/Infrastructure/External Data/OutOfProcessReferenceResolver.swift	
@@ -52,7 +52,7 @@ public class OutOfProcessReferenceResolver: ExternalDocumentationSource, GlobalE
     private let externalLinkResolvingClient: any ExternalLinkResolving
     
     /// The bundle identifier for the reference resolver in the other process.
-    public let bundleID: DocumentationBundle.Identifier
+    public let bundleID: DocumentationContext.Inputs.Identifier
     
     /// Creates a new reference resolver that interacts with another executable.
     ///
@@ -89,7 +89,7 @@ public class OutOfProcessReferenceResolver: ExternalDocumentationSource, GlobalE
     ///   - bundleID: The bundle identifier the server can resolve references for.
     ///   - server: The server to send link resolution requests to.
     ///   - convertRequestIdentifier: The identifier that the resolver will use for convert requests that it sends to the server.
-    public init(bundleID: DocumentationBundle.Identifier, server: DocumentationServer, convertRequestIdentifier: String?) throws {
+    public init(bundleID: DocumentationContext.Inputs.Identifier, server: DocumentationServer, convertRequestIdentifier: String?) throws {
         self.bundleID = bundleID
         self.externalLinkResolvingClient = LongRunningService(
             server: server, convertRequestIdentifier: convertRequestIdentifier)
diff --git a/Sources/SwiftDocC/Infrastructure/Input Discovery/DocumentationInputsProvider.swift b/Sources/SwiftDocC/Infrastructure/Input Discovery/DocumentationInputsProvider.swift
index 681d32dada..b104cc9b30 100644
--- a/Sources/SwiftDocC/Infrastructure/Input Discovery/DocumentationInputsProvider.swift	
+++ b/Sources/SwiftDocC/Infrastructure/Input Discovery/DocumentationInputsProvider.swift	
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2024-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -15,19 +15,19 @@ extension DocumentationContext {
 
     /// A type that provides inputs for a unit of documentation.
     ///
-    /// The inputs provider discovers documentation catalogs on the file system and creates a ``DocumentationBundle`` from the discovered catalog content.
+    /// The inputs provider discovers documentation catalogs on the file system and creates a ``DocumentationContext/Inputs`` from the discovered catalog content.
     ///
-    /// The input provider categorizes the catalog content based on corresponding ``DocumentationBundleFileTypes`` conditions:
+    /// The input provider categorizes the catalog content based on corresponding ``DocumentationInputFileTypes`` conditions:
     ///
-    ///  Category                                 | Condition
-    ///  ---------------------------------------- | -------------------------------------------------
-    ///  ``DocumentationBundle/markupURLs``       | ``DocumentationBundleFileTypes/isMarkupFile(_:)``
-    ///  ``DocumentationBundle/symbolGraphURLs``  | ``DocumentationBundleFileTypes/isSymbolGraphFile(_:)``
-    ///  ``DocumentationBundle/info``             | ``DocumentationBundleFileTypes/isInfoPlistFile(_:)``
-    ///  ``DocumentationBundle/themeSettings``    | ``DocumentationBundleFileTypes/isThemeSettingsFile(_:)``
-    ///  ``DocumentationBundle/customHeader``     | ``DocumentationBundleFileTypes/isCustomHeader(_:)``
-    ///  ``DocumentationBundle/customFooter``     | ``DocumentationBundleFileTypes/isCustomFooter(_:)``
-    ///  ``DocumentationBundle/miscResourceURLs`` | Any file not already matched above.
+    /// Category                                         | Condition
+    /// ------------------------------------------------ | -------------------------------------------------
+    /// ``DocumentationContext/Inputs/markupURLs``       | ``DocumentationInputFileTypes/isMarkupFile(_:)``
+    /// ``DocumentationContext/Inputs/symbolGraphURLs``  | ``DocumentationInputFileTypes/isSymbolGraphFile(_:)``
+    /// ``DocumentationContext/Inputs/info``             | ``DocumentationInputFileTypes/isInfoPlistFile(_:)``
+    /// ``DocumentationContext/Inputs/themeSettings``    | ``DocumentationInputFileTypes/isThemeSettingsFile(_:)``
+    /// ``DocumentationContext/Inputs/customHeader``     | ``DocumentationInputFileTypes/isCustomHeader(_:)``
+    /// ``DocumentationContext/Inputs/customFooter``     | ``DocumentationInputFileTypes/isCustomFooter(_:)``
+    /// ``DocumentationContext/Inputs/miscResourceURLs`` | Any file not already matched above.
     ///
     /// ## Topics
     ///
@@ -72,7 +72,7 @@ extension DocumentationContext {
 
 extension DocumentationContext.InputsProvider {
 
-    private typealias FileTypes = DocumentationBundleFileTypes
+    private typealias FileTypes = DocumentationInputFileTypes
 
     /// A discovered documentation catalog.
     struct CatalogURL {
@@ -130,13 +130,9 @@ extension DocumentationContext.InputsProvider {
 
 // MARK: Create from catalog
 
-extension DocumentationContext {
-    package typealias Inputs = DocumentationBundle
-}
-
 extension DocumentationContext.InputsProvider {
 
-    package typealias Options = BundleDiscoveryOptions
+    package typealias Options = CatalogDiscoveryOptions
 
     /// Creates a collection of documentation inputs from the content of the given documentation catalog.
     /// 
@@ -153,7 +149,7 @@ extension DocumentationContext.InputsProvider {
 
         let info = try DocumentationContext.Inputs.Info(
             from: infoPlistData,
-            bundleDiscoveryOptions: options,
+            catalogDiscoveryOptions: options,
             derivedDisplayName: url.deletingPathExtension().lastPathComponent
         )
 
@@ -219,7 +215,7 @@ extension DocumentationContext.InputsProvider {
         }
         let derivedDisplayName = moduleNames.count == 1 ? moduleNames.first : nil
 
-        let info = try DocumentationContext.Inputs.Info(bundleDiscoveryOptions: options, derivedDisplayName: derivedDisplayName)
+        let info = try DocumentationContext.Inputs.Info(catalogDiscoveryOptions: options, derivedDisplayName: derivedDisplayName)
         
         let topLevelPages: [URL]
         let provider: any DataProvider
@@ -243,7 +239,7 @@ extension DocumentationContext.InputsProvider {
         }
 
         return (
-            inputs: DocumentationBundle(
+            inputs: DocumentationContext.Inputs(
                 info: info,
                 symbolGraphURLs: options.additionalSymbolGraphFiles,
                 markupURLs: topLevelPages,
diff --git a/Sources/SwiftDocC/Infrastructure/Link Resolution/LinkResolver+NavigatorIndex.swift b/Sources/SwiftDocC/Infrastructure/Link Resolution/LinkResolver+NavigatorIndex.swift
index 8f0966fc79..e102a5be79 100644
--- a/Sources/SwiftDocC/Infrastructure/Link Resolution/LinkResolver+NavigatorIndex.swift	
+++ b/Sources/SwiftDocC/Infrastructure/Link Resolution/LinkResolver+NavigatorIndex.swift	
@@ -17,9 +17,9 @@ package struct ExternalRenderNode {
     private var externalEntity: LinkResolver.ExternalEntity
 
     /// The bundle identifier for this external node.
-    private var bundleIdentifier: DocumentationBundle.Identifier
+    private var bundleIdentifier: DocumentationContext.Inputs.Identifier
 
-    init(externalEntity: LinkResolver.ExternalEntity, bundleIdentifier: DocumentationBundle.Identifier) {
+    init(externalEntity: LinkResolver.ExternalEntity, bundleIdentifier: DocumentationContext.Inputs.Identifier) {
         self.externalEntity = externalEntity
         self.bundleIdentifier = bundleIdentifier
     }
diff --git a/Sources/SwiftDocC/Infrastructure/Link Resolution/LinkResolver.swift b/Sources/SwiftDocC/Infrastructure/Link Resolution/LinkResolver.swift
index 20291f286d..9a2d7a8544 100644
--- a/Sources/SwiftDocC/Infrastructure/Link Resolution/LinkResolver.swift	
+++ b/Sources/SwiftDocC/Infrastructure/Link Resolution/LinkResolver.swift	
@@ -18,7 +18,7 @@ public class LinkResolver {
         self.dataProvider = dataProvider
     }
     
-    /// The link resolver to use to resolve links in the local bundle
+    /// The link resolver to use to resolve links in the local documentation.
     var localResolver: PathHierarchyBasedLinkResolver!
     /// A fallback resolver to use when the local resolver fails to resolve a link.
     ///
@@ -106,8 +106,8 @@ public class LinkResolver {
         
         // Check if this is a link to an external documentation source that should have previously been resolved in `DocumentationContext.preResolveExternalLinks(...)`
         if let bundleID = unresolvedReference.bundleID,
-           context.bundle.id != bundleID,
-           urlReadablePath(context.bundle.displayName) != bundleID.rawValue
+           context.inputs.id != bundleID,
+           urlReadablePath(context.inputs.displayName) != bundleID.rawValue
         {
             return .failure(unresolvedReference, TopicReferenceResolutionErrorInfo("No external resolver registered for '\(bundleID)'."))
         }
@@ -185,8 +185,8 @@ private final class FallbackResolverBasedLinkResolver {
         // Check if a fallback reference resolver should resolve this
         let referenceBundleID = unresolvedReference.bundleID ?? parent.bundleID
         guard let fallbackResolver = context.configuration.convertServiceConfiguration.fallbackResolver,
-              fallbackResolver.bundleID == context.bundle.id,
-              context.bundle.id == referenceBundleID || urlReadablePath(context.bundle.displayName) == referenceBundleID.rawValue
+              fallbackResolver.bundleID == context.inputs.id,
+              context.inputs.id == referenceBundleID || urlReadablePath(context.inputs.displayName) == referenceBundleID.rawValue
         else {
             return nil
         }
@@ -204,7 +204,7 @@ private final class FallbackResolverBasedLinkResolver {
         )
         allCandidateURLs.append(alreadyResolved.url)
         
-        let currentBundle = context.bundle
+        let currentBundle = context.inputs
         if !isCurrentlyResolvingSymbolLink {
             // First look up articles path
             allCandidateURLs.append(contentsOf: [
diff --git a/Sources/SwiftDocC/Infrastructure/Link Resolution/PathHierarchy+Serialization.swift b/Sources/SwiftDocC/Infrastructure/Link Resolution/PathHierarchy+Serialization.swift
index d1cfe15985..0c806131e5 100644
--- a/Sources/SwiftDocC/Infrastructure/Link Resolution/PathHierarchy+Serialization.swift	
+++ b/Sources/SwiftDocC/Infrastructure/Link Resolution/PathHierarchy+Serialization.swift	
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2023 Apple Inc. and the Swift project authors
+ Copyright (c) 2023-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -150,7 +150,7 @@ public struct SerializableLinkResolutionInformation: Codable {
     // This type is public so that it can be an argument to a function in `ConvertOutputConsumer`
     
     var version: SemanticVersion
-    var bundleID: DocumentationBundle.Identifier
+    var bundleID: DocumentationContext.Inputs.Identifier
     var pathHierarchy: PathHierarchy.FileRepresentation
     // Separate storage of node data because the path hierarchy doesn't know the resolved references for articles.
     var nonSymbolPaths: [Int: String]
@@ -160,7 +160,7 @@ extension PathHierarchyBasedLinkResolver {
     /// Create a file representation of the link resolver.
     ///
     /// The file representation can be decoded in later documentation builds to resolve external links to the content where the link resolver was originally created for.
-    func prepareForSerialization(bundleID: DocumentationBundle.Identifier) throws -> SerializableLinkResolutionInformation {
+    func prepareForSerialization(bundleID: DocumentationContext.Inputs.Identifier) throws -> SerializableLinkResolutionInformation {
         var nonSymbolPaths: [Int: String] = [:]
         let hierarchyFileRepresentation = PathHierarchy.FileRepresentation(pathHierarchy) { identifiers in
             nonSymbolPaths.reserveCapacity(identifiers.count)
diff --git a/Sources/SwiftDocC/Infrastructure/Link Resolution/PathHierarchy.swift b/Sources/SwiftDocC/Infrastructure/Link Resolution/PathHierarchy.swift
index d4891efab4..ed8e4b8513 100644
--- a/Sources/SwiftDocC/Infrastructure/Link Resolution/PathHierarchy.swift	
+++ b/Sources/SwiftDocC/Infrastructure/Link Resolution/PathHierarchy.swift	
@@ -54,12 +54,12 @@ struct PathHierarchy {
     ///
     /// - Parameters:
     ///   - loader: The symbol graph loader that provides all symbols.
-    ///   - bundleName: The name of the documentation bundle, used as a container for articles and tutorials.
+    ///   - catalogName: The name of the documentation catalog, used as a container for articles and tutorials.
     ///   - moduleKindDisplayName: The display name for the "module" kind of symbol.
     ///   - knownDisambiguatedPathComponents: A list of path components with known required disambiguations.
     init(
         symbolGraphLoader loader: SymbolGraphLoader,
-        bundleName: String,
+        catalogName: String,
         moduleKindDisplayName: String = "Framework",
         knownDisambiguatedPathComponents: [String: [String]]? = nil
     ) {
@@ -420,8 +420,8 @@ struct PathHierarchy {
             lookup[id] = node
             return node
         }
-        self.articlesContainer = roots[bundleName] ?? newNode(bundleName)
-        self.tutorialContainer = newNode(bundleName)
+        self.articlesContainer = roots[catalogName] ?? newNode(catalogName)
+        self.tutorialContainer = newNode(catalogName)
         self.tutorialOverviewContainer = newNode("tutorials")
         
         assert(
diff --git a/Sources/SwiftDocC/Infrastructure/Link Resolution/PathHierarchyBasedLinkResolver.swift b/Sources/SwiftDocC/Infrastructure/Link Resolution/PathHierarchyBasedLinkResolver.swift
index 4dc85a2968..d647804215 100644
--- a/Sources/SwiftDocC/Infrastructure/Link Resolution/PathHierarchyBasedLinkResolver.swift	
+++ b/Sources/SwiftDocC/Infrastructure/Link Resolution/PathHierarchyBasedLinkResolver.swift	
@@ -99,10 +99,10 @@ final class PathHierarchyBasedLinkResolver {
     // MARK: - Adding non-symbols
     
     /// Map the resolved identifiers to resolved topic references for a given bundle's article, tutorial, and technology root pages.
-    func addMappingForRoots(bundle: DocumentationBundle) {
-        resolvedReferenceMap[pathHierarchy.tutorialContainer.identifier] = bundle.tutorialsContainerReference
-        resolvedReferenceMap[pathHierarchy.articlesContainer.identifier] = bundle.articlesDocumentationRootReference
-        resolvedReferenceMap[pathHierarchy.tutorialOverviewContainer.identifier] = bundle.tutorialTableOfContentsContainer
+    func addMappingForRoots(inputs: DocumentationContext.Inputs) {
+        resolvedReferenceMap[pathHierarchy.tutorialContainer.identifier] = inputs.tutorialsContainerReference
+        resolvedReferenceMap[pathHierarchy.articlesContainer.identifier] = inputs.articlesDocumentationRootReference
+        resolvedReferenceMap[pathHierarchy.tutorialOverviewContainer.identifier] = inputs.tutorialTableOfContentsContainer
     }
     
     /// Map the resolved identifiers to resolved topic references for all symbols in the given symbol index.
@@ -264,14 +264,14 @@ final class PathHierarchyBasedLinkResolver {
     ///
     /// - Parameters:
     ///   - symbolGraph: The complete symbol graph to walk through.
-    ///   - bundle: The bundle to use when creating symbol references.
-    func referencesForSymbols(in unifiedGraphs: [String: UnifiedSymbolGraph], bundle: DocumentationBundle, context: DocumentationContext) -> [SymbolGraph.Symbol.Identifier: ResolvedTopicReference] {
+    ///   - context: The context that the symbols belong to.
+    func referencesForSymbols(in unifiedGraphs: [String: UnifiedSymbolGraph], context: DocumentationContext) -> [SymbolGraph.Symbol.Identifier: ResolvedTopicReference] {
         let disambiguatedPaths = pathHierarchy.caseInsensitiveDisambiguatedPaths(includeDisambiguationForUnambiguousChildren: true, includeLanguage: true, allowAdvancedDisambiguation: false)
         
         var result: [SymbolGraph.Symbol.Identifier: ResolvedTopicReference] = [:]
         
         for (moduleName, symbolGraph) in unifiedGraphs {
-            let paths: [ResolvedTopicReference?] = Array(symbolGraph.symbols.values).concurrentMap { unifiedSymbol -> ResolvedTopicReference? in
+            let paths: [ResolvedTopicReference?] = Array(symbolGraph.symbols.values).concurrentMap { (unifiedSymbol: UnifiedSymbolGraph.Symbol) -> ResolvedTopicReference? in
                 let symbol = unifiedSymbol
                 let uniqueIdentifier = unifiedSymbol.uniqueIdentifier
                 
@@ -280,7 +280,7 @@ final class PathHierarchyBasedLinkResolver {
                    pathComponents.count == componentsCount
                 {
                     let symbolReference = SymbolReference(pathComponents: pathComponents, interfaceLanguages: symbol.sourceLanguages)
-                    return ResolvedTopicReference(symbolReference: symbolReference, moduleName: moduleName, bundle: bundle)
+                    return ResolvedTopicReference(symbolReference: symbolReference, moduleName: moduleName, inputs: context.inputs)
                 }
                 
                 guard let path = disambiguatedPaths[uniqueIdentifier] else {
@@ -288,7 +288,7 @@ final class PathHierarchyBasedLinkResolver {
                 }
                 
                 return ResolvedTopicReference(
-                    bundleID: bundle.documentationRootReference.bundleID,
+                    bundleID: context.inputs.documentationRootReference.bundleID,
                     path: NodeURLGenerator.Path.documentationFolder + path,
                     sourceLanguages: symbol.sourceLanguages
                 )
diff --git a/Sources/SwiftDocC/Infrastructure/NodeURLGenerator.swift b/Sources/SwiftDocC/Infrastructure/NodeURLGenerator.swift
index f58a4a32cc..4996e790ab 100644
--- a/Sources/SwiftDocC/Infrastructure/NodeURLGenerator.swift
+++ b/Sources/SwiftDocC/Infrastructure/NodeURLGenerator.swift
@@ -117,25 +117,30 @@ public struct NodeURLGenerator {
     }
     
     /// Returns a string path appropriate for the given semantic node.
-    public static func pathForSemantic(_ semantic: Semantic, source: URL, bundle: DocumentationBundle) -> String {
+    public static func pathForSemantic(_ semantic: Semantic, source: URL, inputInfo: DocumentationContext.Inputs.Info) -> String {
         let fileName = source.deletingPathExtension().lastPathComponent
         
         switch semantic {
         case is TutorialTableOfContents:
             return Path.tutorialTableOfContents(name: fileName).stringValue
         case is Tutorial, is TutorialArticle:
-            return Path.tutorial(bundleName: bundle.displayName, tutorialName: fileName).stringValue
+            return Path.tutorial(bundleName: inputInfo.displayName, tutorialName: fileName).stringValue
         case let article as Article:
             if article.metadata?.technologyRoot != nil {
                 return Path.documentation(path: fileName).stringValue
             } else {
-                return Path.article(bundleName: bundle.displayName, articleName: fileName).stringValue
+                return Path.article(bundleName: inputInfo.displayName, articleName: fileName).stringValue
             }
         default:
             return fileName
         }
     }
     
+    @available(*, deprecated, renamed: "pathForSemantic(_:source:inputInfo:)", message: "Use 'pathForSemantic(_:source:inputInfo:)' instead. This deprecated API will be removed after 6.3 is released")
+    public static func pathForSemantic(_ semantic: Semantic, source: URL, bundle: DocumentationBundle) -> String {
+        pathForSemantic(semantic, source: source, inputInfo: bundle.info)
+    }
+    
     /// Returns the reference's path in a format that is safe for writing to disk.
     public static func fileSafeReferencePath(
         _ reference: ResolvedTopicReference,
diff --git a/Sources/SwiftDocC/Infrastructure/Symbol Graph/GeneratedDocumentationTopics.swift b/Sources/SwiftDocC/Infrastructure/Symbol Graph/GeneratedDocumentationTopics.swift
index 4ceb41fa38..19e0ede338 100644
--- a/Sources/SwiftDocC/Infrastructure/Symbol Graph/GeneratedDocumentationTopics.swift	
+++ b/Sources/SwiftDocC/Infrastructure/Symbol Graph/GeneratedDocumentationTopics.swift	
@@ -96,7 +96,7 @@ enum GeneratedDocumentationTopics {
     
     private static let defaultImplementationGroupTitle = "Default Implementations"
     
-    private static func createCollectionNode(parent: ResolvedTopicReference, title: String, identifiers: [ResolvedTopicReference], context: DocumentationContext, bundle: DocumentationBundle) throws {
+    private static func createCollectionNode(parent: ResolvedTopicReference, title: String, identifiers: [ResolvedTopicReference], context: DocumentationContext, inputs: DocumentationContext.Inputs) throws {
         let automaticCurationSourceLanguage: SourceLanguage
         let automaticCurationSourceLanguages: Set<SourceLanguage>
         automaticCurationSourceLanguage = identifiers.first?.sourceLanguage ?? .swift
@@ -104,7 +104,7 @@ enum GeneratedDocumentationTopics {
         
         // Create the collection topic reference
         let collectionReference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: inputs.id,
             path: NodeURLGenerator.Path.documentationCuration(
                 parentPath: parent.path,
                 articleName: title
@@ -227,8 +227,8 @@ enum GeneratedDocumentationTopics {
     ///   - relationships: A set of relationships to inspect.
     ///   - symbolsURLHierarchy: A symbol graph hierarchy as created during symbol registration.
     ///   - context: A documentation context to update.
-    ///   - bundle: The current documentation bundle.
-    static func createInheritedSymbolsAPICollections(relationships: Set<SymbolGraph.Relationship>, context: DocumentationContext, bundle: DocumentationBundle) throws {
+    ///   - inputs: The current collection of input files.
+    static func createInheritedSymbolsAPICollections(relationships: Set<SymbolGraph.Relationship>, context: DocumentationContext, inputs: DocumentationContext.Inputs) throws {
         var inheritanceIndex = InheritedSymbols()
         
         // Walk the symbol graph relationships and look for parent <-> child links that stem in a different module.
@@ -258,7 +258,7 @@ enum GeneratedDocumentationTopics {
         for (typeReference, collections) in inheritanceIndex.implementingTypes where !collections.inheritedFromTypeName.isEmpty {
             for (_, collection) in collections.inheritedFromTypeName where !collection.identifiers.isEmpty {
                 // Create a collection for the given provider type's inherited symbols
-                try createCollectionNode(parent: typeReference, title: collection.title, identifiers: collection.identifiers, context: context, bundle: bundle)
+                try createCollectionNode(parent: typeReference, title: collection.title, identifiers: collection.identifiers, context: context, inputs: inputs)
             }
         }
     }
diff --git a/Sources/SwiftDocC/Infrastructure/Symbol Graph/ResolvedTopicReference+Symbol.swift b/Sources/SwiftDocC/Infrastructure/Symbol Graph/ResolvedTopicReference+Symbol.swift
index c03c5d306f..b8253172af 100644
--- a/Sources/SwiftDocC/Infrastructure/Symbol Graph/ResolvedTopicReference+Symbol.swift	
+++ b/Sources/SwiftDocC/Infrastructure/Symbol Graph/ResolvedTopicReference+Symbol.swift	
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -15,13 +15,13 @@ extension ResolvedTopicReference {
     /// - Parameters:
     ///   - symbolReference: A reference to a symbol.
     ///   - moduleName: The module, to which the symbol belongs.
-    ///   - bundle: A documentation bundle, to which the symbol belongs.
-    init(symbolReference: SymbolReference, moduleName: String, bundle: DocumentationBundle) {
+    ///   - inputs: A collection of documentation inputs that the symbol belongs to.
+    init(symbolReference: SymbolReference, moduleName: String, inputs: DocumentationContext.Inputs) {
         let path = symbolReference.path.isEmpty ? "" : "/" + symbolReference.path
         
         self.init(
-            bundleID: bundle.documentationRootReference.bundleID,
-            path: bundle.documentationRootReference.appendingPath(moduleName + path).path,
+            bundleID: inputs.documentationRootReference.bundleID,
+            path: inputs.documentationRootReference.appendingPath(moduleName + path).path,
             fragment: nil,
             sourceLanguages: symbolReference.interfaceLanguages
         )
diff --git a/Sources/SwiftDocC/Infrastructure/Symbol Graph/SymbolGraphLoader.swift b/Sources/SwiftDocC/Infrastructure/Symbol Graph/SymbolGraphLoader.swift
index 4418b6ad60..8a3e613302 100644
--- a/Sources/SwiftDocC/Infrastructure/Symbol Graph/SymbolGraphLoader.swift	
+++ b/Sources/SwiftDocC/Infrastructure/Symbol Graph/SymbolGraphLoader.swift	
@@ -11,29 +11,29 @@
 import Foundation
 import SymbolKit
 
-/// Loads symbol graph files from a documentation bundle.
+/// Loads symbol graph files from a collection of inputs.
 ///
-/// A type that groups a bundle's symbol graphs by the module they describe,
+/// A type that groups a catalogs's symbol graphs by the module they describe,
 /// which makes detecting symbol collisions and overloads easier.
 struct SymbolGraphLoader {
     private(set) var symbolGraphs: [URL: SymbolKit.SymbolGraph] = [:]
     private(set) var unifiedGraphs: [String: SymbolKit.UnifiedSymbolGraph] = [:]
     private(set) var graphLocations: [String: [SymbolKit.GraphCollector.GraphKind]] = [:]
     private let dataProvider: any DataProvider
-    private let bundle: DocumentationBundle
+    private let inputs: DocumentationContext.Inputs
     private let symbolGraphTransformer: ((inout SymbolGraph) -> ())?
     
     /// Creates a new symbol graph loader
     /// - Parameters:
-    ///   - bundle: The documentation bundle from which to load symbol graphs.
+    ///   - inputs: The collection of inputs files from which to load symbol graphs.
     ///   - dataProvider: A provider that the loader uses to read symbol graph data.
     ///   - symbolGraphTransformer: An optional closure that transforms the symbol graph after the loader decodes it.
     init(
-        bundle: DocumentationBundle,
+        inputs: DocumentationContext.Inputs,
         dataProvider: any DataProvider,
         symbolGraphTransformer: ((inout SymbolGraph) -> ())? = nil
     ) {
-        self.bundle = bundle
+        self.inputs = inputs
         self.dataProvider = dataProvider
         self.symbolGraphTransformer = symbolGraphTransformer
     }
@@ -49,7 +49,7 @@ struct SymbolGraphLoader {
     /// The symbol graph decoding strategy to use.
     private(set) var decodingStrategy: DecodingConcurrencyStrategy = .concurrentlyEachFileInBatches
 
-    /// Loads all symbol graphs in the given bundle.
+    /// Loads all symbol graphs in the given catalog.
     ///
     /// - Throws: If loading and decoding any of the symbol graph files throws, this method re-throws one of the encountered errors.
     mutating func loadAll() throws {
@@ -82,7 +82,7 @@ struct SymbolGraphLoader {
                 symbolGraphTransformer?(&symbolGraph)
 
                 let (moduleName, isMainSymbolGraph) = Self.moduleNameFor(symbolGraph, at: symbolGraphURL)
-                // If the bundle provides availability defaults add symbol availability data.
+                // If the catalog provides availability defaults add symbol availability data.
                 self.addDefaultAvailability(to: &symbolGraph, moduleName: moduleName)
 
                 // main symbol graphs are ambiguous
@@ -113,22 +113,22 @@ struct SymbolGraphLoader {
         // This strategy benchmarks better when we have multiple
         // "larger" symbol graphs.
         #if os(macOS) || os(iOS)
-        if bundle.symbolGraphURLs.filter({ !$0.lastPathComponent.contains("@") }).count > 1 {
+        if inputs.symbolGraphURLs.filter({ !$0.lastPathComponent.contains("@") }).count > 1 {
             // There are multiple main symbol graphs, better parallelize all files decoding.
             decodingStrategy = .concurrentlyAllFiles
         }
         #endif
         
-        let numberOfSymbolGraphs = bundle.symbolGraphURLs.count
+        let numberOfSymbolGraphs = inputs.symbolGraphURLs.count
         let decodeSignpostHandle = signposter.beginInterval("Decode symbol graphs", id: signposter.makeSignpostID(), "Decode \(numberOfSymbolGraphs) symbol graphs")
         switch decodingStrategy {
         case .concurrentlyAllFiles:
             // Concurrently load and decode all symbol graphs
-            bundle.symbolGraphURLs.concurrentPerform(block: loadGraphAtURL)
+            inputs.symbolGraphURLs.concurrentPerform(block: loadGraphAtURL)
             
         case .concurrentlyEachFileInBatches:
             // Serially load and decode all symbol graphs, each one in concurrent batches.
-            bundle.symbolGraphURLs.forEach(loadGraphAtURL)
+            inputs.symbolGraphURLs.forEach(loadGraphAtURL)
         }
         signposter.endInterval("Decode symbol graphs", decodeSignpostHandle)
         
@@ -166,7 +166,7 @@ struct SymbolGraphLoader {
             var defaultUnavailablePlatforms = [PlatformName]()
             var defaultAvailableInformation = [DefaultAvailability.ModuleAvailability]()
 
-            if let defaultAvailabilities = bundle.info.defaultAvailability?.modules[unifiedGraph.moduleName] {
+            if let defaultAvailabilities = inputs.info.defaultAvailability?.modules[unifiedGraph.moduleName] {
                 let (unavailablePlatforms, availablePlatforms) = defaultAvailabilities.categorize(where: { $0.versionInformation == .unavailable })
                 defaultUnavailablePlatforms = unavailablePlatforms.map(\.platformName)
                 defaultAvailableInformation = availablePlatforms
@@ -264,11 +264,11 @@ struct SymbolGraphLoader {
         }
     }    
 
-    /// If the bundle defines default availability for the symbols in the given symbol graph
+    /// If the catalog defines default availability for the symbols in the given symbol graph
     /// this method adds them to each of the symbols in the graph.
     private func addDefaultAvailability(to symbolGraph: inout SymbolGraph, moduleName: String) {
         // Check if there are defined default availabilities for the current module
-        if let defaultAvailabilities = bundle.info.defaultAvailability?.modules[moduleName],
+        if let defaultAvailabilities = inputs.info.defaultAvailability?.modules[moduleName],
             let platformName = symbolGraph.module.platform.name.map(PlatformName.init) {
 
             // Prepare a default availability versions lookup for this module.
@@ -465,7 +465,7 @@ extension SymbolGraph.Symbol.Availability.AvailabilityItem {
      in from the `defaults`. If the defaults do not have a version for
      this item's domain/platform, also try the `fallbackPlatform`.
 
-     - parameter defaults: Default module availabilities for each platform mentioned in a documentation bundle's `Info.plist`
+     - parameter defaults: Default module availabilities for each platform mentioned in a documentation catalog's `Info.plist`
      - parameter fallbackPlatform: An optional fallback platform name if this item's domain isn't found in the `defaults`.
      */
     func fillingMissingIntroducedVersion(from defaults: [PlatformName: SymbolGraph.SemanticVersion],
diff --git a/Sources/SwiftDocC/Infrastructure/Symbol Graph/SymbolGraphRelationshipsBuilder.swift b/Sources/SwiftDocC/Infrastructure/Symbol Graph/SymbolGraphRelationshipsBuilder.swift
index 836b84775d..96698aae9e 100644
--- a/Sources/SwiftDocC/Infrastructure/Symbol Graph/SymbolGraphRelationshipsBuilder.swift	
+++ b/Sources/SwiftDocC/Infrastructure/Symbol Graph/SymbolGraphRelationshipsBuilder.swift	
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -52,14 +52,12 @@ struct SymbolGraphRelationshipsBuilder {
     /// - Parameters:
     ///   - edge: A symbol graph relationship with a source and a target.
     ///   - selector: The symbol graph selector in which the relationship is relevant.
-    ///   - bundle: A documentation bundle.
     ///   - context: A documentation context.
     ///   - localCache: A cache of local documentation content.
     ///   - engine: A diagnostic collecting engine.
     static func addImplementationRelationship(
         edge: SymbolGraph.Relationship,
         selector: UnifiedSymbolGraph.Selector,
-        in bundle: DocumentationBundle,
         context: DocumentationContext,
         localCache: DocumentationContext.LocalCache,
         engine: DiagnosticEngine
@@ -83,7 +81,7 @@ struct SymbolGraphRelationshipsBuilder {
                 ?? implementorNode.reference.sourceLanguage
             
             let symbolReference = SymbolReference(edge.target, interfaceLanguage: language, symbol: localCache[edge.target]?.symbol)
-            guard let unresolved = UnresolvedTopicReference(symbolReference: symbolReference, bundle: bundle) else {
+            guard let unresolved = UnresolvedTopicReference(symbolReference: symbolReference, inputs: context.inputs) else {
                 // The symbol reference format is invalid.
                 assertionFailure(AssertionMessages.invalidSymbolReference(symbolReference))
                 return
@@ -137,14 +135,14 @@ struct SymbolGraphRelationshipsBuilder {
     /// - Parameters:
     ///   - edge: A symbol-graph relationship with a source and a target.
     ///   - selector: The symbol graph selector in which the relationship is relevant.
-    ///   - bundle: A documentation bundle.
+    ///   - inputs: The collection of inputs files that the context was created from.
     ///   - localCache: A cache of local documentation content.
     ///   - externalCache: A cache of external documentation content.
     ///   - engine: A diagnostic collecting engine.
     static func addConformanceRelationship(
         edge: SymbolGraph.Relationship,
         selector: UnifiedSymbolGraph.Selector,
-        in bundle: DocumentationBundle,
+        in inputs: DocumentationContext.Inputs,
         localCache: DocumentationContext.LocalCache,
         externalCache: DocumentationContext.ExternalCache,
         engine: DiagnosticEngine
@@ -173,7 +171,7 @@ struct SymbolGraphRelationshipsBuilder {
                 ?? conformingNode.reference.sourceLanguage
 
             let symbolReference = SymbolReference(edge.target, interfaceLanguage: language, symbol: localCache[edge.target]?.symbol)
-            guard let unresolved = UnresolvedTopicReference(symbolReference: symbolReference, bundle: bundle) else {
+            guard let unresolved = UnresolvedTopicReference(symbolReference: symbolReference, inputs: inputs) else {
                 // The symbol reference format is invalid.
                 assertionFailure(AssertionMessages.invalidSymbolReference(symbolReference))
                 return
@@ -226,14 +224,14 @@ struct SymbolGraphRelationshipsBuilder {
     /// - Parameters:
     ///   - edge: A symbol graph relationship with a source and a target.
     ///   - selector: The symbol graph selector in which the relationship is relevant.
-    ///   - bundle: A documentation bundle.
+    ///   - inputs: The collection of inputs files that the context was created from.
     ///   - localCache: A cache of local documentation content.
     ///   - externalCache: A cache of external documentation content.
     ///   - engine: A diagnostic collecting engine.
     static func addInheritanceRelationship(
         edge: SymbolGraph.Relationship,
         selector: UnifiedSymbolGraph.Selector,
-        in bundle: DocumentationBundle,
+        in inputs: DocumentationContext.Inputs,
         localCache: DocumentationContext.LocalCache,
         externalCache: DocumentationContext.ExternalCache,
         engine: DiagnosticEngine
@@ -260,7 +258,7 @@ struct SymbolGraphRelationshipsBuilder {
             let language = childNode.reference.sourceLanguage
             
             let symbolReference = SymbolReference(edge.target, interfaceLanguage: language, symbol: nil)
-            guard let unresolved = UnresolvedTopicReference(symbolReference: symbolReference, bundle: bundle) else {
+            guard let unresolved = UnresolvedTopicReference(symbolReference: symbolReference, inputs: inputs) else {
                 // The symbol reference format is invalid.
                 assertionFailure(AssertionMessages.invalidSymbolReference(symbolReference))
                 return
diff --git a/Sources/SwiftDocC/Infrastructure/Symbol Graph/UnresolvedTopicReference+Symbol.swift b/Sources/SwiftDocC/Infrastructure/Symbol Graph/UnresolvedTopicReference+Symbol.swift
index 42cacab44e..5d49a41e37 100644
--- a/Sources/SwiftDocC/Infrastructure/Symbol Graph/UnresolvedTopicReference+Symbol.swift	
+++ b/Sources/SwiftDocC/Infrastructure/Symbol Graph/UnresolvedTopicReference+Symbol.swift	
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -14,11 +14,11 @@ extension UnresolvedTopicReference {
     /// Creates an unresolved reference out of a symbol reference.
     /// - Parameters:
     ///   - symbolReference: A reference to a symbol.
-    ///   - bundle: A documentation bundle.
-    init?(symbolReference: SymbolReference, bundle: DocumentationBundle) {
+    ///   - inputs: A collection of inputs files that the symbol is from.
+    init?(symbolReference: SymbolReference, inputs: DocumentationContext.Inputs) {
         guard var components = URLComponents(string: symbolReference.path) else { return nil }
         components.scheme = ResolvedTopicReference.urlScheme
-        components.host = bundle.id.rawValue
+        components.host = inputs.id.rawValue
         if !components.path.hasPrefix("/") {
             components.path.insert("/", at: components.path.startIndex)
         }
diff --git a/Sources/SwiftDocC/Infrastructure/Topic Graph/AutomaticCuration.swift b/Sources/SwiftDocC/Infrastructure/Topic Graph/AutomaticCuration.swift
index be5516727a..0501f3d04c 100644
--- a/Sources/SwiftDocC/Infrastructure/Topic Graph/AutomaticCuration.swift	
+++ b/Sources/SwiftDocC/Infrastructure/Topic Graph/AutomaticCuration.swift	
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -148,14 +148,12 @@ public struct AutomaticCuration {
     /// - Parameters:
     ///   - node: A node for which to generate a See Also group.
     ///   - context: A documentation context.
-    ///   - bundle: A documentation bundle.
     /// - Returns: A group title and the group's references or links.
     ///   `nil` if the method can't find any relevant links to automatically generate a See Also content.
     static func seeAlso(
         for node: DocumentationNode,
         withTraits variantsTraits: Set<DocumentationDataVariantsTrait>,
         context: DocumentationContext,
-        bundle: DocumentationBundle,
         renderContext: RenderContext?,
         renderer: DocumentationContentRenderer
     ) -> TaskGroup? {
diff --git a/Sources/SwiftDocC/Infrastructure/Workspace/DefaultAvailability.swift b/Sources/SwiftDocC/Infrastructure/Workspace/DefaultAvailability.swift
index 4f4bcb49d7..f6170906e4 100644
--- a/Sources/SwiftDocC/Infrastructure/Workspace/DefaultAvailability.swift
+++ b/Sources/SwiftDocC/Infrastructure/Workspace/DefaultAvailability.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -14,7 +14,7 @@ import Foundation
 ///
 /// Default availability is used as a fallback value for symbols without explicit availability information.
 ///
-/// This information can be authored in the bundle's Info.plist file, as a dictionary of module names to arrays of platform "name" and "version" pairs,
+/// This information can be authored in the catalog's Info.plist file, as a dictionary of module names to arrays of platform "name" and "version" pairs,
 /// or in the case where the platform in unconditionally unavailable, "name" and "unavailable" pairs:
 ///
 /// ```
@@ -107,7 +107,7 @@ public struct DefaultAvailability: Codable, Equatable {
             // semantic version.
             if let introducedVersion {
                 guard let version = Version(versionString: introducedVersion), (2...3).contains(version.count) else {
-                    throw DocumentationBundle.PropertyListError.invalidVersionString(introducedVersion)
+                    throw DocumentationContext.Inputs.PropertyListError.invalidVersionString(introducedVersion)
                 }
             }
         }
diff --git a/Sources/SwiftDocC/Infrastructure/Workspace/DocumentationBundle+Info.swift b/Sources/SwiftDocC/Infrastructure/Workspace/DocumentationBundle+Info.swift
index 28d4490c80..a46a5bc4a0 100644
--- a/Sources/SwiftDocC/Infrastructure/Workspace/DocumentationBundle+Info.swift
+++ b/Sources/SwiftDocC/Infrastructure/Workspace/DocumentationBundle+Info.swift
@@ -10,27 +10,27 @@
 
 public import Foundation
 
-extension DocumentationBundle {
-    /// Information about a documentation bundle that's unrelated to its documentation content.
+extension DocumentationContext.Inputs {
+    /// Information about a documentation catalog that's unrelated to its documentation content.
     ///
-    /// This information is meant to be decoded from the bundle's Info.plist file.
+    /// This information is meant to be decoded from the catalog's Info.plist file.
     public struct Info: Codable, Equatable {
-        /// The display name of the bundle.
+        /// The display name of the catalog.
         public var displayName: String
         
-        /// The unique identifier of the bundle.
-        public var id: DocumentationBundle.Identifier
+        /// The unique identifier of the catalog.
+        public var id: DocumentationContext.Inputs.Identifier
         
-        /// The default language identifier for code listings in the bundle.
+        /// The default language identifier for code listings in the catalog.
         public var defaultCodeListingLanguage: String?
         
-        /// The default availability for the various modules in the bundle.
+        /// The default availability for the various modules in the catalog.
         public var defaultAvailability: DefaultAvailability?
         
-        /// The default kind for the various modules in the bundle.
+        /// The default kind for the various modules in the catalog.
         public var defaultModuleKind: String?
 
-        /// The parsed feature flags that were set for this bundle.
+        /// The parsed feature flags that were set for this catalog.
         internal var featureFlags: BundleFeatureFlags?
 
         /// The keys that must be present in an Info.plist file in order for doc compilation to proceed.
@@ -76,16 +76,16 @@ extension DocumentationBundle {
             }
         }
         
-        /// Creates a new documentation bundle information value.
+        /// Creates a new documentation information value.
         /// - Parameters:
-        ///   - displayName: The display name of the bundle.
-        ///   - id:  The unique identifier of the bundle.
-        ///   - defaultCodeListingLanguage: The default language identifier for code listings in the bundle.
-        ///   - defaultAvailability: The default availability for the various modules in the bundle.
-        ///   - defaultModuleKind: The default kind for the various modules in the bundle.
+        ///   - displayName: The display name of the catalog.
+        ///   - id:  The unique identifier of the catalog.
+        ///   - defaultCodeListingLanguage: The default language identifier for code listings in the catalog.
+        ///   - defaultAvailability: The default availability for the various modules in the catalog.
+        ///   - defaultModuleKind: The default kind for the various modules in the catalog.
         public init(
             displayName: String,
-            id: DocumentationBundle.Identifier,
+            id: DocumentationContext.Inputs.Identifier,
             defaultCodeListingLanguage: String?,
             defaultAvailability: DefaultAvailability?,
             defaultModuleKind: String?
@@ -100,11 +100,10 @@ extension DocumentationBundle {
             )
         }
         
-        /// Creates documentation bundle information from the given Info.plist data, falling back to the values
-        /// in the given bundle discovery options if necessary.
+        /// Creates documentation information from the given Info.plist data, falling back to the values in the given discovery options if necessary.
         init(
             from infoPlist: Data? = nil,
-            bundleDiscoveryOptions options: BundleDiscoveryOptions? = nil,
+            catalogDiscoveryOptions options: CatalogDiscoveryOptions? = nil,
             derivedDisplayName: String? = nil
         ) throws {
             if let infoPlist {
@@ -120,7 +119,7 @@ extension DocumentationBundle {
                 
                 do {
                     self = try propertyListDecoder.decode(
-                        DocumentationBundle.Info.self,
+                        DocumentationContext.Inputs.Info.self,
                         from: infoPlist
                     )
                 } catch DecodingError.dataCorrupted(let context) {
@@ -130,26 +129,26 @@ extension DocumentationBundle {
             } else {
                 try self.init(
                     with: nil,
-                    bundleDiscoveryOptions: options,
+                    catalogDiscoveryOptions: options,
                     derivedDisplayName: derivedDisplayName
                 )
             }
         }
         
         public init(from decoder: any Decoder) throws {
-            let bundleDiscoveryOptions = decoder.userInfo[.bundleDiscoveryOptions] as? BundleDiscoveryOptions
+            let catalogDiscoveryOptions = decoder.userInfo[.bundleDiscoveryOptions] as? CatalogDiscoveryOptions
             let derivedDisplayName = decoder.userInfo[.derivedDisplayName] as? String
             
             try self.init(
                 with: decoder.container(keyedBy: CodingKeys.self),
-                bundleDiscoveryOptions: bundleDiscoveryOptions,
+                catalogDiscoveryOptions: catalogDiscoveryOptions,
                 derivedDisplayName: derivedDisplayName
             )
         }
         
         private init(
-            with values: KeyedDecodingContainer<DocumentationBundle.Info.CodingKeys>?,
-            bundleDiscoveryOptions: BundleDiscoveryOptions?,
+            with values: KeyedDecodingContainer<DocumentationContext.Inputs.Info.CodingKeys>?,
+            catalogDiscoveryOptions: CatalogDiscoveryOptions?,
             derivedDisplayName: String?
         ) throws {
             // Here we define two helper functions that simplify
@@ -164,7 +163,7 @@ extension DocumentationBundle {
                 with key: CodingKeys
             ) throws -> T? where T : Decodable {
                 try values?.decodeIfPresent(T.self, forKey: key)
-                    ?? bundleDiscoveryOptions?.infoPlistFallbacks.decodeIfPresent(T.self, forKey: key.rawValue)
+                    ?? catalogDiscoveryOptions?.infoPlistFallbacks.decodeIfPresent(T.self, forKey: key.rawValue)
             }
             
             /// Helper function that decodes a value of the given type for the given key
@@ -173,13 +172,13 @@ extension DocumentationBundle {
                 _ expectedType: T.Type,
                 with key: CodingKeys
             ) throws -> T where T : Decodable {
-                if let bundleDiscoveryOptions {
+                if let catalogDiscoveryOptions {
                     return try values?.decodeIfPresent(T.self, forKey: key)
-                    ?? bundleDiscoveryOptions.infoPlistFallbacks.decode(T.self, forKey: key.rawValue)
+                    ?? catalogDiscoveryOptions.infoPlistFallbacks.decode(T.self, forKey: key.rawValue)
                 } else if let values {
                     return try values.decode(T.self, forKey: key)
                 } else {
-                    throw DocumentationBundle.PropertyListError.keyNotFound(key.rawValue)
+                    throw DocumentationContext.Inputs.PropertyListError.keyNotFound(key.rawValue)
                 }
             }
             
@@ -190,7 +189,7 @@ extension DocumentationBundle {
             // **all** missing required keys, instead of just the first one hit.
             
             var givenKeys = Set(values?.allKeys ?? []).union(
-                bundleDiscoveryOptions?.infoPlistFallbacks.keys.compactMap {
+                catalogDiscoveryOptions?.infoPlistFallbacks.keys.compactMap {
                     CodingKeys(stringValue: $0)
                 } ?? []
             )
@@ -232,7 +231,7 @@ extension DocumentationBundle {
 
         init(
             displayName: String,
-            id: DocumentationBundle.Identifier,
+            id: DocumentationContext.Inputs.Identifier,
             defaultCodeListingLanguage: String? = nil,
             defaultModuleKind: String? = nil,
             defaultAvailability: DefaultAvailability? = nil,
@@ -248,19 +247,18 @@ extension DocumentationBundle {
     }
 }
 
-extension BundleDiscoveryOptions {
-    /// Creates new bundle discovery options with the given information.
-    /// 
-    /// The given fallback values will be used if any of the discovered bundles are missing that
-    /// value in their Info.plist configuration file.
-    /// 
+extension CatalogDiscoveryOptions {
+    /// Creates new catalog discovery options with the given information.
+    ///
+    /// The given fallback values will be used if the discovered catalog is missing that value in its Info.plist configuration file.
+    ///
     /// - Parameters:
-    ///   - fallbackDisplayName: A fallback display name for the bundle.
-    ///   - fallbackIdentifier: A fallback identifier for the bundle.
-    ///   - fallbackDefaultCodeListingLanguage: A fallback default code listing language for the bundle.
-    ///   - fallbackDefaultModuleKind: A fallback default module kind for the bundle.
-    ///   - fallbackDefaultAvailability: A fallback default availability for the bundle.
-    ///   - additionalSymbolGraphFiles: Additional symbol graph files to augment any discovered bundles.
+    ///   - fallbackDisplayName: A fallback display name for the catalog.
+    ///   - fallbackIdentifier: A fallback identifier for the catalog.
+    ///   - fallbackDefaultCodeListingLanguage: A fallback default code listing language for the catalog.
+    ///   - fallbackDefaultModuleKind: A fallback default module kind for the catalog.
+    ///   - fallbackDefaultAvailability: A fallback default availability for the catalog.
+    ///   - additionalSymbolGraphFiles: Additional symbol graph files to augment the discovered catalog.
     public init(
         fallbackDisplayName: String? = nil,
         fallbackIdentifier: String? = nil,
@@ -274,7 +272,7 @@ extension BundleDiscoveryOptions {
         // This ensures that when new coding keys are added, the compiler will enforce
         // that we handle them here as well.
         
-        let fallbacks = DocumentationBundle.Info.CodingKeys.allCases.compactMap { key -> (String, Any)? in
+        let fallbacks = DocumentationContext.Inputs.Info.CodingKeys.allCases.compactMap { key -> (String, Any)? in
             let value: Any?
             
             switch key {
@@ -307,7 +305,7 @@ extension BundleDiscoveryOptions {
 }
 
 private extension CodingUserInfoKey {
-    /// A user info key to store bundle discovery options in the decoder.
+    /// A user info key to store catalog discovery options in the decoder.
     static let bundleDiscoveryOptions = CodingUserInfoKey(rawValue: "bundleDiscoveryOptions")!
     /// A user info key to store derived display name in the decoder.
     static let derivedDisplayName = CodingUserInfoKey(rawValue: "derivedDisplayName")!
diff --git a/Sources/SwiftDocC/Infrastructure/Workspace/DocumentationWorkspaceDataProvider.swift b/Sources/SwiftDocC/Infrastructure/Workspace/DocumentationWorkspaceDataProvider.swift
index e068262975..686cfb17eb 100644
--- a/Sources/SwiftDocC/Infrastructure/Workspace/DocumentationWorkspaceDataProvider.swift
+++ b/Sources/SwiftDocC/Infrastructure/Workspace/DocumentationWorkspaceDataProvider.swift
@@ -10,25 +10,22 @@
 
 public import Foundation
 
-
-/// Options to configure the discovery of documentation bundles
-public struct BundleDiscoveryOptions {
+/// Options to configure the discovery of a documentation catalog
+public struct CatalogDiscoveryOptions {
     // When adding new configuration, remember to include a default value in the initializer so that an options
     // value can be created without passing any arguments, resulting in the "default" configuration.
-    //
-    // The provider uses the default configuration in the `DocumentationWorkspaceDataProvider.bundles()` function.
     
-    /// Fallback values for information that's missing in the bundle's Info.plist file.
+    /// Fallback values for information that's missing in the catalog's Info.plist file.
     public let infoPlistFallbacks: [String: Any]
     
-    /// Additional symbol graph files that the provider should include in the discovered bundles.
+    /// Additional symbol graph files that the provider should include in the discovered catalog.
     public let additionalSymbolGraphFiles: [URL]
     
     /// Creates a new options value with the given configurations.
     ///
     /// - Parameters:
-    ///   - infoPlistFallbacks: Fallback values for information that's missing in the bundle's Info.plist file.
-    ///   - additionalSymbolGraphFiles: Additional symbol graph files that the provider should include in the discovered bundles.
+    ///   - infoPlistFallbacks: Fallback values for information that's missing in the catalog's Info.plist file.
+    ///   - additionalSymbolGraphFiles: Additional symbol graph files that the provider should include in the discovered catalog.
     public init(
         infoPlistFallbacks: [String: Any] = [:],
         additionalSymbolGraphFiles: [URL] = []
@@ -37,25 +34,24 @@ public struct BundleDiscoveryOptions {
         self.additionalSymbolGraphFiles = additionalSymbolGraphFiles
     }
     
-    /// Creates new bundle discovery options with the provided documentation bundle info
-    /// as Info.plist fallback values.
+    /// Creates new catalog discovery options with the provided documentation info as Info.plist fallback values.
     ///
     /// - Parameters:
-    ///   - fallbackInfo: Fallback documentation bundle information to use if any discovered bundles are missing an Info.plist.
-    ///   - additionalSymbolGraphFiles: Additional symbol graph files to augment any discovered bundles.
+    ///   - fallbackInfo: Fallback documentation information to use if the discovered catalog is missing an Info.plist file.
+    ///   - additionalSymbolGraphFiles: Additional symbol graph files to augment the discovered catalog.
     public init(
-        fallbackInfo: DocumentationBundle.Info,
+        fallbackInfo: DocumentationContext.Inputs.Info,
         additionalSymbolGraphFiles: [URL] = []
     ) throws {
         // Use JSONEncoder to dynamically create the Info.plist fallback
-        // dictionary the `BundleDiscoveryOption`s expect from given DocumentationBundle.Info
+        // dictionary the `CatalogDiscoveryOption`s expect from given DocumentationContext.Inputs.Info
         // model.
         
         let data = try JSONEncoder().encode(fallbackInfo)
         let serializedFallbackInfo = try JSONSerialization.jsonObject(with: data)
         
         guard let fallbackInfoDictionary = serializedFallbackInfo as? [String: Any] else {
-            throw DocumentationBundle.Info.Error.wrongType(
+            throw DocumentationContext.Inputs.Info.Error.wrongType(
                 expected: [String: Any].Type.self,
                 actual: type(of: serializedFallbackInfo)
             )
@@ -67,3 +63,6 @@ public struct BundleDiscoveryOptions {
         )
     }
 }
+
+@available(*, deprecated, renamed: "CatalogDiscoveryOptions", message: "Use 'CatalogDiscoveryOptions' instead. This deprecated type will be removed after 6.3 is released.")
+public typealias BundleDiscoveryOptions = CatalogDiscoveryOptions
diff --git a/Sources/SwiftDocC/Infrastructure/Workspace/FeatureFlags+Info.swift b/Sources/SwiftDocC/Infrastructure/Workspace/FeatureFlags+Info.swift
index dd62465ddd..bc44d2e339 100644
--- a/Sources/SwiftDocC/Infrastructure/Workspace/FeatureFlags+Info.swift
+++ b/Sources/SwiftDocC/Infrastructure/Workspace/FeatureFlags+Info.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2024-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -10,11 +10,11 @@
 
 import Foundation
 
-extension DocumentationBundle.Info {
-    /// A collection of feature flags that can be enabled from a bundle's Info.plist.
+extension DocumentationContext.Inputs.Info {
+    /// A collection of feature flags that can be enabled from a catalog's Info.plist.
     ///
     /// This is a subset of flags from ``FeatureFlags`` that can influence how a documentation
-    /// bundle is written, and so can be considered a property of the documentation itself, rather
+    /// catalog is written, and so can be considered a property of the documentation itself, rather
     /// than as an experimental behavior that can be enabled for one-off builds.
     ///
     /// ```xml
diff --git a/Sources/SwiftDocC/LinkTargets/LinkDestinationSummary.swift b/Sources/SwiftDocC/LinkTargets/LinkDestinationSummary.swift
index 8c6112dbb1..b2e0fdac4b 100644
--- a/Sources/SwiftDocC/LinkTargets/LinkDestinationSummary.swift
+++ b/Sources/SwiftDocC/LinkTargets/LinkDestinationSummary.swift
@@ -14,13 +14,13 @@ import SymbolKit
 
 // Link resolution works in two parts:
 //
-//  1. When DocC compiles a documentation bundle and encounters an "external" reference it will call out to
-//     resolve that reference using the external resolver that's been registered for that bundle identifier.
-//     The reference may be a page in another documentation bundle or a page from another source.
+//  1. When DocC compiles a documentation catalog and encounters an "external" reference it will call out to
+//     resolve that reference using the external resolver that's been registered for that identifier.
+//     The reference may be a page in another documentation catalog or a page from another source.
 //
-//  2. Once DocC has finished compiling the documentation bundle it will summarize all the pages and on-page
+//  2. Once DocC has finished compiling the documentation catalog it will summarize all the pages and on-page
 //     elements that can be linked to.
-//     This information is returned when another documentation bundle resolves a reference for that page.
+//     This information is returned when another unit of documentation resolves a reference for that page.
 //
 //
 //   DocC                                                                                           Backend endpoint
@@ -28,7 +28,7 @@ import SymbolKit
 //  │ ┌──────────────────────────┐                             │                                   │                               │
 //  │ │                          │                             │                                   │                               │
 //  │ │   DocumentationContext   │                             │                                   │                               │
-//  │ │     Register bundle      │                             │                                   │                               │
+//  │ │     Register catalog     │                             │                                   │                               │
 //  │ │                          │                             │                                   │                               │
 //  │ └──────────────────────────┘       Resolve external      │                                   │                               │
 //  │               │                       references         │                                   │                               │
@@ -63,9 +63,9 @@ import SymbolKit
 //  │                                                          │    └───────────────────────┘      │                               │
 //  └──────────────────────────────────────────────────────────┘                                   └───────────────────────────────┘
 
-/// A summary of an element that you can link to from outside the documentation bundle.
+/// A summary of an element that you can link to from outside the unit of documentation.
 ///
-/// The non-optional properties of this summary are all the information needed when another bundle references this element.
+/// The non-optional properties of this summary are all the information needed when another catalog references this element.
 ///
 /// Various information from the summary is used depending on what content references the summarized element. For example:
 ///  - In a paragraph of text, a link to this element will use the ``title`` as the link text and style the tile in code font if the ``kind`` is a type of symbol.
@@ -299,7 +299,7 @@ public struct LinkDestinationSummary: Codable, Equatable {
 // MARK: - Accessing the externally linkable elements
 
 public extension DocumentationNode {
-    /// Summarizes the node and all of its child elements that you can link to from outside the bundle.
+    /// Summarizes the node and all of its child elements that you can link to from outside the local unit of documentation.
     ///
     /// - Parameters:
     ///   - context: The context in which references that are found the node's content are resolved in.
@@ -311,15 +311,15 @@ public extension DocumentationNode {
         renderNode: RenderNode,
         includeTaskGroups: Bool = true
     ) -> [LinkDestinationSummary] {
-        let bundle = context.bundle
-        guard bundle.id == reference.bundleID else {
+        let inputs = context.inputs
+        guard inputs.id == reference.bundleID else {
             // Don't return anything for external references that don't have a bundle in the context.
             return []
         }
-        let urlGenerator = PresentationURLGenerator(context: context, baseURL: bundle.baseURL)
+        let urlGenerator = PresentationURLGenerator(context: context, baseURL: inputs.baseURL)
         let relativePresentationURL = urlGenerator.presentationURLForReference(reference).withoutHostAndPortAndScheme()
         
-        var compiler = RenderContentCompiler(context: context, bundle: bundle, identifier: reference)
+        var compiler = RenderContentCompiler(context: context, identifier: reference)
 
         let platforms = renderNode.metadata.platforms
         
@@ -523,7 +523,7 @@ extension LinkDestinationSummary {
     ///
     /// - Parameters:
     ///   - landmark: The landmark to summarize.
-    ///   - relativeParentPresentationURL: The bundle-relative path of the page that contain this section.
+    ///   - relativeParentPresentationURL: The relative path of the page that contain this section.
     ///   - page: The topic reference of the page that contain this section.
     ///   - compiler: The content compiler that's used to render the section's abstract.
     init?(landmark: any Landmark, relativeParentPresentationURL: URL, page: DocumentationNode, platforms: [PlatformAvailability]?, compiler: inout RenderContentCompiler) {
diff --git a/Sources/SwiftDocC/Model/BuildMetadata.swift b/Sources/SwiftDocC/Model/BuildMetadata.swift
index 39a83aa468..a3c91f482a 100644
--- a/Sources/SwiftDocC/Model/BuildMetadata.swift
+++ b/Sources/SwiftDocC/Model/BuildMetadata.swift
@@ -10,7 +10,7 @@
 
 import Foundation
 
-/// A value that encapsulates metadata for a documentation bundle that DocC built.
+/// A value that encapsulates metadata for a documentation archive that DocC built.
 public struct BuildMetadata: Codable {
     
     /// The current version of the build metadata schema.
@@ -20,18 +20,18 @@ public struct BuildMetadata: Codable {
         patch: 0
     )
     
-    /// The display name of the documentation bundle that DocC built.
+    /// The display name of the documentation archive that DocC built.
     public var bundleDisplayName: String
     
-    /// The bundle identifier of the documentation bundle that DocC built.
-    public let bundleID: DocumentationBundle.Identifier
+    /// The stable identifier of the documentation archive that DocC built.
+    public let bundleID: DocumentationContext.Inputs.Identifier
     
-    /// Creates a build metadata value for a documentation bundle built by DocC.
+    /// Creates a build metadata value for a documentation archive built by DocC.
     ///
     /// - Parameters:
-    ///   - bundleDisplayName: The display name of the documentation bundle.
-    ///   - bundleID: The bundle identifier of the documentation bundle.
-    public init(bundleDisplayName: String, bundleID: DocumentationBundle.Identifier) {
+    ///   - bundleDisplayName: The display name of the documentation archive.
+    ///   - bundleID: The bundle identifier of the documentation archive.
+    public init(bundleDisplayName: String, bundleID: DocumentationContext.Inputs.Identifier) {
         self.bundleDisplayName = bundleDisplayName
         self.bundleID = bundleID
     }
diff --git a/Sources/SwiftDocC/Model/DocumentationNode.swift b/Sources/SwiftDocC/Model/DocumentationNode.swift
index 803ddb7761..da4bc6751f 100644
--- a/Sources/SwiftDocC/Model/DocumentationNode.swift
+++ b/Sources/SwiftDocC/Model/DocumentationNode.swift
@@ -332,14 +332,14 @@ public struct DocumentationNode {
     mutating func initializeSymbolContent(
         documentationExtension: Article?,
         engine: DiagnosticEngine,
-        bundle: DocumentationBundle
+        inputs: DocumentationContext.Inputs
     ) {
         precondition(unifiedSymbol != nil && symbol != nil, "You can only call initializeSymbolContent() on a symbol node.")
         
         let (markup, docChunks, metadataFromDocumentationComment) = Self.contentFrom(
             documentedSymbol: unifiedSymbol?.documentedSymbol,
             documentationExtension: documentationExtension,
-            bundle: bundle,
+            inputs: inputs,
             engine: engine
         )
         
@@ -500,7 +500,7 @@ public struct DocumentationNode {
     static func contentFrom(
         documentedSymbol: SymbolGraph.Symbol?,
         documentationExtension: Article?,
-        bundle: DocumentationBundle? = nil,
+        inputs: DocumentationContext.Inputs? = nil,
         engine: DiagnosticEngine
     ) -> (
         markup: any Markup,
@@ -543,14 +543,14 @@ public struct DocumentationNode {
 
             var problems = [Problem]()
             
-            if let bundle {
+            if let inputs {
                 metadata = DirectiveParser()
                     .parseSingleDirective(
                         Metadata.self,
                         from: &docCommentMarkupElements,
                         parentType: Symbol.self,
                         source: docCommentLocation?.url,
-                        bundle: bundle,
+                        inputs: inputs,
                         problems: &problems
                     )
                 
diff --git a/Sources/SwiftDocC/Model/Identifier.swift b/Sources/SwiftDocC/Model/Identifier.swift
index 469af2f4ca..fa5020aa52 100644
--- a/Sources/SwiftDocC/Model/Identifier.swift
+++ b/Sources/SwiftDocC/Model/Identifier.swift
@@ -140,7 +140,7 @@ extension TopicReferenceResolutionErrorInfo {
 /// > Important: This type has copy-on-write semantics and wraps an underlying class to store
 /// > its data.
 public struct ResolvedTopicReference: Hashable, Codable, Equatable, CustomStringConvertible {
-    typealias ReferenceBundleIdentifier = DocumentationBundle.Identifier
+    typealias ReferenceBundleIdentifier = DocumentationContext.Inputs.Identifier
     private struct ReferenceKey: Hashable {
         var path: String
         var fragment: String?
@@ -150,13 +150,13 @@ public struct ResolvedTopicReference: Hashable, Codable, Equatable, CustomString
     /// A synchronized reference cache to store resolved references.
     private static var sharedPool = Synchronized([ReferenceBundleIdentifier: [ReferenceKey: ResolvedTopicReference]]())
     
-    /// Clears cached references belonging to the bundle with the given identifier.
-    /// - Parameter id: The identifier of the bundle to which the method should clear belonging references.
+    /// Clears cached references belonging to the unit of documentation with the given identifier.
+    /// - Parameter id: The identifier of the unit of documentation to which the method should clear belonging references.
     static func purgePool(for id: ReferenceBundleIdentifier) {
         sharedPool.sync { $0.removeValue(forKey: id) }
     }
     
-    /// Enables reference caching for any identifiers created with the given bundle identifier.
+    /// Enables reference caching for any identifiers created with the given identifier.
     static func enableReferenceCaching(for id: ReferenceBundleIdentifier) {
         sharedPool.sync { sharedPool in
             if !sharedPool.keys.contains(id) {
@@ -176,12 +176,12 @@ public struct ResolvedTopicReference: Hashable, Codable, Equatable, CustomString
     /// The storage for the resolved topic reference's state.
     let _storage: Storage
     
-    /// The identifier of the bundle that owns this documentation topic.
-    public var bundleID: DocumentationBundle.Identifier {
+    /// The identifier of the unit of documentation that owns this documentation topic.
+    public var bundleID: DocumentationContext.Inputs.Identifier {
         _storage.bundleID
     }
     
-    /// The absolute path from the bundle to this topic, delimited by `/`.
+    /// The path from the root of documentation to this topic, delimited by `/`.
     public var path: String {
         return _storage.path
     }
@@ -207,11 +207,11 @@ public struct ResolvedTopicReference: Hashable, Codable, Equatable, CustomString
     }
     
     /// - Note: The `path` parameter is escaped to a path readable string.
-    public init(bundleID: DocumentationBundle.Identifier, path: String, fragment: String? = nil, sourceLanguage: SourceLanguage) {
+    public init(bundleID: DocumentationContext.Inputs.Identifier, path: String, fragment: String? = nil, sourceLanguage: SourceLanguage) {
         self.init(bundleID: bundleID, path: path, fragment: fragment, sourceLanguages: [sourceLanguage])
     }
     
-    public init(bundleID: DocumentationBundle.Identifier, path: String, fragment: String? = nil, sourceLanguages: Set<SourceLanguage>) {
+    public init(bundleID: DocumentationContext.Inputs.Identifier, path: String, fragment: String? = nil, sourceLanguages: Set<SourceLanguage>) {
         self.init(
             bundleID: bundleID,
             urlReadablePath: urlReadablePath(path),
@@ -220,7 +220,7 @@ public struct ResolvedTopicReference: Hashable, Codable, Equatable, CustomString
         )
     }
     
-    private init(bundleID: DocumentationBundle.Identifier, urlReadablePath: String, urlReadableFragment: String? = nil, sourceLanguages: Set<SourceLanguage>) {
+    private init(bundleID: DocumentationContext.Inputs.Identifier, urlReadablePath: String, urlReadableFragment: String? = nil, sourceLanguages: Set<SourceLanguage>) {
         precondition(!sourceLanguages.isEmpty, "ResolvedTopicReference.sourceLanguages cannot be empty")
         // Check for a cached instance of the reference
         let key = ReferenceKey(path: urlReadablePath, fragment: urlReadableFragment, sourceLanguages: sourceLanguages)
@@ -440,7 +440,7 @@ public struct ResolvedTopicReference: Hashable, Codable, Equatable, CustomString
     ///
     /// This is a reference type which allows ``ResolvedTopicReference`` to have copy-on-write behavior.
     class Storage: Hashable {
-        let bundleID: DocumentationBundle.Identifier
+        let bundleID: DocumentationContext.Inputs.Identifier
         let path: String
         let fragment: String?
         let sourceLanguages: Set<SourceLanguage>
@@ -452,7 +452,7 @@ public struct ResolvedTopicReference: Hashable, Codable, Equatable, CustomString
         let absoluteString: String
         
         init(
-            bundleID: DocumentationBundle.Identifier,
+            bundleID: DocumentationContext.Inputs.Identifier,
             path: String,
             fragment: String? = nil,
             sourceLanguages: Set<SourceLanguage>
@@ -521,7 +521,7 @@ extension ResolvedTopicReference: RenderJSONDiffable {
 /// You can create unresolved references from partial information if that information can be derived from the enclosing context when the
 /// reference is resolved. For example:
 ///
-///  - The bundle identifier can be inferred from the documentation bundle that owns the document from which the unresolved reference came.
+///  - The identifier can be inferred from the unit of documentation that owns the document from which the unresolved reference came.
 ///  - The URL scheme of topic references is always "doc".
 ///  - The symbol precise identifier suffix can be left out when there are no known overloads or name collisions for the symbol.
 public struct UnresolvedTopicReference: Hashable, CustomStringConvertible {
@@ -529,7 +529,7 @@ public struct UnresolvedTopicReference: Hashable, CustomStringConvertible {
     public let topicURL: ValidatedURL
     
     /// The bundle identifier, if one was provided in the host name component of the original URL.
-    public var bundleID: DocumentationBundle.Identifier? {
+    public var bundleID: DocumentationContext.Inputs.Identifier? {
         topicURL.components.host.map { .init(rawValue: $0) }
     }
     
@@ -589,17 +589,17 @@ public struct UnresolvedTopicReference: Hashable, CustomStringConvertible {
 
 /// A reference to an auxiliary resource such as an image.
 public struct ResourceReference: Hashable {
-    /// The documentation bundle identifier for the bundle in which this resource resides.
-    public let bundleID: DocumentationBundle.Identifier
+    /// The identifier for the unit of documentation in which this resource resides.
+    public let bundleID: DocumentationContext.Inputs.Identifier
 
-    /// The path of the resource local to its bundle.
+    /// The path of the resource local to its unit of documentation.
     public let path: String
 
     /// Creates a new resource reference.
     /// - Parameters:
     ///   - bundleID: The documentation bundle identifier for the bundle in which this resource resides.
     ///   - path: The path of the resource local to its bundle.
-    init(bundleID: DocumentationBundle.Identifier, path: String) {
+    init(bundleID: DocumentationContext.Inputs.Identifier, path: String) {
         self.bundleID = bundleID
         self.path = path.removingPercentEncoding ?? path
     }
diff --git a/Sources/SwiftDocC/Model/Rendering/DocumentationContentRenderer.swift b/Sources/SwiftDocC/Model/Rendering/DocumentationContentRenderer.swift
index 2ad9f43a8b..6a27f929e9 100644
--- a/Sources/SwiftDocC/Model/Rendering/DocumentationContentRenderer.swift
+++ b/Sources/SwiftDocC/Model/Rendering/DocumentationContentRenderer.swift
@@ -48,17 +48,19 @@ extension RenderReferenceDependencies: Codable {
 public class DocumentationContentRenderer {
 
     let documentationContext: DocumentationContext
-    let bundle: DocumentationBundle
     let urlGenerator: PresentationURLGenerator
     
-    /// Creates a new content renderer for the given documentation context and bundle.
+    /// Creates a new content renderer for the given documentation context and inputs.
     /// - Parameters:
     ///   - documentationContext: A documentation context.
-    ///   - bundle: A documentation bundle.
-    public init(documentationContext: DocumentationContext, bundle: DocumentationBundle) {
+    public init(documentationContext: DocumentationContext) {
         self.documentationContext = documentationContext
-        self.bundle = bundle
-        self.urlGenerator = PresentationURLGenerator(context: documentationContext, baseURL: bundle.baseURL)
+        self.urlGenerator = PresentationURLGenerator(context: documentationContext, baseURL: documentationContext.inputs.baseURL)
+    }
+    
+    @available(*, deprecated, renamed: "init(documentationContext:)", message: "Use 'init(documentationContext:)' instead. This deprecated API will be removed after 6.3 is released")
+    public convenience init(documentationContext: DocumentationContext, bundle _: DocumentationBundle) {
+        self.init(documentationContext: documentationContext)
     }
     
     /// For symbol nodes, returns the declaration render section if any.
@@ -324,7 +326,7 @@ public class DocumentationContentRenderer {
         // Topic render references require the URLs to be relative, even if they're external.
         let presentationURL = urlGenerator.presentationURLForReference(reference)
         
-        var contentCompiler = RenderContentCompiler(context: documentationContext, bundle: bundle, identifier: reference)
+        var contentCompiler = RenderContentCompiler(context: documentationContext, identifier: reference)
         let abstractContent: VariantCollection<[RenderInlineContent]>
         
         var abstractedNode = node
@@ -516,7 +518,7 @@ public class DocumentationContentRenderer {
             }
             
             let supportedLanguages = group.directives[SupportedLanguage.directiveName]?.compactMap {
-                SupportedLanguage(from: $0, source: nil, for: bundle)?.language
+                SupportedLanguage(from: $0, source: nil, for: documentationContext.inputs)?.language
             }
             
             return ReferenceGroup(
diff --git a/Sources/SwiftDocC/Model/Rendering/LinkTitleResolver.swift b/Sources/SwiftDocC/Model/Rendering/LinkTitleResolver.swift
index 73f85a43f4..2aceb26ecf 100644
--- a/Sources/SwiftDocC/Model/Rendering/LinkTitleResolver.swift
+++ b/Sources/SwiftDocC/Model/Rendering/LinkTitleResolver.swift
@@ -31,11 +31,11 @@ struct LinkTitleResolver {
             var problems = [Problem]()
             switch directive.name {
             case Tutorial.directiveName:
-                if let tutorial = Tutorial(from: directive, source: source, for: context.bundle, problems: &problems) {
+                if let tutorial = Tutorial(from: directive, source: source, for: context.inputs, problems: &problems) {
                     return .init(defaultVariantValue: tutorial.intro.title)
                 }
             case TutorialTableOfContents.directiveName:
-                if let overview = TutorialTableOfContents(from: directive, source: source, for: context.bundle, problems: &problems) {
+                if let overview = TutorialTableOfContents(from: directive, source: source, for: context.inputs, problems: &problems) {
                     return .init(defaultVariantValue: overview.name)
                 }
             default: break
diff --git a/Sources/SwiftDocC/Model/Rendering/Navigation Tree/RenderHierarchyTranslator.swift b/Sources/SwiftDocC/Model/Rendering/Navigation Tree/RenderHierarchyTranslator.swift
index 25c6708333..9dc9716365 100644
--- a/Sources/SwiftDocC/Model/Rendering/Navigation Tree/RenderHierarchyTranslator.swift	
+++ b/Sources/SwiftDocC/Model/Rendering/Navigation Tree/RenderHierarchyTranslator.swift	
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -13,18 +13,14 @@ import Foundation
 /// A hierarchy translator that converts a part of the topic graph into a hierarchy tree.
 struct RenderHierarchyTranslator {
     var context: DocumentationContext
-    var bundle: DocumentationBundle
     
     var collectedTopicReferences = Set<ResolvedTopicReference>()
     var linkReferences = [String: LinkReference]()
     
-    /// Creates a new translator for the given bundle in the given context.
-    /// - Parameters:
-    ///   - context: The documentation context for the conversion.
-    ///   - bundle: The documentation bundle for the conversion.
-    init(context: DocumentationContext, bundle: DocumentationBundle) {
+    /// Creates a new translator for the given context.
+    /// - Parameter context: The documentation context for the conversion.
+    init(context: DocumentationContext) {
         self.context = context
-        self.bundle = bundle
     }
     
     static let assessmentsAnchor = urlReadableFragment(TutorialAssessmentsRenderSection.title)
@@ -164,7 +160,7 @@ struct RenderHierarchyTranslator {
             let assessmentReference = ResolvedTopicReference(bundleID: tutorialReference.bundleID, path: tutorialReference.path, fragment: RenderHierarchyTranslator.assessmentsAnchor, sourceLanguage: .swift)
             renderHierarchyTutorial.landmarks.append(RenderHierarchyLandmark(reference: RenderReferenceIdentifier(assessmentReference.absoluteString), kind: .assessment))
             
-            let urlGenerator = PresentationURLGenerator(context: context, baseURL: bundle.baseURL)
+            let urlGenerator = PresentationURLGenerator(context: context, baseURL: context.inputs.baseURL)
             let assessmentLinkReference = LinkReference(
                 identifier: RenderReferenceIdentifier(assessmentReference.absoluteString),
                 title: "Check Your Understanding",
diff --git a/Sources/SwiftDocC/Model/Rendering/PresentationURLGenerator.swift b/Sources/SwiftDocC/Model/Rendering/PresentationURLGenerator.swift
index b8333a03e8..9d33f00359 100644
--- a/Sources/SwiftDocC/Model/Rendering/PresentationURLGenerator.swift
+++ b/Sources/SwiftDocC/Model/Rendering/PresentationURLGenerator.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -17,14 +17,14 @@ import SymbolKit
 public struct PresentationURLGenerator {
     /// The documentation context the URL generator queries for external reference resolvers.
     var context: DocumentationContext
-    /// The URL generator for in-bundle references.
+    /// The URL generator for local documentation references.
     let urlGenerator: NodeURLGenerator
     
     /// Creates a new URL generator.
     ///
     /// - Parameters:
     ///   - context: The documentation context the URL generator will queries for external reference resolvers.
-    ///   - baseURL: The base URL for in-bundle references.
+    ///   - baseURL: The base URL for local documentation references.
     public init(context: DocumentationContext, baseURL: URL) {
         self.context = context
         self.urlGenerator = NodeURLGenerator(baseURL: baseURL)
diff --git a/Sources/SwiftDocC/Model/Rendering/References/RenderReference.swift b/Sources/SwiftDocC/Model/Rendering/References/RenderReference.swift
index 05daf761d1..35936801e4 100644
--- a/Sources/SwiftDocC/Model/Rendering/References/RenderReference.swift
+++ b/Sources/SwiftDocC/Model/Rendering/References/RenderReference.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -12,7 +12,7 @@ public import Foundation
 
 /// A reference to a resource.
 ///
-/// The reference can refer to a resource within a documentation bundle (e.g., another symbol) or an external resource (e.g., a web URL).
+/// The reference can refer to a resource within a unit of documentation (e.g., another symbol) or an external resource (e.g., a web URL).
 /// Check the conforming types to browse the different kinds of references.
 public protocol RenderReference: Codable {
     /// The type of the reference.
diff --git a/Sources/SwiftDocC/Model/Rendering/RenderContentCompiler.swift b/Sources/SwiftDocC/Model/Rendering/RenderContentCompiler.swift
index 58fabccede..119a3d763c 100644
--- a/Sources/SwiftDocC/Model/Rendering/RenderContentCompiler.swift
+++ b/Sources/SwiftDocC/Model/Rendering/RenderContentCompiler.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -20,7 +20,6 @@ extension RenderInlineContent: RenderContent {}
 
 struct RenderContentCompiler: MarkupVisitor {
     var context: DocumentationContext
-    var bundle: DocumentationBundle
     var identifier: ResolvedTopicReference
     var imageReferences: [String: ImageReference] = [:]
     var videoReferences: [String: VideoReference] = [:]
@@ -28,9 +27,8 @@ struct RenderContentCompiler: MarkupVisitor {
     var collectedTopicReferences = GroupedSequence<String, ResolvedTopicReference> { $0.absoluteString }
     var linkReferences: [String: LinkReference] = [:]
     
-    init(context: DocumentationContext, bundle: DocumentationBundle, identifier: ResolvedTopicReference) {
+    init(context: DocumentationContext, identifier: ResolvedTopicReference) {
         self.context = context
-        self.bundle = bundle
         self.identifier = identifier
     }
     
@@ -47,7 +45,7 @@ struct RenderContentCompiler: MarkupVisitor {
     
     mutating func visitCodeBlock(_ codeBlock: CodeBlock) -> [any RenderContent] {
         // Default to the bundle's code listing syntax if one is not explicitly declared in the code block.
-        return [RenderBlockContent.codeListing(.init(syntax: codeBlock.language ?? bundle.info.defaultCodeListingLanguage, code: codeBlock.code.splitByNewlines, metadata: nil))]
+        return [RenderBlockContent.codeListing(.init(syntax: codeBlock.language ?? context.inputs.info.defaultCodeListingLanguage, code: codeBlock.code.splitByNewlines, metadata: nil))]
     }
     
     mutating func visitHeading(_ heading: Heading) -> [any RenderContent] {
diff --git a/Sources/SwiftDocC/Model/Rendering/RenderContentConvertible.swift b/Sources/SwiftDocC/Model/Rendering/RenderContentConvertible.swift
index 6e7325c800..18e358d94c 100644
--- a/Sources/SwiftDocC/Model/Rendering/RenderContentConvertible.swift
+++ b/Sources/SwiftDocC/Model/Rendering/RenderContentConvertible.swift
@@ -24,7 +24,7 @@ extension RenderableDirectiveConvertible {
         _ blockDirective: BlockDirective,
         with contentCompiler: inout RenderContentCompiler
     ) -> [any RenderContent] {
-        guard let directive = Self.init(from: blockDirective, for: contentCompiler.bundle) else {
+        guard let directive = Self.init(from: blockDirective, for: contentCompiler.context.inputs) else {
             return []
         }
         
diff --git a/Sources/SwiftDocC/Model/Rendering/RenderContext.swift b/Sources/SwiftDocC/Model/Rendering/RenderContext.swift
index dade49b7a0..8ab4cfd100 100644
--- a/Sources/SwiftDocC/Model/Rendering/RenderContext.swift
+++ b/Sources/SwiftDocC/Model/Rendering/RenderContext.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -17,21 +17,22 @@ import SymbolKit
 /// converting nodes in bulk, i.e. when converting a complete documentation model for example.
 public struct RenderContext {
     let documentationContext: DocumentationContext
-    let bundle: DocumentationBundle
     let renderer: DocumentationContentRenderer
     
     /// Creates a new render context.
     /// - Warning: Creating a render context pre-renders all content that the context provides.
-    /// - Parameters:
-    ///   - documentationContext: A documentation context.
-    ///   - bundle: A documentation bundle.
-    public init(documentationContext: DocumentationContext, bundle: DocumentationBundle) {
+    /// - Parameter documentationContext: A documentation context.
+    public init(documentationContext: DocumentationContext) {
         self.documentationContext = documentationContext
-        self.bundle = bundle
-        self.renderer = DocumentationContentRenderer(documentationContext: documentationContext, bundle: bundle)
+        self.renderer = DocumentationContentRenderer(documentationContext: documentationContext)
         createRenderedContent()
     }
     
+    @available(*, deprecated, renamed: "init(documentationContext:)", message: "Use 'init(documentationContext:)' instead. This deprecated API will be removed after 6.3 is released")
+    public init(documentationContext: DocumentationContext, bundle _: DocumentationContext.Inputs) {
+        self.init(documentationContext: documentationContext)
+    }
+    
     /// The pre-rendered content per node reference.
     private(set) public var store = RenderReferenceStore()
     
diff --git a/Sources/SwiftDocC/Model/Rendering/RenderNodeTranslator.swift b/Sources/SwiftDocC/Model/Rendering/RenderNodeTranslator.swift
index 1fd747b15a..876cd5cd2e 100644
--- a/Sources/SwiftDocC/Model/Rendering/RenderNodeTranslator.swift
+++ b/Sources/SwiftDocC/Model/Rendering/RenderNodeTranslator.swift
@@ -22,7 +22,7 @@ public struct RenderNodeTranslator: SemanticVisitor {
     /// Resolved topic references that were seen by the visitor. These should be used to populate the references dictionary.
     var collectedTopicReferences: [ResolvedTopicReference] = []
     
-    /// Unresolvable topic references outside the current bundle.
+    /// Unresolvable topic references outside the current unit of documentation.
     var collectedUnresolvedTopicReferences: [UnresolvedTopicReference] = []
     
     /// Any collected constraints to symbol relationships.
@@ -134,7 +134,7 @@ public struct RenderNodeTranslator: SemanticVisitor {
     public mutating func visitTutorial(_ tutorial: Tutorial) -> (any RenderTree)? {
         var node = RenderNode(identifier: identifier, kind: .tutorial)
         
-        var hierarchyTranslator = RenderHierarchyTranslator(context: context, bundle: bundle)
+        var hierarchyTranslator = RenderHierarchyTranslator(context: context)
         
         if let hierarchy = hierarchyTranslator.visitTutorialTableOfContentsNode(identifier) {
             let tutorialTableOfContents = try! context.entity(with: hierarchy.tutorialTableOfContents).semantic as! TutorialTableOfContents
@@ -315,7 +315,7 @@ public struct RenderNodeTranslator: SemanticVisitor {
         
     // Visits a container and expects the elements to be block level elements
     public mutating func visitMarkupContainer(_ markupContainer: MarkupContainer) -> (any RenderTree)? {
-        var contentCompiler = RenderContentCompiler(context: context, bundle: bundle, identifier: identifier)
+        var contentCompiler = RenderContentCompiler(context: context, identifier: identifier)
         let content = markupContainer.elements.reduce(into: [], { result, item in result.append(contentsOf: contentCompiler.visit(item))}) as! [RenderBlockContent]
         collectedTopicReferences.append(contentsOf: contentCompiler.collectedTopicReferences)
         // Copy all the image references found in the markup container.
@@ -327,7 +327,7 @@ public struct RenderNodeTranslator: SemanticVisitor {
     
     // Visits a collection of inline markup elements.
     public mutating func visitMarkup(_ markup: [any Markup]) -> (any RenderTree)? {
-        var contentCompiler = RenderContentCompiler(context: context, bundle: bundle, identifier: identifier)
+        var contentCompiler = RenderContentCompiler(context: context, identifier: identifier)
         let content = markup.reduce(into: [], { result, item in result.append(contentsOf: contentCompiler.visit(item))}) as! [RenderInlineContent]
         collectedTopicReferences.append(contentsOf: contentCompiler.collectedTopicReferences)
         // Copy all the image references.
@@ -401,7 +401,7 @@ public struct RenderNodeTranslator: SemanticVisitor {
             node.sections.append(visitResources(resources) as! ResourcesRenderSection)
         }
         
-        var hierarchyTranslator = RenderHierarchyTranslator(context: context, bundle: bundle)
+        var hierarchyTranslator = RenderHierarchyTranslator(context: context)
         if let (hierarchyVariants, _) = hierarchyTranslator.visitTutorialTableOfContentsNode(identifier, omittingChapters: true) {
             node.hierarchyVariants = hierarchyVariants
             collectedTopicReferences.append(contentsOf: hierarchyTranslator.collectedTopicReferences)
@@ -419,7 +419,7 @@ public struct RenderNodeTranslator: SemanticVisitor {
     
     private mutating func createTopicRenderReferences() -> [String: any RenderReference] {
         var renderReferences: [String: any RenderReference] = [:]
-        let renderer = DocumentationContentRenderer(documentationContext: context, bundle: bundle)
+        let renderer = DocumentationContentRenderer(documentationContext: context)
         
         for reference in collectedTopicReferences {
             var renderReference: TopicRenderReference
@@ -530,7 +530,7 @@ public struct RenderNodeTranslator: SemanticVisitor {
     }
         
     public mutating func visitTutorialReference(_ tutorialReference: TutorialReference) -> (any RenderTree)? {
-        switch context.resolve(tutorialReference.topic, in: bundle.rootReference) {
+        switch context.resolve(tutorialReference.topic, in: context.inputs.rootReference) {
         case let .failure(reference, _):
             return RenderReferenceIdentifier(reference.topicURL.absoluteString)
         case let .success(resolved):
@@ -600,7 +600,7 @@ public struct RenderNodeTranslator: SemanticVisitor {
     public mutating func visitArticle(_ article: Article) -> (any RenderTree)? {
         var node = RenderNode(identifier: identifier, kind: .article)
         // Contains symbol references declared in the Topics section.
-        var topicSectionContentCompiler = RenderContentCompiler(context: context, bundle: bundle, identifier: identifier)
+        var topicSectionContentCompiler = RenderContentCompiler(context: context, identifier: identifier)
         
         node.metadata.title = article.title!.plainText
         
@@ -624,7 +624,7 @@ public struct RenderNodeTranslator: SemanticVisitor {
         
         let documentationNode = try! context.entity(with: identifier)
         
-        var hierarchyTranslator = RenderHierarchyTranslator(context: context, bundle: bundle)
+        var hierarchyTranslator = RenderHierarchyTranslator(context: context)
         let hierarchyVariants = hierarchyTranslator.visitArticle(identifier)
         collectedTopicReferences.append(contentsOf: hierarchyTranslator.collectedTopicReferences)
         node.hierarchyVariants = hierarchyVariants
@@ -806,7 +806,6 @@ public struct RenderNodeTranslator: SemanticVisitor {
                 for: documentationNode,
                 withTraits: allowedTraits,
                 context: context,
-                bundle: bundle,
                 renderContext: renderContext,
                 renderer: contentRenderer
             ) {
@@ -878,7 +877,7 @@ public struct RenderNodeTranslator: SemanticVisitor {
     public mutating func visitTutorialArticle(_ article: TutorialArticle) -> (any RenderTree)? {
         var node = RenderNode(identifier: identifier, kind: .article)
         
-        var hierarchyTranslator = RenderHierarchyTranslator(context: context, bundle: bundle)
+        var hierarchyTranslator = RenderHierarchyTranslator(context: context)
         guard let hierarchy = hierarchyTranslator.visitTutorialTableOfContentsNode(identifier) else {
             // This tutorial article is not curated, so we don't generate a render node.
             // We've warned about this during semantic analysis.
@@ -1029,7 +1028,7 @@ public struct RenderNodeTranslator: SemanticVisitor {
     ) -> [TaskGroupRenderSection] {
         return topics.taskGroups.compactMap { group in
             let supportedLanguages = group.directives[SupportedLanguage.directiveName]?.compactMap {
-                SupportedLanguage(from: $0, source: nil, for: bundle)?.language
+                SupportedLanguage(from: $0, source: nil, for: context.inputs)?.language
             }
             
             // If the task group has a set of supported languages, see if it should render for the allowed traits.
@@ -1201,7 +1200,7 @@ public struct RenderNodeTranslator: SemanticVisitor {
         let identifier = identifier.addingSourceLanguages(documentationNode.availableSourceLanguages)
         
         var node = RenderNode(identifier: identifier, kind: .symbol)
-        var contentCompiler = RenderContentCompiler(context: context, bundle: bundle, identifier: identifier)
+        var contentCompiler = RenderContentCompiler(context: context, identifier: identifier)
         
         /*
          FIXME: We shouldn't be doing this kind of crawling here.
@@ -1241,7 +1240,7 @@ public struct RenderNodeTranslator: SemanticVisitor {
 
         node.metadata.extendedModuleVariants = VariantCollection<String?>(from: symbol.extendedModuleVariants)
         
-        let defaultAvailability = defaultAvailability(for: bundle, moduleName: moduleName.symbolName, currentPlatforms: context.configuration.externalMetadata.currentPlatforms)?
+        let defaultAvailability = defaultAvailability(moduleName: moduleName.symbolName, currentPlatforms: context.configuration.externalMetadata.currentPlatforms)?
             .filter { $0.unconditionallyUnavailable != true }
             .sorted(by: AvailabilityRenderOrder.compare)
         
@@ -1330,10 +1329,10 @@ public struct RenderNodeTranslator: SemanticVisitor {
         
         collectedTopicReferences.append(identifier)
         
-        let contentRenderer = DocumentationContentRenderer(documentationContext: context, bundle: bundle)
+        let contentRenderer = DocumentationContentRenderer(documentationContext: context)
         node.metadata.tags = contentRenderer.tags(for: identifier)
 
-        var hierarchyTranslator = RenderHierarchyTranslator(context: context, bundle: bundle)
+        var hierarchyTranslator = RenderHierarchyTranslator(context: context)
         let hierarchyVariants = hierarchyTranslator.visitSymbol(identifier)
         collectedTopicReferences.append(contentsOf: hierarchyTranslator.collectedTopicReferences)
         node.hierarchyVariants = hierarchyVariants
@@ -1648,7 +1647,6 @@ public struct RenderNodeTranslator: SemanticVisitor {
                 for: documentationNode,
                 withTraits: allowedTraits,
                 context: context,
-                bundle: bundle,
                 renderContext: renderContext,
                 renderer: contentRenderer
             ), !seeAlso.references.isEmpty {
@@ -1774,7 +1772,6 @@ public struct RenderNodeTranslator: SemanticVisitor {
     }
     
     var context: DocumentationContext
-    var bundle: DocumentationBundle
     var identifier: ResolvedTopicReference
     var imageReferences: [String: ImageReference] = [:]
     var videoReferences: [String: VideoReference] = [:]
@@ -1808,8 +1805,8 @@ public struct RenderNodeTranslator: SemanticVisitor {
     }
     
     /// The default availability for modules in a given bundle and module.
-    mutating func defaultAvailability(for bundle: DocumentationBundle, moduleName: String, currentPlatforms: [String: PlatformVersion]?) -> [AvailabilityRenderItem]? {
-        let identifier = BundleModuleIdentifier(bundle: bundle, moduleName: moduleName)
+    mutating func defaultAvailability(moduleName: String, currentPlatforms: [String: PlatformVersion]?) -> [AvailabilityRenderItem]? {
+        let identifier = BundleModuleIdentifier(inputs: context.inputs, moduleName: moduleName)
         
         // Cached availability
         if let availability = bundleAvailability[identifier] {
@@ -1817,7 +1814,7 @@ public struct RenderNodeTranslator: SemanticVisitor {
         }
         
         // Find default module availability if existing
-        guard let bundleDefaultAvailability = bundle.info.defaultAvailability,
+        guard let bundleDefaultAvailability = context.inputs.info.defaultAvailability,
             let moduleAvailability = bundleDefaultAvailability.modules[moduleName] else {
             return nil
         }
@@ -1851,7 +1848,7 @@ public struct RenderNodeTranslator: SemanticVisitor {
     }
     
     private func variants(for documentationNode: DocumentationNode) -> [RenderNode.Variant] {
-        let generator = PresentationURLGenerator(context: context, baseURL: bundle.baseURL)
+        let generator = PresentationURLGenerator(context: context, baseURL: context.inputs.baseURL)
         
         var allVariants: [SourceLanguage: ResolvedTopicReference] = documentationNode.availableSourceLanguages.reduce(into: [:]) { partialResult, language in
             partialResult[language] = identifier
@@ -2002,7 +1999,6 @@ public struct RenderNodeTranslator: SemanticVisitor {
     
     init(
         context: DocumentationContext,
-        bundle: DocumentationBundle,
         identifier: ResolvedTopicReference,
         renderContext: RenderContext? = nil,
         emitSymbolSourceFileURIs: Bool = false,
@@ -2011,10 +2007,9 @@ public struct RenderNodeTranslator: SemanticVisitor {
         symbolIdentifiersWithExpandedDocumentation: [String]? = nil
     ) {
         self.context = context
-        self.bundle = bundle
         self.identifier = identifier
         self.renderContext = renderContext
-        self.contentRenderer = DocumentationContentRenderer(documentationContext: context, bundle: bundle)
+        self.contentRenderer = DocumentationContentRenderer(documentationContext: context)
         self.shouldEmitSymbolSourceFileURIs = emitSymbolSourceFileURIs
         self.shouldEmitSymbolAccessLevels = emitSymbolAccessLevels
         self.sourceRepository = sourceRepository
@@ -2025,8 +2020,8 @@ public struct RenderNodeTranslator: SemanticVisitor {
 fileprivate typealias BundleModuleIdentifier = String
 
 extension BundleModuleIdentifier {
-    fileprivate init(bundle: DocumentationBundle, moduleName: String) {
-        self = "\(bundle.id):\(moduleName)"
+    fileprivate init(inputs: DocumentationContext.Inputs, moduleName: String) {
+        self = "\(inputs.id):\(moduleName)"
     }
 }
 
diff --git a/Sources/SwiftDocC/Model/Rendering/RenderReferenceStore.swift b/Sources/SwiftDocC/Model/Rendering/RenderReferenceStore.swift
index d095303fc5..2b1a8eea25 100644
--- a/Sources/SwiftDocC/Model/Rendering/RenderReferenceStore.swift
+++ b/Sources/SwiftDocC/Model/Rendering/RenderReferenceStore.swift
@@ -38,7 +38,7 @@ public struct RenderReferenceStore: Codable {
     }
     
     /// Returns asset information for the given asset name.
-    public func content(forAssetNamed assetName: String, bundleID: DocumentationBundle.Identifier) -> DataAsset? {
+    public func content(forAssetNamed assetName: String, bundleID: DocumentationContext.Inputs.Identifier) -> DataAsset? {
         assets[AssetReference(assetName: assetName, bundleID: bundleID)]
     }
 }
diff --git a/Sources/SwiftDocC/Semantics/Article/Article.swift b/Sources/SwiftDocC/Semantics/Article/Article.swift
index aec17835f9..31cece3e1c 100644
--- a/Sources/SwiftDocC/Semantics/Article/Article.swift
+++ b/Sources/SwiftDocC/Semantics/Article/Article.swift
@@ -89,14 +89,14 @@ public final class Article: Semantic, MarkupConvertible, Abstracted, Redirected,
     /// Any automatically created task groups.
     var automaticTaskGroups: [AutomaticTaskGroupSection]
 
-    /// Initializes a new article with a given markup and source for a given documentation bundle and documentation context.
+    /// Initializes a new article with a given markup and source for a given documentation catalog.
     ///
     /// - Parameters:
     ///   - markup: The markup that makes up this article's content.
     ///   - source: The location of the file that this article's content comes from.
-    ///   - bundle: The documentation bundle that the source file belongs to.
+    ///   - inputs: The documentation catalog that the source file belongs to.
     ///   - problems: A mutable collection of problems to update with any problem encountered while initializing the article.
-    public convenience init?(from markup: any Markup, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) {
+    public convenience init?(from markup: any Markup, source: URL?, for inputs: DocumentationContext.Inputs, problems: inout [Problem]) {
         guard let title = markup.child(at: 0) as? Heading, title.level == 1 else {
             let range = markup.child(at: 0)?.range ?? SourceLocation(line: 1, column: 1, source: nil)..<SourceLocation(line: 1, column: 1, source: nil)
             let diagnostic = Diagnostic(source: source, severity: .warning, range: range, identifier: "org.swift.docc.Article.Title.NotFound", summary: "An article is expected to start with a top-level heading title")
@@ -125,7 +125,7 @@ public final class Article: Semantic, MarkupConvertible, Abstracted, Redirected,
             guard let childDirective = child as? BlockDirective, childDirective.name == Redirect.directiveName else {
                 return nil
             }
-            return Redirect(from: childDirective, source: source, for: bundle, problems: &problems)
+            return Redirect(from: childDirective, source: source, for: inputs, problems: &problems)
         }
         
         var optionalMetadata = DirectiveParser()
@@ -134,7 +134,7 @@ public final class Article: Semantic, MarkupConvertible, Abstracted, Redirected,
                 from: &remainder,
                 parentType: Article.self,
                 source: source,
-                bundle: bundle,
+                inputs: inputs,
                 problems: &problems
             )
 
@@ -152,7 +152,7 @@ public final class Article: Semantic, MarkupConvertible, Abstracted, Redirected,
             return Options(
                 from: childDirective,
                 source: source,
-                for: bundle,
+                for: inputs,
                 problems: &problems
             )
         }
diff --git a/Sources/SwiftDocC/Semantics/Article/MarkupConvertible.swift b/Sources/SwiftDocC/Semantics/Article/MarkupConvertible.swift
index 2eace344cc..4f756a21b7 100644
--- a/Sources/SwiftDocC/Semantics/Article/MarkupConvertible.swift
+++ b/Sources/SwiftDocC/Semantics/Article/MarkupConvertible.swift
@@ -13,12 +13,12 @@ public import Markdown
 
 /// A type that can be initialized from markup.
 public protocol MarkupConvertible {
-    /// Initializes a new element with a given markup and source that's part of a given documentation bundle.
+    /// Initializes a new element with a given markup and source that's part of a given documentation catalog.
     ///
     /// - Parameters:
     ///   - markup: The markup that makes up this element's content.
     ///   - source: The location of the file that this element's content comes from.
-    ///   - bundle: The documentation bundle that the source file belongs to.
+    ///   - inputs: The collection of input files that the source file belongs to.
     ///   - problems: A mutable collection of problems to update with any problem encountered while initializing the element.
-    init?(from markup: any Markup, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem])
+    init?(from markup: any Markup, source: URL?, for inputs: DocumentationContext.Inputs, problems: inout [Problem])
 }
diff --git a/Sources/SwiftDocC/Semantics/Comment.swift b/Sources/SwiftDocC/Semantics/Comment.swift
index ff9dc106dc..f2ed003ef1 100644
--- a/Sources/SwiftDocC/Semantics/Comment.swift
+++ b/Sources/SwiftDocC/Semantics/Comment.swift
@@ -33,7 +33,7 @@ public final class Comment: Semantic, DirectiveConvertible {
         self.content = content
     }
     
-    public convenience init?(from directive: BlockDirective, source: URL?, for _: DocumentationBundle, problems: inout [Problem]) {
+    public convenience init?(from directive: BlockDirective, source: URL?, for _: DocumentationContext.Inputs, problems: inout [Problem]) {
         precondition(directive.name == Comment.directiveName)
         self.init(originalMarkup: directive, content: MarkupContainer(directive.children))
     }
diff --git a/Sources/SwiftDocC/Semantics/ContentAndMedia.swift b/Sources/SwiftDocC/Semantics/ContentAndMedia.swift
index 83a67b7554..a01b4351a8 100644
--- a/Sources/SwiftDocC/Semantics/ContentAndMedia.swift
+++ b/Sources/SwiftDocC/Semantics/ContentAndMedia.swift
@@ -75,7 +75,7 @@ public final class ContentAndMedia: Semantic, DirectiveConvertible {
         self.mediaPosition = mediaPosition
     }
     
-    public convenience init?(from directive: BlockDirective, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) {
+    public convenience init?(from directive: BlockDirective, source: URL?, for inputs: DocumentationContext.Inputs, problems: inout [Problem]) {
         let arguments = Semantic.Analyses.HasOnlyKnownArguments<ContentAndMedia>(severityIfFound: .warning, allowedArguments: [Semantics.Title.argumentName, Semantics.Layout.argumentName, Semantics.Eyebrow.argumentName]).analyze(directive, children: directive.children, source: source, problems: &problems)
         
         Semantic.Analyses.HasOnlyKnownDirectives<ContentAndMedia>(severityIfFound: .warning, allowedDirectives: [ImageMedia.directiveName, VideoMedia.directiveName]).analyze(directive, children: directive.children, source: source, problems: &problems)
@@ -85,7 +85,7 @@ public final class ContentAndMedia: Semantic, DirectiveConvertible {
         
         let layout = Semantic.Analyses.DeprecatedArgument<ContentAndMedia, Semantics.Layout>.unused(severityIfFound: .warning).analyze(directive, arguments: arguments, problems: &problems)
         
-        let (media, remainder) = Semantic.Analyses.HasExactlyOneMedia<ContentAndMedia>(severityIfNotFound: nil).analyze(directive, children: directive.children, source: source, for: bundle, problems: &problems)
+        let (media, remainder) = Semantic.Analyses.HasExactlyOneMedia<ContentAndMedia>(severityIfNotFound: nil).analyze(directive, children: directive.children, source: source, for: inputs, problems: &problems)
         
         let mediaPosition: MediaPosition
         if let firstChildDirective = directive.child(at: 0) as? BlockDirective,
diff --git a/Sources/SwiftDocC/Semantics/DirectiveConvertable.swift b/Sources/SwiftDocC/Semantics/DirectiveConvertable.swift
index fb2d4d6f9d..fb98e907af 100644
--- a/Sources/SwiftDocC/Semantics/DirectiveConvertable.swift
+++ b/Sources/SwiftDocC/Semantics/DirectiveConvertable.swift
@@ -34,9 +34,9 @@ public protocol DirectiveConvertible {
     /// - Parameters:
     ///   -  directive: The parsed block directive to create a semantic object from.
     ///   -  source: The location of the source file that contains the markup for the parsed block directive.
-    ///   -  bundle: The documentation bundle that the source file belongs to.
+    ///   -  inputs: The documentation bundle that the source file belongs to.
     ///   -  problems: An inout array of ``Problem`` to be collected for later diagnostic reporting.
-    init?(from directive: BlockDirective, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem])
+    init?(from directive: BlockDirective, source: URL?, for inputs: DocumentationContext.Inputs, problems: inout [Problem])
     
     /// Returns a Boolean value indicating whether the `DirectiveConvertible` recognizes the given directive.
     ///
diff --git a/Sources/SwiftDocC/Semantics/DirectiveInfrastructure/AutomaticDirectiveConvertible.swift b/Sources/SwiftDocC/Semantics/DirectiveInfrastructure/AutomaticDirectiveConvertible.swift
index bfd1ab53de..99922cc826 100644
--- a/Sources/SwiftDocC/Semantics/DirectiveInfrastructure/AutomaticDirectiveConvertible.swift
+++ b/Sources/SwiftDocC/Semantics/DirectiveInfrastructure/AutomaticDirectiveConvertible.swift
@@ -92,21 +92,20 @@ extension AutomaticDirectiveConvertible {
     /// the same function but supports collecting an array of problems for diagnostics.
     ///
     /// - Parameters:
-    ///     - directive: The block directive that will be parsed
-    ///     - source: An optional URL for the source location where this directive is written.
-    ///     - bundle: The documentation bundle that owns the directive.
-    ///     - context: The documentation context in which the bundle resides.
+    ///   - directive: The block directive that will be parsed
+    ///   - source: An optional URL for the source location where this directive is written.
+    ///   - inputs: The collection of inputs files that the directive originates from.
     public init?(
         from directive: BlockDirective,
         source: URL? = nil,
-        for bundle: DocumentationBundle
+        for inputs: DocumentationContext.Inputs
     ) {
         var problems = [Problem]()
         
         self.init(
             from: directive,
             source: source,
-            for: bundle,
+            for: inputs,
             problems: &problems
         )
     }
@@ -114,7 +113,7 @@ extension AutomaticDirectiveConvertible {
     public init?(
         from directive: BlockDirective,
         source: URL?,
-        for bundle: DocumentationBundle,
+        for inputs: DocumentationContext.Inputs,
         problems: inout [Problem]
     ) {
         precondition(directive.name == Self.directiveName)
@@ -144,7 +143,7 @@ extension AutomaticDirectiveConvertible {
                 allowedValues: reflectedArgument.allowedValues,
                 expectedFormat: reflectedArgument.expectedFormat,
                 convert: { argumentValue in
-                    return reflectedArgument.parseArgument(bundle, argumentValue)
+                    return reflectedArgument.parseArgument(inputs, argumentValue)
                 },
                 valueTypeDiagnosticName: reflectedArgument.typeDisplayName
             )
@@ -177,7 +176,7 @@ extension AutomaticDirectiveConvertible {
             childType: Comment.self,
             children: remainder,
             source: source,
-            for: bundle,
+            for: inputs,
             problems: &problems
         )
         
@@ -190,7 +189,7 @@ extension AutomaticDirectiveConvertible {
                     parentDirective: directive,
                     children: remainder,
                     source: source,
-                    for: bundle,
+                    for: inputs,
                     problems: &problems
                 )
                 
@@ -214,7 +213,7 @@ extension AutomaticDirectiveConvertible {
                     parentDirective: directive,
                     children: remainder,
                     source: source,
-                    for: bundle,
+                    for: inputs,
                     problems: &problems
                 )
                 
@@ -237,7 +236,7 @@ extension AutomaticDirectiveConvertible {
                     childType: childDirective.type,
                     children: remainder,
                     source: source,
-                    for: bundle,
+                    for: inputs,
                     problems: &problems
                 )
                 
@@ -251,7 +250,7 @@ extension AutomaticDirectiveConvertible {
                     parentDirective: directive,
                     children: remainder,
                     source: source,
-                    for: bundle,
+                    for: inputs,
                     problems: &problems
                 )
                 
diff --git a/Sources/SwiftDocC/Semantics/DirectiveInfrastructure/DirectiveArgumentWrapper.swift b/Sources/SwiftDocC/Semantics/DirectiveInfrastructure/DirectiveArgumentWrapper.swift
index 83639012ac..e55a1087fe 100644
--- a/Sources/SwiftDocC/Semantics/DirectiveInfrastructure/DirectiveArgumentWrapper.swift
+++ b/Sources/SwiftDocC/Semantics/DirectiveInfrastructure/DirectiveArgumentWrapper.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2022-2023 Apple Inc. and the Swift project authors
+ Copyright (c) 2022-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -19,7 +19,7 @@ protocol _DirectiveArgumentProtocol {
     var expectedFormat: String? { get }
     var hiddenFromDocumentation: Bool { get }
     
-    var parseArgument: (_ bundle: DocumentationBundle, _ argumentValue: String) -> (Any?) { get }
+    var parseArgument: (_ inputs: DocumentationContext.Inputs, _ argumentValue: String) -> (Any?) { get }
     
     func setProperty(
         on containingDirective: some AutomaticDirectiveConvertible,
@@ -68,7 +68,7 @@ public struct DirectiveArgumentWrapped<Value>: _DirectiveArgumentProtocol {
     let expectedFormat: String?
     let hiddenFromDocumentation: Bool
     
-    let parseArgument: (_ bundle: DocumentationBundle, _ argumentValue: String) -> (Any?)
+    let parseArgument: (_ bundle: DocumentationContext.Inputs, _ argumentValue: String) -> (Any?)
     
     let defaultValue: Value?
     var storedAsOptional: Bool {
@@ -99,7 +99,7 @@ public struct DirectiveArgumentWrapped<Value>: _DirectiveArgumentProtocol {
     init(
         wrappedValue: Value,
         name: _DirectiveArgumentName = .inferredFromPropertyName,
-        parseArgument: @escaping (_ bundle: DocumentationBundle, _ argumentValue: String) -> (Value?),
+        parseArgument: @escaping (_ bundle: DocumentationContext.Inputs, _ argumentValue: String) -> (Value?),
         allowedValues: [String]? = nil,
         expectedFormat: String? = nil,
         hiddenFromDocumentation: Bool = false
@@ -118,7 +118,7 @@ public struct DirectiveArgumentWrapped<Value>: _DirectiveArgumentProtocol {
     @_disfavoredOverload
     init(
         name: _DirectiveArgumentName = .inferredFromPropertyName,
-        parseArgument: @escaping (_ bundle: DocumentationBundle, _ argumentValue: String) -> (Value?),
+        parseArgument: @escaping (_ bundle: DocumentationContext.Inputs, _ argumentValue: String) -> (Value?),
         allowedValues: [String]? = nil,
         expectedFormat: String? = nil,
         hiddenFromDocumentation: Bool = false
@@ -137,7 +137,7 @@ public struct DirectiveArgumentWrapped<Value>: _DirectiveArgumentProtocol {
     private init(
         value: Value?,
         name: _DirectiveArgumentName,
-        transform: @escaping (_ bundle: DocumentationBundle, _ argumentValue: String) -> (Value?),
+        transform: @escaping (_ bundle: DocumentationContext.Inputs, _ argumentValue: String) -> (Value?),
         allowedValues: [String]?,
         expectedFormat: String?,
         required: Bool?,
@@ -325,7 +325,7 @@ extension DirectiveArgumentWrapped where Value: _OptionalDirectiveArgument {
     @_disfavoredOverload
     init(
         name: _DirectiveArgumentName = .inferredFromPropertyName,
-        parseArgument: @escaping (_ bundle: DocumentationBundle, _ argumentValue: String) -> (Value?),
+        parseArgument: @escaping (_ bundle: DocumentationContext.Inputs, _ argumentValue: String) -> (Value?),
         allowedValues: [String]? = nil,
         hiddenFromDocumentation: Bool = false
     ) {
@@ -336,7 +336,7 @@ extension DirectiveArgumentWrapped where Value: _OptionalDirectiveArgument {
     init(
         wrappedValue: Value,
         name: _DirectiveArgumentName = .inferredFromPropertyName,
-        parseArgument: @escaping (_ bundle: DocumentationBundle, _ argumentValue: String) -> (Value?),
+        parseArgument: @escaping (_ bundle: DocumentationContext.Inputs, _ argumentValue: String) -> (Value?),
         allowedValues: [String]? = nil,
         hiddenFromDocumentation: Bool = false
     ) {
@@ -346,7 +346,7 @@ extension DirectiveArgumentWrapped where Value: _OptionalDirectiveArgument {
     private init(
         value: Value?,
         name: _DirectiveArgumentName,
-        parseArgument: @escaping (_ bundle: DocumentationBundle, _ argumentValue: String) -> (Value?),
+        parseArgument: @escaping (_ bundle: DocumentationContext.Inputs, _ argumentValue: String) -> (Value?),
         allowedValues: [String]? = nil,
         expectedFormat: String? = nil,
         hiddenFromDocumentation: Bool = false
diff --git a/Sources/SwiftDocC/Semantics/DirectiveInfrastructure/DirectiveMirror.swift b/Sources/SwiftDocC/Semantics/DirectiveInfrastructure/DirectiveMirror.swift
index fcc8856aa5..269ac213be 100644
--- a/Sources/SwiftDocC/Semantics/DirectiveInfrastructure/DirectiveMirror.swift
+++ b/Sources/SwiftDocC/Semantics/DirectiveInfrastructure/DirectiveMirror.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2022-2023 Apple Inc. and the Swift project authors
+ Copyright (c) 2022-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -172,7 +172,7 @@ extension DirectiveMirror {
         let propertyLabel: String
         let argument: any _DirectiveArgumentProtocol
         
-        let parseArgument: (_ bundle: DocumentationBundle, _ argumentValue: String) -> (Any?)
+        let parseArgument: (_ inputs: DocumentationContext.Inputs, _ argumentValue: String) -> (Any?)
         
         func setValue(
             on containingDirective: some AutomaticDirectiveConvertible,
diff --git a/Sources/SwiftDocC/Semantics/DirectiveParser.swift b/Sources/SwiftDocC/Semantics/DirectiveParser.swift
index 95d38624ca..dfe4bcee54 100644
--- a/Sources/SwiftDocC/Semantics/DirectiveParser.swift
+++ b/Sources/SwiftDocC/Semantics/DirectiveParser.swift
@@ -23,7 +23,7 @@ struct DirectiveParser<Directive: AutomaticDirectiveConvertible> {
         from markupElements: inout [any Markup],
         parentType: Semantic.Type,
         source: URL?,
-        bundle: DocumentationBundle,
+        inputs: DocumentationContext.Inputs,
         problems: inout [Problem]
     ) -> Directive? {
         let (directiveElements, remainder) = markupElements.categorize { markup -> Directive? in
@@ -35,7 +35,7 @@ struct DirectiveParser<Directive: AutomaticDirectiveConvertible> {
             return Directive(
                 from: childDirective,
                 source: source,
-                for: bundle,
+                for: inputs,
                 problems: &problems
             )
         }
diff --git a/Sources/SwiftDocC/Semantics/ExternalLinks/ExternalMarkupReferenceWalker.swift b/Sources/SwiftDocC/Semantics/ExternalLinks/ExternalMarkupReferenceWalker.swift
index 69502f34f8..3ba0acede4 100644
--- a/Sources/SwiftDocC/Semantics/ExternalLinks/ExternalMarkupReferenceWalker.swift
+++ b/Sources/SwiftDocC/Semantics/ExternalLinks/ExternalMarkupReferenceWalker.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -14,10 +14,10 @@ import Markdown
 /// Walks a markup tree and collects any links external to a given bundle.
 struct ExternalMarkupReferenceWalker: MarkupVisitor {
     /// The local bundle ID, used to identify and skip absolute fully qualified local links.
-    var localBundleID: DocumentationBundle.Identifier
+    var localBundleID: DocumentationContext.Inputs.Identifier
     
     /// After walking a markup tree, all encountered external links are collected grouped by the bundle ID.
-    var collectedExternalLinks = [DocumentationBundle.Identifier: Set<ValidatedURL>]()
+    var collectedExternalLinks = [DocumentationContext.Inputs.Identifier: Set<ValidatedURL>]()
 
     /// Descends down the given elements' children.
     mutating func defaultVisit(_ markup: any Markup) {
@@ -31,7 +31,7 @@ struct ExternalMarkupReferenceWalker: MarkupVisitor {
         // Only process documentation links to external bundles
         guard let destination = link.destination,
               let url = ValidatedURL(parsingAuthoredLink: destination)?.requiring(scheme: ResolvedTopicReference.urlScheme),
-              let bundleID = url.components.host.map({ DocumentationBundle.Identifier(rawValue: $0) }),
+              let bundleID = url.components.host.map({ DocumentationContext.Inputs.Identifier(rawValue: $0) }),
               bundleID != localBundleID
         else {
             return
diff --git a/Sources/SwiftDocC/Semantics/ExternalLinks/ExternalReferenceWalker.swift b/Sources/SwiftDocC/Semantics/ExternalLinks/ExternalReferenceWalker.swift
index b1f2021f4a..2cfa68e837 100644
--- a/Sources/SwiftDocC/Semantics/ExternalLinks/ExternalReferenceWalker.swift
+++ b/Sources/SwiftDocC/Semantics/ExternalLinks/ExternalReferenceWalker.swift
@@ -41,7 +41,7 @@ struct ExternalReferenceWalker: SemanticVisitor {
     private var markupResolver: ExternalMarkupReferenceWalker
     
     /// Collected unresolved external references, grouped by the bundle ID.
-    var collectedExternalReferences: [DocumentationBundle.Identifier: [UnresolvedTopicReference]] {
+    var collectedExternalReferences: [DocumentationContext.Inputs.Identifier: [UnresolvedTopicReference]] {
         return markupResolver.collectedExternalLinks.mapValues { links in
             links.map(UnresolvedTopicReference.init(topicURL:))
         }
@@ -49,7 +49,7 @@ struct ExternalReferenceWalker: SemanticVisitor {
     
     /// Creates a new semantic walker that collects links to other documentation sources.
     /// - Parameter localBundleID: The local bundle ID, used to identify and skip absolute fully qualified local links.
-    init(localBundleID: DocumentationBundle.Identifier) {
+    init(localBundleID: DocumentationContext.Inputs.Identifier) {
         self.markupResolver = ExternalMarkupReferenceWalker(localBundleID: localBundleID)
     }
     
diff --git a/Sources/SwiftDocC/Semantics/General Purpose Analyses/Extract.swift b/Sources/SwiftDocC/Semantics/General Purpose Analyses/Extract.swift
index 38b3611ea0..0e521e4a20 100644
--- a/Sources/SwiftDocC/Semantics/General Purpose Analyses/Extract.swift	
+++ b/Sources/SwiftDocC/Semantics/General Purpose Analyses/Extract.swift	
@@ -18,12 +18,12 @@ extension Semantic.Analyses {
     public struct ExtractAll<Child: Semantic & DirectiveConvertible> {
         public init() {}
         
-        public func analyze(_ directive: BlockDirective, children: some Sequence<any Markup>, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) -> ([Child], remainder: MarkupContainer) {
+        public func analyze(_ directive: BlockDirective, children: some Sequence<any Markup>, source: URL?, for inputs: DocumentationContext.Inputs, problems: inout [Problem]) -> ([Child], remainder: MarkupContainer) {
             return Semantic.Analyses.extractAll(
                 childType: Child.self,
                 children: children,
                 source: source,
-                for: bundle,
+                for: inputs,
                 problems: &problems
             ) as! ([Child], MarkupContainer)
         }
@@ -33,7 +33,7 @@ extension Semantic.Analyses {
         childType: any DirectiveConvertible.Type,
         children: some Sequence<any Markup>,
         source: URL?,
-        for bundle: DocumentationBundle,
+        for inputs: DocumentationContext.Inputs,
         problems: inout [Problem]
     ) -> ([any DirectiveConvertible], remainder: MarkupContainer) {
         let (candidates, remainder) = children.categorize { child -> BlockDirective? in
@@ -44,7 +44,7 @@ extension Semantic.Analyses {
             return childDirective
         }
         let converted = candidates.compactMap {
-            childType.init(from: $0, source: source, for: bundle, problems: &problems)
+            childType.init(from: $0, source: source, for: inputs, problems: &problems)
         }
         return (converted, remainder: MarkupContainer(remainder))
     }
diff --git a/Sources/SwiftDocC/Semantics/General Purpose Analyses/HasAtLeastOne.swift b/Sources/SwiftDocC/Semantics/General Purpose Analyses/HasAtLeastOne.swift
index 7c8172f0d1..57fa7e3fc6 100644
--- a/Sources/SwiftDocC/Semantics/General Purpose Analyses/HasAtLeastOne.swift	
+++ b/Sources/SwiftDocC/Semantics/General Purpose Analyses/HasAtLeastOne.swift	
@@ -25,7 +25,7 @@ extension Semantic.Analyses {
             _ directive: BlockDirective,
             children: some Sequence<any Markup>,
             source: URL?,
-            for bundle: DocumentationBundle,
+            for inputs: DocumentationContext.Inputs,
             problems: inout [Problem]
         ) -> ([Child], remainder: MarkupContainer) {
             Semantic.Analyses.extractAtLeastOne(
@@ -33,7 +33,7 @@ extension Semantic.Analyses {
                 parentDirective: directive,
                 children: children,
                 source: source,
-                for: bundle,
+                for: inputs,
                 severityIfNotFound: severityIfNotFound,
                 problems: &problems
             ) as! ([Child], MarkupContainer)
@@ -45,7 +45,7 @@ extension Semantic.Analyses {
         parentDirective: BlockDirective,
         children: some Sequence<any Markup>,
         source: URL?,
-        for bundle: DocumentationBundle,
+        for inputs: DocumentationContext.Inputs,
         severityIfNotFound: DiagnosticSeverity? = .warning,
         problems: inout [Problem]
     ) -> ([any DirectiveConvertible], remainder: MarkupContainer) {
@@ -79,7 +79,7 @@ extension Semantic.Analyses {
             return childType.init(
                 from: childDirective,
                 source: source,
-                for: bundle,
+                for: inputs,
                 problems: &problems
             )
         }
diff --git a/Sources/SwiftDocC/Semantics/General Purpose Analyses/HasAtMostOne.swift b/Sources/SwiftDocC/Semantics/General Purpose Analyses/HasAtMostOne.swift
index 93765fd5d3..bc9a4beb8d 100644
--- a/Sources/SwiftDocC/Semantics/General Purpose Analyses/HasAtMostOne.swift	
+++ b/Sources/SwiftDocC/Semantics/General Purpose Analyses/HasAtMostOne.swift	
@@ -16,13 +16,13 @@ extension Semantic.Analyses {
      Checks to see if a parent directive has at most one child directive of a specified type. If so, return that child and the remainder.
      */
     public struct HasAtMostOne<Parent: Semantic & DirectiveConvertible, Child: Semantic & DirectiveConvertible> {
-        public func analyze(_ directive: BlockDirective, children: some Sequence<any Markup>, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) -> (Child?, remainder: MarkupContainer) {
+        public func analyze(_ directive: BlockDirective, children: some Sequence<any Markup>, source: URL?, for inputs: DocumentationContext.Inputs, problems: inout [Problem]) -> (Child?, remainder: MarkupContainer) {
             return Semantic.Analyses.extractAtMostOne(
                 childType: Child.self,
                 parentDirective: directive,
                 children: children,
                 source: source,
-                for: bundle,
+                for: inputs,
                 problems: &problems
             ) as! (Child?, MarkupContainer)
         }
@@ -33,7 +33,7 @@ extension Semantic.Analyses {
         parentDirective: BlockDirective,
         children: some Sequence<any Markup>,
         source: URL?,
-        for bundle: DocumentationBundle,
+        for inputs: DocumentationContext.Inputs,
         severityIfNotFound: DiagnosticSeverity = .warning,
         problems: inout [Problem]
     ) -> ((any DirectiveConvertible)?, remainder: MarkupContainer) {
@@ -67,7 +67,7 @@ extension Semantic.Analyses {
             problems.append(Problem(diagnostic: diagnostic, possibleSolutions: []))
         }
         
-        return (childType.init(from: match, source: source, for: bundle, problems: &problems), MarkupContainer(remainder))
+        return (childType.init(from: match, source: source, for: inputs, problems: &problems), MarkupContainer(remainder))
     }
 }
 
diff --git a/Sources/SwiftDocC/Semantics/General Purpose Analyses/HasExactlyOne.swift b/Sources/SwiftDocC/Semantics/General Purpose Analyses/HasExactlyOne.swift
index aa05a6dd63..9f90e0172c 100644
--- a/Sources/SwiftDocC/Semantics/General Purpose Analyses/HasExactlyOne.swift	
+++ b/Sources/SwiftDocC/Semantics/General Purpose Analyses/HasExactlyOne.swift	
@@ -21,13 +21,13 @@ extension Semantic.Analyses {
             self.severityIfNotFound = severityIfNotFound
         }
         
-        public func analyze(_ directive: BlockDirective, children: some Sequence<any Markup>, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) -> (Child?, remainder: MarkupContainer) {
+        public func analyze(_ directive: BlockDirective, children: some Sequence<any Markup>, source: URL?, for inputs: DocumentationContext.Inputs, problems: inout [Problem]) -> (Child?, remainder: MarkupContainer) {
             return Semantic.Analyses.extractExactlyOne(
                 childType: Child.self,
                 parentDirective: directive,
                 children: children,
                 source: source,
-                for: bundle,
+                for: inputs,
                 severityIfNotFound: severityIfNotFound,
                 problems: &problems
             ) as! (Child?, MarkupContainer)
@@ -39,7 +39,7 @@ extension Semantic.Analyses {
         parentDirective: BlockDirective,
         children: some Sequence<any Markup>,
         source: URL?,
-        for bundle: DocumentationBundle,
+        for inputs: DocumentationContext.Inputs,
         severityIfNotFound: DiagnosticSeverity? = .warning,
         problems: inout [Problem]
     ) -> ((any DirectiveConvertible)?, remainder: MarkupContainer) {
@@ -89,7 +89,7 @@ extension Semantic.Analyses {
             }
         }
         
-        return (childType.init(from: candidate, source: source, for: bundle, problems: &problems), MarkupContainer(remainder))
+        return (childType.init(from: candidate, source: source, for: inputs, problems: &problems), MarkupContainer(remainder))
     }
     
     /// Checks a parent directive for the presence of exactly one of two child directives---but not both---to be converted to a type ``SemanticAnalysis/Result``. If so, return that child and the remainder.
@@ -99,7 +99,7 @@ extension Semantic.Analyses {
             self.severityIfNotFound = severityIfNotFound
         }
         
-        public func analyze(_ directive: BlockDirective, children: some Sequence<any Markup>, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) -> (Child1?, Child2?, remainder: MarkupContainer) {
+        public func analyze(_ directive: BlockDirective, children: some Sequence<any Markup>, source: URL?, for bundle: DocumentationContext.Inputs, problems: inout [Problem]) -> (Child1?, Child2?, remainder: MarkupContainer) {
             let (candidates, remainder) = children.categorize { child -> BlockDirective? in
                 guard let childDirective = child as? BlockDirective else {
                     return nil
@@ -149,7 +149,7 @@ extension Semantic.Analyses {
             self.severityIfNotFound = severityIfNotFound
         }
         
-        public func analyze(_ directive: BlockDirective, children: some Sequence<any Markup>, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) -> ((any Media)?, remainder: MarkupContainer) {
+        public func analyze(_ directive: BlockDirective, children: some Sequence<any Markup>, source: URL?, for bundle: DocumentationContext.Inputs, problems: inout [Problem]) -> ((any Media)?, remainder: MarkupContainer) {
             let (foundImage, foundVideo, remainder) = HasExactlyOneOf<Parent, ImageMedia, VideoMedia>(severityIfNotFound: severityIfNotFound).analyze(directive, children: children, source: source, for: bundle, problems: &problems)
             return (foundImage ?? foundVideo, remainder)
         }
@@ -162,7 +162,7 @@ extension Semantic.Analyses {
             self.severityIfNotFound = severityIfNotFound
         }
         
-        public func analyze(_ directive: BlockDirective, children: some Sequence<any Markup>, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) -> ((any Media)?, remainder: MarkupContainer) {
+        public func analyze(_ directive: BlockDirective, children: some Sequence<any Markup>, source: URL?, for bundle: DocumentationContext.Inputs, problems: inout [Problem]) -> ((any Media)?, remainder: MarkupContainer) {
             let (mediaDirectives, remainder) = children.categorize { child -> BlockDirective? in
                 guard let childDirective = child as? BlockDirective else {
                     return nil
diff --git a/Sources/SwiftDocC/Semantics/General Purpose Analyses/HasOnlySequentialHeadings.swift b/Sources/SwiftDocC/Semantics/General Purpose Analyses/HasOnlySequentialHeadings.swift
index b7515b4efa..d48c41e609 100644
--- a/Sources/SwiftDocC/Semantics/General Purpose Analyses/HasOnlySequentialHeadings.swift	
+++ b/Sources/SwiftDocC/Semantics/General Purpose Analyses/HasOnlySequentialHeadings.swift	
@@ -36,7 +36,7 @@ extension Semantic.Analyses {
         }
         
         /// Returns all valid headings.
-        @discardableResult public func analyze(_ directive: BlockDirective, children: some Sequence<any Markup>, source: URL?, for _: DocumentationBundle, problems: inout [Problem]) -> [Heading] {
+        @discardableResult public func analyze(_ directive: BlockDirective, children: some Sequence<any Markup>, source: URL?, for _: DocumentationContext.Inputs, problems: inout [Problem]) -> [Heading] {
             var currentHeadingLevel = startingFromLevel
             var headings: [Heading] = []
             for case let child as Heading in children {
diff --git a/Sources/SwiftDocC/Semantics/MarkupReferenceResolver.swift b/Sources/SwiftDocC/Semantics/MarkupReferenceResolver.swift
index 8f34a30d46..2a273db1c9 100644
--- a/Sources/SwiftDocC/Semantics/MarkupReferenceResolver.swift
+++ b/Sources/SwiftDocC/Semantics/MarkupReferenceResolver.swift
@@ -44,13 +44,11 @@ private func removedLinkDestinationProblem(reference: ResolvedTopicReference, ra
  */
 struct MarkupReferenceResolver: MarkupRewriter {
     var context: DocumentationContext
-    var bundle: DocumentationBundle
     var problems = [Problem]()
     var rootReference: ResolvedTopicReference
     
-    init(context: DocumentationContext, bundle: DocumentationBundle, rootReference: ResolvedTopicReference) {
+    init(context: DocumentationContext, rootReference: ResolvedTopicReference) {
         self.context = context
-        self.bundle = bundle
         self.rootReference = rootReference
     }
 
@@ -84,14 +82,14 @@ struct MarkupReferenceResolver: MarkupRewriter {
                 return nil
             }
             
-            let uncuratedArticleMatch = context.uncuratedArticles[bundle.articlesDocumentationRootReference.appendingPathOfReference(unresolved)]?.source
+            let uncuratedArticleMatch = context.uncuratedArticles[context.inputs.articlesDocumentationRootReference.appendingPathOfReference(unresolved)]?.source
             problems.append(unresolvedReferenceProblem(source: range?.source, range: range, severity: severity, uncuratedArticleMatch: uncuratedArticleMatch, errorInfo: error, fromSymbolLink: fromSymbolLink))
             return nil
         }
     }
 
     mutating func visitImage(_ image: Image) -> (any Markup)? {
-        if let reference = image.reference(in: bundle), !context.resourceExists(with: reference) {
+        if let reference = image.reference(in: context.inputs), !context.resourceExists(with: reference) {
             problems.append(unresolvedResourceProblem(resource: reference, source: image.range?.source, range: image.range, severity: .warning))
         }
 
@@ -172,7 +170,7 @@ struct MarkupReferenceResolver: MarkupRewriter {
         switch blockDirective.name {
         case Snippet.directiveName:
             var problems = [Problem]()
-            guard let snippet = Snippet(from: blockDirective, source: source, for: bundle, problems: &problems) else {
+            guard let snippet = Snippet(from: blockDirective, source: source, for: context.inputs, problems: &problems) else {
                 return blockDirective
             }
             
@@ -192,7 +190,7 @@ struct MarkupReferenceResolver: MarkupRewriter {
                 return blockDirective
             }
         case ImageMedia.directiveName:
-            guard let imageMedia = ImageMedia(from: blockDirective, source: source, for: bundle) else {
+            guard let imageMedia = ImageMedia(from: blockDirective, source: source, for: context.inputs) else {
                 return blockDirective
             }
             
@@ -210,7 +208,7 @@ struct MarkupReferenceResolver: MarkupRewriter {
             
             return blockDirective
         case VideoMedia.directiveName:
-            guard let videoMedia = VideoMedia(from: blockDirective, source: source, for: bundle) else {
+            guard let videoMedia = VideoMedia(from: blockDirective, source: source, for: context.inputs) else {
                 return blockDirective
             }
             
diff --git a/Sources/SwiftDocC/Semantics/Metadata/CallToAction.swift b/Sources/SwiftDocC/Semantics/Metadata/CallToAction.swift
index 569bf8c81e..b550f95cf7 100644
--- a/Sources/SwiftDocC/Semantics/Metadata/CallToAction.swift
+++ b/Sources/SwiftDocC/Semantics/Metadata/CallToAction.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2022-2023 Apple Inc. and the Swift project authors
+ Copyright (c) 2022-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -57,10 +57,10 @@ public final class CallToAction: Semantic, AutomaticDirectiveConvertible {
     @DirectiveArgumentWrapped
     public var url: URL? = nil
 
-    /// The location of the associated link, as a reference to a file in this documentation bundle.
+    /// The location of the associated link, as a reference to a file in this documentation catalog.
     @DirectiveArgumentWrapped(
-        parseArgument: { bundle, argumentValue in
-            ResourceReference(bundleID: bundle.id, path: argumentValue)
+        parseArgument: { inputs, argumentValue in
+            ResourceReference(bundleID: inputs.id, path: argumentValue)
         }
     )
     public var file: ResourceReference? = nil
@@ -149,13 +149,9 @@ public final class CallToAction: Semantic, AutomaticDirectiveConvertible {
 }
 
 extension CallToAction {
-    func resolveFile(
-        for bundle: DocumentationBundle,
-        in context: DocumentationContext,
-        problems: inout [Problem]) -> ResourceReference?
-    {
+    func resolveFile(in context: DocumentationContext, problems: inout [Problem]) -> ResourceReference? {
         if let file = self.file {
-            if context.resolveAsset(named: file.url.lastPathComponent, in: bundle.rootReference) == nil {
+            if context.resolveAsset(named: file.url.lastPathComponent, in: context.inputs.rootReference) == nil {
                 problems.append(.init(
                     diagnostic: Diagnostic(
                         source: url,
diff --git a/Sources/SwiftDocC/Semantics/ReferenceResolver.swift b/Sources/SwiftDocC/Semantics/ReferenceResolver.swift
index 2bb44a90ec..ce06808210 100644
--- a/Sources/SwiftDocC/Semantics/ReferenceResolver.swift
+++ b/Sources/SwiftDocC/Semantics/ReferenceResolver.swift
@@ -95,9 +95,6 @@ struct ReferenceResolver: SemanticVisitor {
     /// The context to use to resolve references.
     var context: DocumentationContext
     
-    /// The bundle in which visited documents reside.
-    var bundle: DocumentationBundle
-    
     /// Problems found while trying to resolve references.
     var problems = [Problem]()
     
@@ -106,10 +103,9 @@ struct ReferenceResolver: SemanticVisitor {
     /// If the documentation is inherited, the reference of the parent symbol.
     var inheritanceParentReference: ResolvedTopicReference?
     
-    init(context: DocumentationContext, bundle: DocumentationBundle, rootReference: ResolvedTopicReference? = nil, inheritanceParentReference: ResolvedTopicReference? = nil) {
+    init(context: DocumentationContext, rootReference: ResolvedTopicReference? = nil, inheritanceParentReference: ResolvedTopicReference? = nil) {
         self.context = context
-        self.bundle = bundle
-        self.rootReference = rootReference ?? bundle.rootReference
+        self.rootReference = rootReference ?? context.inputs.rootReference
         self.inheritanceParentReference = inheritanceParentReference
     }
     
@@ -119,7 +115,7 @@ struct ReferenceResolver: SemanticVisitor {
             return .success(resolved)
             
         case let .failure(unresolved, error):
-            let uncuratedArticleMatch = context.uncuratedArticles[bundle.documentationRootReference.appendingPathOfReference(unresolved)]?.source
+            let uncuratedArticleMatch = context.uncuratedArticles[context.inputs.documentationRootReference.appendingPathOfReference(unresolved)]?.source
             problems.append(unresolvedReferenceProblem(source: range?.source, range: range, severity: severity, uncuratedArticleMatch: uncuratedArticleMatch, errorInfo: error, fromSymbolLink: false))
             return .failure(unresolved, error)
         }
@@ -172,9 +168,9 @@ struct ReferenceResolver: SemanticVisitor {
         
         // Change the context of the project file to `download`
         if let projectFiles = tutorial.projectFiles,
-            var resolvedDownload = context.resolveAsset(named: projectFiles.path, in: bundle.rootReference) {
+            var resolvedDownload = context.resolveAsset(named: projectFiles.path, in: rootReference) {
             resolvedDownload.context = .download
-            context.updateAsset(named: projectFiles.path, asset: resolvedDownload, in: bundle.rootReference)
+            context.updateAsset(named: projectFiles.path, asset: resolvedDownload, in: rootReference)
         }
         
         return Tutorial(originalMarkup: tutorial.originalMarkup, durationMinutes: tutorial.durationMinutes, projectFiles: tutorial.projectFiles, requirements: newRequirements, intro: newIntro, sections: newSections, assessments: newAssessments, callToActionImage: newCallToActionImage, redirects: tutorial.redirects)
@@ -215,7 +211,7 @@ struct ReferenceResolver: SemanticVisitor {
     }
     
     mutating func visitMarkupContainer(_ markupContainer: MarkupContainer) -> Semantic {
-        var markupResolver = MarkupReferenceResolver(context: context, bundle: bundle, rootReference: rootReference)
+        var markupResolver = MarkupReferenceResolver(context: context, rootReference: rootReference)
         let parent = inheritanceParentReference
         let context = self.context
         
@@ -315,7 +311,7 @@ struct ReferenceResolver: SemanticVisitor {
         // i.e. doc:/${SOME_TECHNOLOGY}/${PROJECT} or doc://${BUNDLE_ID}/${SOME_TECHNOLOGY}/${PROJECT}
         switch tutorialReference.topic {
         case .unresolved:
-            let maybeResolved = resolve(tutorialReference.topic, in: bundle.tutorialsContainerReference,
+            let maybeResolved = resolve(tutorialReference.topic, in: context.inputs.tutorialsContainerReference,
                                         range: tutorialReference.originalMarkup.range,
                                         severity: .warning)
             return TutorialReference(originalMarkup: tutorialReference.originalMarkup, tutorial: .resolved(maybeResolved))
@@ -369,10 +365,10 @@ struct ReferenceResolver: SemanticVisitor {
             visitMarkupContainer($0) as? MarkupContainer
         }
         // If there's a call to action with a local-file reference, change its context to `download`
-        if let downloadFile = article.metadata?.callToAction?.resolveFile(for: bundle, in: context, problems: &problems),
-            var resolvedDownload = context.resolveAsset(named: downloadFile.path, in: bundle.rootReference) {
+        if let downloadFile = article.metadata?.callToAction?.resolveFile(in: context, problems: &problems),
+            var resolvedDownload = context.resolveAsset(named: downloadFile.path, in: rootReference) {
             resolvedDownload.context = .download
-            context.updateAsset(named: downloadFile.path, asset: resolvedDownload, in: bundle.rootReference)
+            context.updateAsset(named: downloadFile.path, asset: resolvedDownload, in: rootReference)
         }
 
         return Article(
@@ -543,15 +539,15 @@ fileprivate extension URL {
 }
 
 extension Image {
-    func reference(in bundle: DocumentationBundle) -> ResourceReference? {
+    func reference(in inputs: DocumentationContext.Inputs) -> ResourceReference? {
         guard let source else {
-            return ResourceReference(bundleID: bundle.id, path: "")
+            return ResourceReference(bundleID: inputs.id, path: "")
         }
         
         if let url = URL(string: source), url.isLikelyWebURL {
             return nil
         } else {
-            return ResourceReference(bundleID: bundle.id, path: source)
+            return ResourceReference(bundleID: inputs.id, path: source)
         }
     }
 }
diff --git a/Sources/SwiftDocC/Semantics/SemanticAnalyzer.swift b/Sources/SwiftDocC/Semantics/SemanticAnalyzer.swift
index 7af7e5999a..27cb006478 100644
--- a/Sources/SwiftDocC/Semantics/SemanticAnalyzer.swift
+++ b/Sources/SwiftDocC/Semantics/SemanticAnalyzer.swift
@@ -14,11 +14,11 @@ import Markdown
 struct SemanticAnalyzer: MarkupVisitor {
     var problems = [Problem]()
     let source: URL?
-    let bundle: DocumentationBundle
+    let inputs: DocumentationContext.Inputs
     
-    init(source: URL?, bundle: DocumentationBundle) {
+    init(source: URL?, inputs: DocumentationContext.Inputs) {
         self.source = source
-        self.bundle = bundle
+        self.inputs = inputs
     }
 
     private mutating func analyzeChildren(of markup: any Markup) -> [Semantic] {
@@ -51,13 +51,13 @@ struct SemanticAnalyzer: MarkupVisitor {
             .list(finalConjunction: .or)
         
         if let source {
-            if !topLevelChildren.isEmpty, !DocumentationBundleFileTypes.isTutorialFile(source) {
+            if !topLevelChildren.isEmpty, !DocumentationInputFileTypes.isTutorialFile(source) {
                 // Only tutorials support top level directives. This document has top level directives but is not a tutorial file.
                 let directiveName = type(of: topLevelChildren.first! as! (any DirectiveConvertible)).directiveName
                 let diagnostic = Diagnostic(source: source, severity: .warning, range: document.range, identifier: "org.swift.docc.unsupportedTopLevelChild", summary: "Found unsupported \(directiveName.singleQuoted) directive in '.\(source.pathExtension)' file", explanation: "Only '.tutorial' files support top-level directives")
                 problems.append(Problem(diagnostic: diagnostic, possibleSolutions: []))
                 return nil
-            } else if topLevelChildren.isEmpty, !DocumentationBundleFileTypes.isReferenceDocumentationFile(source) {
+            } else if topLevelChildren.isEmpty, !DocumentationInputFileTypes.isReferenceDocumentationFile(source) {
                 // Only reference documentation support all markdown content. This document has no top level directives but is not a reference documentation file.
                 let diagnostic = Diagnostic(
                     source: source,
@@ -77,7 +77,7 @@ struct SemanticAnalyzer: MarkupVisitor {
         }
         
         if topLevelChildren.isEmpty {
-            guard let article = Article(from: document, source: source, for: bundle, problems: &problems) else {
+            guard let article = Article(from: document, source: source, for: inputs, problems: &problems) else {
                 // We've already diagnosed the invalid article.
                 return nil
             }
@@ -100,58 +100,58 @@ struct SemanticAnalyzer: MarkupVisitor {
     mutating func visitBlockDirective(_ blockDirective: BlockDirective) -> Semantic? {
         switch blockDirective.name {
         case TutorialTableOfContents.directiveName:
-            return TutorialTableOfContents(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return TutorialTableOfContents(from: blockDirective, source: source, for: inputs, problems: &problems)
         case Volume.directiveName:
-            return Volume(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return Volume(from: blockDirective, source: source, for: inputs, problems: &problems)
         case Chapter.directiveName:
-            return Chapter(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return Chapter(from: blockDirective, source: source, for: inputs, problems: &problems)
         case TutorialReference.directiveName:
-            return TutorialReference(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return TutorialReference(from: blockDirective, source: source, for: inputs, problems: &problems)
         case ContentAndMedia.directiveName:
-            return ContentAndMedia(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return ContentAndMedia(from: blockDirective, source: source, for: inputs, problems: &problems)
         case Intro.directiveName:
-            return Intro(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return Intro(from: blockDirective, source: source, for: inputs, problems: &problems)
         case ImageMedia.directiveName:
-            return ImageMedia(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return ImageMedia(from: blockDirective, source: source, for: inputs, problems: &problems)
         case VideoMedia.directiveName:
-            return VideoMedia(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return VideoMedia(from: blockDirective, source: source, for: inputs, problems: &problems)
         case Tutorial.directiveName:
-            return Tutorial(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return Tutorial(from: blockDirective, source: source, for: inputs, problems: &problems)
         case TutorialArticle.directiveName:
-            return TutorialArticle(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return TutorialArticle(from: blockDirective, source: source, for: inputs, problems: &problems)
         case XcodeRequirement.directiveName:
-            return XcodeRequirement(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return XcodeRequirement(from: blockDirective, source: source, for: inputs, problems: &problems)
         case Assessments.directiveName:
-            return Assessments(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return Assessments(from: blockDirective, source: source, for: inputs, problems: &problems)
         case MultipleChoice.directiveName:
-            return MultipleChoice(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return MultipleChoice(from: blockDirective, source: source, for: inputs, problems: &problems)
         case Choice.directiveName:
-            return Choice(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return Choice(from: blockDirective, source: source, for: inputs, problems: &problems)
         case Justification.directiveName:
-            return Justification(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return Justification(from: blockDirective, source: source, for: inputs, problems: &problems)
         case TutorialSection.directiveName:
-            return TutorialSection(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return TutorialSection(from: blockDirective, source: source, for: inputs, problems: &problems)
         case Step.directiveName:
-            return Step(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return Step(from: blockDirective, source: source, for: inputs, problems: &problems)
         case Resources.directiveName:
-            return Resources(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return Resources(from: blockDirective, source: source, for: inputs, problems: &problems)
         case Comment.directiveName:
-            return Comment(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return Comment(from: blockDirective, source: source, for: inputs, problems: &problems)
         case DeprecationSummary.directiveName:
-            return DeprecationSummary(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return DeprecationSummary(from: blockDirective, source: source, for: inputs, problems: &problems)
         case Metadata.directiveName:
-            return Metadata(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return Metadata(from: blockDirective, source: source, for: inputs, problems: &problems)
         case Redirect.directiveName:
-            return Redirect(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return Redirect(from: blockDirective, source: source, for: inputs, problems: &problems)
         case DocumentationExtension.directiveName:
-            return DocumentationExtension(from: blockDirective, source: source, for: bundle, problems: &problems)
+            return DocumentationExtension(from: blockDirective, source: source, for: inputs, problems: &problems)
         case Snippet.directiveName:
             // A snippet directive does not need to stay around as a Semantic object.
             // we only need to check the path argument and that it doesn't
             // have any inner content as a convenience to the author.
             // The path will resolve as a symbol link later in the
             // MarkupReferenceResolver.
-            _ = Snippet(from: blockDirective, source: source, for: bundle, problems: &problems)
+            _ = Snippet(from: blockDirective, source: source, for: inputs, problems: &problems)
             return nil
         case Options.directiveName:
             return nil
@@ -166,7 +166,7 @@ struct SemanticAnalyzer: MarkupVisitor {
             guard let directive = directiveType.init(
                 from: blockDirective,
                 source: source,
-                for: bundle,
+                for: inputs,
                 problems: &problems
             ) else {
                 return nil
diff --git a/Sources/SwiftDocC/Semantics/Snippets/Snippet.swift b/Sources/SwiftDocC/Semantics/Snippets/Snippet.swift
index 417f4c5dc3..12e0001476 100644
--- a/Sources/SwiftDocC/Semantics/Snippets/Snippet.swift
+++ b/Sources/SwiftDocC/Semantics/Snippets/Snippet.swift
@@ -65,7 +65,7 @@ public final class Snippet: Semantic, AutomaticDirectiveConvertible {
 
 extension Snippet: RenderableDirectiveConvertible {
     func render(with contentCompiler: inout RenderContentCompiler) -> [any RenderContent] {
-        guard let snippet = Snippet(from: originalMarkup, for: contentCompiler.bundle) else {
+        guard let snippet = Snippet(from: originalMarkup, for: contentCompiler.context.inputs) else {
                 return []
             }
             
diff --git a/Sources/SwiftDocC/Semantics/Symbol/Symbol.swift b/Sources/SwiftDocC/Semantics/Symbol/Symbol.swift
index a62aac5ba7..deb0413567 100644
--- a/Sources/SwiftDocC/Semantics/Symbol/Symbol.swift
+++ b/Sources/SwiftDocC/Semantics/Symbol/Symbol.swift
@@ -48,13 +48,6 @@ public import SymbolKit
 /// - ``seeAlsoVariants``
 /// - ``returnsSectionVariants``
 /// - ``parametersSectionVariants``
-/// - ``dictionaryKeysSectionVariants``
-/// - ``possibleValuesSectionVariants``
-/// - ``httpEndpointSectionVariants``
-/// - ``httpParametersSectionVariants``
-/// - ``httpResponsesSectionVariants``
-/// - ``httpBodySectionVariants``
-/// - ``redirectsVariants``
 /// - ``abstractVariants``
 /// - ``isDeprecatedVariants``
 /// - ``isSPIVariants``
diff --git a/Sources/SwiftDocC/Semantics/Technology/Resources/Resources.swift b/Sources/SwiftDocC/Semantics/Technology/Resources/Resources.swift
index ba00a1b633..cefa682ce3 100644
--- a/Sources/SwiftDocC/Semantics/Technology/Resources/Resources.swift
+++ b/Sources/SwiftDocC/Semantics/Technology/Resources/Resources.swift
@@ -54,7 +54,7 @@ public final class Resources: Semantic, DirectiveConvertible, Abstracted, Redire
         self.redirects = redirects
     }
     
-    public convenience init?(from directive: BlockDirective, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) {
+    public convenience init?(from directive: BlockDirective, source: URL?, for inputs: DocumentationContext.Inputs, problems: inout [Problem]) {
         precondition(directive.name == Resources.directiveName)
         
         var remainder: [any Markup]
@@ -76,7 +76,7 @@ public final class Resources: Semantic, DirectiveConvertible, Abstracted, Redire
             guard let childDirective = child as? BlockDirective, childDirective.name == Redirect.directiveName else {
                 return nil
             }
-            return Redirect(from: childDirective, source: source, for: bundle, problems: &problems)
+            return Redirect(from: childDirective, source: source, for: inputs, problems: &problems)
         }
         
         let tiles: [Tile]
@@ -84,7 +84,7 @@ public final class Resources: Semantic, DirectiveConvertible, Abstracted, Redire
             guard let childDirective = child as? BlockDirective, Tile.DirectiveNames(rawValue: childDirective.name) != nil else {
                 return nil
             }
-            return Tile(from: childDirective, source: source, for: bundle, problems: &problems)
+            return Tile(from: childDirective, source: source, for: inputs, problems: &problems)
         }
         
         var seenTileDirectiveNames = Set<String>()
diff --git a/Sources/SwiftDocC/Semantics/Technology/Resources/Tile.swift b/Sources/SwiftDocC/Semantics/Technology/Resources/Tile.swift
index a8975c57d6..2e1463d153 100644
--- a/Sources/SwiftDocC/Semantics/Technology/Resources/Tile.swift
+++ b/Sources/SwiftDocC/Semantics/Technology/Resources/Tile.swift
@@ -166,7 +166,7 @@ public final class Tile: Semantic, DirectiveConvertible {
         self.init(originalMarkup: directive, identifier: tileIdentifier, title: title, destination: destination, content: MarkupContainer(directive.children))
     }
     
-    public convenience init?(from directive: BlockDirective, source: URL?, for _: DocumentationBundle, problems: inout [Problem]) {
+    public convenience init?(from directive: BlockDirective, source: URL?, for _: DocumentationContext.Inputs, problems: inout [Problem]) {
         switch directive.name {
         case Tile.DirectiveNames.documentation.rawValue:
             self.init(genericTile: directive,
diff --git a/Sources/SwiftDocC/Semantics/Technology/TutorialTableOfContents.swift b/Sources/SwiftDocC/Semantics/Technology/TutorialTableOfContents.swift
index 7e7098c0fb..00f6822112 100644
--- a/Sources/SwiftDocC/Semantics/Technology/TutorialTableOfContents.swift
+++ b/Sources/SwiftDocC/Semantics/Technology/TutorialTableOfContents.swift
@@ -59,7 +59,7 @@ public final class TutorialTableOfContents: Semantic, DirectiveConvertible, Abst
         }
     }
     
-    public convenience init?(from directive: BlockDirective, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) {
+    public convenience init?(from directive: BlockDirective, source: URL?, for inputs: DocumentationContext.Inputs, problems: inout [Problem]) {
         precondition(directive.name == TutorialTableOfContents.directiveName)
         
         let arguments = Semantic.Analyses.HasOnlyKnownArguments<TutorialTableOfContents>(severityIfFound: .warning, allowedArguments: [Semantics.Name.argumentName]).analyze(directive, children: directive.children, source: source, problems: &problems)
@@ -67,15 +67,15 @@ public final class TutorialTableOfContents: Semantic, DirectiveConvertible, Abst
         Semantic.Analyses.HasOnlyKnownDirectives<TutorialTableOfContents>(severityIfFound: .warning, allowedDirectives: [Intro.directiveName, Volume.directiveName, Chapter.directiveName, Resources.directiveName, Redirect.directiveName]).analyze(directive, children: directive.children, source: source, problems: &problems)
     
         let requiredName = Semantic.Analyses.HasArgument<TutorialTableOfContents, Semantics.Name>(severityIfNotFound: .warning).analyze(directive, arguments: arguments, problems: &problems)
-        let requiredIntro = Semantic.Analyses.HasExactlyOne<TutorialTableOfContents, Intro>(severityIfNotFound: .warning).analyze(directive, children: directive.children, source: source, for: bundle, problems: &problems).0
+        let requiredIntro = Semantic.Analyses.HasExactlyOne<TutorialTableOfContents, Intro>(severityIfNotFound: .warning).analyze(directive, children: directive.children, source: source, for: inputs, problems: &problems).0
         
         var volumes: [Volume]
         var remainder: MarkupContainer
-        (volumes, remainder) = Semantic.Analyses.HasAtLeastOne<TutorialTableOfContents, Volume>(severityIfNotFound: nil).analyze(directive, children: directive.children, source: source, for: bundle, problems: &problems)
+        (volumes, remainder) = Semantic.Analyses.HasAtLeastOne<TutorialTableOfContents, Volume>(severityIfNotFound: nil).analyze(directive, children: directive.children, source: source, for: inputs, problems: &problems)
 
         // Retrieve chapters outside volumes.
         let chapters: [Chapter]
-        (chapters, remainder) = Semantic.Analyses.HasAtLeastOne<TutorialTableOfContents, Chapter>(severityIfNotFound: nil).analyze(directive, children: directive.children, source: source, for: bundle, problems: &problems)
+        (chapters, remainder) = Semantic.Analyses.HasAtLeastOne<TutorialTableOfContents, Chapter>(severityIfNotFound: nil).analyze(directive, children: directive.children, source: source, for: inputs, problems: &problems)
 
         if !chapters.isEmpty {
             if !volumes.isEmpty {
@@ -94,10 +94,10 @@ public final class TutorialTableOfContents: Semantic, DirectiveConvertible, Abst
         }
         
         let resources: Resources?
-        (resources, remainder) = Semantic.Analyses.HasExactlyOne<TutorialTableOfContents, Resources>(severityIfNotFound: nil).analyze(directive, children: remainder, source: source, for: bundle, problems: &problems)
+        (resources, remainder) = Semantic.Analyses.HasExactlyOne<TutorialTableOfContents, Resources>(severityIfNotFound: nil).analyze(directive, children: remainder, source: source, for: inputs, problems: &problems)
 
         let redirects: [Redirect]
-            (redirects, remainder) = Semantic.Analyses.HasAtLeastOne<Chapter, Redirect>(severityIfNotFound: nil).analyze(directive, children: remainder, source: source, for: bundle, problems: &problems)
+            (redirects, remainder) = Semantic.Analyses.HasAtLeastOne<Chapter, Redirect>(severityIfNotFound: nil).analyze(directive, children: remainder, source: source, for: inputs, problems: &problems)
         
         guard let name = requiredName,
             let intro = requiredIntro else {
diff --git a/Sources/SwiftDocC/Semantics/Technology/Volume/Volume.swift b/Sources/SwiftDocC/Semantics/Technology/Volume/Volume.swift
index 40e606ca6a..900357def3 100644
--- a/Sources/SwiftDocC/Semantics/Technology/Volume/Volume.swift
+++ b/Sources/SwiftDocC/Semantics/Technology/Volume/Volume.swift
@@ -63,7 +63,7 @@ public final class Volume: Semantic, DirectiveConvertible, Abstracted, Redirecte
         }
     }
     
-    public convenience init?(from directive: BlockDirective, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) {
+    public convenience init?(from directive: BlockDirective, source: URL?, for inputs: DocumentationContext.Inputs, problems: inout [Problem]) {
         precondition(directive.name == Volume.directiveName)
         
         let arguments = Semantic.Analyses.HasOnlyKnownArguments<Volume>(severityIfFound: .warning, allowedArguments: [Semantics.Name.argumentName]).analyze(directive, children: directive.children, source: source, problems: &problems)
@@ -74,14 +74,14 @@ public final class Volume: Semantic, DirectiveConvertible, Abstracted, Redirecte
         
         let image: ImageMedia?
         var remainder: MarkupContainer
-        (image, remainder) = Semantic.Analyses.HasExactlyOne<Volume, ImageMedia>(severityIfNotFound: .warning).analyze(directive, children: directive.children, source: source, for: bundle, problems: &problems)
+        (image, remainder) = Semantic.Analyses.HasExactlyOne<Volume, ImageMedia>(severityIfNotFound: .warning).analyze(directive, children: directive.children, source: source, for: inputs, problems: &problems)
         
         let chapters: [Chapter]
-        (chapters, remainder) = Semantic.Analyses.HasAtLeastOne<Volume, Chapter>(severityIfNotFound: .warning).analyze(directive, children: remainder, source: source, for: bundle, problems: &problems)
+        (chapters, remainder) = Semantic.Analyses.HasAtLeastOne<Volume, Chapter>(severityIfNotFound: .warning).analyze(directive, children: remainder, source: source, for: inputs, problems: &problems)
         _ = Semantic.Analyses.HasContent<Volume>(additionalContext: "A \(Volume.directiveName.singleQuoted) directive should at least have a sentence summarizing what the reader will learn").analyze(directive, children: remainder, source: source, problems: &problems)
         
         let redirects: [Redirect]
-        (redirects, remainder) = Semantic.Analyses.HasAtLeastOne<Chapter, Redirect>(severityIfNotFound: nil).analyze(directive, children: remainder, source: source, for: bundle, problems: &problems)
+        (redirects, remainder) = Semantic.Analyses.HasAtLeastOne<Chapter, Redirect>(severityIfNotFound: nil).analyze(directive, children: remainder, source: source, for: inputs, problems: &problems)
         
         guard let name = requiredName else {
             return nil
diff --git a/Sources/SwiftDocC/Semantics/Tutorial/Assessments/Multiple Choice/MultipleChoice.swift b/Sources/SwiftDocC/Semantics/Tutorial/Assessments/Multiple Choice/MultipleChoice.swift
index 3b8eecfa2f..8550187bc6 100644
--- a/Sources/SwiftDocC/Semantics/Tutorial/Assessments/Multiple Choice/MultipleChoice.swift	
+++ b/Sources/SwiftDocC/Semantics/Tutorial/Assessments/Multiple Choice/MultipleChoice.swift	
@@ -51,7 +51,7 @@ public final class MultipleChoice: Semantic, DirectiveConvertible {
         self.choices = choices
     }
     
-    public convenience init?(from directive: BlockDirective, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) {
+    public convenience init?(from directive: BlockDirective, source: URL?, for inputs: DocumentationContext.Inputs, problems: inout [Problem]) {
         precondition(directive.name == MultipleChoice.directiveName)
         
         _ = Semantic.Analyses.HasOnlyKnownArguments<MultipleChoice>(severityIfFound: .warning, allowedArguments: []).analyze(directive, children: directive.children, source: source, problems: &problems)
@@ -70,7 +70,7 @@ public final class MultipleChoice: Semantic, DirectiveConvertible {
         }
         
         let choices: [Choice]
-        (choices, remainder) = Semantic.Analyses.ExtractAll<Choice>().analyze(directive, children: remainder, source: source, for: bundle, problems: &problems)
+        (choices, remainder) = Semantic.Analyses.ExtractAll<Choice>().analyze(directive, children: remainder, source: source, for: inputs, problems: &problems)
         
         if choices.count < 2 || choices.count > 4 {
             let diagnostic = Diagnostic(source: source, severity: .warning, range: directive.range, identifier: "org.swift.docc.\(MultipleChoice.self).CorrectNumberOfChoices", summary: "`\(MultipleChoice.directiveName)` should contain 2-4 `\(Choice.directiveName)` child directives")
@@ -115,7 +115,7 @@ public final class MultipleChoice: Semantic, DirectiveConvertible {
         }
         
         let images: [ImageMedia]
-        (images, remainder) = Semantic.Analyses.ExtractAll<ImageMedia>().analyze(directive, children: remainder, source: source, for: bundle, problems: &problems)
+        (images, remainder) = Semantic.Analyses.ExtractAll<ImageMedia>().analyze(directive, children: remainder, source: source, for: inputs, problems: &problems)
         
         if images.count > 1 {
             for extraneousImage in images.suffix(from: 1) {
diff --git a/Sources/SwiftDocC/Semantics/Tutorial/Tasks/Steps/Code.swift b/Sources/SwiftDocC/Semantics/Tutorial/Tasks/Steps/Code.swift
index ceca8cb7f0..f91c530b3a 100644
--- a/Sources/SwiftDocC/Semantics/Tutorial/Tasks/Steps/Code.swift
+++ b/Sources/SwiftDocC/Semantics/Tutorial/Tasks/Steps/Code.swift
@@ -59,7 +59,7 @@ public final class Code: Semantic, DirectiveConvertible {
         self.preview = preview
     }
     
-    public convenience init?(from directive: BlockDirective, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) {
+    public convenience init?(from directive: BlockDirective, source: URL?, for inputs: DocumentationContext.Inputs, problems: inout [Problem]) {
         precondition(directive.name == Code.directiveName)
         
         let arguments = Semantic.Analyses.HasOnlyKnownArguments<Code>(severityIfFound: .warning, allowedArguments: [Semantics.File.argumentName, Semantics.PreviousFile.argumentName, Semantics.Name.argumentName, Semantics.ResetDiff.argumentName]).analyze(directive, children: directive.children, source: source, problems: &problems)
@@ -67,7 +67,7 @@ public final class Code: Semantic, DirectiveConvertible {
         Semantic.Analyses.HasOnlyKnownDirectives<Code>(severityIfFound: .warning, allowedDirectives: [ImageMedia.directiveName, VideoMedia.directiveName]).analyze(directive, children: directive.children, source: source, problems: &problems)
         
         guard let requiredFileReference = Semantic.Analyses.HasArgument<Code, Semantics.File>(severityIfNotFound: .warning).analyze(directive, arguments: arguments, problems: &problems) else { return nil }
-        let fileReference = ResourceReference(bundleID: bundle.id, path: requiredFileReference)
+        let fileReference = ResourceReference(bundleID: inputs.id, path: requiredFileReference)
         
         guard let requiredFileName = Semantic.Analyses.HasArgument<Code, Semantics.Name>(severityIfNotFound: .warning).analyze(directive, arguments: arguments, problems: &problems) else { return nil }
         
@@ -80,10 +80,10 @@ public final class Code: Semantic, DirectiveConvertible {
             shouldResetDiff = false
         }
        
-        let (optionalPreview, _) = Semantic.Analyses.HasExactlyOneImageOrVideoMedia<Code>(severityIfNotFound: nil).analyze(directive, children: directive.children, source: source, for: bundle, problems: &problems)
+        let (optionalPreview, _) = Semantic.Analyses.HasExactlyOneImageOrVideoMedia<Code>(severityIfNotFound: nil).analyze(directive, children: directive.children, source: source, for: inputs, problems: &problems)
         
         let optionalPreviousFileReference = Semantic.Analyses.HasArgument<Code, Semantics.PreviousFile>(severityIfNotFound: nil).analyze(directive, arguments: arguments, problems: &problems).map { argument in
-            ResourceReference(bundleID: bundle.id, path: argument)
+            ResourceReference(bundleID: inputs.id, path: argument)
         }
         
         self.init(originalMarkup: directive, fileReference: fileReference, fileName: requiredFileName, previousFileReference: optionalPreviousFileReference, shouldResetDiff: shouldResetDiff, preview: optionalPreview)
diff --git a/Sources/SwiftDocC/Semantics/Tutorial/Tasks/Steps/Step.swift b/Sources/SwiftDocC/Semantics/Tutorial/Tasks/Steps/Step.swift
index 625e16572f..78cf270b80 100644
--- a/Sources/SwiftDocC/Semantics/Tutorial/Tasks/Steps/Step.swift
+++ b/Sources/SwiftDocC/Semantics/Tutorial/Tasks/Steps/Step.swift
@@ -46,7 +46,7 @@ public final class Step: Semantic, DirectiveConvertible {
         self.caption = caption
     }
     
-    public convenience init?(from directive: BlockDirective, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) {
+    public convenience init?(from directive: BlockDirective, source: URL?, for inputs: DocumentationContext.Inputs, problems: inout [Problem]) {
         precondition(directive.name == Step.directiveName)
         
         _ = Semantic.Analyses.HasOnlyKnownArguments<Step>(severityIfFound: .warning, allowedArguments: []).analyze(directive, children: directive.children, source: source, problems: &problems)
@@ -55,10 +55,10 @@ public final class Step: Semantic, DirectiveConvertible {
         
         var remainder: MarkupContainer
         let optionalMedia: (any Media)?
-        (optionalMedia, remainder) = Semantic.Analyses.HasExactlyOneMedia<Step>(severityIfNotFound: nil).analyze(directive, children: directive.children, source: source, for: bundle, problems: &problems)
+        (optionalMedia, remainder) = Semantic.Analyses.HasExactlyOneMedia<Step>(severityIfNotFound: nil).analyze(directive, children: directive.children, source: source, for: inputs, problems: &problems)
         
         let optionalCode: Code?
-        (optionalCode, remainder) = Semantic.Analyses.HasExactlyOne<Step, Code>(severityIfNotFound: nil).analyze(directive, children: remainder, source: source, for: bundle, problems: &problems)
+        (optionalCode, remainder) = Semantic.Analyses.HasExactlyOne<Step, Code>(severityIfNotFound: nil).analyze(directive, children: remainder, source: source, for: inputs, problems: &problems)
         
         let paragraphs: [Paragraph]
         (paragraphs, remainder) = Semantic.Analyses.ExtractAllMarkup<Paragraph>().analyze(directive, children: remainder, source: source, problems: &problems)
diff --git a/Sources/SwiftDocC/Semantics/Tutorial/Tasks/Steps/Steps.swift b/Sources/SwiftDocC/Semantics/Tutorial/Tasks/Steps/Steps.swift
index 9edba4a4cb..96da81f3c9 100644
--- a/Sources/SwiftDocC/Semantics/Tutorial/Tasks/Steps/Steps.swift
+++ b/Sources/SwiftDocC/Semantics/Tutorial/Tasks/Steps/Steps.swift
@@ -34,7 +34,7 @@ public final class Steps: Semantic, DirectiveConvertible {
         self.content = content
     }
     
-    public convenience init?(from directive: BlockDirective, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) {
+    public convenience init?(from directive: BlockDirective, source: URL?, for inputs: DocumentationContext.Inputs, problems: inout [Problem]) {
         precondition(directive.name == Steps.directiveName)
         
         _ = Semantic.Analyses.HasOnlyKnownArguments<Steps>(severityIfFound: .warning, allowedArguments: [])
@@ -46,7 +46,7 @@ public final class Steps: Semantic, DirectiveConvertible {
         let stepsContent: [Semantic] = directive.children.compactMap { child -> Semantic? in
             if let directive = child as? BlockDirective,
                 directive.name == Step.directiveName {
-                return Step(from: directive, source: source, for: bundle, problems: &problems)
+                return Step(from: directive, source: source, for: inputs, problems: &problems)
             } else {
                 return MarkupContainer(child)
             }
diff --git a/Sources/SwiftDocC/Semantics/Tutorial/Tasks/TutorialSection.swift b/Sources/SwiftDocC/Semantics/Tutorial/Tasks/TutorialSection.swift
index 17ded53583..d95a3bcecb 100644
--- a/Sources/SwiftDocC/Semantics/Tutorial/Tasks/TutorialSection.swift
+++ b/Sources/SwiftDocC/Semantics/Tutorial/Tasks/TutorialSection.swift
@@ -77,7 +77,7 @@ public final class TutorialSection: Semantic, DirectiveConvertible, Abstracted,
         }
     }
     
-    public convenience init?(from directive: BlockDirective, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) {
+    public convenience init?(from directive: BlockDirective, source: URL?, for inputs: DocumentationContext.Inputs, problems: inout [Problem]) {
         precondition(directive.name == TutorialSection.directiveName)
         
         let arguments = Semantic.Analyses.HasOnlyKnownArguments<TutorialSection>(severityIfFound: .warning, allowedArguments: [Semantics.Title.argumentName]).analyze(directive, children: directive.children, source: source, problems: &problems)
@@ -88,14 +88,14 @@ public final class TutorialSection: Semantic, DirectiveConvertible, Abstracted,
         
         var remainder: MarkupContainer
         let optionalSteps: Steps?
-        (optionalSteps, remainder) = Semantic.Analyses.HasExactlyOne<TutorialSection, Steps>(severityIfNotFound: .warning).analyze(directive, children: directive.children, source: source, for: bundle, problems: &problems)
+        (optionalSteps, remainder) = Semantic.Analyses.HasExactlyOne<TutorialSection, Steps>(severityIfNotFound: .warning).analyze(directive, children: directive.children, source: source, for: inputs, problems: &problems)
         
-        Semantic.Analyses.HasOnlySequentialHeadings<TutorialArticle>(severityIfFound: .warning, startingFromLevel: 2).analyze(directive, children: remainder, source: source, for: bundle, problems: &problems)
+        Semantic.Analyses.HasOnlySequentialHeadings<TutorialArticle>(severityIfFound: .warning, startingFromLevel: 2).analyze(directive, children: remainder, source: source, for: inputs, problems: &problems)
         
         let redirects: [Redirect]
-            (redirects, remainder) = Semantic.Analyses.HasAtLeastOne<Chapter, Redirect>(severityIfNotFound: nil).analyze(directive, children: remainder, source: source, for: bundle, problems: &problems)
+            (redirects, remainder) = Semantic.Analyses.HasAtLeastOne<Chapter, Redirect>(severityIfNotFound: nil).analyze(directive, children: remainder, source: source, for: inputs, problems: &problems)
         
-        let content = StackedContentParser.topLevelContent(from: remainder, source: source, for: bundle, problems: &problems)
+        let content = StackedContentParser.topLevelContent(from: remainder, source: source, for: inputs, problems: &problems)
         
         guard let title = requiredTitle else {
             return nil
diff --git a/Sources/SwiftDocC/Semantics/TutorialArticle/TutorialArticle.swift b/Sources/SwiftDocC/Semantics/TutorialArticle/TutorialArticle.swift
index 56961cba84..15fb2a8905 100644
--- a/Sources/SwiftDocC/Semantics/TutorialArticle/TutorialArticle.swift
+++ b/Sources/SwiftDocC/Semantics/TutorialArticle/TutorialArticle.swift
@@ -102,7 +102,7 @@ public final class TutorialArticle: Semantic, DirectiveConvertible, Abstracted,
         self.redirects = redirects
     }
     
-    public convenience init?(from directive: BlockDirective, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) {
+    public convenience init?(from directive: BlockDirective, source: URL?, for inputs: DocumentationContext.Inputs, problems: inout [Problem]) {
         precondition(directive.name == TutorialArticle.directiveName)
         
         let arguments = Semantic.Analyses.HasOnlyKnownArguments<TutorialArticle>(severityIfFound: .warning, allowedArguments: [Semantics.Time.argumentName])
@@ -116,20 +116,20 @@ public final class TutorialArticle: Semantic, DirectiveConvertible, Abstracted,
             
         var remainder: MarkupContainer
         let optionalIntro: Intro?
-        (optionalIntro, remainder) = Semantic.Analyses.HasExactlyOne<TutorialArticle, Intro>(severityIfNotFound: .warning).analyze(directive, children: directive.children, source: source, for: bundle, problems: &problems)
+        (optionalIntro, remainder) = Semantic.Analyses.HasExactlyOne<TutorialArticle, Intro>(severityIfNotFound: .warning).analyze(directive, children: directive.children, source: source, for: inputs, problems: &problems)
         
-        let headings = Semantic.Analyses.HasOnlySequentialHeadings<TutorialArticle>(severityIfFound: .warning, startingFromLevel: 2).analyze(directive, children: remainder, source: source, for: bundle, problems: &problems)
+        let headings = Semantic.Analyses.HasOnlySequentialHeadings<TutorialArticle>(severityIfFound: .warning, startingFromLevel: 2).analyze(directive, children: remainder, source: source, for: inputs, problems: &problems)
         
-        let content = StackedContentParser.topLevelContent(from: remainder, source: source, for: bundle, problems: &problems)
+        let content = StackedContentParser.topLevelContent(from: remainder, source: source, for: inputs, problems: &problems)
         
         let optionalAssessments: Assessments?
-        (optionalAssessments, remainder) = Semantic.Analyses.HasAtMostOne<Tutorial, Assessments>().analyze(directive, children: remainder, source: source, for: bundle, problems: &problems)
+        (optionalAssessments, remainder) = Semantic.Analyses.HasAtMostOne<Tutorial, Assessments>().analyze(directive, children: remainder, source: source, for: inputs, problems: &problems)
         
         let optionalCallToActionImage: ImageMedia?
-        (optionalCallToActionImage, remainder) = Semantic.Analyses.HasExactlyOne<TutorialTableOfContents, ImageMedia>(severityIfNotFound: nil).analyze(directive, children: remainder, source: source, for: bundle, problems: &problems)
+        (optionalCallToActionImage, remainder) = Semantic.Analyses.HasExactlyOne<TutorialTableOfContents, ImageMedia>(severityIfNotFound: nil).analyze(directive, children: remainder, source: source, for: inputs, problems: &problems)
         
         let redirects: [Redirect]
-            (redirects, remainder) = Semantic.Analyses.HasAtLeastOne<Chapter, Redirect>(severityIfNotFound: nil).analyze(directive, children: remainder, source: source, for: bundle, problems: &problems)
+            (redirects, remainder) = Semantic.Analyses.HasAtLeastOne<Chapter, Redirect>(severityIfNotFound: nil).analyze(directive, children: remainder, source: source, for: inputs, problems: &problems)
         
         self.init(originalMarkup: directive, durationMinutes: optionalTime, intro: optionalIntro, content: content, assessments: optionalAssessments, callToActionImage: optionalCallToActionImage, landmarks: headings, redirects: redirects.isEmpty ? nil : redirects)
     }
@@ -152,14 +152,14 @@ public enum MarkupLayout {
 }
 
 struct StackedContentParser {
-    static func topLevelContent(from markup: some Sequence<any Markup>, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) -> [MarkupLayout] {
+    static func topLevelContent(from markup: some Sequence<any Markup>, source: URL?, for inputs: DocumentationContext.Inputs, problems: inout [Problem]) -> [MarkupLayout] {
         return markup.reduce(into: []) { (accumulation, nextBlock) in
             if let directive = nextBlock as? BlockDirective {
                 if directive.name == Stack.directiveName,
-                    let stack = Stack(from: directive, source: source, for: bundle, problems: &problems) {
+                    let stack = Stack(from: directive, source: source, for: inputs, problems: &problems) {
                     accumulation.append(.stack(stack))
                 } else if directive.name == ContentAndMedia.directiveName,
-                    let contentAndMedia = ContentAndMedia(from: directive, source: source, for: bundle, problems: &problems) {
+                    let contentAndMedia = ContentAndMedia(from: directive, source: source, for: inputs, problems: &problems) {
                     accumulation.append(.contentAndMedia(contentAndMedia))
                 }
             } else {
diff --git a/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/AddingFeatureFlags.md b/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/AddingFeatureFlags.md
index 3712ca2aa0..9517c5c782 100644
--- a/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/AddingFeatureFlags.md
+++ b/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/AddingFeatureFlags.md
@@ -27,14 +27,11 @@ instance, which can then be used during the compilation process.
 
 ### Feature flags in Info.plist
 
-A subset of feature flags can affect how a documentation bundle is authored. For example, the
-experimental overloaded symbol presentation can affect how a bundle curates its symbols due to the 
-creation of overload group pages. These flags should also be added to the
-``DocumentationBundle/Info/BundleFeatureFlags`` type, so that they can be parsed out of a bundle's
-Info.plist.
+A subset of feature flags can affect how you write documentation. 
+For example, the experimental overloaded symbol presentation can affect how you curate symbols due to the creation of overload group pages. 
+Feature flags like this can be defined in the ``DocumentationContext/Inputs/Info/BundleFeatureFlags`` the, so that they can be parsed out of a documentation catalog's Info.plist file.
 
-Feature flags that are loaded from an Info.plist file are saved into the global feature flags while
-the bundle is being registered. To ensure that your new feature flag is properly loaded, update the
-``FeatureFlags/loadFlagsFromBundle(_:)`` method to load your new field into the global flags.
+Feature flags that are loaded from an Info.plist file are saved into the global ``FeatureFlags/current`` feature flags during the context registration. 
+To ensure that your new feature flag is properly loaded, update the ``FeatureFlags/loadFlagsFromBundle(_:)`` method to load your new field into the global ``FeatureFlags/current`` flags.
 
-<!-- Copyright (c) 2024 Apple Inc and the Swift Project authors. All Rights Reserved. -->
+<!-- Copyright (c) 2024-2025 Apple Inc and the Swift Project authors. All Rights Reserved. -->
diff --git a/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/Benchmarking.md b/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/Benchmarking.md
index 7f97baff97..b66d0d9130 100644
--- a/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/Benchmarking.md
+++ b/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/Benchmarking.md
@@ -36,17 +36,17 @@ This will only gather new metrics for the local changes, as you iterate, but wil
 
 When you work on a particular feature and you want to track a given custom metric you can temporarily add it to the log.
 
-For example, to add a metric that counts the registered bundles, create a `BundlesCount` class that adopts the ``BenchmarkMetric`` protocol:
+For example, to add a metric that counts the the number of markdown files in the collection of inputs, create a `MarkdownFileCount` class that adopts the ``BenchmarkMetric`` protocol:
 
 ```swift
-class BundlesCount: BenchmarkMetric {
-  static let identifier = "bundles-count"
-  static let displayName = "Bundles Count"
+class MarkdownFileCount: BenchmarkMetric {
+  static let identifier = "markdown-file-count"
+  static let displayName = "Markdown File Count"
   
   var result: MetricValue?
   
   init(context: DocumentationContext) {
-    result = .number(Double(context.registeredBundles.count))
+    result = .number(Double(context.inputs.markupURLs.count))
   }
 }
 ```
@@ -80,4 +80,4 @@ benchmark(add: BundlesCount(context: context))
 - ``benchmark(end:benchmarkLog:)``
 - ``benchmark(wrap:benchmarkLog:body:)``
 
-<!-- Copyright (c) 2021-2024 Apple Inc and the Swift Project authors. All Rights Reserved. -->
+<!-- Copyright (c) 2021-2025 Apple Inc and the Swift Project authors. All Rights Reserved. -->
diff --git a/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/Communication.md b/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/Communication.md
index 9b7e3d80bf..7d2fc01456 100644
--- a/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/Communication.md
+++ b/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/Communication.md
@@ -19,7 +19,6 @@ Offer native integration of DocC in your IDE.
 
 - ``FileServerProvider``
 - ``FileServer``
-- ``FileSystemRenderNodeProvider``
 - ``FileSystemServerProvider``
 - ``MemoryFileServerProvider``
 
diff --git a/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/DocumentationContextGroup.md b/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/DocumentationContextGroup.md
index 32904e973c..9378d7c1ad 100644
--- a/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/DocumentationContextGroup.md
+++ b/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/DocumentationContextGroup.md
@@ -7,7 +7,7 @@ Build and query the in-memory documentation model.
 A documentation context is the the in-memory representation of a "unit" of documentation (for example a module, package, or technology). 
 The context is generally responsible for:
 
- - Analyzing bundle file contents and converting to semantic models.
+ - Analyzing input file contents and converting to semantic models.
  - Managing a graph of documentation nodes (a single node representing one documentation topic).
  - Processing assets like media files or download archives.
  - Resolving links to external documentation sources via ``ExternalDocumentationSource`` and resolving external symbols via ``GlobalExternalSymbolResolver``.
@@ -15,16 +15,16 @@ The context is generally responsible for:
 
 ### Creating a Context
 
-Use ``DocumentationContext/init(bundle:dataProvider:diagnosticEngine:configuration:)`` to create a context for a given bundle:
+Use ``DocumentationContext/init(inputs:dataProvider:diagnosticEngine:configuration:)`` to create a context for a given collection of inputs files:
 
 ```swift
 let inputsProvider = DocumentationContext.InputsProvider()
-let (bundle, dataProvider) = try inputsProvider.inputsAndDataProvider(
+let (inputs, dataProvider) = try inputsProvider.inputsAndDataProvider(
     startingPoint: catalogURL, 
     options: bundleDiscoveryOptions
 )
 
-let context = try DocumentationContext(bundle: bundle, dataProvider: dataProvider)
+let context = try DocumentationContext(inputs: inputs, dataProvider: dataProvider)
 ```
 
 ### Accessing Documentation
@@ -33,7 +33,7 @@ Use ``DocumentationContext/entity(with:)`` to access a documentation node by its
 
 ```swift
 let reference = ResolvedTopicReference(
-    bundleID: "com.mybundle",
+    bundleID: "com.example",
     path: "/documentation/ValidationKit/EmailValidator",
     fragment: nil,
     sourceLanguage: .swift)
@@ -74,9 +74,7 @@ let sourceFileURL = try context.documentURL(for: reference)
 
 ### Code Listings
 
-- ``AttributedCodeListing``
-- ``UnresolvedCodeListingReference``
 - ``CodeColorsPreferenceKey``
 - ``SRGBColor``
 
-<!-- Copyright (c) 2021-2024 Apple Inc and the Swift Project authors. All Rights Reserved. -->
+<!-- Copyright (c) 2021-2025 Apple Inc and the Swift Project authors. All Rights Reserved. -->
diff --git a/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/DocumentationIndexing.md b/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/DocumentationIndexing.md
index 80316b7ddd..5daca6ccb6 100644
--- a/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/DocumentationIndexing.md
+++ b/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/DocumentationIndexing.md
@@ -28,7 +28,6 @@ Each rendering model element adopts the ``TextIndexing`` protocol in order to pr
 
 - ``AvailabilityIndex``
 - ``RenderNodeDataExtractor``
-- ``RenderNodeProvider``
 - ``Serializable``
 - ``AnyCodable``
 - ``AnyMetadata``
diff --git a/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/InputDiscovery.md b/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/InputDiscovery.md
index 80d38636c0..e83ceb3de9 100644
--- a/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/InputDiscovery.md
+++ b/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/InputDiscovery.md
@@ -4,7 +4,7 @@ Learn how to discover documentation inputs on the file system.
 
 ## Discussion
 
-A ``DocumentationContext/InputsProvider`` discovers documentation catalogs on the file system and creates a ``DocumentationBundle`` from the discovered catalog content.
+A ``DocumentationContext/InputsProvider`` discovers documentation catalogs on the file system and creates a ``DocumentationContext/Inputs`` from the discovered catalog content.
 
 ```swift
 let inputProvider = DocumentationContext.InputsProvider(fileManager: fileSystem)
@@ -12,9 +12,9 @@ let inputProvider = DocumentationContext.InputsProvider(fileManager: fileSystem)
 guard let catalogURL = try inputProvider.findCatalog(startingPoint: startingPoint) else {
     return
 }
-let bundle = try inputProvider.makeInputs(contentOf: catalogURL, options: BundleDiscoveryOptions())
+let inputs = try inputProvider.makeInputs(contentOf: catalogURL, options: CatalogDiscoveryOptions())
 
-print("A bundle with ID: \(bundle.identifier)")
+print("Documentation inputs with ID: \(inputs.identifier)")
 ```
 
 You can also create documentation inputs, without a documentation catalog, from a list of symbol graph files: 
@@ -22,41 +22,41 @@ You can also create documentation inputs, without a documentation catalog, from
 ```swift
 let inputProvider = DocumentationContext.InputsProvider(fileManager: fileSystem)
 
-guard let (bundle, dataProvider) = try inputProvider.makeInputsFromSymbolGraphs(
-    options: BundleDiscoveryOptions(
+guard let (inputs, dataProvider) = try inputProvider.makeInputsFromSymbolGraphs(
+    options: CatalogDiscoveryOptions(
         additionalSymbolGraphFiles: listOfSymbolGraphLocations
     )
 ) else {
     return
 }
 
-print("A bundle with ID: \(bundle.identifier)")
+print("Documentation inputs with ID: \(inputs.identifier)")
 ```
 
-> Note: use the returned `dataProvider` to create a ``DocumentationContext`` from this ``DocumentationBundle``. 
+> Note: use the returned `dataProvider` to create a ``DocumentationContext`` from this ``DocumentationContext/Inputs``. 
 
-It's common to want combine these two strategies and require that they discover a ``DocumentationBundle``. 
+It's common to want combine these two strategies and require that they discover a ``DocumentationContext/Inputs``. 
 For this use-case, use the
 ``DocumentationContext/InputsProvider/inputsAndDataProvider(startingPoint:allowArbitraryCatalogDirectories:options:)`` method:
 
 ```swift
 let inputProvider = DocumentationContext.InputsProvider(fileManager: fileSystem)
 
-let (bundle, dataProvider) = try inputProvider.inputsAndDataProvider(
+let (inputs, dataProvider) = try inputProvider.inputsAndDataProvider(
     startingPoint: maybeStartingPoint,
-    options: BundleDiscoveryOptions(
+    options: CatalogDiscoveryOptions(
         additionalSymbolGraphFiles: listOfSymbolGraphLocations
     )
 )
 
-print("A bundle with ID: \(bundle.identifier)")
+print("Documentation inputs with ID: \(inputs.identifier)")
 ```
 
-### Bundle Contents
+### Input files
 
-A ``DocumentationBundle`` represents the list of "discovered" input files--categorized by their kind--to use as documentation inputs.
+A ``DocumentationContext/Inputs`` represents the list of "discovered" input files--categorized by their kind--to use as documentation inputs.
 
-Use a ``DataProvider`` that the ``DocumentationContext/InputsProvider`` returned alongside the bundle to read the files in the bundle.
+Use a ``DataProvider`` that the ``DocumentationContext/InputsProvider`` returned alongside the inputs to its files.
 
 ## Topics
 
@@ -65,22 +65,22 @@ Use a ``DataProvider`` that the ``DocumentationContext/InputsProvider`` returned
 - ``DocumentationContext/InputsProvider``
 - ``DocumentationContext/InputsProvider/inputsAndDataProvider(startingPoint:allowArbitraryCatalogDirectories:options:)``
 
-### Documentation Bundle
+### Inputs
 
-- ``DocumentationBundle``
-- ``BundleIdentifier``
-- ``DocumentationBundleFileTypes``
+- ``DocumentationContext/Inputs``
+- ``DocumentationContext/Inputs/Identifier``
+- ``DocumentationInputFileTypes``
 
-### Bundle Assets
+### Assets
 
 - ``DataTraitCollection``
 - ``DataAsset``
 - ``BundleData``
 
-### Bundle Metadata
+### Inputs Metadata
 
 - ``ExternalMetadata``
 - ``DefaultAvailability``
 - ``PlatformVersion``
 
-<!-- Copyright (c) 2021-2024 Apple Inc and the Swift Project authors. All Rights Reserved. -->
+<!-- Copyright (c) 2021-2025 Apple Inc and the Swift Project authors. All Rights Reserved. -->
diff --git a/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/PersistingDocumentation.md b/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/PersistingDocumentation.md
index e08c6a54d6..603115b690 100644
--- a/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/PersistingDocumentation.md
+++ b/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/PersistingDocumentation.md
@@ -9,7 +9,7 @@ Once the in-memory documentation model is finalized each of its graph nodes can
 The ``DocumentationNodeConverter`` type converts documentation nodes to rendering nodes:
 
 ```swift
-let converter = DocumentationNodeConverter(bundle: myBundle, context: myContext)
+let converter = DocumentationNodeConverter(context: myContext)
 let renderNode = converter.convert(documentationNode)
 ```
 
@@ -38,4 +38,4 @@ The precise path inside the output folder where resulting JSON file is saved is
 - ``RenderNodeTransformationContext``
 - ``RenderNodeTransformer``
 
-<!-- Copyright (c) 2021-2024 Apple Inc and the Swift Project authors. All Rights Reserved. -->
+<!-- Copyright (c) 2021-2025 Apple Inc and the Swift Project authors. All Rights Reserved. -->
diff --git a/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/RenderingModel/RenderingModel.md b/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/RenderingModel/RenderingModel.md
index d9284d75e0..a899f82eb0 100644
--- a/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/RenderingModel/RenderingModel.md
+++ b/Sources/SwiftDocC/SwiftDocC.docc/SwiftDocC/RenderingModel/RenderingModel.md
@@ -8,7 +8,7 @@ A representation of the in-memory model's documentation nodes when compiled into
 
 A documentation node represents a single documentation topic and it might reference a variety of resources within the documentation context. Unlike a documentation node, a rendering node is a self-contained entity that includes any and all data necessary to display a single page of documentation.
 
-Hereto a rendering node contains data not only about a single specific topic (a tutorial, an article, or a framework symbol) but also data about its hierarchy in the documentation bundle, the titles and abstracts of any linked symbols, and any other metadata needed to display a single documentation page.
+Hereto a rendering node contains data not only about a single specific topic (a tutorial, an article, or a framework symbol) but also data about its hierarchy in the documentation, the titles and abstracts of any linked symbols, and any other metadata needed to display a single documentation page.
 
 ``RenderNodeTranslator`` is the type that converts a ``DocumentationNode`` into a ``RenderNode`` and ``PresentationURLGenerator`` is the one that automatically determines the location of the resulting rendering node within the compiled documentation.
 
@@ -74,4 +74,4 @@ Hereto a rendering node contains data not only about a single specific topic (a
 
 - ``SemanticVersion``
 
-<!-- Copyright (c) 2021 Apple Inc and the Swift Project authors. All Rights Reserved. -->
+<!-- Copyright (c) 2021-2025 Apple Inc and the Swift Project authors. All Rights Reserved. -->
diff --git a/Sources/SwiftDocC/Utility/FeatureFlags.swift b/Sources/SwiftDocC/Utility/FeatureFlags.swift
index def7e642d1..b3a90bb331 100644
--- a/Sources/SwiftDocC/Utility/FeatureFlags.swift
+++ b/Sources/SwiftDocC/Utility/FeatureFlags.swift
@@ -32,9 +32,9 @@ public struct FeatureFlags: Codable {
     /// Creates a set of feature flags with all default values.
     public init() {}
 
-    /// Set feature flags that were loaded from a bundle's Info.plist.
-    internal mutating func loadFlagsFromBundle(_ bundleFlags: DocumentationBundle.Info.BundleFeatureFlags) {
-        if let overloadsPresentation = bundleFlags.experimentalOverloadedSymbolPresentation {
+    /// Set feature flags that were loaded from an input files Info.plist.
+    internal mutating func loadFlagsFromInputs(_ inputFilesFlags: DocumentationContext.Inputs.Info.BundleFeatureFlags) {
+        if let overloadsPresentation = inputFilesFlags.experimentalOverloadedSymbolPresentation {
             self.isExperimentalOverloadedSymbolPresentationEnabled = overloadsPresentation
         }
     }
diff --git a/Sources/SwiftDocC/Utility/FoundationExtensions/Dictionary+TypedValues.swift b/Sources/SwiftDocC/Utility/FoundationExtensions/Dictionary+TypedValues.swift
index 6ca1858aca..34ff43d05c 100644
--- a/Sources/SwiftDocC/Utility/FoundationExtensions/Dictionary+TypedValues.swift
+++ b/Sources/SwiftDocC/Utility/FoundationExtensions/Dictionary+TypedValues.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -53,7 +53,7 @@ enum TypedValueError: DescribedError {
     /// The requested value is of the wrong type.
     case wrongType(key: String, expected: Any.Type, actual: Any.Type)
     /// One or more required ``DocumentationBundle.Info.Key``s are missing.
-    case missingRequiredKeys([DocumentationBundle.Info.CodingKeys])
+    case missingRequiredKeys([DocumentationContext.Inputs.Info.CodingKeys])
     
     var errorDescription: String {
         switch self {
diff --git a/Sources/SwiftDocCTestUtilities/FilesAndFolders.swift b/Sources/SwiftDocCTestUtilities/FilesAndFolders.swift
index 248dcdc9db..406366c281 100644
--- a/Sources/SwiftDocCTestUtilities/FilesAndFolders.swift
+++ b/Sources/SwiftDocCTestUtilities/FilesAndFolders.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -94,11 +94,17 @@ public struct InfoPlist: File, DataRepresentable {
     /// The information that the Into.plist file contains.
     public let content: Content
 
-    public init(displayName: String? = nil, identifier: String? = nil, defaultAvailability: [String: [DefaultAvailability.ModuleAvailability]]? = nil) {
+    public init(
+        displayName: String? = nil,
+        identifier: String? = nil,
+        defaultAvailability: [String: [DefaultAvailability.ModuleAvailability]]? = nil,
+        defaultCodeListingLanguage: String? = nil
+    ) {
         self.content = Content(
             displayName: displayName,
             identifier: identifier,
-            defaultAvailability: defaultAvailability
+            defaultAvailability: defaultAvailability,
+            defaultCodeListingLanguage: defaultCodeListingLanguage
         )
     }
 
@@ -106,25 +112,29 @@ public struct InfoPlist: File, DataRepresentable {
         public let displayName: String?
         public let identifier: String?
         public let defaultAvailability: [String: [DefaultAvailability.ModuleAvailability]]?
-
-        fileprivate init(displayName: String?, identifier: String?, defaultAvailability: [String: [DefaultAvailability.ModuleAvailability]]?) {
+        public let defaultCodeListingLanguage: String?
+        
+        fileprivate init(displayName: String?, identifier: String?, defaultAvailability: [String: [DefaultAvailability.ModuleAvailability]]?, defaultCodeListingLanguage: String?) {
             self.displayName = displayName
             self.identifier = identifier
             self.defaultAvailability = defaultAvailability
+            self.defaultCodeListingLanguage = defaultCodeListingLanguage
         }
 
         public init(from decoder: any Decoder) throws {
-            let container = try decoder.container(keyedBy: DocumentationBundle.Info.CodingKeys.self)
+            let container = try decoder.container(keyedBy: DocumentationContext.Inputs.Info.CodingKeys.self)
             displayName = try container.decodeIfPresent(String.self, forKey: .displayName)
             identifier = try container.decodeIfPresent(String.self, forKey: .id)
             defaultAvailability = try container.decodeIfPresent([String : [DefaultAvailability.ModuleAvailability]].self, forKey: .defaultAvailability)
+            defaultCodeListingLanguage = try container.decodeIfPresent(String.self, forKey: .defaultCodeListingLanguage)
         }
         
         public func encode(to encoder: any Encoder) throws {
-            var container = encoder.container(keyedBy: DocumentationBundle.Info.CodingKeys.self)
+            var container = encoder.container(keyedBy: DocumentationContext.Inputs.Info.CodingKeys.self)
             try container.encodeIfPresent(displayName, forKey: .displayName)
             try container.encodeIfPresent(identifier, forKey: .id)
             try container.encodeIfPresent(defaultAvailability, forKey: .defaultAvailability)
+            try container.encodeIfPresent(defaultCodeListingLanguage, forKey: .defaultCodeListingLanguage)
         }
     }
 
diff --git a/Sources/SwiftDocCUtilities/Action/Actions/Convert/ConvertAction.swift b/Sources/SwiftDocCUtilities/Action/Actions/Convert/ConvertAction.swift
index 6f0af6647c..f64f01196e 100644
--- a/Sources/SwiftDocCUtilities/Action/Actions/Convert/ConvertAction.swift
+++ b/Sources/SwiftDocCUtilities/Action/Actions/Convert/ConvertAction.swift
@@ -81,7 +81,7 @@ public struct ConvertAction: AsyncAction {
         fileManager: any FileManagerProtocol = FileManager.default,
         temporaryDirectory: URL,
         documentationCoverageOptions: DocumentationCoverageOptions = .noCoverage,
-        bundleDiscoveryOptions: BundleDiscoveryOptions = .init(),
+        bundleDiscoveryOptions: CatalogDiscoveryOptions = .init(),
         diagnosticLevel: String? = nil,
         diagnosticEngine: DiagnosticEngine? = nil,
         diagnosticFilePath: URL? = nil,
@@ -167,7 +167,7 @@ public struct ConvertAction: AsyncAction {
         }
         configuration.externalDocumentationConfiguration.dependencyArchives = dependencies
         
-        let (bundle, dataProvider) = try signposter.withIntervalSignpost("Discover inputs", id: signposter.makeSignpostID()) {
+        let (inputs, dataProvider) = try signposter.withIntervalSignpost("Discover inputs", id: signposter.makeSignpostID()) {
             try DocumentationContext.InputsProvider(fileManager: fileManager)
             .inputsAndDataProvider(
                 startingPoint: documentationBundleURL,
@@ -178,12 +178,12 @@ public struct ConvertAction: AsyncAction {
 
         self.configuration = configuration
         
-        self.bundle = bundle
+        self.inputs = inputs
         self.dataProvider = dataProvider
     }
     
     let configuration: DocumentationContext.Configuration
-    private let bundle: DocumentationBundle
+    private let inputs: DocumentationContext.Inputs
     private let dataProvider: any DataProvider
     
     /// A block of extra work that tests perform to affect the time it takes to convert documentation
@@ -286,10 +286,10 @@ public struct ConvertAction: AsyncAction {
             workingDirectory: temporaryFolder,
             fileManager: fileManager)
 
-        let indexer = try Indexer(outputURL: temporaryFolder, bundleID: bundle.id)
+        let indexer = try Indexer(outputURL: temporaryFolder, bundleID: inputs.id)
 
         let registerInterval = signposter.beginInterval("Register", id: signposter.makeSignpostID())
-        let context = try await DocumentationContext(bundle: bundle, dataProvider: dataProvider, diagnosticEngine: diagnosticEngine, configuration: configuration)
+        let context = try await DocumentationContext(inputs: inputs, dataProvider: dataProvider, diagnosticEngine: diagnosticEngine, configuration: configuration)
         signposter.endInterval("Register", registerInterval)
         
         let outputConsumer = ConvertFileWritingConsumer(
@@ -300,7 +300,7 @@ public struct ConvertAction: AsyncAction {
             indexer: indexer,
             enableCustomTemplates: experimentalEnableCustomTemplates,
             transformForStaticHostingIndexHTML: transformForStaticHosting ? indexHTML : nil,
-            bundleID: bundle.id
+            bundleID: inputs.id
         )
 
         if experimentalModifyCatalogWithGeneratedCuration, let catalogURL = rootURL {
@@ -318,7 +318,6 @@ public struct ConvertAction: AsyncAction {
         do {
             conversionProblems = try signposter.withIntervalSignpost("Process") {
                 try ConvertActionConverter.convert(
-                    bundle: bundle,
                     context: context,
                     outputConsumer: outputConsumer,
                     sourceRepository: sourceRepository,
@@ -347,7 +346,7 @@ public struct ConvertAction: AsyncAction {
             let tableOfContentsFilename = CatalogTemplateKind.tutorialTopLevelFilename
             let source = rootURL?.appendingPathComponent(tableOfContentsFilename)
             var replacements = [Replacement]()
-            if let tableOfContentsTemplate = CatalogTemplateKind.tutorialTemplateFiles(bundle.displayName)[tableOfContentsFilename] {
+            if let tableOfContentsTemplate = CatalogTemplateKind.tutorialTemplateFiles(inputs.displayName)[tableOfContentsFilename] {
                 replacements.append(
                     Replacement(
                         range: .init(line: 1, column: 1, source: source) ..< .init(line: 1, column: 1, source: source),
@@ -438,7 +437,7 @@ public struct ConvertAction: AsyncAction {
                 context: context,
                 indexer: nil,
                 transformForStaticHostingIndexHTML: nil,
-                bundleID: bundle.id
+                bundleID: inputs.id
             )
 
             try outputConsumer.consume(benchmarks: Benchmark.main)
diff --git a/Sources/SwiftDocCUtilities/Action/Actions/Convert/ConvertFileWritingConsumer.swift b/Sources/SwiftDocCUtilities/Action/Actions/Convert/ConvertFileWritingConsumer.swift
index 56e4925851..9133d48424 100644
--- a/Sources/SwiftDocCUtilities/Action/Actions/Convert/ConvertFileWritingConsumer.swift
+++ b/Sources/SwiftDocCUtilities/Action/Actions/Convert/ConvertFileWritingConsumer.swift
@@ -34,7 +34,7 @@ struct ConvertFileWritingConsumer: ConvertOutputConsumer, ExternalNodeConsumer {
         indexer: ConvertAction.Indexer?,
         enableCustomTemplates: Bool = false,
         transformForStaticHostingIndexHTML: URL?,
-        bundleID: DocumentationBundle.Identifier?
+        bundleID: DocumentationContext.Inputs.Identifier?
     ) {
         self.targetFolder = targetFolder
         self.bundleRootFolder = bundleRootFolder
@@ -73,7 +73,7 @@ struct ConvertFileWritingConsumer: ConvertOutputConsumer, ExternalNodeConsumer {
         indexer?.index(externalRenderNode)
     }
     
-    func consume(assetsInBundle bundle: DocumentationBundle) throws {
+    func consume(assetsInInputs inputs: DocumentationContext.Inputs) throws {
         func copyAsset(_ asset: DataAsset, to destinationFolder: URL) throws {
             for sourceURL in asset.variants.values where !sourceURL.isAbsoluteWebURL {
                 let assetName = sourceURL.lastPathComponent
@@ -84,7 +84,7 @@ struct ConvertFileWritingConsumer: ConvertOutputConsumer, ExternalNodeConsumer {
             }
         }
 
-        let bundleID = bundle.id
+        let bundleID = inputs.id
         assert(bundleID.rawValue == self.assetPrefixComponent, "Unexpectedly encoding assets for a bundle other than the one this output consumer was created for.")
         
         // Create images directory if needed.
@@ -129,21 +129,21 @@ struct ConvertFileWritingConsumer: ConvertOutputConsumer, ExternalNodeConsumer {
         // If the bundle contains a `header.html` file, inject a <template> into
         // the `index.html` file using its contents. This will only be done if
         // the --experimental-enable-custom-templates flag is given
-        if let customHeader = bundle.customHeader, enableCustomTemplates {
+        if let customHeader = inputs.customHeader, enableCustomTemplates {
             try injectCustomTemplate(customHeader, identifiedBy: .header)
         }
 
         // If the bundle contains a `footer.html` file, inject a <template> into
         // the `index.html` file using its contents. This will only be done if
         // the --experimental-enable-custom-templates flag is given
-        if let customFooter = bundle.customFooter, enableCustomTemplates {
+        if let customFooter = inputs.customFooter, enableCustomTemplates {
             try injectCustomTemplate(customFooter, identifiedBy: .footer)
         }
 
         // Copy the `theme-settings.json` file into the output directory if one
         // is provided. It will override any default `theme-settings.json` file
         // that the renderer template may already contain.
-        if let themeSettings = bundle.themeSettings {
+        if let themeSettings = inputs.themeSettings {
             let targetFile = targetFolder.appendingPathComponent(themeSettings.lastPathComponent, isDirectory: false)
             if fileManager.fileExists(atPath: targetFile.path) {
                 try fileManager.removeItem(at: targetFile)
diff --git a/Sources/SwiftDocCUtilities/Action/Actions/Convert/Indexer.swift b/Sources/SwiftDocCUtilities/Action/Actions/Convert/Indexer.swift
index 5a721a8e45..250bf81d3b 100644
--- a/Sources/SwiftDocCUtilities/Action/Actions/Convert/Indexer.swift
+++ b/Sources/SwiftDocCUtilities/Action/Actions/Convert/Indexer.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -33,7 +33,7 @@ extension ConvertAction {
         /// - Parameters:
         ///   - outputURL: The target directory to create the index file.
         ///   - bundleID: The identifier of the bundle being indexed.
-        init(outputURL: URL, bundleID: DocumentationBundle.Identifier) throws {
+        init(outputURL: URL, bundleID: DocumentationContext.Inputs.Identifier) throws {
             let indexURL = outputURL.appendingPathComponent("index", isDirectory: true)
             indexBuilder = Synchronized<NavigatorIndex.Builder>(
                 NavigatorIndex.Builder(
diff --git a/Sources/SwiftDocCUtilities/Action/Actions/EmitGeneratedCurationAction.swift b/Sources/SwiftDocCUtilities/Action/Actions/EmitGeneratedCurationAction.swift
index 5678ccc081..7aa2bea825 100644
--- a/Sources/SwiftDocCUtilities/Action/Actions/EmitGeneratedCurationAction.swift
+++ b/Sources/SwiftDocCUtilities/Action/Actions/EmitGeneratedCurationAction.swift
@@ -45,12 +45,12 @@ struct EmitGeneratedCurationAction: AsyncAction {
         let inputProvider = DocumentationContext.InputsProvider(fileManager: fileManager)
         let (bundle, dataProvider) = try inputProvider.inputsAndDataProvider(
             startingPoint: catalogURL,
-            options: BundleDiscoveryOptions(
+            options: CatalogDiscoveryOptions(
                 infoPlistFallbacks: [:],
                 additionalSymbolGraphFiles: symbolGraphFiles(in: additionalSymbolGraphDirectory)
             )
         )
-        let context = try await DocumentationContext(bundle: bundle, dataProvider: dataProvider)
+        let context = try await DocumentationContext(inputs: bundle, dataProvider: dataProvider)
 
         let writer = GeneratedCurationWriter(context: context, catalogURL: catalogURL, outputURL: outputURL)
         let curation = try writer.generateDefaultCurationContents(fromSymbol: startingPointSymbolLink, depthLimit: depthLimit)
@@ -69,5 +69,5 @@ private func symbolGraphFiles(in directory: URL?) -> [URL] {
     
     let subpaths = FileManager.default.subpaths(atPath: directory.path) ?? []
     return subpaths.map { directory.appendingPathComponent($0) }
-        .filter { DocumentationBundleFileTypes.isSymbolGraphFile($0) }
+        .filter { DocumentationInputFileTypes.isSymbolGraphFile($0) }
 }
diff --git a/Sources/SwiftDocCUtilities/ArgumentParsing/ActionExtensions/ConvertAction+CommandInitialization.swift b/Sources/SwiftDocCUtilities/ArgumentParsing/ActionExtensions/ConvertAction+CommandInitialization.swift
index e8c8a31b45..c6af62ec06 100644
--- a/Sources/SwiftDocCUtilities/ArgumentParsing/ActionExtensions/ConvertAction+CommandInitialization.swift
+++ b/Sources/SwiftDocCUtilities/ArgumentParsing/ActionExtensions/ConvertAction+CommandInitialization.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -87,10 +87,10 @@ extension ConvertAction {
 }
 
 package extension Docc.Convert {
-    var bundleDiscoveryOptions: BundleDiscoveryOptions {
+    var bundleDiscoveryOptions: CatalogDiscoveryOptions {
         let additionalSymbolGraphFiles = symbolGraphFiles(in: additionalSymbolGraphDirectory)
         
-        return BundleDiscoveryOptions(
+        return CatalogDiscoveryOptions(
             fallbackDisplayName: fallbackBundleDisplayName,
             fallbackIdentifier: fallbackBundleIdentifier,
             fallbackDefaultCodeListingLanguage: defaultCodeListingLanguage,
@@ -105,5 +105,5 @@ private func symbolGraphFiles(in directory: URL?) -> [URL] {
     
     let subpaths = FileManager.default.subpaths(atPath: directory.path) ?? []
     return subpaths.map { directory.appendingPathComponent($0) }
-        .filter { DocumentationBundleFileTypes.isSymbolGraphFile($0) }
+        .filter { DocumentationInputFileTypes.isSymbolGraphFile($0) }
 }
diff --git a/Sources/SwiftDocCUtilities/SwiftDocCUtilities.docc/SwiftDocCUtilities.md b/Sources/SwiftDocCUtilities/SwiftDocCUtilities.docc/SwiftDocCUtilities.md
index 0e3a8b4f47..c2c45cc416 100644
--- a/Sources/SwiftDocCUtilities/SwiftDocCUtilities.docc/SwiftDocCUtilities.md
+++ b/Sources/SwiftDocCUtilities/SwiftDocCUtilities.docc/SwiftDocCUtilities.md
@@ -38,7 +38,6 @@ Adding a new sub-command automatically adds routing and execution of its code, a
 ### Actions Design
 - ``Action``
 - ``ActionResult``
-- ``RecreatingContext``
 
 ### Execution Workflow
 - ``Throttle``
diff --git a/Sources/SwiftDocCUtilities/SwiftDocCUtilities.docc/SwiftDocCUtilities/Extensions/Docc.md b/Sources/SwiftDocCUtilities/SwiftDocCUtilities.docc/SwiftDocCUtilities/Extensions/Docc.md
index f7e904530e..4e5991a2d5 100644
--- a/Sources/SwiftDocCUtilities/SwiftDocCUtilities.docc/SwiftDocCUtilities/Extensions/Docc.md
+++ b/Sources/SwiftDocCUtilities/SwiftDocCUtilities.docc/SwiftDocCUtilities/Extensions/Docc.md
@@ -9,7 +9,7 @@
 ### Command Line Options
 
 - ``DocCArchiveOption``
-- ``DocumentationBundleOption``
+- ``DocumentationCatalogOption``
 - ``OutOfProcessLinkResolverOption``
 - ``TemplateOption``
 
diff --git a/Sources/docc/DocCDocumentation.docc/DocC.symbols.json b/Sources/docc/DocCDocumentation.docc/DocC.symbols.json
index 71145763e5..f19ff0436a 100644
--- a/Sources/docc/DocCDocumentation.docc/DocC.symbols.json
+++ b/Sources/docc/DocCDocumentation.docc/DocC.symbols.json
@@ -1340,7 +1340,7 @@
             "text" : "     **(optional)**"
           },
           {
-            "text" : "  - file: The location of the associated link, as a reference to a file in this documentation bundle."
+            "text" : "  - file: The location of the associated link, as a reference to a file in this documentation catalog."
           },
           {
             "text" : "     **(optional)**"
diff --git a/Sources/docc/DocCDocumentation.docc/Reference Syntax/Tutorials Syntax/building-an-interactive-tutorial.md b/Sources/docc/DocCDocumentation.docc/Reference Syntax/Tutorials Syntax/building-an-interactive-tutorial.md
index 0dca7877a1..6c01d90f4d 100644
--- a/Sources/docc/DocCDocumentation.docc/Reference Syntax/Tutorials Syntax/building-an-interactive-tutorial.md	
+++ b/Sources/docc/DocCDocumentation.docc/Reference Syntax/Tutorials Syntax/building-an-interactive-tutorial.md	
@@ -168,7 +168,7 @@ Add any images and videos that you reference throughout your tutorial to the Res
 To view your tutorial, invoke the following command to compile it:
 
 ```
-docc preview MyPackage.docc --fallback-display-name MyPackage --fallback-bundle-identifier com.example.MyPackage --fallback-bundle-version 1
+docc preview MyPackage.docc
 ```
 
 DocC compiles your documentation catalog and generates the tutorial. Copy the URL from the terminal and paste it into your browser to view the tutorial.
diff --git a/Sources/docc/DocCDocumentation.docc/customizing-the-appearance-of-your-documentation-pages.md b/Sources/docc/DocCDocumentation.docc/customizing-the-appearance-of-your-documentation-pages.md
index 844a7e9250..9542099fe1 100644
--- a/Sources/docc/DocCDocumentation.docc/customizing-the-appearance-of-your-documentation-pages.md
+++ b/Sources/docc/DocCDocumentation.docc/customizing-the-appearance-of-your-documentation-pages.md
@@ -80,7 +80,7 @@ of a green hue.
 As a general rule, the default color properties provided by DocC assumes a
 naming convention where "fill" colors are used for backgrounds and "figure"
 colors are used for foreground colors, like text. Note that colors defined in 
-`theme-settings.json` will be used across all pages of your documentation bundle.
+`theme-settings.json` will be used across all pages of your documentation.
 
 > Tip:
 > For a more complete example of a fully customized documentation website, you
@@ -255,4 +255,4 @@ Most notably:
 [3]: https://mportiz08.github.io/swift-docc/documentation/docc
 [4]: https://mportiz08.github.io/swift-docc/theme-settings.json
 
-<!-- Copyright (c) 2022 Apple Inc and the Swift Project authors. All Rights Reserved. -->
+<!-- Copyright (c) 2022-2025 Apple Inc and the Swift Project authors. All Rights Reserved. -->
diff --git a/Sources/docc/DocCDocumentation.docc/distributing-documentation-to-other-developers.md b/Sources/docc/DocCDocumentation.docc/distributing-documentation-to-other-developers.md
index c26f2b3ad7..2f3068c148 100644
--- a/Sources/docc/DocCDocumentation.docc/distributing-documentation-to-other-developers.md
+++ b/Sources/docc/DocCDocumentation.docc/distributing-documentation-to-other-developers.md
@@ -10,8 +10,7 @@ you only have documentation comments in your source files, or you craft a full
 learning experience that includes articles and tutorials, you can easily share the documentation in your code base with other
 developers.
 
-To share your documentation, you create a documentation archive, a
-self-contained bundle that has everything you need, including:
+To share your documentation, you create a documentation archive, a self-contained output artifact that has everything you need, including:
 
 - Compiled documentation from in-source comments, articles, tutorials, and
   resources
@@ -32,9 +31,6 @@ Alternatively, use the `docc` command-line tool directly, for example:
 
 ```shell 
 docc convert MyNewPackage.docc \
-  --fallback-display-name MyNewPackage \
-  --fallback-bundle-identifier com.example.MyNewPackage \
-  --fallback-bundle-version 1 \
   --additional-symbol-graph-dir .build \
   --output-dir MyNewPackage.doccarchive
 ```
@@ -89,19 +85,16 @@ setting when building in Xcode.
 
 ### Send a Documentation Archive Directly to Developers
 
-Because a documentation archive is a self-contained bundle, you can easily
-share it with other developers. For example, you can send it by email just like
-a regular document, include it with a binary distribution of your framework or
-package, or make it downloadable from a website.
+Because a documentation archive is self-contained, you can easily share it with other developers. 
+For example, you can send it by email just like a regular document, include it with a binary distribution of your framework or package, or make it downloadable from a website.
 
 To remove an imported documentation archive, place your pointer over the item
 to display the More button, and then choose Remove.
 
 ### Host a Documentation Archive on Your Website
 
-When DocC exports a documentation archive, it includes a single-page web app
-in the bundle. This web app renders the documentation content as HTML, letting
-you host the documentation archive on a web server.
+When DocC exports a documentation archive, it includes a single-page web app in the output. 
+This web app renders the documentation content as HTML, letting you host the documentation archive on a web server.
 
 For reference documentation and articles, the web app uses a URL path that
 begins with `/documentation`. For tutorials, the URL path begins with
@@ -163,7 +156,7 @@ To host a documentation archive on your website, do the following:
    `MyNewPackage.doccarchive`.
 2. Add a rule on the server to rewrite incoming URLs that begin with
    `/documentation` or `/tutorial` to `MyNewPackage.doccarchive/index.html`.
-3. Add another rule for incoming requests to support bundled resources in the
+3. Add another rule for incoming requests to support the resources in the
    documentation archive, such as CSS files and image assets.
 
 The following example `.htaccess` file defines rules suitable for use with Apache:
@@ -193,4 +186,4 @@ to date by using a continuous integration workflow that builds the
 documentation archive using `docc`, and copies the resulting
 `.doccarchive` to your web server.
 
-<!-- Copyright (c) 2021-2023 Apple Inc and the Swift Project authors. All Rights Reserved. -->
+<!-- Copyright (c) 2021-2025 Apple Inc and the Swift Project authors. All Rights Reserved. -->
diff --git a/Tests/SwiftDocCTests/Benchmark/ExternalTopicsHashTests.swift b/Tests/SwiftDocCTests/Benchmark/ExternalTopicsHashTests.swift
index 4e87138288..e143365a07 100644
--- a/Tests/SwiftDocCTests/Benchmark/ExternalTopicsHashTests.swift
+++ b/Tests/SwiftDocCTests/Benchmark/ExternalTopicsHashTests.swift
@@ -40,7 +40,7 @@ class ExternalTopicsGraphHashTests: XCTestCase {
     
     func testNoMetricAddedIfNoExternalTopicsAreResolved() async throws {
         // Load bundle without using external resolvers
-        let (_, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         XCTAssertTrue(context.externallyResolvedLinks.isEmpty)
         
         // Try adding external topics metrics
@@ -56,7 +56,7 @@ class ExternalTopicsGraphHashTests: XCTestCase {
         
         // Add external links and verify the checksum is always the same
         func computeTopicHash(file: StaticString = #filePath, line: UInt = #line) async throws -> String {
-            let (_, _, context) = try await self.testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [externalResolver.bundleID: externalResolver]) { url in
+            let (_, context) = try await self.loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [externalResolver.bundleID: externalResolver]) { url in
             try """
             # ``SideKit/SideClass``
 
@@ -92,7 +92,7 @@ class ExternalTopicsGraphHashTests: XCTestCase {
         
         // Add external links and verify the checksum is always the same
         func computeTopicHash(file: StaticString = #filePath, line: UInt = #line) async throws -> String {
-            let (_, _, context) = try await self.testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [externalResolver.bundleID: externalResolver], externalSymbolResolver: self.externalSymbolResolver) { url in
+            let (_, context) = try await self.loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [externalResolver.bundleID: externalResolver], externalSymbolResolver: self.externalSymbolResolver) { url in
             try """
             # ``SideKit/SideClass``
 
@@ -128,7 +128,7 @@ class ExternalTopicsGraphHashTests: XCTestCase {
         let externalResolver = self.externalResolver
 
         // Load a bundle with external links
-        let (_, _, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [externalResolver.bundleID: externalResolver]) { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [externalResolver.bundleID: externalResolver]) { url in
         try """
         # ``SideKit/SideClass``
 
diff --git a/Tests/SwiftDocCTests/Benchmark/TopicAnchorHashTests.swift b/Tests/SwiftDocCTests/Benchmark/TopicAnchorHashTests.swift
index 72f714b752..5109f991b1 100644
--- a/Tests/SwiftDocCTests/Benchmark/TopicAnchorHashTests.swift
+++ b/Tests/SwiftDocCTests/Benchmark/TopicAnchorHashTests.swift
@@ -14,7 +14,7 @@ import XCTest
 class TopicAnchorHashTests: XCTestCase {
     func testAnchorSectionsHash() async throws {
         func computeTopicHash(file: StaticString = #filePath, line: UInt = #line) async throws -> String {
-            let (_, context) = try await self.testBundleAndContext(named: "BundleWithLonelyDeprecationDirective")
+            let (_, context) = try await self.loadFromDisk(catalogName: "BundleWithLonelyDeprecationDirective")
             let testBenchmark = Benchmark()
             benchmark(add: Benchmark.TopicAnchorHash(context: context), benchmarkLog: testBenchmark)
             
@@ -33,7 +33,7 @@ class TopicAnchorHashTests: XCTestCase {
     func testTopicAnchorsChangedHash() async throws {
         // Verify that the hash changes if we change the topic graph
         let initialHash: String
-        let (_, context) = try await testBundleAndContext(named: "BundleWithLonelyDeprecationDirective")
+        let context = try await loadFromDisk(catalogName: "BundleWithLonelyDeprecationDirective")
         
         do {
             let testBenchmark = Benchmark()
diff --git a/Tests/SwiftDocCTests/Benchmark/TopicGraphHashTests.swift b/Tests/SwiftDocCTests/Benchmark/TopicGraphHashTests.swift
index 4204122882..c74e5ba5cc 100644
--- a/Tests/SwiftDocCTests/Benchmark/TopicGraphHashTests.swift
+++ b/Tests/SwiftDocCTests/Benchmark/TopicGraphHashTests.swift
@@ -14,7 +14,7 @@ import XCTest
 class TopicGraphHashTests: XCTestCase {
     func testTopicGraphSameHash() async throws {
         func computeTopicHash(file: StaticString = #filePath, line: UInt = #line) async throws -> String {
-            let (_, context) = try await self.testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+            let (_, context) = try await self.loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
             let testBenchmark = Benchmark()
             benchmark(add: Benchmark.TopicGraphHash(context: context), benchmarkLog: testBenchmark)
             
@@ -33,7 +33,7 @@ class TopicGraphHashTests: XCTestCase {
     func testTopicGraphChangedHash() async throws {
         // Verify that the hash changes if we change the topic graph
         let initialHash: String
-        let (_, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         
         do {
             let testBenchmark = Benchmark()
@@ -89,7 +89,7 @@ class TopicGraphHashTests: XCTestCase {
             "/externally/resolved/path/to/article2": .success(.init(referencePath: "/externally/resolved/path/to/article2")),
         ]
         
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [
             "com.external.testbundle" : resolver
         ]) { url in
             // Add external links to the MyKit Topics.
@@ -106,7 +106,7 @@ class TopicGraphHashTests: XCTestCase {
         }
         
         // Get MyKit symbol
-        let entity = try context.entity(with: .init(bundleID: bundle.id, path: "/documentation/MyKit", sourceLanguage: .swift))
+        let entity = try context.entity(with: .init(bundleID: context.inputs.id, path: "/documentation/MyKit", sourceLanguage: .swift))
         let taskGroupLinks = try XCTUnwrap((entity.semantic as? Symbol)?.topics?.taskGroups.first?.links.compactMap({ $0.destination }))
         
         // Verify the task group links have been resolved and are still present in the link list.
@@ -118,7 +118,7 @@ class TopicGraphHashTests: XCTestCase {
         ])
         
         // Verify correct hierarchy under `MyKit` in the topic graph dump including external symbols.
-        let myKitRef = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit", sourceLanguage: .swift)
+        let myKitRef = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit", sourceLanguage: .swift)
         let myKitNode = try XCTUnwrap(context.topicGraph.nodeWithReference(myKitRef))
         
         let expectedHierarchyWithExternalSymbols = """
diff --git a/Tests/SwiftDocCTests/Catalog Processing/GeneratedCurationWriterTests.swift b/Tests/SwiftDocCTests/Catalog Processing/GeneratedCurationWriterTests.swift
index a158e95440..c35451a170 100644
--- a/Tests/SwiftDocCTests/Catalog Processing/GeneratedCurationWriterTests.swift	
+++ b/Tests/SwiftDocCTests/Catalog Processing/GeneratedCurationWriterTests.swift	
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2023-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2023-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -15,7 +15,7 @@ class GeneratedCurationWriterTests: XCTestCase {
     private let testOutputURL = URL(fileURLWithPath: "/unit-test/output-dir") // Nothing is written to this path in this test
     
     func testWriteTopLevelSymbolCuration() async throws {
-        let (url, _, context) = try await testBundleAndContext(named: "MixedLanguageFrameworkWithLanguageRefinements")
+        let (url, context) = try await loadFromDisk(catalogName: "MixedLanguageFrameworkWithLanguageRefinements")
         
         let writer = try XCTUnwrap(GeneratedCurationWriter(context: context, catalogURL: url, outputURL: testOutputURL))
         let contentsToWrite = try writer.generateDefaultCurationContents(depthLimit: 0)
@@ -111,7 +111,7 @@ class GeneratedCurationWriterTests: XCTestCase {
     }
     
     func testWriteSymbolCurationFromTopLevelSymbol() async throws {
-        let (url, _, context) = try await testBundleAndContext(named: "MixedLanguageFrameworkWithLanguageRefinements")
+        let (url, context) = try await loadFromDisk(catalogName: "MixedLanguageFrameworkWithLanguageRefinements")
         
         let writer = try XCTUnwrap(GeneratedCurationWriter(context: context, catalogURL: url, outputURL: testOutputURL))
         
@@ -142,7 +142,7 @@ class GeneratedCurationWriterTests: XCTestCase {
     }
     
     func testWriteSymbolCurationWithLimitedDepth() async throws {
-        let (url, _, context) = try await testBundleAndContext(named: "BundleWithSameNameForSymbolAndContainer")
+        let (url, context) = try await loadFromDisk(catalogName: "BundleWithSameNameForSymbolAndContainer")
         
         let writer = try XCTUnwrap(GeneratedCurationWriter(context: context, catalogURL: url, outputURL: testOutputURL))
         let depthLevelsToTest = [nil, 0, 1, 2, 3, 4, 5]
@@ -253,7 +253,7 @@ class GeneratedCurationWriterTests: XCTestCase {
     }
     
     func testSkipsManuallyCuratedPages() async throws {
-        let (url, _, context) = try await testBundleAndContext(named: "MixedManualAutomaticCuration")
+        let (url, context) = try await loadFromDisk(catalogName: "MixedManualAutomaticCuration")
         
         let writer = try XCTUnwrap(GeneratedCurationWriter(context: context, catalogURL: url, outputURL: testOutputURL))
         let contentsToWrite = try writer.generateDefaultCurationContents()
@@ -283,7 +283,7 @@ class GeneratedCurationWriterTests: XCTestCase {
     }
     
     func testAddsCommentForDisambiguatedLinks() async throws {
-        let (url, _, context) = try await testBundleAndContext(named: "OverloadedSymbols")
+        let (url, context) = try await loadFromDisk(catalogName: "OverloadedSymbols")
         
         let writer = try XCTUnwrap(GeneratedCurationWriter(context: context, catalogURL: url, outputURL: testOutputURL))
         let contentsToWrite = try writer.generateDefaultCurationContents(fromSymbol: "OverloadedProtocol")
@@ -309,7 +309,7 @@ class GeneratedCurationWriterTests: XCTestCase {
     }
     
     func testLinksSupportNonPathCharacters() async throws {
-        let (url, _, context) = try await testBundleAndContext(named: "InheritedOperators")
+        let (url, context) = try await loadFromDisk(catalogName: "InheritedOperators")
         
         let writer = try XCTUnwrap(GeneratedCurationWriter(context: context, catalogURL: url, outputURL: testOutputURL))
         let contentsToWrite = try writer.generateDefaultCurationContents(fromSymbol: "MyNumber")
@@ -347,7 +347,7 @@ class GeneratedCurationWriterTests: XCTestCase {
     }
     
     func testGeneratingLanguageSpecificCuration() async throws {
-        let (url, _, context) = try await testBundleAndContext(named: "GeometricalShapes")
+        let (url, context) = try await loadFromDisk(catalogName: "GeometricalShapes")
         
         let writer = try XCTUnwrap(GeneratedCurationWriter(context: context, catalogURL: url, outputURL: testOutputURL))
         let contentsToWrite = try writer.generateDefaultCurationContents()
@@ -440,7 +440,7 @@ class GeneratedCurationWriterTests: XCTestCase {
     
     
     func testCustomOutputLocation() async throws {
-        let (url, _, context) = try await testBundleAndContext(named: "MixedLanguageFrameworkWithLanguageRefinements")
+        let (url, context) = try await loadFromDisk(catalogName: "MixedLanguageFrameworkWithLanguageRefinements")
         
         let writer = try XCTUnwrap(GeneratedCurationWriter(context: context, catalogURL: url, outputURL: testOutputURL))
         let contentsToWrite = try writer.generateDefaultCurationContents()
diff --git a/Tests/SwiftDocCTests/Checker/Checkers/NonInclusiveLanguageCheckerTests.swift b/Tests/SwiftDocCTests/Checker/Checkers/NonInclusiveLanguageCheckerTests.swift
index 2dd37d3c3e..6413d8160a 100644
--- a/Tests/SwiftDocCTests/Checker/Checkers/NonInclusiveLanguageCheckerTests.swift
+++ b/Tests/SwiftDocCTests/Checker/Checkers/NonInclusiveLanguageCheckerTests.swift
@@ -182,7 +182,7 @@ func aBlackListedFunc() {
         let catalog = Folder(name: "unit-test.docc", content: [
             TextFile(name: "Root.md", utf8Content: nonInclusiveContent)
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         XCTAssertEqual(context.problems.count, 0) // Non-inclusive content is an info-level diagnostic, so it's filtered out.
     }
@@ -203,7 +203,7 @@ func aBlackListedFunc() {
             ])
             var configuration = DocumentationContext.Configuration()
             configuration.externalMetadata.diagnosticLevel = severity
-            let (_, context) = try await loadBundle(catalog: catalog, diagnosticEngine: .init(filterLevel: severity), configuration: configuration)
+            let context = try await load(catalog: catalog, diagnosticEngine: .init(filterLevel: severity), configuration: configuration)
             
             // Verify that checker diagnostics were emitted or not, depending on the diagnostic level set.
             XCTAssertEqual(context.problems.contains(where: { $0.diagnostic.identifier == "org.swift.docc.NonInclusiveLanguage" }), enabled)
diff --git a/Tests/SwiftDocCTests/Converter/DocumentationContextConverterTests.swift b/Tests/SwiftDocCTests/Converter/DocumentationContextConverterTests.swift
index 381720b5b2..3ac409320f 100644
--- a/Tests/SwiftDocCTests/Converter/DocumentationContextConverterTests.swift
+++ b/Tests/SwiftDocCTests/Converter/DocumentationContextConverterTests.swift
@@ -14,14 +14,14 @@ import XCTest
 
 class DocumentationContextConverterTests: XCTestCase {
     func testRenderNodesAreIdentical() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         
         // We'll use this to convert nodes ad-hoc
-        let perNodeConverter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let perNodeConverter = DocumentationNodeConverter(context: context)
         
         // We'll use these to convert nodes in bulk
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
-        let bulkNodeConverter = DocumentationContextConverter(bundle: bundle, context: context, renderContext: renderContext)
+        let renderContext = RenderContext(documentationContext: context)
+        let bulkNodeConverter = DocumentationContextConverter(context: context, renderContext: renderContext)
         let encoder = JSONEncoder()
         
         for identifier in context.knownPages {
@@ -41,8 +41,8 @@ class DocumentationContextConverterTests: XCTestCase {
     }
     
     func testSymbolLocationsAreOnlyIncludedWhenRequested() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let renderContext = RenderContext(documentationContext: context)
         
         let fillIntroducedSymbolNode = try XCTUnwrap(
             context.documentationCache["s:14FillIntroduced19macOSOnlyDeprecatedyyF"]
@@ -50,7 +50,6 @@ class DocumentationContextConverterTests: XCTestCase {
         
         do {
             let documentationContextConverter = DocumentationContextConverter(
-                bundle: bundle,
                 context: context,
                 renderContext: renderContext,
                 emitSymbolSourceFileURIs: true)
@@ -61,7 +60,6 @@ class DocumentationContextConverterTests: XCTestCase {
         
         do {
             let documentationContextConverter = DocumentationContextConverter(
-                bundle: bundle,
                 context: context,
                 renderContext: renderContext)
             
@@ -71,8 +69,8 @@ class DocumentationContextConverterTests: XCTestCase {
     }
     
     func testSymbolAccessLevelsAreOnlyIncludedWhenRequested() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let renderContext = RenderContext(documentationContext: context)
         
         let fillIntroducedSymbolNode = try XCTUnwrap(
             context.documentationCache["s:14FillIntroduced19macOSOnlyDeprecatedyyF"]
@@ -80,7 +78,6 @@ class DocumentationContextConverterTests: XCTestCase {
         
         do {
             let documentationContextConverter = DocumentationContextConverter(
-                bundle: bundle,
                 context: context,
                 renderContext: renderContext,
                 emitSymbolAccessLevels: true
@@ -92,7 +89,6 @@ class DocumentationContextConverterTests: XCTestCase {
         
         do {
             let documentationContextConverter = DocumentationContextConverter(
-                bundle: bundle,
                 context: context,
                 renderContext: renderContext)
             
diff --git a/Tests/SwiftDocCTests/Converter/RenderContextTests.swift b/Tests/SwiftDocCTests/Converter/RenderContextTests.swift
index 7ac0d4240f..0bbddc4ab4 100644
--- a/Tests/SwiftDocCTests/Converter/RenderContextTests.swift
+++ b/Tests/SwiftDocCTests/Converter/RenderContextTests.swift
@@ -14,9 +14,9 @@ import XCTest
 
 class RenderContextTests: XCTestCase {
     func testCreatesRenderReferences() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
+        let renderContext = RenderContext(documentationContext: context)
         
         // Verify render references are created for all topics
         XCTAssertEqual(Array(renderContext.store.topics.keys.sorted(by: { $0.absoluteString < $1.absoluteString })), context.knownIdentifiers.sorted(by: { $0.absoluteString < $1.absoluteString }), "Didn't create render references for all context topics.")
diff --git a/Tests/SwiftDocCTests/Converter/RenderNodeCodableTests.swift b/Tests/SwiftDocCTests/Converter/RenderNodeCodableTests.swift
index 2295ec79f7..613637bec6 100644
--- a/Tests/SwiftDocCTests/Converter/RenderNodeCodableTests.swift
+++ b/Tests/SwiftDocCTests/Converter/RenderNodeCodableTests.swift
@@ -146,7 +146,7 @@ class RenderNodeCodableTests: XCTestCase {
             subdirectory: "Test Resources"
         )!
         
-        let bundleID: DocumentationBundle.Identifier = #function
+        let bundleID: DocumentationContext.Inputs.Identifier = #function
         
         let renderNodeWithUniqueBundleID = try String(contentsOf: exampleRenderNodeJSON)
             .replacingOccurrences(of: "org.swift.docc.example", with: bundleID.rawValue)
@@ -170,7 +170,7 @@ class RenderNodeCodableTests: XCTestCase {
     }
     
     func testEncodeRenderNodeWithCustomTopicSectionStyle() async throws {
-        let (bundle, context) = try await testBundleAndContext()
+        let context = try await makeEmptyContext()
         var problems = [Problem]()
         
         let source = """
@@ -185,7 +185,7 @@ class RenderNodeCodableTests: XCTestCase {
         
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let article = try XCTUnwrap(
-            Article(from: document.root, source: nil, for: bundle, problems: &problems)
+            Article(from: document.root, source: nil, for: context.inputs, problems: &problems)
         )
         
         let reference = ResolvedTopicReference(
@@ -203,7 +203,7 @@ class RenderNodeCodableTests: XCTestCase {
         )
         context.topicGraph.addNode(topicGraphNode)
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let node = try XCTUnwrap(translator.visitArticle(article) as? RenderNode)
         XCTAssertEqual(node.topicSectionsStyle, .compactGrid)
         
diff --git a/Tests/SwiftDocCTests/Converter/TopicRenderReferenceEncoderTests.swift b/Tests/SwiftDocCTests/Converter/TopicRenderReferenceEncoderTests.swift
index c3014f1983..1eceabe6e8 100644
--- a/Tests/SwiftDocCTests/Converter/TopicRenderReferenceEncoderTests.swift
+++ b/Tests/SwiftDocCTests/Converter/TopicRenderReferenceEncoderTests.swift
@@ -156,10 +156,10 @@ class TopicRenderReferenceEncoderTests: XCTestCase {
     }
     
     /// Verifies that when JSON encoder should sort keys, the custom render reference cache
-    /// respects that setting and prints the referencs in alphabetical order.
+    /// respects that setting and prints the references in alphabetical order.
     func testSortedReferences() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let converter = DocumentationNodeConverter(context: context)
 
         // Create a JSON encoder
         let encoder = RenderJSONEncoder.makeEncoder()
@@ -218,8 +218,8 @@ class TopicRenderReferenceEncoderTests: XCTestCase {
     
     // Verifies that there is no extra comma at the end of the references list.
     func testRemovesLastReferencesListDelimiter() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let converter = DocumentationNodeConverter(context: context)
 
         // Create a JSON encoder
         let encoder = RenderJSONEncoder.makeEncoder()
diff --git a/Tests/SwiftDocCTests/DeprecatedDiagnosticsDigestWarningTests.swift b/Tests/SwiftDocCTests/DeprecatedDiagnosticsDigestWarningTests.swift
index f8875ee299..1dd1a3078f 100644
--- a/Tests/SwiftDocCTests/DeprecatedDiagnosticsDigestWarningTests.swift
+++ b/Tests/SwiftDocCTests/DeprecatedDiagnosticsDigestWarningTests.swift
@@ -23,12 +23,11 @@ class DeprecatedDiagnosticsDigestWarningTests: XCTestCase {
             An empty root page
             """)
         ])
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         let outputConsumer = TestOutputConsumer()
         
         _ = try ConvertActionConverter.convert(
-            bundle: bundle,
             context: context,
             outputConsumer: outputConsumer,
             sourceRepository: nil,
@@ -49,12 +48,11 @@ class DeprecatedDiagnosticsDigestWarningTests: XCTestCase {
             This link will result in a warning: ``NotFound``.
             """)
         ])
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         let outputConsumer = TestOutputConsumer()
         
         _ = try ConvertActionConverter.convert(
-            bundle: bundle,
             context: context,
             outputConsumer: outputConsumer,
             sourceRepository: nil,
@@ -79,7 +77,7 @@ private class TestOutputConsumer: ConvertOutputConsumer, ExternalNodeConsumer {
     }
     
     func consume(renderNode: RenderNode) throws { }
-    func consume(assetsInBundle bundle: DocumentationBundle) throws { }
+    func consume(assetsInBundle bundle: DocumentationContext.Inputs) throws { }
     func consume(linkableElementSummaries: [LinkDestinationSummary]) throws { }
     func consume(indexingRecords: [IndexingRecord]) throws { }
     func consume(assets: [RenderReferenceType: [any RenderReference]]) throws { }
diff --git a/Tests/SwiftDocCTests/Diagnostics/DiagnosticTests.swift b/Tests/SwiftDocCTests/Diagnostics/DiagnosticTests.swift
index 17d945f5c1..7ed38e199a 100644
--- a/Tests/SwiftDocCTests/Diagnostics/DiagnosticTests.swift
+++ b/Tests/SwiftDocCTests/Diagnostics/DiagnosticTests.swift
@@ -79,7 +79,7 @@ class DiagnosticTests: XCTestCase {
     
     /// Test offsetting diagnostic ranges
     func testOffsetDiagnostics() async throws {
-        let (bundle, context) = try await loadBundle(catalog: Folder(name: "unit-test.docc", content: [
+        let context = try await load(catalog: Folder(name: "unit-test.docc", content: [
             JSONFile(name: "SomeModuleName.symbols.json", content: makeSymbolGraph(moduleName: "SomeModuleName"))
         ]))
 
@@ -87,7 +87,7 @@ class DiagnosticTests: XCTestCase {
         let markup = Document(parsing: content, source: URL(string: "/tmp/foo.symbols.json"), options: .parseSymbolLinks)
         
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
-        var resolver = ReferenceResolver(context: context, bundle: bundle, rootReference: moduleReference)
+        var resolver = ReferenceResolver(context: context, rootReference: moduleReference)
         
         // Resolve references
         _ = resolver.visitMarkup(markup)
diff --git a/Tests/SwiftDocCTests/DocumentationService/ConvertService/ConvertServiceTests.swift b/Tests/SwiftDocCTests/DocumentationService/ConvertService/ConvertServiceTests.swift
index 2550a52345..b0247d6848 100644
--- a/Tests/SwiftDocCTests/DocumentationService/ConvertService/ConvertServiceTests.swift
+++ b/Tests/SwiftDocCTests/DocumentationService/ConvertService/ConvertServiceTests.swift
@@ -15,7 +15,7 @@ import SymbolKit
 import SwiftDocCTestUtilities
 
 class ConvertServiceTests: XCTestCase {
-    private let testBundleInfo = DocumentationBundle.Info(
+    private let testBundleInfo = DocumentationContext.Inputs.Info(
         displayName: "TestBundle",
         id: "identifier"
     )
@@ -30,7 +30,7 @@ class ConvertServiceTests: XCTestCase {
         let symbolGraph = try Data(contentsOf: symbolGraphFile)
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: ["s:5MyKit0A5ClassC10myFunctionyyF"],
             documentPathsToConvert: [],
             symbolGraphs: [symbolGraph],
@@ -113,7 +113,7 @@ class ConvertServiceTests: XCTestCase {
         let myFunctionExtensionData = try Data(contentsOf: myFunctionExtension)
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: ["s:5MyKit0A5ClassC10myFunctionyyF"],
             documentPathsToConvert: [],
             symbolGraphs: [symbolGraph],
@@ -162,7 +162,7 @@ class ConvertServiceTests: XCTestCase {
         let symbolGraph = try Data(contentsOf: symbolGraphFile)
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: ["s:5MyKit0A5ClassC10myFunctionyyF"],
             documentPathsToConvert: [],
             symbolGraphs: [symbolGraph],
@@ -203,7 +203,7 @@ class ConvertServiceTests: XCTestCase {
         let symbolGraph = try Data(contentsOf: symbolGraphFile)
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: ["s:5MyKit0A5ClassC10myFunctionyyF"],
             documentPathsToConvert: [],
             symbolGraphs: [symbolGraph],
@@ -237,7 +237,7 @@ class ConvertServiceTests: XCTestCase {
         let symbolGraph = try Data(contentsOf: symbolGraphFile)
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: ["s:5MyKit0A5ClassC10myFunctionyyF"],
             documentPathsToConvert: [],
             symbolGraphs: [symbolGraph],
@@ -303,7 +303,7 @@ class ConvertServiceTests: XCTestCase {
         )
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: ["s:5MyKit0A5ClassC10myFunctionyyF"],
             documentPathsToConvert: [],
             symbolGraphs: [symbolGraph],
@@ -376,7 +376,7 @@ class ConvertServiceTests: XCTestCase {
         )
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: ["s:5MyKit0A5ClassC10myFunctionyyF"],
             documentPathsToConvert: [],
             symbolGraphs: [symbolGraph],
@@ -428,7 +428,7 @@ class ConvertServiceTests: XCTestCase {
         let symbolGraph = try Data(contentsOf: symbolGraphFile)
         
         var request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: ["s:5MyKit0A5ClassC10myFunctionyyF"],
             documentPathsToConvert: [],
             symbolGraphs: [symbolGraph],
@@ -542,7 +542,7 @@ class ConvertServiceTests: XCTestCase {
         let symbolGraph = try Data(contentsOf: symbolGraphFile)
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: ["s:5MyKit0A5ClassC10myFunctionyyF"],
             documentPathsToConvert: [],
             symbolGraphs: [symbolGraph],
@@ -603,7 +603,7 @@ class ConvertServiceTests: XCTestCase {
         let symbolGraph = try Data(contentsOf: symbolGraphFile)
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: ["s:5MyKit0A5ClassC10myFunctionyyF"],
             documentPathsToConvert: [],
             symbolGraphs: [symbolGraph],
@@ -653,7 +653,7 @@ class ConvertServiceTests: XCTestCase {
         let symbolGraph = try Data(contentsOf: symbolGraphFile)
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: ["s:5MyKit0A5ClassC10myFunctionyyF"],
             documentPathsToConvert: [],
             symbolGraphs: [symbolGraph],
@@ -689,7 +689,7 @@ class ConvertServiceTests: XCTestCase {
         let symbolGraph = try Data(contentsOf: symbolGraphFile)
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: ["s:5MyKit0A5ClassC10myFunctionyyF"],
             documentPathsToConvert: [],
             symbolGraphs: [symbolGraph],
@@ -725,7 +725,7 @@ class ConvertServiceTests: XCTestCase {
         let symbolGraph = try Data(contentsOf: symbolGraphFile)
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: ["s:5MyKit0A5ClassC10myFunctionyyF"],
             documentPathsToConvert: [],
             symbolGraphs: [symbolGraph],
@@ -758,7 +758,7 @@ class ConvertServiceTests: XCTestCase {
         let symbolGraph = try Data(contentsOf: symbolGraphFile)
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: ["s:5MyKit0A5ClassC10myFunctionyyF"],
             documentPathsToConvert: [],
             symbolGraphs: [symbolGraph],
@@ -791,7 +791,7 @@ class ConvertServiceTests: XCTestCase {
         let article = try Data(contentsOf: articleFile)
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: nil,
             documentPathsToConvert: nil,
             symbolGraphs: [],
@@ -870,10 +870,10 @@ class ConvertServiceTests: XCTestCase {
         let catalog = tempURL.appendingPathComponent("TutorialWithCodeTest.docc")
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: nil,
             documentPathsToConvert: nil,
-            bundleLocation: nil,
+            catalogLocation: nil,
             symbolGraphs: [],
             knownDisambiguatedSymbolPathComponents: nil,
             markupFiles: [],
@@ -1019,7 +1019,7 @@ class ConvertServiceTests: XCTestCase {
             """.data(using: .utf8))
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: nil,
             documentPathsToConvert: nil,
             symbolGraphs: [],
@@ -1245,7 +1245,7 @@ class ConvertServiceTests: XCTestCase {
         let tutorial = try Data(contentsOf: tutorialFile)
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: nil,
             documentPathsToConvert: nil,
             symbolGraphs: [],
@@ -1291,7 +1291,7 @@ class ConvertServiceTests: XCTestCase {
         let tutorialOverview = try Data(contentsOf: tutorialOverviewFile)
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: nil,
             documentPathsToConvert: nil,
             symbolGraphs: [],
@@ -1365,7 +1365,7 @@ class ConvertServiceTests: XCTestCase {
         let symbolGraph = try Data(contentsOf: symbolGraphFile)
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: nil,
             documentPathsToConvert: nil,
             symbolGraphs: [symbolGraph],
@@ -1386,10 +1386,10 @@ class ConvertServiceTests: XCTestCase {
             forResource: "LegacyBundle_DoNotUseInNewTests", withExtension: "docc", subdirectory: "Test Bundles")!
                 
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: nil,
             documentPathsToConvert: nil,
-            bundleLocation: testBundleURL,
+            catalogLocation: testBundleURL,
             symbolGraphs: [],
             markupFiles: [],
             miscResourceURLs: []
@@ -1447,10 +1447,10 @@ class ConvertServiceTests: XCTestCase {
             forResource: "LegacyBundle_DoNotUseInNewTests", withExtension: "docc", subdirectory: "Test Bundles")!
                 
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: ["s:5MyKit0A5ClassC10myFunctionyyF"],
             documentPathsToConvert: ["/documentation/Test-Bundle/article"],
-            bundleLocation: testBundleURL,
+            catalogLocation: testBundleURL,
             symbolGraphs: [],
             markupFiles: [],
             miscResourceURLs: []
@@ -1471,10 +1471,10 @@ class ConvertServiceTests: XCTestCase {
             forResource: "LegacyBundle_DoNotUseInNewTests", withExtension: "docc", subdirectory: "Test Bundles")!
                 
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: [],
             documentPathsToConvert: [],
-            bundleLocation: testBundleURL,
+            catalogLocation: testBundleURL,
             symbolGraphs: [],
             markupFiles: [],
             miscResourceURLs: []
@@ -1494,8 +1494,8 @@ class ConvertServiceTests: XCTestCase {
         arrays. (github.com/apple/swift/issues/57363)
         """)
         #else
-        let (testBundleURL, _, _) = try await testBundleAndContext(
-            copying: "LegacyBundle_DoNotUseInNewTests",
+        let (testBundleURL, _) = try await loadFromDisk(
+            copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests",
             excludingPaths: [
                 "sidekit.symbols.json",
                 "mykit-iOS.symbols.json",
@@ -1505,11 +1505,11 @@ class ConvertServiceTests: XCTestCase {
         )
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: [],
             documentPathsToConvert: [],
             includeRenderReferenceStore: true,
-            bundleLocation: testBundleURL,
+            catalogLocation: testBundleURL,
             symbolGraphs: [],
             markupFiles: [],
             miscResourceURLs: []
@@ -1623,8 +1623,8 @@ class ConvertServiceTests: XCTestCase {
         arrays. (github.com/apple/swift/issues/57363)
         """)
         #else
-        let (testBundleURL, _, _) = try await testBundleAndContext(
-            copying: "LegacyBundle_DoNotUseInNewTests",
+        let (testBundleURL, _) = try await loadFromDisk(
+            copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests",
             excludingPaths: [
                 "mykit-iOS.symbols.json",
                 "MyKit@SideKit.symbols.json",
@@ -1633,11 +1633,11 @@ class ConvertServiceTests: XCTestCase {
         )
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: [],
             documentPathsToConvert: [],
             includeRenderReferenceStore: true,
-            bundleLocation: testBundleURL,
+            catalogLocation: testBundleURL,
             symbolGraphs: [],
             markupFiles: [],
             miscResourceURLs: []
@@ -1665,18 +1665,18 @@ class ConvertServiceTests: XCTestCase {
         arrays. (github.com/apple/swift/issues/57363)
         """)
         #else
-        let (testBundleURL, _, _) = try await testBundleAndContext(
+        let (testBundleURL, _) = try await loadFromDisk(
             // Use a bundle that contains only articles, one of which is declared as the TechnologyRoot and curates the
             // other articles.
-            copying: "BundleWithTechnologyRoot"
+            copyingCatalogNamed: "BundleWithTechnologyRoot"
         )
         
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: [],
             documentPathsToConvert: [],
             includeRenderReferenceStore: true,
-            bundleLocation: testBundleURL,
+            catalogLocation: testBundleURL,
             symbolGraphs: [],
             markupFiles: [],
             miscResourceURLs: []
@@ -1728,7 +1728,7 @@ class ConvertServiceTests: XCTestCase {
         let symbolGraph = try Data(contentsOf: symbolGraphFile)
         
         let request = ConvertRequest(
-            bundleInfo: DocumentationBundle.Info(
+            info: DocumentationContext.Inputs.Info(
                 displayName: "TestBundle",
                 id: "com.test.bundle"
             ),
@@ -2017,7 +2017,7 @@ class ConvertServiceTests: XCTestCase {
         let symbolGraph = try Data(contentsOf: symbolGraphFile)
         
         let request = ConvertRequest(
-            bundleInfo: DocumentationBundle.Info(
+            info: DocumentationContext.Inputs.Info(
                 displayName: "TestBundle",
                 id: "org.swift.example"
             ),
@@ -2126,7 +2126,7 @@ class ConvertServiceTests: XCTestCase {
         let symbolGraph = try Data(contentsOf: symbolGraphFile)
         
         let request = ConvertRequest(
-            bundleInfo: DocumentationBundle.Info(
+            info: DocumentationContext.Inputs.Info(
                 displayName: "TestBundleDisplayName",
                 id: "com.test.bundle"
             ),
@@ -2164,7 +2164,7 @@ class ConvertServiceTests: XCTestCase {
         let symbolGraph = try Data(contentsOf: symbolGraphFile)
         
         let request = ConvertRequest(
-            bundleInfo: DocumentationBundle.Info(
+            info: DocumentationContext.Inputs.Info(
                 displayName: "TestBundleDisplayName",
                 id: "com.test.bundle"
             ),
@@ -2203,7 +2203,7 @@ class ConvertServiceTests: XCTestCase {
         let symbolGraph = try Data(contentsOf: symbolGraphFile)
         
         let request = ConvertRequest(
-            bundleInfo: DocumentationBundle.Info(
+            info: DocumentationContext.Inputs.Info(
                 displayName: "TestBundleDisplayName",
                 id: "com.test.bundle"
             ),
@@ -2297,7 +2297,7 @@ class ConvertServiceTests: XCTestCase {
     
     func testReturnsErrorWhenConversionThrows() throws {
         let request = ConvertRequest(
-            bundleInfo: testBundleInfo,
+            info: testBundleInfo,
             externalIDsToConvert: nil,
             symbolGraphs: [Data()],
             markupFiles: [],
@@ -2331,9 +2331,9 @@ class ConvertServiceTests: XCTestCase {
         let bundleURL = tempURL.appendingPathComponent("unit-test.docc")
         
         let requestWithDifferentBundleID = ConvertRequest(
-            bundleInfo: DocumentationBundle.Info(displayName: "DisplayName", id: "com.example.something-else"),
+            info: DocumentationContext.Inputs.Info(displayName: "DisplayName", id: "com.example.something-else"),
             externalIDsToConvert: [],
-            bundleLocation: bundleURL,
+            catalogLocation: bundleURL,
             symbolGraphs: [],
             markupFiles: [],
             miscResourceURLs: []
@@ -2341,9 +2341,9 @@ class ConvertServiceTests: XCTestCase {
         XCTAssertEqual(try linkResolutionRequestsForConvertRequest(requestWithDifferentBundleID), [], "Shouldn't make any link resolution requests because the bundle IDs are different.")
         
         let requestWithSameBundleID = ConvertRequest(
-            bundleInfo: DocumentationBundle.Info(displayName: "DisplayName", id: "com.example.something"),
+            info: DocumentationContext.Inputs.Info(displayName: "DisplayName", id: "com.example.something"),
             externalIDsToConvert: [],
-            bundleLocation: bundleURL,
+            catalogLocation: bundleURL,
             symbolGraphs: [],
             markupFiles: [],
             miscResourceURLs: []
diff --git a/Tests/SwiftDocCTests/DocumentationService/DocumentationServer+DefaultTests.swift b/Tests/SwiftDocCTests/DocumentationService/DocumentationServer+DefaultTests.swift
index 6f4ddc2c61..6230320bc1 100644
--- a/Tests/SwiftDocCTests/DocumentationService/DocumentationServer+DefaultTests.swift
+++ b/Tests/SwiftDocCTests/DocumentationService/DocumentationServer+DefaultTests.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -66,7 +66,7 @@ class DocumentationServer_DefaultTests: XCTestCase {
         let symbolGraph = try Data(contentsOf: symbolGraphFile)
         
         let request = ConvertRequest(
-            bundleInfo: DocumentationBundle.Info(
+            info: DocumentationContext.Inputs.Info(
                 displayName: "TestBundle",
                 id: "identifier"
             ),
diff --git a/Tests/SwiftDocCTests/Indexing/ExternalRenderNodeTests.swift b/Tests/SwiftDocCTests/Indexing/ExternalRenderNodeTests.swift
index 4ca7dc631e..caa6aebee9 100644
--- a/Tests/SwiftDocCTests/Indexing/ExternalRenderNodeTests.swift
+++ b/Tests/SwiftDocCTests/Indexing/ExternalRenderNodeTests.swift
@@ -56,10 +56,9 @@ class ExternalRenderNodeTests: XCTestCase {
     }
         
     func testExternalRenderNode() async throws {
-        
         let externalResolver = generateExternalResolver()
-        let (_, bundle, context) = try await testBundleAndContext(
-            copying: "MixedLanguageFramework",
+        let (_, context) = try await loadFromDisk(
+            copyingCatalogNamed: "MixedLanguageFramework",
             externalResolvers: [externalResolver.bundleID: externalResolver]
         ) { url in
             let mixedLanguageFrameworkExtension = """
@@ -82,7 +81,7 @@ class ExternalRenderNodeTests: XCTestCase {
         var externalRenderNodes = [ExternalRenderNode]()
         for externalLink in context.externalCache {
             externalRenderNodes.append(
-                ExternalRenderNode(externalEntity: externalLink.value, bundleIdentifier: bundle.id)
+                ExternalRenderNode(externalEntity: externalLink.value, bundleIdentifier: context.inputs.id)
             )
         }
         externalRenderNodes.sort(by: \.titleVariants.defaultValue)
@@ -167,8 +166,8 @@ class ExternalRenderNodeTests: XCTestCase {
 
     func testNavigatorWithExternalNodes() async throws {
         let externalResolver = generateExternalResolver()
-        let (_, bundle, context) = try await testBundleAndContext(
-            copying: "MixedLanguageFramework",
+        let (_, context) = try await loadFromDisk(
+            copyingCatalogNamed: "MixedLanguageFramework",
             externalResolvers: [externalResolver.bundleID: externalResolver]
         ) { url in
             let mixedLanguageFrameworkExtension = """
@@ -187,13 +186,13 @@ class ExternalRenderNodeTests: XCTestCase {
                 """
             try mixedLanguageFrameworkExtension.write(to: url.appendingPathComponent("/MixedLanguageFramework.md"), atomically: true, encoding: .utf8)
         }
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
-        let converter = DocumentationContextConverter(bundle: bundle, context: context, renderContext: renderContext)
+        let renderContext = RenderContext(documentationContext: context)
+        let converter = DocumentationContextConverter(context: context, renderContext: renderContext)
         let targetURL = try createTemporaryDirectory()
-        let builder = NavigatorIndex.Builder(outputURL: targetURL, bundleIdentifier: bundle.id.rawValue, sortRootChildrenByName: true, groupByLanguage: true)
+        let builder = NavigatorIndex.Builder(outputURL: targetURL, bundleIdentifier: context.inputs.id.rawValue, sortRootChildrenByName: true, groupByLanguage: true)
         builder.setup()
         for externalLink in context.externalCache {
-            let externalRenderNode = ExternalRenderNode(externalEntity: externalLink.value, bundleIdentifier: bundle.id)
+            let externalRenderNode = ExternalRenderNode(externalEntity: externalLink.value, bundleIdentifier: context.inputs.id)
             try builder.index(renderNode: externalRenderNode)
         }
         for identifier in context.knownPages {
@@ -230,8 +229,8 @@ class ExternalRenderNodeTests: XCTestCase {
     func testNavigatorWithExternalNodesOnlyAddsCuratedNodesToNavigator() async throws {
         let externalResolver = generateExternalResolver()
         
-        let (_, bundle, context) = try await testBundleAndContext(
-            copying: "MixedLanguageFramework",
+        let (_, context) = try await loadFromDisk(
+            copyingCatalogNamed: "MixedLanguageFramework",
             externalResolvers: [externalResolver.bundleID: externalResolver]
         ) { url in
             let mixedLanguageFrameworkExtension = """
@@ -252,13 +251,13 @@ class ExternalRenderNodeTests: XCTestCase {
                 """
             try mixedLanguageFrameworkExtension.write(to: url.appendingPathComponent("/MixedLanguageFramework.md"), atomically: true, encoding: .utf8)
         }
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
-        let converter = DocumentationContextConverter(bundle: bundle, context: context, renderContext: renderContext)
+        let renderContext = RenderContext(documentationContext: context)
+        let converter = DocumentationContextConverter(context: context, renderContext: renderContext)
         let targetURL = try createTemporaryDirectory()
-        let builder = NavigatorIndex.Builder(outputURL: targetURL, bundleIdentifier: bundle.id.rawValue, sortRootChildrenByName: true, groupByLanguage: true)
+        let builder = NavigatorIndex.Builder(outputURL: targetURL, bundleIdentifier: context.inputs.id.rawValue, sortRootChildrenByName: true, groupByLanguage: true)
         builder.setup()
         for externalLink in context.externalCache {
-            let externalRenderNode = ExternalRenderNode(externalEntity: externalLink.value, bundleIdentifier: bundle.id)
+            let externalRenderNode = ExternalRenderNode(externalEntity: externalLink.value, bundleIdentifier: context.inputs.id)
             try builder.index(renderNode: externalRenderNode)
         }
         for identifier in context.knownPages {
diff --git a/Tests/SwiftDocCTests/Indexing/IndexingTests.swift b/Tests/SwiftDocCTests/Indexing/IndexingTests.swift
index 758f370cb0..e48693d5e0 100644
--- a/Tests/SwiftDocCTests/Indexing/IndexingTests.swift
+++ b/Tests/SwiftDocCTests/Indexing/IndexingTests.swift
@@ -15,11 +15,11 @@ class IndexingTests: XCTestCase {
     
     // MARK: - Tutorial
     func testTutorial() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         let tutorialReference = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/tutorials/Test-Bundle/TestTutorial", sourceLanguage: .swift)
         let node = try context.entity(with: tutorialReference)
         let tutorial = node.semantic as! Tutorial
-        var converter = RenderNodeTranslator(context: context, bundle: bundle, identifier: tutorialReference)
+        var converter = RenderNodeTranslator(context: context, identifier: tutorialReference)
         let renderNode = converter.visit(tutorial) as! RenderNode
         let indexingRecords = try renderNode.indexingRecords(onPage: tutorialReference)
         XCTAssertEqual(4, indexingRecords.count)
@@ -89,11 +89,11 @@ class IndexingTests: XCTestCase {
     // MARK: - Article
     
     func testArticle() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         let articleReference = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/tutorials/Test-Bundle/TestTutorialArticle", sourceLanguage: .swift)
         let node = try context.entity(with: articleReference)
         let article = node.semantic as! TutorialArticle
-        var converter = RenderNodeTranslator(context: context, bundle: bundle, identifier: articleReference)
+        var converter = RenderNodeTranslator(context: context, identifier: articleReference)
         let renderNode = converter.visit(article) as! RenderNode
         let indexingRecords = try renderNode.indexingRecords(onPage: articleReference)
         
@@ -187,11 +187,11 @@ class IndexingTests: XCTestCase {
     }
     
     func testRootPageIndexingRecord() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         let articleReference = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/MyKit", sourceLanguage: .swift)
         let node = try context.entity(with: articleReference)
         let article = node.semantic as! Symbol
-        var converter = RenderNodeTranslator(context: context, bundle: bundle, identifier: articleReference)
+        var converter = RenderNodeTranslator(context: context, identifier: articleReference)
         let renderNode = converter.visit(article) as! RenderNode
         let indexingRecords = try renderNode.indexingRecords(onPage: articleReference)
         
@@ -207,12 +207,12 @@ class IndexingTests: XCTestCase {
     }
     
     func testSymbolIndexingRecord() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { url in
-            // Modify the documentaion to have default availability for MyKit so that there is platform availability
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { url in
+            // Modify the documentation to have default availability for MyKit so that there is platform availability
             // information for MyProtocol (both in the render node and in the indexing record.
             let plistURL = url.appendingPathComponent("Info.plist")
             let plistData = try Data(contentsOf: plistURL)
-            var plist = try DocumentationBundle.Info(from: plistData)
+            var plist = try DocumentationContext.Inputs.Info(from: plistData)
             let existingAvailability = plist.defaultAvailability?.modules["FillIntroduced"]
             plist.defaultAvailability?.modules["MyKit"] = existingAvailability
             XCTAssertNotNil(plist.defaultAvailability?.modules["MyKit"])
@@ -224,7 +224,7 @@ class IndexingTests: XCTestCase {
         let articleReference = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/MyKit/MyProtocol", sourceLanguage: .swift)
         let node = try context.entity(with: articleReference)
         let article = node.semantic as! Symbol
-        var converter = RenderNodeTranslator(context: context, bundle: bundle, identifier: articleReference)
+        var converter = RenderNodeTranslator(context: context, identifier: articleReference)
         let renderNode = converter.visit(article) as! RenderNode
         let indexingRecords = try renderNode.indexingRecords(onPage: articleReference)
         
diff --git a/Tests/SwiftDocCTests/Indexing/NavigatorIndexTests.swift b/Tests/SwiftDocCTests/Indexing/NavigatorIndexTests.swift
index 71ea0f8da4..f318c1f4f9 100644
--- a/Tests/SwiftDocCTests/Indexing/NavigatorIndexTests.swift
+++ b/Tests/SwiftDocCTests/Indexing/NavigatorIndexTests.swift
@@ -303,7 +303,7 @@ Root
     }
     
     func testLoadingNavigatorIndexDoesNotCacheReferences() throws {
-        let uniqueTestBundleIdentifier: DocumentationBundle.Identifier = #function
+        let uniqueTestBundleIdentifier: DocumentationContext.Inputs.Identifier = #function
         
         let targetURL = try createTemporaryDirectory()
         let indexURL = targetURL.appendingPathComponent("nav.index")
@@ -457,9 +457,9 @@ Root
     }
     
     func testNavigatorIndexGeneration() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
-        let converter = DocumentationContextConverter(bundle: bundle, context: context, renderContext: renderContext)
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let renderContext = RenderContext(documentationContext: context)
+        let converter = DocumentationContextConverter(context: context, renderContext: renderContext)
         var results = Set<String>()
         
         // Create an index 10 times to ensure we have not non-deterministic behavior across builds
@@ -646,10 +646,10 @@ Root
             """),
         ])
         
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
-        let converter = DocumentationContextConverter(bundle: bundle, context: context, renderContext: renderContext)
+        let renderContext = RenderContext(documentationContext: context)
+        let converter = DocumentationContextConverter(context: context, renderContext: renderContext)
         
         let targetURL = try createTemporaryDirectory()
         let builder = NavigatorIndex.Builder(outputURL: targetURL, bundleIdentifier: testBundleIdentifier)
@@ -694,12 +694,12 @@ Root
     }
     
     func testNavigatorWithDifferentSwiftAndObjectiveCHierarchies() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(named: "GeometricalShapes")
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
-        let converter = DocumentationContextConverter(bundle: bundle, context: context, renderContext: renderContext)
+        let (_, context) = try await loadFromDisk(catalogName: "GeometricalShapes")
+        let renderContext = RenderContext(documentationContext: context)
+        let converter = DocumentationContextConverter(context: context, renderContext: renderContext)
         
-        let fromMemoryBuilder  = NavigatorIndex.Builder(outputURL: try createTemporaryDirectory(), bundleIdentifier: bundle.id.rawValue, sortRootChildrenByName: true, groupByLanguage: true)
-        let fromDecodedBuilder = NavigatorIndex.Builder(outputURL: try createTemporaryDirectory(), bundleIdentifier: bundle.id.rawValue, sortRootChildrenByName: true, groupByLanguage: true)
+        let fromMemoryBuilder  = NavigatorIndex.Builder(outputURL: try createTemporaryDirectory(), bundleIdentifier: context.inputs.id.rawValue, sortRootChildrenByName: true, groupByLanguage: true)
+        let fromDecodedBuilder = NavigatorIndex.Builder(outputURL: try createTemporaryDirectory(), bundleIdentifier: context.inputs.id.rawValue, sortRootChildrenByName: true, groupByLanguage: true)
         fromMemoryBuilder.setup()
         fromDecodedBuilder.setup()
         
@@ -955,9 +955,9 @@ Root
     }
     
     func testNavigatorIndexUsingPageTitleGeneration() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
-        let converter = DocumentationContextConverter(bundle: bundle, context: context, renderContext: renderContext)
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let renderContext = RenderContext(documentationContext: context)
+        let converter = DocumentationContextConverter(context: context, renderContext: renderContext)
         var results = Set<String>()
         
         // Create an index 10 times to ensure we have not non-deterministic behavior across builds
@@ -1004,8 +1004,8 @@ Root
     }
     
     func testNavigatorIndexGenerationNoPaths() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let converter = DocumentationNodeConverter(context: context)
         var results = Set<String>()
         
         // Create an index 10 times to ensure we have not non-deterministic behavior across builds
@@ -1081,9 +1081,9 @@ Root
 
     
     func testNavigatorIndexGenerationWithCuratedFragment() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
-        let converter = DocumentationContextConverter(bundle: bundle, context: context, renderContext: renderContext)
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let renderContext = RenderContext(documentationContext: context)
+        let converter = DocumentationContextConverter(context: context, renderContext: renderContext)
         var results = Set<String>()
         
         // Create an index 10 times to ensure we have no non-deterministic behavior across builds
@@ -1144,9 +1144,9 @@ Root
     }
     
     func testNavigatorIndexAvailabilityGeneration() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
-        let converter = DocumentationContextConverter(bundle: bundle, context: context, renderContext: renderContext)
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let renderContext = RenderContext(documentationContext: context)
+        let converter = DocumentationContextConverter(context: context, renderContext: renderContext)
         
         let targetURL = try createTemporaryDirectory()
         let builder = NavigatorIndex.Builder(outputURL: targetURL, bundleIdentifier: testBundleIdentifier, sortRootChildrenByName: true)
@@ -1248,12 +1248,12 @@ Root
     }
     
     func testCustomIconsInNavigator() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "BookLikeContent") // This content has a @PageImage with the "icon" purpose
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
-        let converter = DocumentationContextConverter(bundle: bundle, context: context, renderContext: renderContext)
+        let context = try await loadFromDisk(catalogName: "BookLikeContent") // This content has a @PageImage with the "icon" purpose
+        let renderContext = RenderContext(documentationContext: context)
+        let converter = DocumentationContextConverter(context: context, renderContext: renderContext)
         
         let targetURL = try createTemporaryDirectory()
-        let builder = NavigatorIndex.Builder(outputURL: targetURL, bundleIdentifier: bundle.id.rawValue, sortRootChildrenByName: true)
+        let builder = NavigatorIndex.Builder(outputURL: targetURL, bundleIdentifier: context.inputs.id.rawValue, sortRootChildrenByName: true)
         builder.setup()
         
         for identifier in context.knownPages {
@@ -1269,14 +1269,14 @@ Root
         
         let imageReference = try XCTUnwrap(renderIndex.references["plus.svg"])
         XCTAssertEqual(imageReference.asset.variants.values.map(\.path).sorted(), [
-            "/images/\(bundle.id)/plus.svg",
+            "/images/\(context.inputs.id)/plus.svg",
         ])
     }
     
     func testNavigatorIndexDifferentHasherGeneration() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
-        let converter = DocumentationContextConverter(bundle: bundle, context: context, renderContext: renderContext)
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let renderContext = RenderContext(documentationContext: context)
+        let converter = DocumentationContextConverter(context: context, renderContext: renderContext)
         
         let targetURL = try createTemporaryDirectory()
         let builder = NavigatorIndex.Builder(outputURL: targetURL, bundleIdentifier: testBundleIdentifier, sortRootChildrenByName: true)
@@ -1723,8 +1723,8 @@ Root
     }
     
     func testNavigatorIndexAsReadOnlyFile() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let converter = DocumentationNodeConverter(context: context)
         
         let targetURL = try createTemporaryDirectory()
         let builder = NavigatorIndex.Builder(outputURL: targetURL, bundleIdentifier: "org.swift.docc.test", sortRootChildrenByName: true)
@@ -2050,11 +2050,11 @@ Root
         var configuration = DocumentationContext.Configuration()
         configuration.externalMetadata.currentPlatforms = platformMetadata
         
-        let (_, bundle, context) = try await testBundleAndContext(named: "AvailabilityBetaBundle", configuration: configuration)
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
-        let converter = DocumentationContextConverter(bundle: bundle, context: context, renderContext: renderContext)
+        let (_, context) = try await loadFromDisk(catalogName: "AvailabilityBetaBundle", configuration: configuration)
+        let renderContext = RenderContext(documentationContext: context)
+        let converter = DocumentationContextConverter(context: context, renderContext: renderContext)
         let targetURL = try createTemporaryDirectory()
-        let builder = NavigatorIndex.Builder(outputURL: targetURL, bundleIdentifier: bundle.id.rawValue, sortRootChildrenByName: true)
+        let builder = NavigatorIndex.Builder(outputURL: targetURL, bundleIdentifier: context.inputs.id.rawValue, sortRootChildrenByName: true)
         builder.setup()
         for identifier in context.knownPages {
             let entity = try context.entity(with: identifier)
@@ -2093,9 +2093,9 @@ Root
     }
 
     func generatedNavigatorIndex(for testBundleName: String, bundleIdentifier: String) async throws -> NavigatorIndex {
-        let (bundle, context) = try await testBundleAndContext(named: testBundleName)
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
-        let converter = DocumentationContextConverter(bundle: bundle, context: context, renderContext: renderContext)
+        let context = try await loadFromDisk(catalogName: testBundleName)
+        let renderContext = RenderContext(documentationContext: context)
+        let converter = DocumentationContextConverter(context: context, renderContext: renderContext)
 
         let targetURL = try createTemporaryDirectory()
         let builder = NavigatorIndex.Builder(outputURL: targetURL, bundleIdentifier: bundleIdentifier, sortRootChildrenByName: true, groupByLanguage: true)
diff --git a/Tests/SwiftDocCTests/Indexing/RenderIndexTests.swift b/Tests/SwiftDocCTests/Indexing/RenderIndexTests.swift
index 0481fb8237..a5d68bcf8c 100644
--- a/Tests/SwiftDocCTests/Indexing/RenderIndexTests.swift
+++ b/Tests/SwiftDocCTests/Indexing/RenderIndexTests.swift
@@ -648,10 +648,10 @@ final class RenderIndexTests: XCTestCase {
         )
         try bundle.write(to: bundleDirectory)
 
-        let (_, loadedBundle, context) = try await loadBundle(from: bundleDirectory)
+        let context = try await loadFromDisk(catalogURL: bundleDirectory)
 
         XCTAssertEqual(
-            try generatedRenderIndex(for: loadedBundle, withIdentifier: "com.test.example", withContext: context),
+            try generatedRenderIndex(withIdentifier: "com.test.example", withContext: context),
             try RenderIndex.fromString(#"""
             {
                 "interfaceLanguages": {
@@ -736,14 +736,14 @@ final class RenderIndexTests: XCTestCase {
         )
     }
     
-    func generatedRenderIndex(for testBundleName: String, with bundleIdentifier: String) async throws -> RenderIndex {
-        let (bundle, context) = try await testBundleAndContext(named: testBundleName)
-        return try generatedRenderIndex(for: bundle, withIdentifier: bundleIdentifier, withContext: context)
+    private func generatedRenderIndex(for testBundleName: String, with bundleIdentifier: String) async throws -> RenderIndex {
+        let context = try await loadFromDisk(catalogName: testBundleName)
+        return try generatedRenderIndex(withIdentifier: bundleIdentifier, withContext: context)
     }
     
-    func generatedRenderIndex(for bundle: DocumentationBundle, withIdentifier bundleIdentifier: String, withContext context: DocumentationContext) throws -> RenderIndex {
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
-        let converter = DocumentationContextConverter(bundle: bundle, context: context, renderContext: renderContext)
+    private func generatedRenderIndex(withIdentifier bundleIdentifier: String, withContext context: DocumentationContext) throws -> RenderIndex {
+        let renderContext = RenderContext(documentationContext: context)
+        let converter = DocumentationContextConverter(context: context, renderContext: renderContext)
         let indexDirectory = try createTemporaryDirectory()
         let builder = NavigatorIndex.Builder(
             outputURL: indexDirectory,
diff --git a/Tests/SwiftDocCTests/Infrastructure/AnchorSectionTests.swift b/Tests/SwiftDocCTests/Infrastructure/AnchorSectionTests.swift
index 968cca594f..5941857b35 100644
--- a/Tests/SwiftDocCTests/Infrastructure/AnchorSectionTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/AnchorSectionTests.swift
@@ -17,19 +17,19 @@ import Markdown
 class AnchorSectionTests: XCTestCase {
         
     func testResolvingArticleSubsections() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "BundleWithLonelyDeprecationDirective")
+        let context = try await loadFromDisk(catalogName: "BundleWithLonelyDeprecationDirective")
         
         // Verify the sub-sections of the article have been collected in the context
         [
-            ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/TechnologyX/Article", fragment: "Article-Sub-Section", sourceLanguage: .swift),
-            ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/TechnologyX/Article", fragment: "Article-Sub-Sub-Section", sourceLanguage: .swift),
+            ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/TechnologyX/Article", fragment: "Article-Sub-Section", sourceLanguage: .swift),
+            ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/TechnologyX/Article", fragment: "Article-Sub-Sub-Section", sourceLanguage: .swift),
         ]
         .forEach { sectionReference in
             XCTAssertTrue(context.nodeAnchorSections.keys.contains(sectionReference))
         }
         
         // Load the module page
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/CoolFramework", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/CoolFramework", sourceLanguage: .swift)
         let entity = try context.entity(with: reference)
         
         // Extract the links from the discussion
@@ -66,7 +66,7 @@ class AnchorSectionTests: XCTestCase {
         }
 
         // Verify collecting section render references
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
         let renderNode = converter.convert(entity)
 
         let sectionReference = try XCTUnwrap(renderNode.references["doc://org.swift.docc.example/documentation/TechnologyX/Article#Article-Sub-Section"] as? TopicRenderReference)
@@ -75,19 +75,19 @@ class AnchorSectionTests: XCTestCase {
     }
 
     func testResolvingSymbolSubsections() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "BundleWithLonelyDeprecationDirective")
+        let context = try await loadFromDisk(catalogName: "BundleWithLonelyDeprecationDirective")
         
         // Verify the sub-sections of the article have been collected in the context
         [
-            ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/CoolFramework/CoolClass", fragment: "Symbol-Sub-Section", sourceLanguage: .swift),
-            ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/CoolFramework/CoolClass", fragment: "Symbol-Sub-Sub-Section", sourceLanguage: .swift),
+            ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/CoolFramework/CoolClass", fragment: "Symbol-Sub-Section", sourceLanguage: .swift),
+            ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/CoolFramework/CoolClass", fragment: "Symbol-Sub-Sub-Section", sourceLanguage: .swift),
         ]
         .forEach { sectionReference in
             XCTAssertTrue(context.nodeAnchorSections.keys.contains(sectionReference))
         }
         
         // Load the module page
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/CoolFramework", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/CoolFramework", sourceLanguage: .swift)
         let entity = try context.entity(with: reference)
         
         // Extract the links from the discussion
@@ -124,7 +124,7 @@ class AnchorSectionTests: XCTestCase {
         }
 
         // Verify collecting section render references
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
         let renderNode = converter.convert(entity)
 
         let sectionReference = try XCTUnwrap(renderNode.references["doc://org.swift.docc.example/documentation/CoolFramework/CoolClass#Symbol-Sub-Section"] as? TopicRenderReference)
@@ -133,19 +133,19 @@ class AnchorSectionTests: XCTestCase {
     }
 
     func testResolvingRootPageSubsections() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "BundleWithLonelyDeprecationDirective")
+        let context = try await loadFromDisk(catalogName: "BundleWithLonelyDeprecationDirective")
         
         // Verify the sub-sections of the article have been collected in the context
         [
-            ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/CoolFramework", fragment: "Module-Sub-Section", sourceLanguage: .swift),
-            ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/CoolFramework", fragment: "Module-Sub-Sub-Section", sourceLanguage: .swift),
+            ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/CoolFramework", fragment: "Module-Sub-Section", sourceLanguage: .swift),
+            ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/CoolFramework", fragment: "Module-Sub-Sub-Section", sourceLanguage: .swift),
         ]
         .forEach { sectionReference in
             XCTAssertTrue(context.nodeAnchorSections.keys.contains(sectionReference))
         }
         
         // Load the article page
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/TechnologyX/Article", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/TechnologyX/Article", sourceLanguage: .swift)
         let entity = try context.entity(with: reference)
         
         // Extract the links from the discussion
@@ -182,7 +182,7 @@ class AnchorSectionTests: XCTestCase {
         }
 
         // Verify collecting section render references
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
         let renderNode = converter.convert(entity)
 
         let sectionReference = try XCTUnwrap(renderNode.references["doc://org.swift.docc.example/documentation/CoolFramework#Module-Sub-Section"] as? TopicRenderReference)
@@ -191,7 +191,7 @@ class AnchorSectionTests: XCTestCase {
     }
     
     func testWarnsWhenCuratingSections() async throws {
-        let (_, context) = try await testBundleAndContext(named: "BundleWithLonelyDeprecationDirective")
+        let context = try await loadFromDisk(catalogName: "BundleWithLonelyDeprecationDirective")
         
         // The module page has 3 section links in a Topics group,
         // the context should contain the three warnings about those links
diff --git a/Tests/SwiftDocCTests/Infrastructure/AutoCapitalizationTests.swift b/Tests/SwiftDocCTests/Infrastructure/AutoCapitalizationTests.swift
index 8eb5ce13c3..0f1bb44b8c 100644
--- a/Tests/SwiftDocCTests/Infrastructure/AutoCapitalizationTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/AutoCapitalizationTests.swift
@@ -60,18 +60,18 @@ class AutoCapitalizationTests: XCTestCase {
         let catalog = Folder(name: "unit-test.docc", content: [
             JSONFile(name: "ModuleName.symbols.json", content: symbolGraph)
         ])
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         XCTAssertEqual(context.problems.count, 0)
         
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleName/functionName(...)", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleName/functionName(...)", sourceLanguage: .swift)
         let node = try context.entity(with: reference)
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
         let parameterSections = symbol.parametersSectionVariants
         XCTAssertEqual(parameterSections[.swift]?.parameters.map(\.name), ["one", "two", "three", "four", "five"])
         
         let parameterSectionTranslator = ParametersSectionTranslator()
-        var renderNodeTranslator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var renderNodeTranslator = RenderNodeTranslator(context: context, identifier: reference)
         var renderNode = renderNodeTranslator.visit(symbol) as! RenderNode
         let translatedParameters = parameterSectionTranslator.translateSection(for: symbol, renderNode: &renderNode, renderNodeTranslator: &renderNodeTranslator)
         let paramsRenderSection = translatedParameters?.defaultValue?.section as! ParametersRenderSection
@@ -105,18 +105,18 @@ class AutoCapitalizationTests: XCTestCase {
         let catalog = Folder(name: "unit-test.docc", content: [
             JSONFile(name: "ModuleName.symbols.json", content: symbolGraph)
         ])
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         XCTAssertEqual(context.problems.count, 0)
         
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleName/functionName(...)", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleName/functionName(...)", sourceLanguage: .swift)
         let node = try context.entity(with: reference)
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
         let parameterSections = symbol.parametersSectionVariants
         XCTAssertEqual(parameterSections[.swift]?.parameters.map(\.name), ["one", "two", "three", "four", "five"])
         
         let parameterSectionTranslator = ParametersSectionTranslator()
-        var renderNodeTranslator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var renderNodeTranslator = RenderNodeTranslator(context: context, identifier: reference)
         var renderNode = renderNodeTranslator.visit(symbol) as! RenderNode
         let translatedParameters = parameterSectionTranslator.translateSection(for: symbol, renderNode: &renderNode, renderNodeTranslator: &renderNodeTranslator)
         let paramsRenderSection = translatedParameters?.defaultValue?.section as! ParametersRenderSection
@@ -146,16 +146,16 @@ class AutoCapitalizationTests: XCTestCase {
         let catalog = Folder(name: "unit-test.docc", content: [
             JSONFile(name: "ModuleName.symbols.json", content: symbolGraph)
         ])
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         XCTAssertEqual(context.problems.count, 0)
         
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleName/functionName(...)", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleName/functionName(...)", sourceLanguage: .swift)
         let node = try context.entity(with: reference)
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
         
         let returnsSectionTranslator = ReturnsSectionTranslator()
-        var renderNodeTranslator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var renderNodeTranslator = RenderNodeTranslator(context: context, identifier: reference)
         var renderNode = renderNodeTranslator.visit(symbol) as! RenderNode
         let translatedReturns = returnsSectionTranslator.translateSection(for: symbol, renderNode: &renderNode, renderNodeTranslator: &renderNodeTranslator)
         let returnsRenderSection = translatedReturns?.defaultValue?.section as! ContentRenderSection
diff --git a/Tests/SwiftDocCTests/Infrastructure/AutomaticCurationTests.swift b/Tests/SwiftDocCTests/Infrastructure/AutomaticCurationTests.swift
index c66d094540..99eea6eca2 100644
--- a/Tests/SwiftDocCTests/Infrastructure/AutomaticCurationTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/AutomaticCurationTests.swift
@@ -38,9 +38,9 @@ class AutomaticCurationTests: XCTestCase {
                     ))
                 ])
             
-            let (bundle, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
             
-            try assertRenderedPage(atPath: "/documentation/ModuleName/SomeClass", containsAutomaticTopicSectionFor: kind, context: context, bundle: bundle)
+            try assertRenderedPage(atPath: "/documentation/ModuleName/SomeClass", containsAutomaticTopicSectionFor: kind, context: context)
         }
     }
     
@@ -83,10 +83,10 @@ class AutomaticCurationTests: XCTestCase {
                     )),
                 ])
             
-            let (bundle, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
             
-            try assertRenderedPage(atPath: "/documentation/ModuleName", containsAutomaticTopicSectionFor: .extendedModule, context: context, bundle: bundle)
-            try assertRenderedPage(atPath: "/documentation/ModuleName/ExtendedModule", containsAutomaticTopicSectionFor: kind, context: context, bundle: bundle)
+            try assertRenderedPage(atPath: "/documentation/ModuleName", containsAutomaticTopicSectionFor: .extendedModule, context: context)
+            try assertRenderedPage(atPath: "/documentation/ModuleName/ExtendedModule", containsAutomaticTopicSectionFor: kind, context: context)
         }
     }
     
@@ -94,12 +94,11 @@ class AutomaticCurationTests: XCTestCase {
         atPath path: String,
         containsAutomaticTopicSectionFor kind: SymbolGraph.Symbol.KindIdentifier,
         context: DocumentationContext,
-        bundle: DocumentationBundle,
         file: StaticString = #filePath,
         line: UInt = #line
     ) throws {
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: path, sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: path, sourceLanguage: .swift))
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = try XCTUnwrap(translator.visit(node.semantic) as? RenderNode, file: file, line: line)
         
         for section in renderNode.topicSections {
@@ -117,7 +116,7 @@ class AutomaticCurationTests: XCTestCase {
     }
     
     func testAutomaticTopicsSkippingCustomCuratedSymbols() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], configureBundle: { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", configureBundle: { url in
             // Curate some of members of SideClass in an API collection
             try """
             # Some API collection
@@ -136,11 +135,11 @@ class AutomaticCurationTests: XCTestCase {
             """.write(to: url.appendingPathComponent("sideclass.md"), atomically: true, encoding: .utf8)
         })
 
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClass", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClass", sourceLanguage: .swift))
         
         // Compile the render node to flex the automatic curator
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(symbol) as! RenderNode
         
         // Verify that uncurated element `SideKit/SideClass/Element` is
@@ -172,7 +171,7 @@ class AutomaticCurationTests: XCTestCase {
         for curatedIndices in variationsOfChildrenToCurate {
             let manualCuration = curatedIndices.map { "- <\(allExpectedChildren[$0])>" }.joined(separator: "\n")
             
-            let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { url in
+            let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { url in
                 try """
                 # ``SideKit/SideClass``
 
@@ -186,10 +185,10 @@ class AutomaticCurationTests: XCTestCase {
                 """.write(to: url.appendingPathComponent("documentation/sideclass.md"), atomically: true, encoding: .utf8)
             }
             
-            let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClass", sourceLanguage: .swift))
+            let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClass", sourceLanguage: .swift))
             // Compile docs and verify the generated Topics section
             let symbol = node.semantic as! Symbol
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(symbol) as! RenderNode
             
             // Verify that all the symbols are curated, either manually or automatically
@@ -231,7 +230,7 @@ class AutomaticCurationTests: XCTestCase {
     }
     
     func testSeeAlsoSectionForAutomaticallyCuratedTopics() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { url in
             var graph = try JSONDecoder().decode(SymbolGraph.self, from: Data(contentsOf: url.appendingPathComponent("sidekit.symbols.json")))
             
             // Copy `SideClass` a handful of times
@@ -348,8 +347,8 @@ class AutomaticCurationTests: XCTestCase {
         
         // The first topic section
         do {
-            let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClass", sourceLanguage: .swift))
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClass", sourceLanguage: .swift))
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
             
             // SideKit includes the "Manually curated" task group and additional automatically created groups.
@@ -364,8 +363,8 @@ class AutomaticCurationTests: XCTestCase {
         
         // The second topic section
         do {
-            let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClassFour", sourceLanguage: .swift))
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClassFour", sourceLanguage: .swift))
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
             
             // The other symbols in the same topic section appear in this See Also section
@@ -377,8 +376,8 @@ class AutomaticCurationTests: XCTestCase {
         
         // The second topic section
         do {
-            let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClassSix", sourceLanguage: .swift))
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClassSix", sourceLanguage: .swift))
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
             
             // The other symbols in the same topic section appear in this See Also section
@@ -389,22 +388,22 @@ class AutomaticCurationTests: XCTestCase {
         
         // The automatically curated symbols shouldn't have a See Also section
         do {
-            let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClassEight", sourceLanguage: .swift))
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClassEight", sourceLanguage: .swift))
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
             
             XCTAssertNil(renderNode.seeAlsoSections.first, "This symbol was automatically curated and shouldn't have a See Also section")
         }
         do {
-            let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClassNine", sourceLanguage: .swift))
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClassNine", sourceLanguage: .swift))
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
             
             XCTAssertNil(renderNode.seeAlsoSections.first, "This symbol was automatically curated and shouldn't have a See Also section")
         }
         do {
-            let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClassTen", sourceLanguage: .swift))
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClassTen", sourceLanguage: .swift))
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
             
             XCTAssertNil(renderNode.seeAlsoSections.first, "This symbol was automatically curated and shouldn't have a See Also section")
@@ -421,7 +420,7 @@ class AutomaticCurationTests: XCTestCase {
             forResource: "TopLevelCuration.symbols", withExtension: "json", subdirectory: "Test Resources")!
         
         // Create a test bundle copy with the symbol graph from above
-        let (bundleURL, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { url in
+        let (bundleURL, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { url in
             try? FileManager.default.copyItem(at: topLevelCurationSGFURL, to: url.appendingPathComponent("TopLevelCuration.symbols.json"))
         }
         defer {
@@ -430,8 +429,8 @@ class AutomaticCurationTests: XCTestCase {
 
         do {
             // Get the framework render node
-            let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/TestBed", sourceLanguage: .swift))
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/TestBed", sourceLanguage: .swift))
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
             
             // Verify that `B` isn't automatically curated under the framework node
@@ -443,8 +442,8 @@ class AutomaticCurationTests: XCTestCase {
         
         do {
             // Get the `A` render node
-            let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/TestBed/A", sourceLanguage: .swift))
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/TestBed/A", sourceLanguage: .swift))
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
             
             // Verify that `B` was in fact curated under `A`
@@ -456,7 +455,7 @@ class AutomaticCurationTests: XCTestCase {
     }
 
     func testNoAutoCuratedMixedLanguageDuplicates() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "MixedLanguageFramework") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "MixedLanguageFramework") { url in
 
             // Load the existing Obj-C symbol graph from this fixture.
             let path = "symbol-graphs/clang/MixedLanguageFramework.symbols.json"
@@ -480,10 +479,10 @@ class AutomaticCurationTests: XCTestCase {
             try newGraphData.write(to: url.appendingPathComponent("symbol-graphs/clang/MixedLanguageFramework.symbols.json"))
         }
 
-        // Load the "MixedLanguageProtocol Implementations" API COllection
+        // Load the "MixedLanguageProtocol Implementations" API Collection
         let protocolImplementationsNode = try context.entity(
             with: ResolvedTopicReference(
-                bundleID: bundle.id,
+                bundleID: context.inputs.id,
                 path: "/documentation/MixedLanguageFramework/MixedLanguageClassConformingToProtocol/MixedLanguageProtocol-Implementations",
                 sourceLanguages: [.swift, .objectiveC]
             )
@@ -505,14 +504,10 @@ class AutomaticCurationTests: XCTestCase {
     }
 
     func testRelevantLanguagesAreAutoCuratedInMixedLanguageFramework() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "MixedLanguageFramework")
+        let context = try await loadFromDisk(catalogName: "MixedLanguageFramework")
         
         let frameworkDocumentationNode = try context.entity(
-            with: ResolvedTopicReference(
-                bundleID: bundle.id,
-                path: "/documentation/MixedLanguageFramework",
-                sourceLanguages: [.swift, .objectiveC]
-            )
+            with: XCTUnwrap(context.soleRootModuleReference)
         )
         
         let swiftTopics = try AutomaticCuration.topics(
@@ -578,16 +573,13 @@ class AutomaticCurationTests: XCTestCase {
         let whatsitSymbols = Bundle.module.url(
             forResource: "Whatsit-Objective-C.symbols", withExtension: "json", subdirectory: "Test Resources")!
 
-        let (bundleURL, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { url in
             try? FileManager.default.copyItem(at: whatsitSymbols, to: url.appendingPathComponent("Whatsit-Objective-C.symbols.json"))
         }
-        defer {
-            try? FileManager.default.removeItem(at: bundleURL)
-        }
 
         let frameworkDocumentationNode = try context.entity(
             with: ResolvedTopicReference(
-                bundleID: bundle.id,
+                bundleID: context.inputs.id,
                 path: "/documentation/Whatsit",
                 sourceLanguages: [.objectiveC]
             )
@@ -613,7 +605,7 @@ class AutomaticCurationTests: XCTestCase {
 
         let classDocumentationNode = try context.entity(
             with: ResolvedTopicReference(
-                bundleID: bundle.id,
+                bundleID: context.inputs.id,
                 path: "/documentation/Whatsit/Whatsit",
                 sourceLanguages: [.objectiveC]
             )
@@ -639,16 +631,13 @@ class AutomaticCurationTests: XCTestCase {
         let symbolURL = Bundle.module.url(
             forResource: "TypeSubscript.symbols", withExtension: "json", subdirectory: "Test Resources")!
 
-        let (bundleURL, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { url in
             try? FileManager.default.copyItem(at: symbolURL, to: url.appendingPathComponent("TypeSubscript.symbols.json"))
         }
-        defer {
-            try? FileManager.default.removeItem(at: bundleURL)
-        }
 
         let containerDocumentationNode = try context.entity(
             with: ResolvedTopicReference(
-                bundleID: bundle.id,
+                bundleID: context.inputs.id,
                 path: "/documentation/ThirdOrder/SomeStruct",
                 sourceLanguages: [.swift]
             )
@@ -671,14 +660,10 @@ class AutomaticCurationTests: XCTestCase {
     }
 
     func testCPlusPlusSymbolsAreCuratedProperly() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "CxxSymbols")
+        let context = try await loadFromDisk(catalogName: "CxxSymbols")
 
         let rootDocumentationNode = try context.entity(
-            with: .init(
-                bundleID: bundle.id,
-                path: "/documentation/CxxSymbols",
-                sourceLanguage: .objectiveC
-            )
+            with: XCTUnwrap(context.soleRootModuleReference)
         )
         let topics = try AutomaticCuration.topics(
             for: rootDocumentationNode,
@@ -703,7 +688,7 @@ class AutomaticCurationTests: XCTestCase {
     // Ensures that manually curated sample code articles are not also
     // automatically curated.
     func testSampleCodeArticlesRespectManualCuration() async throws {
-        let renderNode = try await renderNode(atPath: "/documentation/SomeSample", fromTestBundleNamed: "SampleBundle")
+        let renderNode = try await renderNode(atPath: "/documentation/SomeSample", fromOnDiskCatalogNamed: "SampleBundle")
         
         guard renderNode.topicSections.count == 2 else {
             XCTFail("Expected to find '2' topic sections. Found: \(renderNode.topicSections.count.description.singleQuoted).")
@@ -736,7 +721,7 @@ class AutomaticCurationTests: XCTestCase {
 
         let protocolRenderNode = try await renderNode(
             atPath: "/documentation/ShapeKit/OverloadedProtocol",
-            fromTestBundleNamed: "OverloadedSymbols")
+            fromOnDiskCatalogNamed: "OverloadedSymbols")
 
         guard protocolRenderNode.topicSections.count == 1, let protocolTopicSection = protocolRenderNode.topicSections.first else {
             XCTFail("Expected to find 1 topic section, found \(protocolRenderNode.topicSections.count): \(protocolRenderNode.topicSections.map(\.title?.singleQuoted))")
@@ -750,7 +735,7 @@ class AutomaticCurationTests: XCTestCase {
 
         let overloadGroupRenderNode = try await renderNode(
             atPath: "/documentation/ShapeKit/OverloadedProtocol/fourthTestMemberName(test:)",
-            fromTestBundleNamed: "OverloadedSymbols")
+            fromOnDiskCatalogNamed: "OverloadedSymbols")
 
         XCTAssertEqual(
             overloadGroupRenderNode.topicSections.count, 0,
@@ -761,11 +746,11 @@ class AutomaticCurationTests: XCTestCase {
     func testAutomaticCurationHandlesOverloadsWithLanguageFilters() async throws {
         enableFeatureFlag(\.isExperimentalOverloadedSymbolPresentationEnabled)
 
-        let (bundle, context) = try await testBundleAndContext(named: "OverloadedSymbols")
+        let (_, context) = try await loadFromDisk(catalogName: "OverloadedSymbols")
 
         let protocolDocumentationNode = try context.entity(
             with: .init(
-                bundleID: bundle.id,
+                bundleID: context.inputs.id,
                 path: "/documentation/ShapeKit/OverloadedProtocol",
                 sourceLanguage: .swift))
 
@@ -802,7 +787,7 @@ class AutomaticCurationTests: XCTestCase {
     func testAutomaticCurationDropsOverloadGroupWhenOverloadsAreCurated() async throws {
         enableFeatureFlag(\.isExperimentalOverloadedSymbolPresentationEnabled)
 
-        let (_, bundle, context) = try await testBundleAndContext(copying: "OverloadedSymbols") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "OverloadedSymbols") { url in
             try """
             # ``OverloadedProtocol``
 
@@ -819,13 +804,13 @@ class AutomaticCurationTests: XCTestCase {
 
         let protocolDocumentationNode = try context.entity(
             with: .init(
-                bundleID: bundle.id,
+                bundleID: context.inputs.id,
                 path: "/documentation/ShapeKit/OverloadedProtocol",
                 sourceLanguage: .swift))
 
         // Compile the render node to flex the automatic curator
         let symbol = protocolDocumentationNode.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: protocolDocumentationNode.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: protocolDocumentationNode.reference)
         let renderNode = translator.visit(symbol) as! RenderNode
 
         XCTAssertEqual(renderNode.topicSections.count, 2)
@@ -862,7 +847,7 @@ class AutomaticCurationTests: XCTestCase {
             - ``SecondClass``
             """),
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
         
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
@@ -894,7 +879,7 @@ class AutomaticCurationTests: XCTestCase {
             - <doc:API-Collection>
             """),
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
         
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
@@ -922,7 +907,7 @@ class AutomaticCurationTests: XCTestCase {
             - ``SecondClass``
             """),
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
         
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
@@ -954,7 +939,7 @@ class AutomaticCurationTests: XCTestCase {
             - <doc:API-Collection>
             """),
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
         
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
@@ -982,7 +967,7 @@ class AutomaticCurationTests: XCTestCase {
             - ``SecondClass``
             """),
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
         
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
@@ -1011,7 +996,7 @@ class AutomaticCurationTests: XCTestCase {
             - ``FirstClass/firstMember``
             """),
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
         
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
@@ -1045,7 +1030,7 @@ class AutomaticCurationTests: XCTestCase {
             - <doc:API-Collection>
             """),
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
         
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
@@ -1077,7 +1062,7 @@ class AutomaticCurationTests: XCTestCase {
             - ``FirstClass/firstMember``
             """),
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
         
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
@@ -1123,7 +1108,7 @@ class AutomaticCurationTests: XCTestCase {
             - <doc:API-Collection-1>
             """),
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
         
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
@@ -1156,7 +1141,7 @@ class AutomaticCurationTests: XCTestCase {
             - ``OuterClass/someMember``
             """),
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
         
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
@@ -1195,7 +1180,7 @@ class AutomaticCurationTests: XCTestCase {
             # First article
             """),
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
         
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
@@ -1242,12 +1227,12 @@ class AutomaticCurationTests: XCTestCase {
              """),
              ])
              let catalogURL = try exampleDocumentation.write(inside: createTemporaryDirectory())
-             let (_, bundle, context) = try await loadBundle(from: catalogURL)
+             let context = try await loadFromDisk(catalogURL: catalogURL)
 
-             let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleName/SomeClass", sourceLanguage: .swift))
+             let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleName/SomeClass", sourceLanguage: .swift))
 
              // Compile docs and verify the generated Topics section
-             var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+             var translator = RenderNodeTranslator(context: context, identifier: node.reference)
              let renderNode = try XCTUnwrap(translator.visit(node.semantic) as? RenderNode)
 
              // Verify that there are no duplicate sections in `SomeClass`'s "Topics" section
@@ -1285,7 +1270,7 @@ class AutomaticCurationTests: XCTestCase {
         ])
         
         // Load the bundle
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
         
         // Get the module and its automatic curation groups
@@ -1351,7 +1336,7 @@ class AutomaticCurationTests: XCTestCase {
         ])
 
         // Load the bundle
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
         
         // Get the module and its automatic curation groups
diff --git a/Tests/SwiftDocCTests/Infrastructure/BundleDiscoveryTests.swift b/Tests/SwiftDocCTests/Infrastructure/BundleDiscoveryTests.swift
index 323fe5a2c5..ee5beb295e 100644
--- a/Tests/SwiftDocCTests/Infrastructure/BundleDiscoveryTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/BundleDiscoveryTests.swift
@@ -29,7 +29,7 @@ class BundleDiscoveryTests: XCTestCase {
     func testBundleFormat() throws {
         let allFiles = try flatListOfFiles()
         
-        func parsedBundle(from folder: any File) throws -> DocumentationBundle {
+        func parsedBundle(from folder: any File) throws -> DocumentationContext.Inputs {
             let fileSystem = try TestFileSystem(folders: [
                 Folder(name: "path", content: [
                     Folder(name: "to", content: [
@@ -39,8 +39,8 @@ class BundleDiscoveryTests: XCTestCase {
             ])
             
             let inputProvider = DocumentationContext.InputsProvider(fileManager: fileSystem)
-            let (bundle, _) = try inputProvider.inputsAndDataProvider(startingPoint: URL(fileURLWithPath: "/"), options: .init())
-            return bundle
+            let (inputs, _) = try inputProvider.inputsAndDataProvider(startingPoint: URL(fileURLWithPath: "/"), options: .init())
+            return inputs
         }
         
         let expectedBundle = try parsedBundle(from: CopyOfFolder(original: testBundleLocation))
@@ -119,15 +119,15 @@ class BundleDiscoveryTests: XCTestCase {
             Folder(name: "path", content: [
                 Folder(name: "to", content: [
                     // The test bundle without all the symbol graph files
-                    CopyOfFolder(original: testBundleLocation, filter: { !DocumentationBundleFileTypes.isSymbolGraphFile($0) }),
+                    CopyOfFolder(original: testBundleLocation, filter: { !DocumentationInputFileTypes.isSymbolGraphFile($0) }),
                     
                     // Just the symbol graph files in a non-bundle folder
-                    CopyOfFolder(original: testBundleLocation, newName: "Not a catalog", filter: { DocumentationBundleFileTypes.isSymbolGraphFile($0) }),
+                    CopyOfFolder(original: testBundleLocation, newName: "Not a catalog", filter: { DocumentationInputFileTypes.isSymbolGraphFile($0) }),
                 ])
             ])
         ])
         
-        let bundleDiscoveryOptions = BundleDiscoveryOptions(
+        let bundleDiscoveryOptions = CatalogDiscoveryOptions(
             infoPlistFallbacks: [
                 "CFBundleDisplayName": "Fallback Display Name",
             ],
@@ -160,7 +160,7 @@ class BundleDiscoveryTests: XCTestCase {
     func testNoInfoPlist() throws {
         let catalog = Folder(name: "Something.docc", content: [])
 
-        let bundleDiscoveryOptions = BundleDiscoveryOptions(
+        let bundleDiscoveryOptions = CatalogDiscoveryOptions(
             infoPlistFallbacks: [
                 "CFBundleDisplayName": "Fallback Display Name",
                 "CFBundleIdentifier": "com.fallback.bundle.identifier"
diff --git a/Tests/SwiftDocCTests/Infrastructure/DocumentationBundleTests.swift b/Tests/SwiftDocCTests/Infrastructure/DocumentationBundleTests.swift
deleted file mode 100644
index 4671760ea2..0000000000
--- a/Tests/SwiftDocCTests/Infrastructure/DocumentationBundleTests.swift
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
- This source file is part of the Swift.org open source project
-
- Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
- Licensed under Apache License v2.0 with Runtime Library Exception
-
- See https://swift.org/LICENSE.txt for license information
- See https://swift.org/CONTRIBUTORS.txt for Swift project authors
-*/
-
-import XCTest
-
-class DocumentationBundleTests: XCTestCase {
-    // Test whether the bundle correctly loads a documentation source folder.
-    func testBundleInitWithRootURL() throws {
-        XCTAssertNoThrow(try testBundleFromRootURL(named: "LegacyBundle_DoNotUseInNewTests"))
-    }
-}
diff --git a/Tests/SwiftDocCTests/Infrastructure/DocumentationContext/DocumentationContext+MixedLanguageLinkResolutionTests.swift b/Tests/SwiftDocCTests/Infrastructure/DocumentationContext/DocumentationContext+MixedLanguageLinkResolutionTests.swift
index 24fc0d736f..765c3b0621 100644
--- a/Tests/SwiftDocCTests/Infrastructure/DocumentationContext/DocumentationContext+MixedLanguageLinkResolutionTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/DocumentationContext/DocumentationContext+MixedLanguageLinkResolutionTests.swift
@@ -14,7 +14,7 @@ import XCTest
 class DocumentationContext_MixedLanguageLinkResolutionTests: XCTestCase {
     
     func testResolvingLinksWhenSymbolHasSameNameInBothLanguages() async throws {
-        let (_, _, context) = try await testBundleAndContext(copying: "MixedLanguageFrameworkComplexLinks") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "MixedLanguageFrameworkComplexLinks") { url in
              let swiftSymbolGraph = url.appendingPathComponent("symbol-graph/swift/ObjCLinks.symbols.json")
              try String(contentsOf: swiftSymbolGraph)
                  .replacingOccurrences(of: "FooSwift", with: "FooObjC")
diff --git a/Tests/SwiftDocCTests/Infrastructure/DocumentationContext/DocumentationContext+MixedLanguageSourceLanguagesTests.swift b/Tests/SwiftDocCTests/Infrastructure/DocumentationContext/DocumentationContext+MixedLanguageSourceLanguagesTests.swift
index 2206ad29ea..be71163674 100644
--- a/Tests/SwiftDocCTests/Infrastructure/DocumentationContext/DocumentationContext+MixedLanguageSourceLanguagesTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/DocumentationContext/DocumentationContext+MixedLanguageSourceLanguagesTests.swift
@@ -44,7 +44,7 @@ class DocumentationContext_MixedLanguageSourceLanguagesTests: XCTestCase {
             "moduleAvailableLanguages can only contain Swift and Objective-C as languages."
         )
         
-        let (_, _, context) = try await testBundleAndContext(copying: "MixedLanguageFramework") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "MixedLanguageFramework") { url in
             try """
             # MyArticle
             
diff --git a/Tests/SwiftDocCTests/Infrastructure/DocumentationContext/DocumentationContext+RootPageTests.swift b/Tests/SwiftDocCTests/Infrastructure/DocumentationContext/DocumentationContext+RootPageTests.swift
index 9523dc0966..76adfd03ef 100644
--- a/Tests/SwiftDocCTests/Infrastructure/DocumentationContext/DocumentationContext+RootPageTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/DocumentationContext/DocumentationContext+RootPageTests.swift
@@ -15,7 +15,7 @@ import SwiftDocCTestUtilities
 
 class DocumentationContext_RootPageTests: XCTestCase {
     func testArticleOnlyCatalogWithExplicitTechnologyRoot() async throws {
-        let (_, context) = try await loadBundle(catalog:
+        let context = try await load(catalog:
             Folder(name: "no-sgf-test.docc", content: [
                 // Root page for the collection
                 TextFile(name: "ReleaseNotes.md", utf8Content: """
@@ -51,7 +51,7 @@ class DocumentationContext_RootPageTests: XCTestCase {
     }
 
     func testWarnsAboutExtensionFileTechnologyRoot() async throws {
-        let (_, context) = try await loadBundle(catalog:
+        let context = try await load(catalog:
             Folder(name: "no-sgf-test.docc", content: [
                 // Root page for the collection
                 TextFile(name: "ReleaseNotes.md", utf8Content: """
@@ -85,7 +85,7 @@ class DocumentationContext_RootPageTests: XCTestCase {
     }
     
     func testSingleArticleWithoutTechnologyRootDirective() async throws {
-        let (_, context) = try await loadBundle(catalog:
+        let context = try await load(catalog:
             Folder(name: "Something.docc", content: [
                 TextFile(name: "Article.md", utf8Content: """
                 # My article
@@ -102,7 +102,7 @@ class DocumentationContext_RootPageTests: XCTestCase {
     }
     
     func testMultipleArticlesWithoutTechnologyRootDirective() async throws {
-        let (_, context) = try await loadBundle(catalog:
+        let context = try await load(catalog:
             Folder(name: "Something.docc", content: [
                 TextFile(name: "First.md", utf8Content: """
                 # My first article
@@ -136,7 +136,7 @@ class DocumentationContext_RootPageTests: XCTestCase {
     }
     
     func testMultipleArticlesWithoutTechnologyRootDirectiveWithOneMatchingTheCatalogName() async throws {
-        let (_, context) = try await loadBundle(catalog:
+        let context = try await load(catalog:
             Folder(name: "Something.docc", content: [
                 TextFile(name: "Something.md", utf8Content: """
                 # Some article
diff --git a/Tests/SwiftDocCTests/Infrastructure/DocumentationContext/DocumentationContextTests.swift b/Tests/SwiftDocCTests/Infrastructure/DocumentationContext/DocumentationContextTests.swift
index 11326bef88..528c0231f6 100644
--- a/Tests/SwiftDocCTests/Infrastructure/DocumentationContext/DocumentationContextTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/DocumentationContext/DocumentationContextTests.swift
@@ -37,9 +37,9 @@ extension CollectionDifference {
 
 class DocumentationContextTests: XCTestCase {
     func testLoadEntity() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         
-        let identifier = ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/Test-Bundle/TestTutorial", sourceLanguage: .swift)
+        let identifier = ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/Test-Bundle/TestTutorial", sourceLanguage: .swift)
         
         XCTAssertThrowsError(try context.entity(with: ResolvedTopicReference(bundleID: "some.other.bundle", path: "/tutorials/Test-Bundle/TestTutorial", sourceLanguage: .swift)))
         
@@ -371,57 +371,57 @@ class DocumentationContextTests: XCTestCase {
     }
         
     func testThrowsErrorForMissingResource() async throws {
-        let (_, context) = try await testBundleAndContext()
+        let context = try await makeEmptyContext()
         XCTAssertThrowsError(try context.resource(with: ResourceReference(bundleID: "com.example.missing", path: "/missing.swift")), "Expected requesting an unknown file to result in an error.")
     }
 
     func testThrowsErrorForQualifiedImagePaths() async throws {
-        let (bundle, context) = try await loadBundle(catalog: Folder(name: "unit-test.docc", content: [
+        let context = try await load(catalog: Folder(name: "unit-test.docc", content: [
             DataFile(name: "figure1.jpg", data: Data())
         ]))
-        let id = bundle.id
+        let id = context.inputs.id
 
         let figure = ResourceReference(bundleID: id, path: "figure1.jpg")
         let imageFigure = ResourceReference(bundleID: id, path: "images/figure1.jpg")
 
-        XCTAssertNoThrow(try context.resource(with: figure), "\(figure.path) expected in \(bundle.displayName)")
+        XCTAssertNoThrow(try context.resource(with: figure), "\(figure.path) expected in \(context.inputs.displayName)")
         XCTAssertThrowsError(try context.resource(with: imageFigure), "Images should be registered (and referred to) by their name, not by their path.")
     }
     
     func testResourceExists() async throws {
-        let (bundle, context) = try await loadBundle(catalog: Folder(name: "unit-test.docc", content: [
+        let context = try await load(catalog: Folder(name: "unit-test.docc", content: [
             DataFile(name: "figure1.jpg", data: Data()),
             DataFile(name: "introposter.jpg", data: Data()),
         ]))
         
         let existingImageReference = ResourceReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "introposter"
         )
         let nonexistentImageReference = ResourceReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "nonexistent-image"
         )
         XCTAssertTrue(
             context.resourceExists(with: existingImageReference),
-            "\(existingImageReference.path) expected in \(bundle.displayName)"
+            "\(existingImageReference.path) expected in \(context.inputs.displayName)"
         )
         XCTAssertFalse(
             context.resourceExists(with: nonexistentImageReference),
-            "\(nonexistentImageReference.path) does not exist in \(bundle.displayName)"
+            "\(nonexistentImageReference.path) does not exist in \(context.inputs.displayName)"
         )
         
         let correctImageReference = ResourceReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "figure1.jpg"
         )
         let incorrectImageReference = ResourceReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "images/figure1.jpg"
         )
         XCTAssertTrue(
             context.resourceExists(with: correctImageReference),
-            "\(correctImageReference.path) expected in \(bundle.displayName)"
+            "\(correctImageReference.path) expected in \(context.inputs.displayName)"
         )
         XCTAssertFalse(
             context.resourceExists(with: incorrectImageReference),
@@ -458,7 +458,7 @@ class DocumentationContextTests: XCTestCase {
         ])
 
         // Parse this test content
-        let (_, context) = try await loadBundle(catalog: exampleDocumentation)
+        let context = try await load(catalog: exampleDocumentation)
         
         // Verify all the reference identifiers for this content
         XCTAssertEqual(context.knownIdentifiers.count, 3)
@@ -473,7 +473,7 @@ class DocumentationContextTests: XCTestCase {
     }
     
     func testRegisteredImages() async throws {
-        let (bundle, context) = try await loadBundle(catalog: Folder(name: "unit-test.docc", content: [
+        let context = try await load(catalog: Folder(name: "unit-test.docc", content: [
             DataFile(name: "figure1.jpg",          data: Data()),
             DataFile(name: "figure1.png",          data: Data()),
             DataFile(name: "figure1~dark.png",     data: Data()),
@@ -489,7 +489,7 @@ class DocumentationContextTests: XCTestCase {
         ]))
         
         let imagesRegistered = context
-            .registeredImageAssets(for: bundle.id)
+            .registeredImageAssets(for: context.inputs.id)
             .flatMap { $0.variants.map { $0.value.lastPathComponent } }
             .sorted()
         
@@ -513,9 +513,9 @@ class DocumentationContextTests: XCTestCase {
     }
     
     func testExternalAssets() async throws {
-        let (bundle, context) = try await testBundleAndContext()
+        let context = try await makeEmptyContext()
         
-        let image = context.resolveAsset(named: "https://example.com/figure.png", in: bundle.rootReference)
+        let image = context.resolveAsset(named: "https://example.com/figure.png", in: context.inputs.rootReference)
         XCTAssertNotNil(image)
         guard let image else {
             return
@@ -523,7 +523,7 @@ class DocumentationContextTests: XCTestCase {
         XCTAssertEqual(image.context, .display)
         XCTAssertEqual(image.variants, [DataTraitCollection(userInterfaceStyle: .light, displayScale: .standard): URL(string: "https://example.com/figure.png")!])
         
-        let video = context.resolveAsset(named: "https://example.com/introvideo.mp4", in: bundle.rootReference)
+        let video = context.resolveAsset(named: "https://example.com/introvideo.mp4", in: context.inputs.rootReference)
         XCTAssertNotNil(video)
         guard let video else { return }
         XCTAssertEqual(video.context, .display)
@@ -531,7 +531,7 @@ class DocumentationContextTests: XCTestCase {
     }
     
     func testDownloadAssets() async throws {
-        let (bundle, context) = try await loadBundle(catalog: Folder(name: "unit-test.docc", content: [
+        let context = try await load(catalog: Folder(name: "unit-test.docc", content: [
             DataFile(name: "intro.png", data: Data()),
             DataFile(name: "project.zip", data: Data()),
             
@@ -564,12 +564,12 @@ class DocumentationContextTests: XCTestCase {
             
         ]))
         
-        let downloadsBefore = context.registeredDownloadsAssets(for: bundle.id)
+        let downloadsBefore = context.registeredDownloadsAssets(for: context.inputs.id)
         XCTAssertEqual(downloadsBefore.count, 1)
         XCTAssertEqual(downloadsBefore.first?.variants.values.first?.lastPathComponent, "project.zip")
         
         guard var assetOriginal = context
-            .registeredImageAssets(for: bundle.id)
+            .registeredImageAssets(for: context.inputs.id)
             .first(where: { asset -> Bool in
                 return asset.variants.values.first(where: { url -> Bool in
                     return url.path.contains("intro.png")
@@ -581,10 +581,10 @@ class DocumentationContextTests: XCTestCase {
         
         // Update the asset.
         assetOriginal.context = .download
-        context.updateAsset(named: "intro.png", asset: assetOriginal, in: bundle.rootReference)
+        context.updateAsset(named: "intro.png", asset: assetOriginal, in: context.inputs.rootReference)
         
         guard let assetUpdated = context
-            .registeredImageAssets(for: bundle.id)
+            .registeredImageAssets(for: context.inputs.id)
             .first(where: { asset -> Bool in
                 return asset.variants.values.first(where: { url -> Bool in
                     return url.path.contains("intro.png")
@@ -598,7 +598,7 @@ class DocumentationContextTests: XCTestCase {
         XCTAssertEqual(assetUpdated.context, .download)
         
         // Verify the asset is accessible in the downloads collection.
-        var downloadsAfter = context.registeredDownloadsAssets(for: bundle.id)
+        var downloadsAfter = context.registeredDownloadsAssets(for: context.inputs.id)
         XCTAssertEqual(downloadsAfter.count, 2)
         downloadsAfter.removeAll(where: { $0.variants.values.first?.lastPathComponent == "project.zip" })
         XCTAssertEqual(downloadsAfter.count, 1)
@@ -606,7 +606,7 @@ class DocumentationContextTests: XCTestCase {
     }
 
     func testDetectsReferenceCollision() async throws {
-        let (_, context) = try await testBundleAndContext(named: "TestBundleWithDupe")
+        let context = try await loadFromDisk(catalogName: "TestBundleWithDupe")
 
         let problemWithDuplicate = context.problems.filter { $0.diagnostic.identifier == "org.swift.docc.DuplicateReference" }
 
@@ -618,7 +618,7 @@ class DocumentationContextTests: XCTestCase {
     }
     
     func testDetectsMultipleMarkdownFilesWithSameName() async throws {
-        let (_, context) = try await testBundleAndContext(named: "TestBundleWithDupMD")
+        let context = try await loadFromDisk(catalogName: "TestBundleWithDupMD")
 
         let problemWithDuplicateReference = context.problems.filter { $0.diagnostic.identifier == "org.swift.docc.DuplicateReference" }
 
@@ -676,7 +676,7 @@ class DocumentationContextTests: XCTestCase {
                 )
             ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
 
         // Since documentation extensions' filenames have no impact on the URL of pages, we should not see warnings enforcing unique filenames for them.
         let problemWithDuplicateReference = context.problems.filter { $0.diagnostic.identifier == "org.swift.docc.DuplicateReference" }
@@ -705,7 +705,7 @@ class DocumentationContextTests: XCTestCase {
             # Some root page
             """)
         ])
-        let (_, context) = try await loadBundle(catalog: catalog, configuration: configuration)
+        let context = try await load(catalog: catalog, configuration: configuration)
         
         /// Checks if the custom check added problems to the context.
         let testProblems = context.problems.filter({ (problem) -> Bool in
@@ -738,7 +738,7 @@ class DocumentationContextTests: XCTestCase {
             ])
         ])
         
-        let (_, context) = try await loadBundle(catalog: testCatalog)
+        let context = try await load(catalog: testCatalog)
         
         XCTAssertEqual(context.knownPages.map { $0.path }, ["/tutorials/TestIgnoresUnknownMarkupFiles/Article1"])
         XCTAssertTrue(context.problems.map { $0.diagnostic.identifier }.contains("org.swift.docc.Article.Title.NotFound"))
@@ -760,7 +760,7 @@ class DocumentationContextTests: XCTestCase {
             ])
         ])
         
-        let (_, context) = try await loadBundle(catalog: testCatalog)
+        let context = try await load(catalog: testCatalog)
         
         // Symbols are loaded
         XCTAssertFalse(context.documentationCache.isEmpty)
@@ -1027,10 +1027,10 @@ class DocumentationContextTests: XCTestCase {
                 JSONFile(name: "symbols\(forwards ? "2" : "1").symbols.json", content: iOSSymbolGraph),
             ])
 
-            let (bundle, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
 
             let reference = ResolvedTopicReference(
-                bundleID: bundle.id,
+                bundleID: context.inputs.id,
                 path: "/documentation/TestProject/TestSymbol",
                 sourceLanguage: .swift
             )
@@ -1087,10 +1087,10 @@ class DocumentationContextTests: XCTestCase {
                 JSONFile(name: "symbols\(forwards ? "2" : "1").symbols.json", content: iOSSymbolGraph),
             ])
 
-            let (bundle, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
 
             let reference = ResolvedTopicReference(
-                bundleID: bundle.id,
+                bundleID: context.inputs.id,
                 path: "/documentation/TestProject/TestSymbol",
                 sourceLanguage: .swift
             )
@@ -1123,7 +1123,7 @@ class DocumentationContextTests: XCTestCase {
             ]),
         ])
         
-        let (_, context) = try await loadBundle(catalog: testCatalog)
+        let context = try await load(catalog: testCatalog)
         
         // MyClass is loaded
         guard let myClass = context.documentationCache["s:5MyKit0A5ClassC"],
@@ -1180,7 +1180,7 @@ class DocumentationContextTests: XCTestCase {
             ])
         ])
         
-        let (_, context) = try await loadBundle(catalog: testCatalog)
+        let context = try await load(catalog: testCatalog)
         
         // MyFunction is loaded
         XCTAssertNotNil(context.documentationCache[myFunctionSymbolPreciseIdentifier], "myFunction which only exist on iOS should be found in the graph")
@@ -1208,7 +1208,7 @@ class DocumentationContextTests: XCTestCase {
             ])
         ])
         
-        let (_, context) = try await loadBundle(catalog: testCatalog)
+        let context = try await load(catalog: testCatalog)
         
         // SideClass is loaded
         guard let sideClass = context.documentationCache["s:7SideKit0A5ClassC"],
@@ -1239,7 +1239,7 @@ class DocumentationContextTests: XCTestCase {
             ])
         ])
         
-        let (_, context) = try await loadBundle(catalog: testCatalog)
+        let context = try await load(catalog: testCatalog)
         
         // MyClass is loaded
         guard let myClass = context.documentationCache["s:5MyKit0A5ClassC"],
@@ -1271,7 +1271,7 @@ class DocumentationContextTests: XCTestCase {
             """),
         ])
         
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
 
         let duplicateExtensionProblems = context.problems.filter { $0.diagnostic.identifier == "org.swift.docc.DuplicateMarkdownTitleSymbolReferences" }
         let diagnostic = try XCTUnwrap(duplicateExtensionProblems.first).diagnostic
@@ -1280,7 +1280,7 @@ class DocumentationContextTests: XCTestCase {
         // Verify that both files are mentioned in the diagnostic and its note.
         let mentionedMarkupURLs = Set(diagnostic.notes.map(\.source) + [source])
         
-        let missingMarkupURLs = Set(bundle.markupURLs).subtracting(mentionedMarkupURLs)
+        let missingMarkupURLs = Set(context.inputs.markupURLs).subtracting(mentionedMarkupURLs)
         
         XCTAssert(missingMarkupURLs.isEmpty, "\(missingMarkupURLs.map(\.lastPathComponent).sorted()) isn't mentioned in the diagnostic.")
     }
@@ -1328,13 +1328,13 @@ class DocumentationContextTests: XCTestCase {
                 """),
             ] + testData.symbolGraphFiles)
             
-            let (bundle, context) = try await loadBundle(catalog: testCatalog)
-            let renderContext = RenderContext(documentationContext: context, bundle: bundle)
+            let context = try await load(catalog: testCatalog)
+            let renderContext = RenderContext(documentationContext: context)
             
-            let identifier = ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/TestOverview", sourceLanguage: .swift)
+            let identifier = ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/TestOverview", sourceLanguage: .swift)
             let node = try context.entity(with: identifier)
             
-            let converter = DocumentationContextConverter(bundle: bundle, context: context, renderContext: renderContext)
+            let converter = DocumentationContextConverter(context: context, renderContext: renderContext)
             let renderNode = try XCTUnwrap(converter.renderNode(for: node))
             
             XCTAssertEqual(
@@ -1351,7 +1351,7 @@ class DocumentationContextTests: XCTestCase {
     }
     
     func testCuratesSymbolsAndArticlesCorrectly() async throws {
-        let (_, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
 
         // Sort the edges for each node to get consistent results, no matter the order that the symbols were processed.
         for (source, targets) in context.topicGraph.edges {
@@ -1429,7 +1429,7 @@ let expected = """
                        [["doc://org.swift.docc.example/documentation/MyKit", "doc://org.swift.docc.example/documentation/MyKit/MyClass"], ["doc://org.swift.docc.example/documentation/MyKit", "doc://org.swift.docc.example/documentation/MyKit/MyProtocol", "doc://org.swift.docc.example/documentation/MyKit/MyClass"]])
     }
     
-    func createNode(in context: DocumentationContext, bundle: DocumentationBundle, parent: ResolvedTopicReference, name: String) throws -> (DocumentationNode, TopicGraph.Node) {
+    func createNode(in context: DocumentationContext, parent: ResolvedTopicReference, name: String) throws -> (DocumentationNode, TopicGraph.Node) {
         let reference = parent.appendingPath(name)
         let node = DocumentationNode(reference: reference, kind: .article, sourceLanguage: .swift, name: .conceptual(title: name), markup: Document(parsing: "# \(name)"), semantic: nil)
         let tgNode = TopicGraph.Node(reference: reference, kind: .article, source: .external, title: name)
@@ -1446,7 +1446,7 @@ let expected = """
         let catalog = Folder(name: "unit-test.docc", content: [
             JSONFile(name: "SomeModuleName.symbols.json", content: makeSymbolGraph(moduleName: "SomeModuleName"))
         ])
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
         
         ///
@@ -1454,10 +1454,10 @@ let expected = """
         ///
 
         /// Create /documentation/MyKit/AAA & /documentation/MyKit/BBB
-        let (aaaNode, _) = try createNode(in: context, bundle: bundle, parent: moduleReference, name: "AAA")
-        let (_, bbbTgNode) = try createNode(in: context, bundle: bundle, parent: moduleReference, name: "BBB")
+        let (aaaNode, _) = try createNode(in: context, parent: moduleReference, name: "AAA")
+        let (_, bbbTgNode) = try createNode(in: context, parent: moduleReference, name: "BBB")
         /// Create /documentation/MyKit/AAA/CCC, curate also under BBB
-        let (cccNode, cccTgNode) = try createNode(in: context, bundle: bundle, parent: aaaNode.reference, name: "CCC")
+        let (cccNode, cccTgNode) = try createNode(in: context, parent: aaaNode.reference, name: "CCC")
         context.topicGraph.addEdge(from: bbbTgNode, to: cccTgNode)
         
         let canonicalPathCCC = try XCTUnwrap(context.shortestFinitePath(to: cccNode.reference))
@@ -1468,10 +1468,10 @@ let expected = """
         ///
 
         /// Create /documentation/MyKit/DDD & /documentation/MyKit/EEE
-        let (_, dddTgNode) = try createNode(in: context, bundle: bundle, parent: moduleReference, name: "DDD")
-        let (eeeNode, _) = try createNode(in: context, bundle: bundle, parent: moduleReference, name: "EEE")
+        let (_, dddTgNode) = try createNode(in: context, parent: moduleReference, name: "DDD")
+        let (eeeNode, _) = try createNode(in: context, parent: moduleReference, name: "EEE")
         /// Create /documentation/MyKit/DDD/FFF, curate also under EEE
-        let (fffNode, fffTgNode) = try createNode(in: context, bundle: bundle, parent: eeeNode.reference, name: "FFF")
+        let (fffNode, fffTgNode) = try createNode(in: context, parent: eeeNode.reference, name: "FFF")
         context.topicGraph.addEdge(from: dddTgNode, to: fffTgNode)
         
         let canonicalPathFFF = try XCTUnwrap(context.shortestFinitePath(to: fffNode.reference))
@@ -1482,7 +1482,7 @@ let expected = """
         let catalog = Folder(name: "unit-test.docc", content: [
             JSONFile(name: "SomeModuleName.symbols.json", content: makeSymbolGraph(moduleName: "SomeModuleName"))
         ])
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
         let moduleTopicNode = try XCTUnwrap(context.topicGraph.nodeWithReference(moduleReference))
         
@@ -1491,10 +1491,10 @@ let expected = """
         ///
 
         /// Create /documentation/MyKit/AAA & /documentation/MyKit/BBB
-        let (aaaNode, aaaTgNode) = try createNode(in: context, bundle: bundle, parent: moduleReference, name: "AAA")
-        let (_, bbbTgNode) = try createNode(in: context, bundle: bundle, parent: moduleReference, name: "BBB")
+        let (aaaNode, aaaTgNode) = try createNode(in: context, parent: moduleReference, name: "AAA")
+        let (_, bbbTgNode) = try createNode(in: context, parent: moduleReference, name: "BBB")
         /// Create /documentation/MyKit/AAA/CCC and also curate under /documentation/MyKit
-        let (cccNode, cccTgNode) = try createNode(in: context, bundle: bundle, parent: aaaNode.reference, name: "CCC")
+        let (cccNode, cccTgNode) = try createNode(in: context, parent: aaaNode.reference, name: "CCC")
         context.topicGraph.addEdge(from: moduleTopicNode, to: cccTgNode)
         context.topicGraph.addEdge(from: aaaTgNode, to: cccTgNode)
         context.topicGraph.addEdge(from: bbbTgNode, to: cccTgNode)
@@ -1507,10 +1507,10 @@ let expected = """
         ///
 
         /// Create /documentation/MyKit/DDD & /documentation/MyKit/EEE
-        let (_, dddTgNode) = try createNode(in: context, bundle: bundle, parent: moduleReference, name: "DDD")
-        let (eeeNode, eeeTgNode) = try createNode(in: context, bundle: bundle, parent: moduleReference, name: "EEE")
+        let (_, dddTgNode) = try createNode(in: context, parent: moduleReference, name: "DDD")
+        let (eeeNode, eeeTgNode) = try createNode(in: context, parent: moduleReference, name: "EEE")
         /// Create /documentation/MyKit/DDD/FFF, curate also under /documentation/MyKit
-        let (fffNode, fffTgNode) = try createNode(in: context, bundle: bundle, parent: eeeNode.reference, name: "FFF")
+        let (fffNode, fffTgNode) = try createNode(in: context, parent: eeeNode.reference, name: "FFF")
         context.topicGraph.addEdge(from: eeeTgNode, to: fffTgNode)
         context.topicGraph.addEdge(from: dddTgNode, to: fffTgNode)
         context.topicGraph.addEdge(from: moduleTopicNode, to: fffTgNode)
@@ -1526,7 +1526,7 @@ let expected = """
                 makeSymbol(id: "some-class-id",    kind: .class,    pathComponents: ["SomeClass"]),
             ])),
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         // Verify the node is a child of the module node when the graph is loaded.
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
@@ -1538,7 +1538,7 @@ let expected = """
     /// Tests whether tutorial curated multiple times gets the correct breadcrumbs and hierarchy.
     func testCurateTutorialMultipleTimes() async throws {
         // Curate "TestTutorial" under MyKit as well as TechnologyX.
-        let (_, _, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             let myKitURL = root.appendingPathComponent("documentation/mykit.md")
             let text = try String(contentsOf: myKitURL).replacingOccurrences(of: "## Topics", with: """
             ## Topics
@@ -1565,7 +1565,7 @@ let expected = """
 
     func testNonOverloadPaths() async throws {
         // Add some symbol collisions to graph
-        let (_, _, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             let sideKitURL = root.appendingPathComponent("sidekit.symbols.json")
             let text = try String(contentsOf: sideKitURL).replacingOccurrences(of: "\"symbols\" : [", with: """
             "symbols" : [
@@ -1620,7 +1620,7 @@ let expected = """
         let catalog = Folder(name: "unit-test.docc", content: [
             JSONFile(name: "SomeModuleName.symbols.json", content: makeSymbolGraph(moduleName: "SomeModuleName")),
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         XCTAssertEqual(
             context.soleRootModuleReference.map { context.sourceLanguages(for: $0) },
@@ -1631,7 +1631,7 @@ let expected = """
     
     func testOverloadPlusNonOverloadCollisionPaths() async throws {
         // Add some symbol collisions to graph
-        let (_, _, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             let sideKitURL = root.appendingPathComponent("sidekit.symbols.json")
             let text = try String(contentsOf: sideKitURL).replacingOccurrences(of: "\"symbols\" : [", with: """
             "symbols" : [
@@ -1708,7 +1708,7 @@ let expected = """
             ])),
         ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
         
         // Get the node, verify its kind is unknown
@@ -1717,7 +1717,7 @@ let expected = """
     }
     
     func testCuratingSymbolsWithSpecialCharacters() async throws {
-        let (_, _, context) = try await testBundleAndContext(copying: "InheritedOperators") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "InheritedOperators") { root in
             try """
             # ``Operators/MyNumber``
             
@@ -1756,7 +1756,7 @@ let expected = """
     }
     
     func testOperatorReferences() async throws {
-        let (_, context) = try await testBundleAndContext(named: "InheritedOperators")
+        let context = try await loadFromDisk(catalogName: "InheritedOperators")
         
         let pageIdentifiersAndNames = Dictionary(uniqueKeysWithValues: try context.knownPages.map { reference in
             (key: reference.path, value: try context.entity(with: reference).name.description)
@@ -1824,7 +1824,7 @@ let expected = """
                 """),
             ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
 
         XCTAssertEqual(context.problems.map(\.diagnostic.summary), ["Redeclaration of 'Hello world.md'; this file will be skipped"])
         
@@ -1897,8 +1897,7 @@ let expected = """
             - <doc:Article:-with-various!-whitespace-&-punctuation.-in,-filename>
             """),
         ])
-        let bundleURL = try catalog.write(inside: createTemporaryDirectory())
-        let (_, bundle, context) = try await loadBundle(from: bundleURL)
+        let context = try await load(catalog: catalog)
 
         let problems = context.problems
         XCTAssertEqual(problems.count, 0, "Unexpected problems: \(problems.map(\.diagnostic.summary).sorted())")
@@ -1924,7 +1923,7 @@ let expected = """
             )
         }
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: moduleReference)
+        var translator = RenderNodeTranslator(context: context, identifier: moduleReference)
         let renderNode = translator.visit(moduleSymbol) as! RenderNode
         
         // Verify that the resolved links rendered as links
@@ -2029,7 +2028,7 @@ let expected = """
     
     func testNonOverloadCollisionFromExtension() async throws {
         // Add some symbol collisions to graph
-        let (_, _, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: ["mykit-iOS.symbols.json"]) { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", excludingPaths: ["mykit-iOS.symbols.json"]) { root in
             let sideKitURL = root.appendingPathComponent("something@SideKit.symbols.json")
             let text = """
             {
@@ -2113,7 +2112,7 @@ let expected = """
             """),
         ])
         
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         let unmatchedSidecarProblem = try XCTUnwrap(context.problems.first(where: { $0.diagnostic.identifier == "org.swift.docc.SymbolUnmatched" }))
         XCTAssertNotNil(unmatchedSidecarProblem)
@@ -2122,7 +2121,7 @@ let expected = """
         let source = try XCTUnwrap(unmatchedSidecarProblem.diagnostic.source)
         
         let unmatchedSidecarDiagnostic = unmatchedSidecarProblem.diagnostic
-        XCTAssertTrue(bundle.markupURLs.contains(source.standardizedFileURL), "One of the files should be the diagnostic source")
+        XCTAssertTrue(context.inputs.markupURLs.contains(source.standardizedFileURL), "One of the files should be the diagnostic source")
         XCTAssertEqual(unmatchedSidecarDiagnostic.range, SourceLocation(line: 1, column: 3, source: unmatchedSidecarProblem.diagnostic.source)..<SourceLocation(line: 1, column: 32, source: unmatchedSidecarProblem.diagnostic.source))
         
         XCTAssertEqual(unmatchedSidecarDiagnostic.summary, "No symbol matched '/ModuleName/UnknownSymbol'. 'UnknownSymbol' doesn't exist at '/ModuleName'.")
@@ -2151,11 +2150,11 @@ let expected = """
             """),
         ])
         
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary).joined(separator: "\n"))")
         
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleName/Symbol_Name", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleName/Symbol_Name", sourceLanguage: .swift)
         let node = try context.entity(with: reference)
         
         XCTAssertEqual((node.semantic as? Symbol)?.abstract?.plainText, "Extend a symbol with a space in its name.")
@@ -2191,12 +2190,12 @@ let expected = """
             """),
         ])
         
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         XCTAssert(context.problems.isEmpty, "Unexpected problems:\n\(context.problems.map(\.diagnostic.summary).joined(separator: "\n"))")
         
         do {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleName/OldSymbol", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleName/OldSymbol", sourceLanguage: .swift)
             let node = try context.entity(with: reference)
             
             let deprecatedSection = try XCTUnwrap((node.semantic as? Symbol)?.deprecatedSummary)
@@ -2205,7 +2204,7 @@ let expected = """
         }
         
         do {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/unit-test/Article", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/unit-test/Article", sourceLanguage: .swift)
             let node = try context.entity(with: reference)
             
             let deprecatedSection = try XCTUnwrap((node.semantic as? Article)?.deprecationSummary)
@@ -2229,11 +2228,11 @@ let expected = """
             """),
         ])
         
-        let (bundle, context) = try await loadBundle(catalog: catalog, diagnosticEngine: .init(filterLevel: .information))
+        let context = try await load(catalog: catalog, diagnosticEngine: .init(filterLevel: .information))
         XCTAssertNil(context.soleRootModuleReference)
         
         let curationDiagnostics = context.problems.filter({ $0.diagnostic.identifier == "org.swift.docc.ArticleUncurated" }).map(\.diagnostic)
-        let sidecarDiagnostic = try XCTUnwrap(curationDiagnostics.first(where: { $0.source?.standardizedFileURL == bundle.markupURLs.first?.standardizedFileURL }))
+        let sidecarDiagnostic = try XCTUnwrap(curationDiagnostics.first(where: { $0.source?.standardizedFileURL == context.inputs.markupURLs.first?.standardizedFileURL }))
         XCTAssertNil(sidecarDiagnostic.range)
         XCTAssertEqual(sidecarDiagnostic.summary, "You haven't curated 'doc://unit-test/documentation/unit-test/Article'")
         XCTAssertEqual(sidecarDiagnostic.severity, .information)
@@ -2241,7 +2240,7 @@ let expected = """
     
     func testUpdatesReferencesForChildrenOfCollisions() async throws {
         // Add some symbol collisions to graph
-        let (_, _, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             let sideKitURL = root.appendingPathComponent("sidekit.symbols.json")
             var text = try String(contentsOf: sideKitURL)
             
@@ -2389,7 +2388,7 @@ let expected = """
         var newArticle1URL: URL!
         
         // Add an article without curating it anywhere
-        let (_, _, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             /// Curate MyKit -> new-article1
             let myKitURL = root.appendingPathComponent("documentation").appendingPathComponent("mykit.md")
             try """
@@ -2425,7 +2424,7 @@ let expected = """
     }
 
     func testPrefersNonSymbolsInDocLink() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "SymbolsWithSameNameAsModule") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "SymbolsWithSameNameAsModule") { url in
             // This bundle has a top-level struct named "Wrapper". Adding an article named "Wrapper.md" introduces a possibility for a link collision
             try """
             # An article
@@ -2451,8 +2450,8 @@ let expected = """
         let moduleReference = try XCTUnwrap(context.rootModules.first)
         let moduleNode = try context.entity(with: moduleReference)
         
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
-        let converter = DocumentationContextConverter(bundle: bundle, context: context, renderContext: renderContext)
+        let renderContext = RenderContext(documentationContext: context)
+        let converter = DocumentationContextConverter(context: context, renderContext: renderContext)
         
         let renderNode = try XCTUnwrap(converter.renderNode(for: moduleNode))
         let curatedTopic = try XCTUnwrap(renderNode.topicSections.first?.identifiers.first)
@@ -2468,7 +2467,7 @@ let expected = """
     // Modules that are being extended should not have their own symbol in the current bundle's graph.
     func testNoSymbolForTertiarySymbolGraphModules() async throws {
         // Add an article without curating it anywhere
-        let (_, _, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             /// Create an extension only symbol graph.
             let tertiaryURL = root.appendingPathComponent("Tertiary@MyKit.symbols.json")
             try """
@@ -2502,7 +2501,7 @@ let expected = """
     }
     
     func testDeclarationTokenKinds() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         
         let myFunc = try context.entity(with: ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift))
         
@@ -2516,7 +2515,7 @@ let expected = """
         
         // Render declaration and compare token kinds with symbol graph
         let symbol = myFunc.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: myFunc.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: myFunc.reference)
         let renderNode = translator.visitSymbol(symbol) as! RenderNode
         
         let declarationTokens = renderNode.primaryContentSections.mapFirst { section -> [String]? in
@@ -2629,7 +2628,7 @@ let expected = """
             try text.write(to: referencesURL, atomically: true, encoding: .utf8)
             
             // Load the bundle & reference resolve symbol graph docs
-            let (_, _, context) = try await loadBundle(from: targetURL)
+            let context = try await loadFromDisk(catalogURL: targetURL)
             
             guard context.problems.count == 5 else {
                 XCTFail("Expected 5 problems during reference resolving; got \(context.problems.count)")
@@ -2650,13 +2649,13 @@ let expected = """
     }
     
     func testNavigatorTitle() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         func renderNodeForPath(path: String) throws -> (DocumentationNode, RenderNode) {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: path, sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: path, sourceLanguage: .swift)
             let node = try context.entity(with: reference)
 
             let symbol = node.semantic as! Symbol
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+            var translator = RenderNodeTranslator(context: context, identifier: reference)
             let renderNode = translator.visitSymbol(symbol) as! RenderNode
 
             return (node, renderNode)
@@ -2689,11 +2688,8 @@ let expected = """
     }
     
     func testCrossSymbolGraphPathCollisions() async throws {
-        // Create temp folder
-        let tempURL = try createTemporaryDirectory()
-
         // Create test bundle
-        let catalogURL = try Folder(name: "collisions.docc", content: [
+        let catalog = Folder(name: "collisions.docc", content: [
             InfoPlist(displayName: "Collisions", identifier: "com.test.collisions"),
             CopyOfFile(original: Bundle.module.url(
                         forResource: "Collisions-iOS.symbols", withExtension: "json",
@@ -2701,10 +2697,10 @@ let expected = """
             CopyOfFile(original: Bundle.module.url(
                         forResource: "Collisions-macOS.symbols", withExtension: "json",
                         subdirectory: "Test Resources")!),
-        ]).write(inside: tempURL)
+        ])
         
         // Load test bundle
-        let (_, _, context) = try await loadBundle(from: catalogURL)
+        let context = try await load(catalog: catalog)
         
         let referenceForPath: (String) -> ResolvedTopicReference = { path in
             return ResolvedTopicReference(bundleID: "com.test.collisions", path: "/documentation" + path, sourceLanguage: .swift)
@@ -2735,7 +2731,7 @@ let expected = """
             subdirectory: "Test Resources"
         )!
         
-        let testBundle = try Folder(
+        let catalog = Folder(
             name: "unit-test.docc",
             content: [
                 CopyOfFile(original: inheritedDefaultImplementationsSGF),
@@ -2748,20 +2744,19 @@ let expected = """
                 - ``Comparable/localDefaultImplementation()``
                 """)
             ]
-        ).write(inside: createTemporaryDirectory())
-        
-        let (_, _, context) = try await loadBundle(from: testBundle)
+        )
+        let context = try await load(catalog: catalog)
         
         let problem = try XCTUnwrap(context.problems.first(where: { $0.diagnostic.identifier == "org.swift.docc.unresolvedTopicReference" }))
         XCTAssertEqual(problem.diagnostic.summary, "'FirstTarget/Comparable/localDefaultImplementation()' has no page and isn't available for linking.")
     }
     
     func testContextCachesReferences() async throws {
-        let bundleID: DocumentationBundle.Identifier = #function
+        let bundleID: DocumentationContext.Inputs.Identifier = #function
         // Verify there is no pool bucket for the bundle we're about to test
         XCTAssertNil(ResolvedTopicReference._numberOfCachedReferences(bundleID: bundleID))
         
-        let (_, _, _) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], configureBundle: { rootURL in
+        let (_, _) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], configureBundle: { rootURL in
             let infoPlistURL = rootURL.appendingPathComponent("Info.plist", isDirectory: false)
             try! String(contentsOf: infoPlistURL)
                 .replacingOccurrences(of: "org.swift.docc.example", with: bundleID.rawValue)
@@ -2789,7 +2784,7 @@ let expected = """
     }
     
     func testAbstractAfterMetadataDirective() async throws {
-        let (_, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         
         // Get the SideKit/SideClass/init() node and verify it has an abstract and no discussion.
         // We're verifying that the metadata directive between the title and the abstract didn't cause
@@ -2803,18 +2798,15 @@ let expected = """
         // XCTAssertNil(markupModel.discussionSection)
     }
 
-    /// rdar://69242313
     func testLinkResolutionDoesNotSkipSymbolGraph() async throws {
-        let tempURL = try createTemporaryDirectory()
-        
-        let bundleURL = try Folder(name: "Missing.docc", content: [
+        let catalog = Folder(name: "Missing.docc", content: [
             InfoPlist(displayName: "MissingDocs", identifier: "com.test.missing-docs"),
             CopyOfFile(original: Bundle.module.url(
                         forResource: "MissingDocs.symbols", withExtension: "json",
                         subdirectory: "Test Resources")!),
-        ]).write(inside: tempURL)
+        ])
         
-        let (_, _, context) = try await loadBundle(from: bundleURL)
+        let context = try await load(catalog: catalog)
         
         // MissingDocs contains a struct that has a link to a non-existent type.
         // If there are no problems, that indicates that symbol graph link
@@ -2840,10 +2832,10 @@ let expected = """
     }
     
     func testTaskGroupsPersistInitialRangesFromMarkup() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let (_, context) = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
 
         // Verify task group ranges are persisted for symbol docs
-        let symbolReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit", sourceLanguage: .swift)
+        let symbolReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit", sourceLanguage: .swift)
         let symbol = try XCTUnwrap((try? context.entity(with: symbolReference))?.semantic as? Symbol)
         let symbolTopics = try XCTUnwrap(symbol.topics)
         symbolTopics.originalLinkRangesByGroup.forEach { group in
@@ -2851,7 +2843,7 @@ let expected = """
         }
         
         // Verify task group ranges are persisted for articles
-        let articleReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Test-Bundle/article", sourceLanguage: .swift)
+        let articleReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Test-Bundle/article", sourceLanguage: .swift)
         let article = try XCTUnwrap((try? context.entity(with: articleReference))?.semantic as? Article)
         let articleTopics = try XCTUnwrap(article.topics)
         articleTopics.originalLinkRangesByGroup.forEach { group in
@@ -2877,7 +2869,7 @@ let expected = """
     /// Tests that diagnostics raised during link resolution for symbols have the correct source URLs
     /// - Bug: rdar://63288817
     func testDiagnosticsForSymbolsHaveCorrectSource() async throws {
-        let (_, _, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { url in
             let extensionFile = """
             # ``SideKit/SideClass/myFunction()``
 
@@ -2920,9 +2912,7 @@ let expected = """
     }
 
     func testLinkResolutionDiagnosticsEmittedForTechnologyPages() async throws {
-        let tempURL = try createTemporaryDirectory()
-
-        let bundleURL = try Folder(name: "module-links.docc", content: [
+        let catalog = Folder(name: "module-links.docc", content: [
             InfoPlist(displayName: "Test", identifier: "com.test.docc"),
             CopyOfFile(original: Bundle.module.url(
                 forResource: "LegacyBundle_DoNotUseInNewTests",
@@ -2945,9 +2935,9 @@ let expected = """
                 - ``SideClass``
                 - ``SideProtocol``
                 """),
-        ]).write(inside: tempURL)
+        ])
 
-        let (_, _, context) = try await loadBundle(from: bundleURL)
+        let context = try await load(catalog: catalog)
         let problems = context.diagnosticEngine.problems
         let linkResolutionProblems = problems.filter { $0.diagnostic.source?.relativePath.hasSuffix("sidekit.md") == true }
         XCTAssertEqual(linkResolutionProblems.count, 1)
@@ -2987,7 +2977,7 @@ let expected = """
                     - <doc:#NotFoundHeading>
                     """),
                     ])
-                let (_, context) = try await loadBundle(catalog: catalog)
+                let context = try await load(catalog: catalog)
                 
                 XCTAssertEqual(context.problems.map(\.diagnostic.summary), [
                     "'NotFoundSymbol' doesn't exist at '/Root'",
@@ -3032,7 +3022,7 @@ let expected = """
                         """),
                     ])
                 
-                let (_, context) = try await loadBundle(catalog: catalog)
+                let context = try await load(catalog: catalog)
                 
                 XCTAssertEqual(context.problems.map(\.diagnostic.summary), [
                     "'NotFoundSymbol' doesn't exist at '/CatalogName'",
@@ -3077,7 +3067,7 @@ let expected = """
                     """),
             ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         XCTAssertEqual(context.problems.map(\.diagnostic.summary).sorted(), [
             "'NotFoundArticle' doesn't exist at '/CatalogName/Second'",
@@ -3091,9 +3081,7 @@ let expected = """
     }
     
     func testResolvingLinksToHeaders() async throws {
-        let tempURL = try createTemporaryDirectory()
-
-        let bundleURL = try Folder(name: "module-links.docc", content: [
+        let catalog = Folder(name: "module-links.docc", content: [
             InfoPlist(displayName: "Test", identifier: "com.test.docc"),
             TextFile(name: "article.md", utf8Content: """
                 # Top Level Article
@@ -3153,9 +3141,9 @@ let expected = """
                 - <doc:article#Emoji:-%F0%9F%92%BB>
                 
                 """),
-        ]).write(inside: tempURL)
+        ])
 
-        let (_, _, context) = try await loadBundle(from: bundleURL)
+        let context = try await load(catalog: catalog)
         
         let articleReference = try XCTUnwrap(context.knownPages.first)
         let node = try context.entity(with: articleReference)
@@ -3181,7 +3169,7 @@ let expected = """
     }
 
     func testResolvingLinksToTopicSections() async throws {
-        let (_, context) = try await loadBundle(catalog:
+        let context = try await load(catalog:
             Folder(name: "unit-test.docc", content: [
                 JSONFile(name: "ModuleName.symbols.json", content: makeSymbolGraph(moduleName: "ModuleName")),
                 
@@ -3286,8 +3274,8 @@ let expected = """
         ])
         
         // Verify that the links are resolved in the render model.
-        let bundle = try XCTUnwrap(context.bundle)
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        _ = try XCTUnwrap(context.inputs)
+        let converter = DocumentationNodeConverter(context: context)
         let renderNode = converter.convert(entity)
         
         XCTAssertEqual(renderNode.topicSections.map(\.anchor), [
@@ -3325,7 +3313,7 @@ let expected = """
     func testExtensionCanUseLanguageSpecificRelativeLinks() async throws {
         // This test uses a symbol with different names in Swift and Objective-C, each with a member that's only available in that language.
         let symbolID = "some-symbol-id"
-        let (_, context) = try await loadBundle(catalog:
+        let context = try await load(catalog:
             Folder(name: "unit-test.docc", content: [
                 Folder(name: "swift", content: [
                     JSONFile(name: "ModuleName.symbols.json", content: makeSymbolGraph(
@@ -3447,7 +3435,7 @@ let expected = """
         ## Overview
         The function overview
         """
-        let exampleDocumentation = Folder(name: "MyKit.docc", content: [
+        let catalog = Folder(name: "MyKit.docc", content: [
             Folder(name: "Symbols", content: [
                 CopyOfFile(original: Bundle.module.url(forResource: "mykit-one-symbol.symbols", withExtension: "json", subdirectory: "Test Resources")!),
             ]),
@@ -3467,11 +3455,9 @@ let expected = """
             """),
             InfoPlist(displayName: "MyKit", identifier: "com.test.MyKit"),
         ])
-        let tempURL = try createTemporaryDirectory()
-        let bundleURL = try exampleDocumentation.write(inside: tempURL)
 
         // Parse this test content
-        let (_, _, context) = try await loadBundle(from: bundleURL)
+        let context = try await load(catalog: catalog)
 
         let identifier = "org.swift.docc.DuplicateMarkdownTitleSymbolReferences"
         let duplicateMarkdownProblems = context.problems.filter({ $0.diagnostic.identifier == identifier })
@@ -3487,7 +3473,7 @@ let expected = """
     func testMatchesCorrectlyDocExtensionToChildOfCollisionTopic() async throws {
         let fifthTestMemberPath = "ShapeKit/OverloadedParentStruct-1jr3p/fifthTestMember"
         
-        let (_, bundle, context) = try await testBundleAndContext(copying: "OverloadedSymbols") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "OverloadedSymbols") { url in
             // Add an article to be curated from collided nodes' doc extensions.
             try """
             # New Article
@@ -3522,10 +3508,10 @@ let expected = """
             """.write(to: url.appendingPathComponent("fifthTestMember.md"), atomically: true, encoding: .utf8)
         }
         
-        let articleReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ShapeKit/NewArticle", sourceLanguage: .swift)
+        let articleReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ShapeKit/NewArticle", sourceLanguage: .swift)
         
         // Fetch the "OverloadedParentStruct" node
-        let reference1 = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ShapeKit/OverloadedParentStruct-1jr3p", sourceLanguage: .swift)
+        let reference1 = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ShapeKit/OverloadedParentStruct-1jr3p", sourceLanguage: .swift)
         let node1 = try context.entity(with: reference1)
         let symbol1 = try XCTUnwrap(node1.semantic as? Symbol)
         
@@ -3538,7 +3524,7 @@ let expected = """
         XCTAssertTrue(tgNode1.contains(articleReference))
         
         // Fetch the "fifthTestMember" node
-        let reference2 = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/\(fifthTestMemberPath)", sourceLanguage: .swift)
+        let reference2 = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/\(fifthTestMemberPath)", sourceLanguage: .swift)
        
         let node2 = try context.entity(with: reference2)
         let symbol2 = try XCTUnwrap(node2.semantic as? Symbol)
@@ -3555,7 +3541,7 @@ let expected = """
     }
     
     func testMatchesDocumentationExtensionsAsSymbolLinks() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "MixedLanguageFrameworkWithLanguageRefinements") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "MixedLanguageFrameworkWithLanguageRefinements") { url in
             // Two colliding symbols that differ by capitalization.
             try """
             # ``MixedFramework/CollisionsWithDifferentCapitalization/someThing``
@@ -3621,7 +3607,7 @@ let expected = """
         
         do {
             // The resolved reference needs more disambiguation than the documentation extension link did.
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MixedFramework/CollisionsWithDifferentCapitalization/someThing-90i4h", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MixedFramework/CollisionsWithDifferentCapitalization/someThing-90i4h", sourceLanguage: .swift)
             
             let node = try context.entity(with: reference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
@@ -3630,7 +3616,7 @@ let expected = """
         
         do {
             // The resolved reference needs more disambiguation than the documentation extension link did.
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MixedFramework/CollisionsWithDifferentCapitalization/something-2c4k6", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MixedFramework/CollisionsWithDifferentCapitalization/something-2c4k6", sourceLanguage: .swift)
             
             let node = try context.entity(with: reference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
@@ -3639,7 +3625,7 @@ let expected = """
         
         do {
             // The resolved reference needs the language info alongside the symbol kind info.
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MixedFramework/CollisionsWithEscapedKeywords/subscript()-swift.method", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MixedFramework/CollisionsWithEscapedKeywords/subscript()-swift.method", sourceLanguage: .swift)
             
             let node = try context.entity(with: reference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
@@ -3648,7 +3634,7 @@ let expected = """
         
         do {
             // The resolved reference needs the language info alongside the symbol kind info.
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MixedFramework/CollisionsWithEscapedKeywords/subscript()-swift.subscript", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MixedFramework/CollisionsWithEscapedKeywords/subscript()-swift.subscript", sourceLanguage: .swift)
             
             let node = try context.entity(with: reference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
@@ -3657,7 +3643,7 @@ let expected = """
         
         do {
             // The resolved reference needs the language info alongside the symbol kind info.
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MixedFramework/CollisionsWithEscapedKeywords/subscript()-swift.type.method", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MixedFramework/CollisionsWithEscapedKeywords/subscript()-swift.type.method", sourceLanguage: .swift)
             
             let node = try context.entity(with: reference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
@@ -3666,7 +3652,7 @@ let expected = """
     }
     
     func testMatchesDocumentationExtensionsWithSourceLanguageSpecificLinks() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "MixedLanguageFrameworkWithLanguageRefinements") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "MixedLanguageFrameworkWithLanguageRefinements") { url in
             // typedef NS_OPTIONS(NSInteger, MyObjectiveCOption) {
             //     MyObjectiveCOptionNone                                      = 0,
             //     MyObjectiveCOptionFirst                                     = 1 << 0,
@@ -3732,7 +3718,7 @@ let expected = """
         
         do {
             // The resolved reference needs more disambiguation than the documentation extension link did.
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MixedFramework/MyObjectiveCOption/first", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MixedFramework/MyObjectiveCOption/first", sourceLanguage: .swift)
             
             let node = try context.entity(with: reference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
@@ -3741,7 +3727,7 @@ let expected = """
         
         do {
             // The resolved reference needs more disambiguation than the documentation extension link did.
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MixedFramework/MyObjectiveCOption/secondCaseSwiftName", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MixedFramework/MyObjectiveCOption/secondCaseSwiftName", sourceLanguage: .swift)
             
             let node = try context.entity(with: reference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
@@ -3750,7 +3736,7 @@ let expected = """
         
         do {
             // The resolved reference needs the language info alongside the symbol kind info.
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MixedFramework/MyObjectiveCClassSwiftName/myMethod(argument:)", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MixedFramework/MyObjectiveCClassSwiftName/myMethod(argument:)", sourceLanguage: .swift)
             
             let node = try context.entity(with: reference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
@@ -3759,7 +3745,7 @@ let expected = """
         
         do {
             // The resolved reference needs the language info alongside the symbol kind info.
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MixedFramework/MyObjectiveCClassSwiftName/myMethodSwiftName()", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MixedFramework/MyObjectiveCClassSwiftName/myMethodSwiftName()", sourceLanguage: .swift)
             
             let node = try context.entity(with: reference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
@@ -3768,7 +3754,7 @@ let expected = """
     }
     
     func testMatchesDocumentationExtensionsRelativeToModule() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "MixedLanguageFrameworkWithLanguageRefinements") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "MixedLanguageFrameworkWithLanguageRefinements") { url in
             // Top level symbols, omitting the module name
             try """
             # ``MyStruct/myStructProperty``
@@ -3793,7 +3779,7 @@ let expected = """
         
         do {
             // The resolved reference needs more disambiguation than the documentation extension link did.
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MixedFramework/MyStruct/myStructProperty", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MixedFramework/MyStruct/myStructProperty", sourceLanguage: .swift)
             
             let node = try context.entity(with: reference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
@@ -3802,7 +3788,7 @@ let expected = """
         
         do {
             // The resolved reference needs more disambiguation than the documentation extension link did.
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MixedFramework/MyTypeAlias", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MixedFramework/MyTypeAlias", sourceLanguage: .swift)
             
             let node = try context.entity(with: reference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
@@ -3811,7 +3797,7 @@ let expected = """
     }
     
     func testCurationOfSymbolsWithSameNameAsModule() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "SymbolsWithSameNameAsModule") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "SymbolsWithSameNameAsModule") { url in
             // Top level symbols, omitting the module name
             try """
             # ``Something``
@@ -3828,7 +3814,7 @@ let expected = """
         
         do {
             // The resolved reference needs more disambiguation than the documentation extension link did.
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Something", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Something", sourceLanguage: .swift)
             
             let node = try context.entity(with: reference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
@@ -3841,7 +3827,7 @@ let expected = """
     }
     
     func testMultipleDocumentationExtensionMatchDiagnostic() async throws {
-        let (_, _, context) = try await testBundleAndContext(copying: "MixedLanguageFrameworkWithLanguageRefinements") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "MixedLanguageFrameworkWithLanguageRefinements") { url in
             // typedef NS_OPTIONS(NSInteger, MyObjectiveCOption) {
             //     MyObjectiveCOptionNone                                      = 0,
             //     MyObjectiveCOptionFirst                                     = 1 << 0,
@@ -3915,9 +3901,7 @@ let expected = """
             """)
         
         do {
-            let tempURL = try createTemporaryDirectory()
-            
-            let bundleURL = try Folder(name: "Module.docc", content: [
+            let catalog = Folder(name: "Module.docc", content: [
                 InfoPlist(displayName: "Module", identifier: "org.swift.docc.example"),
                 TextFile(name: "Module.md", utf8Content: """
                 # Autocurated Articles
@@ -3930,13 +3914,13 @@ let expected = """
                 """),
                 articleOne,
                 articleTwo,
-            ]).write(inside: tempURL)
-            let (_, bundle, context) = try await loadBundle(from: bundleURL)
+            ])
+            let context = try await load(catalog: catalog)
             
             let identifiers = context.problems.map(\.diagnostic.identifier)
             XCTAssertFalse(identifiers.contains(where: { $0 == "org.swift.docc.ArticleUncurated" }))
             
-            let rootReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Module", sourceLanguage: .swift)
+            let rootReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Module", sourceLanguage: .swift)
             let docNode = try context.entity(with: rootReference)
             let article = try XCTUnwrap(docNode.semantic as? Article)
             XCTAssertNil(article.topics)
@@ -3951,9 +3935,7 @@ let expected = """
         }
         
         do {
-            let tempURL = try createTemporaryDirectory()
-            
-            let bundleURL = try Folder(name: "Module.docc", content: [
+            let catalog = Folder(name: "Module.docc", content: [
                 InfoPlist(displayName: "Module", identifier: "org.swift.docc.example"),
                 TextFile(name: "Module.md", utf8Content: """
                     # Autocurated Articles
@@ -3970,10 +3952,10 @@ let expected = """
                     """),
                 articleOne,
                 articleTwo,
-            ]).write(inside: tempURL)
-            let (_, bundle, context) = try await loadBundle(from: bundleURL)
+            ])
+            let context = try await load(catalog: catalog)
             
-            let rootReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Module", sourceLanguage: .swift)
+            let rootReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Module", sourceLanguage: .swift)
             let docNode = try context.entity(with: rootReference)
             let article = try XCTUnwrap(docNode.semantic as? Article)
             XCTAssertNotNil(article.topics)
@@ -3982,9 +3964,7 @@ let expected = """
     }
     
     func testAutomaticTaskGroupsPlacedAfterManualCuration() async throws {
-        let tempURL = try createTemporaryDirectory()
-        
-        let bundleURL = try Folder(name: "Module.docc", content: [
+        let catalog = Folder(name: "Module.docc", content: [
             InfoPlist(displayName: "Module", identifier: "org.swift.docc.example"),
             TextFile(name: "Module.md", utf8Content: """
                 # Autocurated Articles
@@ -4013,10 +3993,10 @@ let expected = """
                 ### Group
                 - <doc:Article1>
                 """),
-        ]).write(inside: tempURL)
-        let (_, bundle, context) = try await loadBundle(from: bundleURL)
+        ])
+        let context = try await load(catalog: catalog)
         
-        let rootReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Module", sourceLanguage: .swift)
+        let rootReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Module", sourceLanguage: .swift)
         let docNode = try context.entity(with: rootReference)
         let article = try XCTUnwrap(docNode.semantic as? Article)
         
@@ -4037,19 +4017,19 @@ let expected = """
     
     // Verifies if the context resolves linkable nodes.
     func testLinkableNodes() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { url in
             try "# Article1".write(to: url.appendingPathComponent("resolvable-article.md"), atomically: true, encoding: .utf8)
             let myKitURL = url.appendingPathComponent("documentation").appendingPathComponent("mykit.md")
             try String(contentsOf: myKitURL)
                 .replacingOccurrences(of: " - <doc:article>", with: " - <doc:resolvable-article>")
                 .write(to: myKitURL, atomically: true, encoding: .utf8)
         }
-        let moduleReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit", sourceLanguage: .swift)
+        let moduleReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit", sourceLanguage: .swift)
 
         // Try resolving the new resolvable node
         switch context.resolve(.unresolved(UnresolvedTopicReference(topicURL: ValidatedURL(parsingExact: "doc:resolvable-article")!)), in: moduleReference) {
         case .success(let resolvedReference):
-            XCTAssertEqual(resolvedReference.absoluteString, "doc://\(bundle.id)/documentation/Test-Bundle/resolvable-article")
+            XCTAssertEqual(resolvedReference.absoluteString, "doc://\(context.inputs.id)/documentation/Test-Bundle/resolvable-article")
             XCTAssertNoThrow(try context.entity(with: resolvedReference))
         case .failure(_, let errorMessage):
             XCTFail("Did not resolve resolvable link. Error: \(errorMessage)")
@@ -4059,7 +4039,7 @@ let expected = """
     // Verifies if the context fails to resolve non-resolvable nodes.
     func testNonLinkableNodes() async throws {
         // Create a bundle with variety absolute and relative links and symbol links to a non linkable node.
-        let (_, _, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], externalResolvers: [:], externalSymbolResolver: nil, configureBundle: { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", configureBundle: { url in
             try """
             # ``SideKit/SideClass``
             Abstract.
@@ -4184,29 +4164,25 @@ let expected = """
         // Verify resolves correctly between a bundle with an article and a tutorial.
         do {
             let infoPlistURL = try XCTUnwrap(Bundle.module.url(forResource: "Info+Availability", withExtension: "plist", subdirectory: "Test Resources"))
-            let testBundle = Folder(name: "test.docc", content: [
+            let catalog = Folder(name: "test.docc", content: [
                 CopyOfFile(original: infoPlistURL, newName: "Info.plist"),
                 TextFile(name: "TestRoot.md", utf8Content: testRootPageSource),
                 TextFile(name: "Test.md", utf8Content: testArticleSource),
                 TextFile(name: "TestTechnology.tutorial", utf8Content: testTechnologySource),
                 TextFile(name: "Test.tutorial", utf8Content: testTutorialSource),
             ])
-            let tempFolderURL = try createTemporaryDirectory().appendingPathComponent("test.docc")
-            try testBundle.write(to: tempFolderURL)
-            
-            // Load the bundle
-            let (_, bundle, context) = try await loadBundle(from: tempFolderURL)
+            let context = try await load(catalog: catalog)
             // Verify the context contains the conflicting topic names
             // Article
-            XCTAssertNotNil(context.documentationCache[ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Test-Bundle/Test", sourceLanguage: .swift)])
+            XCTAssertNotNil(context.documentationCache[ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Test-Bundle/Test", sourceLanguage: .swift)])
             // Tutorial
-            XCTAssertNotNil(context.documentationCache[ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/Test-Bundle/Test", sourceLanguage: .swift)])
+            XCTAssertNotNil(context.documentationCache[ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/Test-Bundle/Test", sourceLanguage: .swift)])
             
             let unresolved = TopicReference.unresolved(.init(topicURL: try XCTUnwrap(ValidatedURL(parsingExact: "doc:Test"))))
-            let expected = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Test-Bundle/Test", sourceLanguage: .swift)
+            let expected = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Test-Bundle/Test", sourceLanguage: .swift)
 
             // Resolve from various locations in the bundle
-            for parent in [bundle.rootReference, bundle.documentationRootReference, bundle.tutorialTableOfContentsContainer] {
+            for parent in [context.inputs.rootReference, context.inputs.documentationRootReference, context.inputs.tutorialTableOfContentsContainer] {
                 switch context.resolve(unresolved, in: parent) {
                     case .success(let reference):
                         if reference.path != expected.path {
@@ -4220,7 +4196,7 @@ let expected = """
         // Verify resolves correctly between a bundle with an article, a tutorial, and a symbol
         do {
             let infoPlistURL = try XCTUnwrap(Bundle.module.url(forResource: "Info+Availability", withExtension: "plist", subdirectory: "Test Resources"))
-            let testBundle = Folder(name: "test.docc", content: [
+            let catalog = Folder(name: "test.docc", content: [
                 CopyOfFile(original: infoPlistURL, newName: "Info.plist"),
                 TextFile(name: "TestRoot.md", utf8Content: testRootPageSource),
                 TextFile(name: "Test.md", utf8Content: testArticleSource),
@@ -4228,27 +4204,23 @@ let expected = """
                 TextFile(name: "TestTechnology.tutorial", utf8Content: testTechnologySource),
                 TextFile(name: "Test.tutorial", utf8Content: testTutorialSource),
             ])
-            let tempFolderURL = try createTemporaryDirectory().appendingPathComponent("test.docc")
-            try testBundle.write(to: tempFolderURL)
-            
-            // Load the bundle
-            let (_, bundle, context) = try await loadBundle(from: tempFolderURL)
+            let context = try await load(catalog: catalog)
             // Verify the context contains the conflicting topic names
             // Article
-            XCTAssertNotNil(context.documentationCache[ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Test-Bundle/Test", sourceLanguage: .swift)])
+            XCTAssertNotNil(context.documentationCache[ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Test-Bundle/Test", sourceLanguage: .swift)])
             // Tutorial
-            XCTAssertNotNil(context.documentationCache[ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/Test-Bundle/Test", sourceLanguage: .swift)])
+            XCTAssertNotNil(context.documentationCache[ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/Test-Bundle/Test", sourceLanguage: .swift)])
             // Symbol
-            XCTAssertNotNil(context.documentationCache[ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Minimal_docs/Test", sourceLanguage: .swift)])
+            XCTAssertNotNil(context.documentationCache[ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Minimal_docs/Test", sourceLanguage: .swift)])
             
             let unresolved = TopicReference.unresolved(.init(topicURL: try XCTUnwrap(ValidatedURL(parsingExact: "doc:Test"))))
-            let expected = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Test-Bundle/Test", sourceLanguage: .swift)
+            let expected = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Test-Bundle/Test", sourceLanguage: .swift)
             
             let symbolReference = try XCTUnwrap(context.documentationCache.reference(symbolID: "s:12Minimal_docs4TestV"))
             
 
             // Resolve from various locations in the bundle
-            for parent in [bundle.rootReference, bundle.documentationRootReference, bundle.tutorialTableOfContentsContainer, symbolReference] {
+            for parent in [context.inputs.rootReference, context.inputs.documentationRootReference, context.inputs.tutorialTableOfContentsContainer, symbolReference] {
                 switch context.resolve(unresolved, in: parent) {
                     case .success(let reference):
                         if reference.path != expected.path {
@@ -4264,7 +4236,7 @@ let expected = """
         // Verify resolves correctly a double-backtick link.
         do {
             let infoPlistURL = try XCTUnwrap(Bundle.module.url(forResource: "Info+Availability", withExtension: "plist", subdirectory: "Test Resources"))
-            let testBundle = Folder(name: "test.docc", content: [
+            let catalog = Folder(name: "test.docc", content: [
                 CopyOfFile(original: infoPlistURL, newName: "Info.plist"),
                 TextFile(name: "Minimal_docs.md", utf8Content:
                             """
@@ -4289,15 +4261,11 @@ let expected = """
                 TextFile(name: "TestTechnology.tutorial", utf8Content: testTechnologySource),
                 TextFile(name: "Test.tutorial", utf8Content: testTutorialSource),
             ])
-            let tempFolderURL = try createTemporaryDirectory().appendingPathComponent("test.docc")
-            try testBundle.write(to: tempFolderURL)
+            let context = try await load(catalog: catalog)
             
-            // Load the bundle
-            let (_, bundle, context) = try await loadBundle(from: tempFolderURL)
-            
-            let symbolReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Minimal_docs/Test", sourceLanguage: .swift)
-            let moduleReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Minimal_docs", sourceLanguage: .swift)
-            let articleReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Test-Bundle/Test", sourceLanguage: .swift)
+            let symbolReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Minimal_docs/Test", sourceLanguage: .swift)
+            let moduleReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Minimal_docs", sourceLanguage: .swift)
+            let articleReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Test-Bundle/Test", sourceLanguage: .swift)
 
             // Verify we resolve/not resolve non-symbols when calling directly context.resolve(...)
             // with an explicit preference.
@@ -4323,7 +4291,7 @@ let expected = """
 
             // Verify the context contains the conflicting topic names
             // Tutorial
-            XCTAssertNotNil(context.documentationCache[ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/Test-Bundle/Test", sourceLanguage: .swift)])
+            XCTAssertNotNil(context.documentationCache[ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/Test-Bundle/Test", sourceLanguage: .swift)])
             // Symbol
             XCTAssertNotNil(context.documentationCache[symbolReference])
             
@@ -4355,19 +4323,15 @@ let expected = """
                 .replacingOccurrences(of: #"Test"#, with: #"Minimal_docs"#)
         
             let infoPlistURL = try XCTUnwrap(Bundle.module.url(forResource: "Info+Availability", withExtension: "plist", subdirectory: "Test Resources"))
-            let testBundle = Folder(name: "test.docc", content: [
+            let catalog = Folder(name: "test.docc", content: [
                 CopyOfFile(original: infoPlistURL, newName: "Info.plist"),
                 TextFile(name: "TestFramework.symbols.json", utf8Content: symbolGraphFixture),
             ])
-            let tempFolderURL = try createTemporaryDirectory().appendingPathComponent("test.docc")
-            try testBundle.write(to: tempFolderURL)
-            
-            // Load the bundle
-            let (_, bundle, context) = try await loadBundle(from: tempFolderURL)
+            let context = try await load(catalog: catalog)
             
             // Verify the module and symbol node kinds.
-            let symbolReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Minimal_docs/Minimal_docs", sourceLanguage: .swift)
-            let moduleReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Minimal_docs", sourceLanguage: .swift)
+            let symbolReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Minimal_docs/Minimal_docs", sourceLanguage: .swift)
+            let moduleReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Minimal_docs", sourceLanguage: .swift)
 
             XCTAssertEqual(context.topicGraph.nodeWithReference(symbolReference)?.kind, .structure)
             XCTAssertEqual(context.topicGraph.nodeWithReference(moduleReference)?.kind, .module)
@@ -4396,19 +4360,13 @@ let expected = """
     /// }
     /// ```
     func testWarningForUnresolvableLinksInInheritedDocs() async throws {
-        // Create temp folder
-        let tempURL = try createTemporaryDirectory()
-
-        // Create test bundle
-        let bundleURL = try Folder(name: "InheritedDocs.docc", content: [
+        let catalog = Folder(name: "InheritedDocs.docc", content: [
             InfoPlist(displayName: "Inheritance", identifier: "com.test.inheritance"),
             CopyOfFile(original: Bundle.module.url(
                         forResource: "InheritedDocs-RelativeLinks.symbols", withExtension: "json",
                         subdirectory: "Test Resources")!),
-        ]).write(inside: tempURL)
-        
-        // Load the test bundle
-        let (_, _, context) = try await loadBundle(from: bundleURL)
+        ])
+        let context = try await load(catalog: catalog)
         
         // Get the emitted diagnostic and verify it contains a solution and replacement fix-it.
         let problem = try XCTUnwrap(context.problems.first(where: { p in
@@ -4438,8 +4396,8 @@ let expected = """
     }
     
     func testCustomModuleKind() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "BundleWithExecutableModuleKind")
-        XCTAssertEqual(bundle.info.defaultModuleKind, "Executable")
+        let context = try await loadFromDisk(catalogName: "BundleWithExecutableModuleKind")
+        XCTAssertEqual(context.inputs.info.defaultModuleKind, "Executable")
         
         let moduleSymbol = try XCTUnwrap(context.documentationCache["ExampleDocumentedExecutable"]?.symbol)
         XCTAssertEqual(moduleSymbol.kind.identifier.identifier, "module")
@@ -4479,7 +4437,7 @@ let expected = """
             InfoPlist(displayName: "TestBundle", identifier: "com.test.example")
         ])
         
-        let (_, context) = try await loadBundle(catalog: exampleDocumentation)
+        let context = try await load(catalog: exampleDocumentation)
         
         XCTAssertEqual(
             context.documentationCache.count,
@@ -4499,17 +4457,17 @@ let expected = """
             """),
         ])
         
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
         
         XCTAssertEqual(
             context.documentationExtensionURL(for: moduleReference.appendingPath("SomeClass")),
-            bundle.markupURLs.first
+            context.inputs.markupURLs.first
         )
     }
     
     func testDocumentationExtensionURLForReferenceReturnsNilForTutorialReference() async throws {
-        let (_, _, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests")
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests")
         
         XCTAssertNil(
             context.documentationExtensionURL(
@@ -4531,7 +4489,7 @@ let expected = """
         //     return "collection"
         //   }
         // }
-        let (_, _, context) = try await testBundleAndContext(copying: "ModuleWithProtocolExtensions")
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "ModuleWithProtocolExtensions")
 
         // The member function of the protocol extension
         // should have a constraint: Self is Collection
@@ -4576,7 +4534,7 @@ let expected = """
         // One doc comment in the Obj-C header file contains an invalid doc
         // link on line 24, columns 56-63:
         // "Log a hello world message. This line contains an ``invalid`` link."
-        let (_, context) = try await testBundleAndContext(named: "ObjCFrameworkWithInvalidLink")
+        let context = try await loadFromDisk(catalogName: "ObjCFrameworkWithInvalidLink")
         let problems = context.problems
         if FeatureFlags.current.isParametersAndReturnsValidationEnabled {
             XCTAssertEqual(4, problems.count)
@@ -4738,8 +4696,8 @@ let expected = """
                 """),
             ])
         
-        let (bundle, context) = try await loadBundle(catalog: catalog)
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleName/SomeError/Code-swift.enum/someCase", sourceLanguage: .swift)
+        let context = try await load(catalog: catalog)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleName/SomeError/Code-swift.enum/someCase", sourceLanguage: .swift)
         
         XCTAssertEqual(
             context.topicGraph.reverseEdgesGraph.cycles(from: reference).map { $0.map(\.lastPathComponent) },
@@ -4776,13 +4734,13 @@ let expected = """
             """),
         ])
         
-        var (_, context) = try await loadBundle(catalog: catalog)
+        var context = try await load(catalog: catalog)
         var problems = context.diagnosticEngine.problems
         var linkResolutionProblems = problems.filter { $0.diagnostic.source?.relativePath.hasSuffix("Extension.md") == true }
         XCTAssertEqual(linkResolutionProblems.count, 2)
         var problem = try XCTUnwrap(linkResolutionProblems.last)
         XCTAssertEqual(problem.diagnostic.summary, "\'NonExistingDoc\' doesn\'t exist at \'/SomeModuleName/SomeClass\'")
-        (_, _, context) = try await testBundleAndContext(copying: "BookLikeContent") { url in
+        (_, context) = try await loadFromDisk(copyingCatalogNamed: "BookLikeContent") { url in
             let extensionFile = """
             # My Article
 
@@ -4826,7 +4784,7 @@ let expected = """
                     symbols: symbols
                 ))
             ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
 
         for kindID in overloadableKindIDs {
@@ -4913,7 +4871,7 @@ let expected = """
                 </plist>
                 """.utf8))
             ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
 
         for kindID in overloadableKindIDs {
@@ -4952,7 +4910,7 @@ let expected = """
                 ))
             ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         for kindID in nonOverloadableKindIDs {
             // Find the 4 symbols of this specific kind
@@ -4983,7 +4941,7 @@ let expected = """
                 </plist>
                 """.utf8))
             ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
 
         let unknownFeatureFlagProblems = context.problems.filter({ $0.diagnostic.identifier == "org.swift.docc.UnknownBundleFeatureFlag" })
         XCTAssertEqual(unknownFeatureFlagProblems.count, 1)
@@ -5008,7 +4966,7 @@ let expected = """
                 </plist>
                 """.utf8))
             ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
 
         let unknownFeatureFlagProblems = context.problems.filter({ $0.diagnostic.identifier == "org.swift.docc.UnknownBundleFeatureFlag" })
         XCTAssertEqual(unknownFeatureFlagProblems.count, 1)
@@ -5043,7 +5001,7 @@ let expected = """
                     ])),
             ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
 
         let overloadGroupNode: DocumentationNode
@@ -5120,7 +5078,7 @@ let expected = """
                     ])),
             ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
 
         let overloadGroupNode: DocumentationNode
@@ -5195,7 +5153,7 @@ let expected = """
                     ])),
             ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
 
         let overloadGroupNode: DocumentationNode
@@ -5264,7 +5222,7 @@ let expected = """
                         makeSymbol(id: "symbol-2", kind: symbolKind, pathComponents: ["SymbolName"]),
                     ])),
             ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
 
         let overloadGroupNode: DocumentationNode
@@ -5342,7 +5300,7 @@ let expected = """
                     """)
                 ])
 
-            let (_, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
 
             let problems = context.problems.sorted(by: \.diagnostic.summary)
             XCTAssertEqual(problems.count, 1)
@@ -5396,7 +5354,7 @@ let expected = """
                     """)
                 ])
 
-            let (_, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
 
             let problems = context.problems.sorted(by: \.diagnostic.summary)
             XCTAssertEqual(problems.count, 1)
@@ -5448,7 +5406,7 @@ let expected = """
                     """)
                 ])
 
-            let (_, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
 
             let problems = context.problems.sorted(by: \.diagnostic.summary)
             XCTAssertEqual(problems.count, 1)
@@ -5476,7 +5434,7 @@ let expected = """
         let externalModuleName = "ExternalModuleName"
         
         func makeExternalDependencyFiles() async throws -> (SerializableLinkResolutionInformation, [LinkDestinationSummary]) {
-            let (bundle, context) = try await loadBundle(
+            let context = try await load(
                 catalog: Folder(name: "Dependency.docc", content: [
                     JSONFile(name: "\(externalModuleName).symbols.json", content: makeSymbolGraph(moduleName: externalModuleName)),
                     TextFile(name: "Extension.md", utf8Content: """
@@ -5488,14 +5446,14 @@ let expected = """
             )
             
             // Retrieve the link information from the dependency, as if '--enable-experimental-external-link-support' was passed to DocC
-            let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+            let converter = DocumentationNodeConverter(context: context)
             let linkSummaries: [LinkDestinationSummary] = try context.knownPages.flatMap { reference in
                 let entity = try context.entity(with: reference)
                 let renderNode = try XCTUnwrap(converter.convert(entity))
                 
                 return entity.externallyLinkableElementSummaries(context: context, renderNode: renderNode, includeTaskGroups: false)
             }
-            let linkResolutionInformation = try context.linkResolver.localResolver.prepareForSerialization(bundleID: bundle.id)
+            let linkResolutionInformation = try context.linkResolver.localResolver.prepareForSerialization(bundleID: context.inputs.id)
             
             return (linkResolutionInformation, linkSummaries)
         }
@@ -5517,7 +5475,7 @@ let expected = """
             URL(fileURLWithPath: "/path/to/SomeDependency.doccarchive")
         ]
         
-        let (bundle, context) = try await loadBundle(
+        let context = try await load(
             catalog: catalog,
             otherFileSystemDirectories: [
                 Folder(name: "path", content: [
@@ -5536,7 +5494,7 @@ let expected = """
         let reference = try XCTUnwrap(context.soleRootModuleReference)
         let node = try context.entity(with: reference)
         
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
         let renderNode = converter.convert(node)
         
         let externalReference = "doc://Dependency/documentation/ExternalModuleName"
@@ -5561,7 +5519,7 @@ let expected = """
     }
 
     func testResolvesAlternateDeclarations() async throws {
-        let (bundle, context) = try await loadBundle(catalog: Folder(
+        let context = try await load(catalog: Folder(
             name: "unit-test.docc",
             content: [
                 TextFile(name: "Symbol.md", utf8Content: """
@@ -5603,7 +5561,7 @@ let expected = """
             ]
         ))
         
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/unit-test/Symbol", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/unit-test/Symbol", sourceLanguage: .swift)
         
         let entity = try context.entity(with: reference)
         XCTAssertEqual(entity.metadata?.alternateRepresentations.count, 3)
@@ -5612,14 +5570,14 @@ let expected = """
         var alternateRepresentation = try XCTUnwrap(entity.metadata?.alternateRepresentations.first)
         XCTAssertEqual(
             alternateRepresentation.reference,
-            .resolved(.success(.init(bundleID: bundle.id, path: "/documentation/unit-test/CounterpartSymbol", sourceLanguage: .objectiveC)))
+            .resolved(.success(.init(bundleID: context.inputs.id, path: "/documentation/unit-test/CounterpartSymbol", sourceLanguage: .objectiveC)))
         )
         
         // Second alternate representation without "``" should also have been resolved successfully
         alternateRepresentation = try XCTUnwrap(entity.metadata?.alternateRepresentations.dropFirst().first)
         XCTAssertEqual(
             alternateRepresentation.reference,
-            .resolved(.success(.init(bundleID: bundle.id, path: "/documentation/unit-test/OtherCounterpartSymbol", sourceLanguage: .objectiveC)))
+            .resolved(.success(.init(bundleID: context.inputs.id, path: "/documentation/unit-test/OtherCounterpartSymbol", sourceLanguage: .objectiveC)))
         )
         
         // Third alternate representation shouldn't have been resolved at all
@@ -5639,7 +5597,7 @@ let expected = """
     }
         
     func testDiagnosesSymbolAlternateDeclarations() async throws {
-        let (_, context) = try await loadBundle(catalog: Folder(
+        let context = try await load(catalog: Folder(
             name: "unit-test.docc",
             content: [
                 TextFile(name: "Symbol.md", utf8Content: """
@@ -5710,7 +5668,7 @@ let expected = """
     }
     
     func testDiagnosesArticleAlternateDeclarations() async throws {
-        let (_, context) = try await loadBundle(catalog: Folder(
+        let context = try await load(catalog: Folder(
             name: "unit-test.docc",
             content: [
                 TextFile(name: "Symbol.md", utf8Content: """
diff --git a/Tests/SwiftDocCTests/Infrastructure/DocumentationCuratorTests.swift b/Tests/SwiftDocCTests/Infrastructure/DocumentationCuratorTests.swift
index 84321b58f9..f74daee11f 100644
--- a/Tests/SwiftDocCTests/Infrastructure/DocumentationCuratorTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/DocumentationCuratorTests.swift
@@ -28,9 +28,9 @@ class DocumentationCuratorTests: XCTestCase {
     }
     
     func testCrawl() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         
-        var crawler = DocumentationCurator(in: context, bundle: bundle)
+        var crawler = DocumentationCurator(in: context)
         let mykit = try context.entity(with: ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/MyKit", sourceLanguage: .swift))
 
         var symbolsWithCustomCuration = [ResolvedTopicReference]()
@@ -75,7 +75,7 @@ class DocumentationCuratorTests: XCTestCase {
     }
     
     func testCrawlDiagnostics() async throws {
-        let (tempCatalogURL, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { url in
+        let (tempCatalogURL, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { url in
             let extensionFile = url.appendingPathComponent("documentation/myfunction.md")
             
             try """
@@ -97,7 +97,7 @@ class DocumentationCuratorTests: XCTestCase {
         }
         let extensionFile = tempCatalogURL.appendingPathComponent("documentation/myfunction.md")
         
-        var crawler = DocumentationCurator(in: context, bundle: bundle)
+        var crawler = DocumentationCurator(in: context)
         let mykit = try context.entity(with: ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/MyKit", sourceLanguage: .swift))
         
         XCTAssertNoThrow(try crawler.crawlChildren(of: mykit.reference, prepareForCuration: { _ in }, relateNodes: { _, _ in }))
@@ -137,7 +137,7 @@ class DocumentationCuratorTests: XCTestCase {
     }
     
     func testCyclicCurationDiagnostic() async throws {
-        let (_, context) = try await loadBundle(catalog:
+        let context = try await load(catalog:
             Folder(name: "unit-test.docc", content: [
                 // A number of articles with this cyclic curation:
                 //
@@ -228,7 +228,7 @@ class DocumentationCuratorTests: XCTestCase {
                 - ``NotFound``
                 """),
             ])
-            let (bundle, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
             XCTAssertEqual(
                 context.problems.map(\.diagnostic.summary),
                 [
@@ -266,7 +266,7 @@ class DocumentationCuratorTests: XCTestCase {
             )
             
             // Verify that the rendered top-level page doesn't have an automatic "Classes" topic section anymore.
-            let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+            let converter = DocumentationNodeConverter(context: context)
             let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
             let rootRenderNode = converter.convert(try context.entity(with: moduleReference))
             
@@ -286,7 +286,7 @@ class DocumentationCuratorTests: XCTestCase {
     }
     
     func testModuleUnderTechnologyRoot() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "SourceLocations") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "SourceLocations") { url in
             try """
             # Root curating a module
 
@@ -303,7 +303,7 @@ class DocumentationCuratorTests: XCTestCase {
             """.write(to: url.appendingPathComponent("Root.md"), atomically: true, encoding: .utf8)
         }
         
-        let crawler = DocumentationCurator(in: context, bundle: bundle)
+        let crawler = DocumentationCurator(in: context)
         XCTAssert(context.problems.isEmpty, "Expected no problems. Found: \(context.problems.map(\.diagnostic.summary))")
         
         guard let moduleNode = context.documentationCache["SourceLocations"],
@@ -319,7 +319,7 @@ class DocumentationCuratorTests: XCTestCase {
     }
     
     func testCuratorDoesNotRelateNodesWhenArticleLinksContainExtraPathComponents() async throws {
-        let (bundle, context) = try await loadBundle(catalog:
+        let context = try await load(catalog:
             Folder(name: "CatalogName.docc", content: [
                 TextFile(name: "Root.md", utf8Content: """
                 # Root
@@ -395,7 +395,7 @@ class DocumentationCuratorTests: XCTestCase {
         ])
         
         let rootPage = try context.entity(with: rootReference)
-        let renderer = DocumentationNodeConverter(bundle: bundle, context: context)
+        let renderer = DocumentationNodeConverter(context: context)
         let renderNode = renderer.convert(rootPage)
         
         XCTAssertEqual(renderNode.topicSections.map(\.title), [
@@ -418,7 +418,7 @@ class DocumentationCuratorTests: XCTestCase {
     }
         
     func testModuleUnderAncestorOfTechnologyRoot() async throws {
-        let (_, _, context) = try await testBundleAndContext(copying: "SourceLocations") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "SourceLocations") { url in
             try """
             # Root with ancestor curating a module
             
@@ -459,9 +459,9 @@ class DocumentationCuratorTests: XCTestCase {
     }
 
     func testSymbolLinkResolving() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         
-        let crawler = DocumentationCurator(in: context, bundle: bundle)
+        let crawler = DocumentationCurator(in: context)
         
         // Resolve top-level symbol in module parent
         do {
@@ -512,9 +512,9 @@ class DocumentationCuratorTests: XCTestCase {
     }
     
     func testLinkResolving() async throws {
-        let (sourceRoot, bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let (sourceRoot, context) = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         
-        var crawler = DocumentationCurator(in: context, bundle: bundle)
+        var crawler = DocumentationCurator(in: context)
         
         // Resolve and curate an article in module root (absolute link)
         do {
@@ -567,7 +567,7 @@ class DocumentationCuratorTests: XCTestCase {
     }
     
     func testGroupLinkValidation() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { root in
             // Create a sidecar with invalid group links
             try! """
             # ``SideKit``
@@ -607,7 +607,7 @@ class DocumentationCuratorTests: XCTestCase {
             """.write(to: root.appendingPathComponent("documentation").appendingPathComponent("api-collection.md"), atomically: true, encoding: .utf8)
         }
         
-        var crawler = DocumentationCurator(in: context, bundle: bundle)
+        var crawler = DocumentationCurator(in: context)
         let reference = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/SideKit", sourceLanguage: .swift)
         
         try crawler.crawlChildren(of: reference, prepareForCuration: {_ in }) { (_, _) in }
@@ -661,16 +661,16 @@ class DocumentationCuratorTests: XCTestCase {
     ///        +-- MyArticle ( <--- This should be crawled even if we've mixed manual and automatic curation)
     /// ```
     func testMixedManualAndAutomaticCuration() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "MixedManualAutomaticCuration")
+        let context = try await loadFromDisk(catalogName: "MixedManualAutomaticCuration")
         
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/TestBed/TopClass/NestedEnum/SecondLevelNesting", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/TestBed/TopClass/NestedEnum/SecondLevelNesting", sourceLanguage: .swift)
         let entity = try context.entity(with: reference)
         let symbol = try XCTUnwrap(entity.semantic as? Symbol)
         
         // Verify the link was resolved and it's found in the node's topics task group.
         XCTAssertEqual("doc://com.test.TestBed/documentation/TestBed/MyArticle", symbol.topics?.taskGroups.first?.links.first?.destination)
         
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
         let renderNode = converter.convert(entity)
         
         // Verify the article identifier is included in the task group for the render node.
@@ -678,7 +678,7 @@ class DocumentationCuratorTests: XCTestCase {
         
         // Verify that the ONLY curation for `TopClass/name` is the manual curation under `MyArticle`
         // and the automatic curation under `TopClass` is not present.
-        let nameReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/TestBed/TopClass/name", sourceLanguage: .swift)
+        let nameReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/TestBed/TopClass/name", sourceLanguage: .swift)
         XCTAssertEqual(context.finitePaths(to: nameReference).map({ $0.map(\.path) }), [
             ["/documentation/TestBed", "/documentation/TestBed/TopClass", "/documentation/TestBed/TopClass-API-Collection"],
             ["/documentation/TestBed", "/documentation/TestBed/TopClass", "/documentation/TestBed/TopClass/NestedEnum", "/documentation/TestBed/TopClass/NestedEnum/SecondLevelNesting", "/documentation/TestBed/MyArticle"],
@@ -686,7 +686,7 @@ class DocumentationCuratorTests: XCTestCase {
 
         // Verify that the BOTH manual curations for `TopClass/age` are preserved
         // even if one of the manual curations overlaps with the inheritance edge from the symbol graph.
-        let ageReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/TestBed/TopClass/age", sourceLanguage: .swift)
+        let ageReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/TestBed/TopClass/age", sourceLanguage: .swift)
         XCTAssertEqual(context.finitePaths(to: ageReference).map({ $0.map(\.path) }), [
             ["/documentation/TestBed", "/documentation/TestBed/TopClass"],
             ["/documentation/TestBed", "/documentation/TestBed/TopClass", "/documentation/TestBed/TopClass-API-Collection"],
@@ -697,9 +697,9 @@ class DocumentationCuratorTests: XCTestCase {
     /// In case a symbol has automatically curated children and is manually curated multiple times,
     /// the hierarchy should be created as it's authored. rdar://75453839
     func testMultipleManualCurationIsPreserved() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "MixedManualAutomaticCuration")
+        let (_, context) = try await loadFromDisk(catalogName: "MixedManualAutomaticCuration")
         
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/TestBed/DoublyManuallyCuratedClass/type()", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/TestBed/DoublyManuallyCuratedClass/type()", sourceLanguage: .swift)
         
         XCTAssertEqual(context.finitePaths(to: reference).map({ $0.map({ $0.path }) }), [
             [
diff --git a/Tests/SwiftDocCTests/Infrastructure/DocumentationBundleFileTypesTests.swift b/Tests/SwiftDocCTests/Infrastructure/DocumentationInputFileTypesTests.swift
similarity index 52%
rename from Tests/SwiftDocCTests/Infrastructure/DocumentationBundleFileTypesTests.swift
rename to Tests/SwiftDocCTests/Infrastructure/DocumentationInputFileTypesTests.swift
index f274d3f82e..5fcbb34f14 100644
--- a/Tests/SwiftDocCTests/Infrastructure/DocumentationBundleFileTypesTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/DocumentationInputFileTypesTests.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -11,48 +11,48 @@
 import XCTest
 @testable import SwiftDocC
 
-class DocumentationBundleFileTypesTests: XCTestCase {
+class DocumentationInputFileTypesTests: XCTestCase {
     func testIsCustomHeader() {
-        XCTAssertTrue(DocumentationBundleFileTypes.isCustomHeader(
+        XCTAssertTrue(DocumentationInputFileTypes.isCustomHeader(
             URL(fileURLWithPath: "header.html")))
-        XCTAssertTrue(DocumentationBundleFileTypes.isCustomHeader(
+        XCTAssertTrue(DocumentationInputFileTypes.isCustomHeader(
             URL(fileURLWithPath: "/header.html")))
-        XCTAssertFalse(DocumentationBundleFileTypes.isCustomHeader(
+        XCTAssertFalse(DocumentationInputFileTypes.isCustomHeader(
             URL(fileURLWithPath: "header")))
-        XCTAssertFalse(DocumentationBundleFileTypes.isCustomHeader(
+        XCTAssertFalse(DocumentationInputFileTypes.isCustomHeader(
             URL(fileURLWithPath: "/header.html/foo")))
-        XCTAssertFalse(DocumentationBundleFileTypes.isCustomHeader(
+        XCTAssertFalse(DocumentationInputFileTypes.isCustomHeader(
             URL(fileURLWithPath: "footer.html")))
-        XCTAssertTrue(DocumentationBundleFileTypes.isCustomHeader(
+        XCTAssertTrue(DocumentationInputFileTypes.isCustomHeader(
             URL(fileURLWithPath: "DocC.docc/header.html")))
     }
 
     func testIsCustomFooter() {
-        XCTAssertTrue(DocumentationBundleFileTypes.isCustomFooter(
+        XCTAssertTrue(DocumentationInputFileTypes.isCustomFooter(
             URL(fileURLWithPath: "footer.html")))
-        XCTAssertTrue(DocumentationBundleFileTypes.isCustomFooter(
+        XCTAssertTrue(DocumentationInputFileTypes.isCustomFooter(
             URL(fileURLWithPath: "/footer.html")))
-        XCTAssertFalse(DocumentationBundleFileTypes.isCustomFooter(
+        XCTAssertFalse(DocumentationInputFileTypes.isCustomFooter(
             URL(fileURLWithPath: "footer")))
-        XCTAssertFalse(DocumentationBundleFileTypes.isCustomFooter(
+        XCTAssertFalse(DocumentationInputFileTypes.isCustomFooter(
             URL(fileURLWithPath: "/footer.html/foo")))
-        XCTAssertFalse(DocumentationBundleFileTypes.isCustomFooter(
+        XCTAssertFalse(DocumentationInputFileTypes.isCustomFooter(
             URL(fileURLWithPath: "header.html")))
-        XCTAssertTrue(DocumentationBundleFileTypes.isCustomFooter(
+        XCTAssertTrue(DocumentationInputFileTypes.isCustomFooter(
             URL(fileURLWithPath: "DocC.docc/footer.html")))
     }
 
     func testIsThemeSettingsFile() {
-        XCTAssertTrue(DocumentationBundleFileTypes.isThemeSettingsFile(
+        XCTAssertTrue(DocumentationInputFileTypes.isThemeSettingsFile(
             URL(fileURLWithPath: "theme-settings.json")))
-        XCTAssertTrue(DocumentationBundleFileTypes.isThemeSettingsFile(
+        XCTAssertTrue(DocumentationInputFileTypes.isThemeSettingsFile(
             URL(fileURLWithPath: "/a/b/theme-settings.json")))
 
-        XCTAssertFalse(DocumentationBundleFileTypes.isThemeSettingsFile(
+        XCTAssertFalse(DocumentationInputFileTypes.isThemeSettingsFile(
             URL(fileURLWithPath: "theme-settings.txt")))
-        XCTAssertFalse(DocumentationBundleFileTypes.isThemeSettingsFile(
+        XCTAssertFalse(DocumentationInputFileTypes.isThemeSettingsFile(
             URL(fileURLWithPath: "not-theme-settings.json")))
-        XCTAssertFalse(DocumentationBundleFileTypes.isThemeSettingsFile(
+        XCTAssertFalse(DocumentationInputFileTypes.isThemeSettingsFile(
             URL(fileURLWithPath: "/a/theme-settings.json/bar")))
     }
 }
diff --git a/Tests/SwiftDocCTests/Infrastructure/DocumentationBundleIdentifierTests.swift b/Tests/SwiftDocCTests/Infrastructure/DocumentationInputsIdentifierTests.swift
similarity index 91%
rename from Tests/SwiftDocCTests/Infrastructure/DocumentationBundleIdentifierTests.swift
rename to Tests/SwiftDocCTests/Infrastructure/DocumentationInputsIdentifierTests.swift
index 160406e6fd..89942c91c8 100644
--- a/Tests/SwiftDocCTests/Infrastructure/DocumentationBundleIdentifierTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/DocumentationInputsIdentifierTests.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2024-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -11,8 +11,8 @@
 import XCTest
 @testable import SwiftDocC
 
-class DocumentationBundleIdentifierTests: XCTestCase {
-    private typealias Identifier = DocumentationBundle.Identifier
+class DocumentationInputsIdentifierTests: XCTestCase {
+    private typealias Identifier = DocumentationContext.Inputs.Identifier
     
     func testInitialization() {
         let id = Identifier(rawValue: "com.example.test")
diff --git a/Tests/SwiftDocCTests/Infrastructure/DocumentationBundleInfoTests.swift b/Tests/SwiftDocCTests/Infrastructure/DocumentationInputsInfoTests.swift
similarity index 84%
rename from Tests/SwiftDocCTests/Infrastructure/DocumentationBundleInfoTests.swift
rename to Tests/SwiftDocCTests/Infrastructure/DocumentationInputsInfoTests.swift
index 65c54072f9..f7ce61a3fc 100644
--- a/Tests/SwiftDocCTests/Infrastructure/DocumentationBundleInfoTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/DocumentationInputsInfoTests.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -11,7 +11,7 @@
 import XCTest
 @testable import SwiftDocC
 
-class DocumentationBundleInfoTests: XCTestCase {
+class DocumentationInputsInfoTests: XCTestCase {
     // Test whether the bundle correctly loads the test bundle Info.plist file.
     func testLoadTestBundleInfoPlist() throws {
         let infoPlistURL = Bundle.module.url(
@@ -19,7 +19,7 @@ class DocumentationBundleInfoTests: XCTestCase {
             .appendingPathComponent("Info.plist")
 
         let infoPlistData = try Data(contentsOf: infoPlistURL)
-        let info = try DocumentationBundle.Info(from: infoPlistData)
+        let info = try DocumentationContext.Inputs.Info(from: infoPlistData)
         
         XCTAssertEqual(info.displayName, "Test Bundle")
         XCTAssertEqual(info.id.rawValue, "org.swift.docc.example")
@@ -32,7 +32,7 @@ class DocumentationBundleInfoTests: XCTestCase {
             forResource: "Info+Availability", withExtension: "plist", subdirectory: "Test Resources")!
         
         let infoPlistData = try Data(contentsOf: infoPlistURL)
-        let info = try DocumentationBundle.Info(from: infoPlistData)
+        let info = try DocumentationContext.Inputs.Info(from: infoPlistData)
 
         XCTAssertEqual(
             info.defaultAvailability?
@@ -68,7 +68,7 @@ class DocumentationBundleInfoTests: XCTestCase {
         
         let infoPlistWithoutDisplayNameData = Data(infoPlistWithoutDisplayName.utf8)
         
-        let bundleDiscoveryOptions = BundleDiscoveryOptions(
+        let bundleDiscoveryOptions = CatalogDiscoveryOptions(
             infoPlistFallbacks: [
                 "CFBundleDisplayName": "Fallback Display Name",
                 "CFBundleIdentifier": "com.fallback.Identifier"
@@ -76,33 +76,33 @@ class DocumentationBundleInfoTests: XCTestCase {
         )
         
         XCTAssertEqual(
-            try DocumentationBundle.Info(
+            try DocumentationContext.Inputs.Info(
                 from: infoPlistWithAllFieldsData,
-                bundleDiscoveryOptions: bundleDiscoveryOptions
+                catalogDiscoveryOptions: bundleDiscoveryOptions
             ),
-            DocumentationBundle.Info(
+            DocumentationContext.Inputs.Info(
                 displayName: "Info Plist Display Name",
                 id: "com.info.Plist"
             )
         )
         
         XCTAssertEqual(
-            try DocumentationBundle.Info(
+            try DocumentationContext.Inputs.Info(
                 from: nil,
-                bundleDiscoveryOptions: bundleDiscoveryOptions
+                catalogDiscoveryOptions: bundleDiscoveryOptions
             ),
-            DocumentationBundle.Info(
+            DocumentationContext.Inputs.Info(
                 displayName: "Fallback Display Name",
                 id: "com.fallback.Identifier"
             )
         )
         
         XCTAssertEqual(
-            try DocumentationBundle.Info(
+            try DocumentationContext.Inputs.Info(
                 from: infoPlistWithoutDisplayNameData,
-                bundleDiscoveryOptions: bundleDiscoveryOptions
+                catalogDiscoveryOptions: bundleDiscoveryOptions
             ),
-            DocumentationBundle.Info(
+            DocumentationContext.Inputs.Info(
                 displayName: "Fallback Display Name",
                 id: "com.info.Plist"
             )
@@ -122,11 +122,11 @@ class DocumentationBundleInfoTests: XCTestCase {
         let infoPlistWithoutVersionData = Data(infoPlistWithoutVersion.utf8)
         
         XCTAssertEqual(
-            try DocumentationBundle.Info(
+            try DocumentationContext.Inputs.Info(
                 from: infoPlistWithoutVersionData,
-                bundleDiscoveryOptions: nil
+                catalogDiscoveryOptions: nil
             ),
-            DocumentationBundle.Info(
+            DocumentationContext.Inputs.Info(
                 displayName: "Info Plist Display Name",
                 id: "com.info.Plist"
             )
@@ -194,13 +194,13 @@ class DocumentationBundleInfoTests: XCTestCase {
         
         """
         
-        let decodedInfo = try DocumentationBundle.Info(from: Data(infoPlist.utf8))
+        let decodedInfo = try DocumentationContext.Inputs.Info(from: Data(infoPlist.utf8))
         
         let propertyListEncoder = PropertyListEncoder()
         propertyListEncoder.outputFormat = .xml
         let reEncodedInfo = try propertyListEncoder.encode(decodedInfo)
         
-        let reDecodedInfo = try DocumentationBundle.Info(from: reEncodedInfo)
+        let reDecodedInfo = try DocumentationContext.Inputs.Info(from: reEncodedInfo)
         XCTAssertEqual(decodedInfo, reDecodedInfo)
         
         let reEncodedString = try XCTUnwrap(String(
@@ -215,7 +215,7 @@ class DocumentationBundleInfoTests: XCTestCase {
     }
     
     func testFallbackToBundleDiscoveryOptions() throws {
-        let bundleDiscoveryOptions = BundleDiscoveryOptions(
+        let bundleDiscoveryOptions = CatalogDiscoveryOptions(
             fallbackDisplayName: "Display Name",
             fallbackIdentifier: "swift.org.Identifier",
             fallbackDefaultCodeListingLanguage: "swift",
@@ -232,10 +232,10 @@ class DocumentationBundleInfoTests: XCTestCase {
             )
         )
         
-        let info = try DocumentationBundle.Info(bundleDiscoveryOptions: bundleDiscoveryOptions)
+        let info = try DocumentationContext.Inputs.Info(catalogDiscoveryOptions: bundleDiscoveryOptions)
         XCTAssertEqual(
             info,
-            DocumentationBundle.Info(
+            DocumentationContext.Inputs.Info(
                 displayName: "Display Name",
                 id: "swift.org.Identifier",
                 defaultCodeListingLanguage: "swift",
@@ -255,7 +255,7 @@ class DocumentationBundleInfoTests: XCTestCase {
     }
     
     func testFallbackToInfoInBundleDiscoveryOptions() throws {
-        let info = DocumentationBundle.Info(
+        let info = DocumentationContext.Inputs.Info(
             displayName: "Display Name",
             id: "swift.org.Identifier",
             defaultCodeListingLanguage: "swift",
@@ -272,10 +272,10 @@ class DocumentationBundleInfoTests: XCTestCase {
             )
         )
         
-        let bundleDiscoveryOptions = try BundleDiscoveryOptions(fallbackInfo: info)
+        let bundleDiscoveryOptions = try CatalogDiscoveryOptions(fallbackInfo: info)
         XCTAssertEqual(
             info,
-            try DocumentationBundle.Info(bundleDiscoveryOptions: bundleDiscoveryOptions)
+            try DocumentationContext.Inputs.Info(catalogDiscoveryOptions: bundleDiscoveryOptions)
         )
     }
     
@@ -308,12 +308,12 @@ class DocumentationBundleInfoTests: XCTestCase {
         
         let valueMissingInvalidPlistData = Data(valueMissingInvalidPlist.utf8)
         XCTAssertThrowsError(
-            try DocumentationBundle.Info(from: valueMissingInvalidPlistData),
+            try DocumentationContext.Inputs.Info(from: valueMissingInvalidPlistData),
             "Info.plist decode didn't throw as expected"
         ) { error in
-            XCTAssertTrue(error is DocumentationBundle.Info.Error)
+            XCTAssertTrue(error is DocumentationContext.Inputs.Info.Error)
             let errorTypeChecking: Bool
-            if case DocumentationBundle.Info.Error.plistDecodingError(_) = error {
+            if case DocumentationContext.Inputs.Info.Error.plistDecodingError(_) = error {
                 errorTypeChecking = true
             } else {
                 errorTypeChecking = false
@@ -334,12 +334,12 @@ class DocumentationBundleInfoTests: XCTestCase {
         let infoPlistWithoutRequiredKeysData = Data(infoPlistWithoutRequiredKeys.utf8)
         
         XCTAssertEqual(
-            try DocumentationBundle.Info(
+            try DocumentationContext.Inputs.Info(
                 from: infoPlistWithoutRequiredKeysData,
-                bundleDiscoveryOptions: nil,
+                catalogDiscoveryOptions: nil,
                 derivedDisplayName: "Derived Display Name"
             ),
-            DocumentationBundle.Info(
+            DocumentationContext.Inputs.Info(
                 displayName: "Derived Display Name",
                 id: "Derived Display Name"
             )
@@ -359,12 +359,12 @@ class DocumentationBundleInfoTests: XCTestCase {
         let infoPlistWithoutRequiredKeysData = Data(infoPlistWithoutRequiredKeys.utf8)
         
         XCTAssertEqual(
-            try DocumentationBundle.Info(
+            try DocumentationContext.Inputs.Info(
                 from: infoPlistWithoutRequiredKeysData,
-                bundleDiscoveryOptions: nil,
+                catalogDiscoveryOptions: nil,
                 derivedDisplayName: "Derived Display Name"
             ),
-            DocumentationBundle.Info(
+            DocumentationContext.Inputs.Info(
                 displayName: "Derived Display Name",
                 id: "org.swift.docc.example"
             )
@@ -384,11 +384,11 @@ class DocumentationBundleInfoTests: XCTestCase {
         let infoPlistWithoutRequiredKeysData = Data(infoPlistWithoutRequiredKeys.utf8)
         
         XCTAssertEqual(
-            try DocumentationBundle.Info(
+            try DocumentationContext.Inputs.Info(
                 from: infoPlistWithoutRequiredKeysData,
-                bundleDiscoveryOptions: nil
+                catalogDiscoveryOptions: nil
             ),
-            DocumentationBundle.Info(
+            DocumentationContext.Inputs.Info(
                 displayName: "Example",
                 id: "Example"
             )
@@ -413,9 +413,9 @@ class DocumentationBundleInfoTests: XCTestCase {
         """
 
         let infoPlistWithFeatureFlagsData = Data(infoPlistWithFeatureFlags.utf8)
-        let info = try DocumentationBundle.Info(
+        let info = try DocumentationContext.Inputs.Info(
             from: infoPlistWithFeatureFlagsData,
-            bundleDiscoveryOptions: nil)
+            catalogDiscoveryOptions: nil)
 
         let featureFlags = try XCTUnwrap(info.featureFlags)
         XCTAssertTrue(try XCTUnwrap(featureFlags.experimentalOverloadedSymbolPresentation))
diff --git a/Tests/SwiftDocCTests/Infrastructure/ExternalPathHierarchyResolverTests.swift b/Tests/SwiftDocCTests/Infrastructure/ExternalPathHierarchyResolverTests.swift
index 7af1fa06eb..b7e75a4d37 100644
--- a/Tests/SwiftDocCTests/Infrastructure/ExternalPathHierarchyResolverTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/ExternalPathHierarchyResolverTests.swift
@@ -699,7 +699,7 @@ class ExternalPathHierarchyResolverTests: XCTestCase {
             )
         }
         
-        let (dependencyBundle, dependencyContext) = try await loadBundle(
+        let dependencyContext = try await load(
             catalog: Folder(name: "Dependency.docc", content: [
                 InfoPlist(identifier: "com.example.dependency"), // This isn't necessary but makes it easier to distinguish the identifier from the module name in the external references.
                 JSONFile(name: "Dependency.symbols.json", content: makeSymbolGraph(moduleName: "Dependency", symbols: symbols))
@@ -707,7 +707,7 @@ class ExternalPathHierarchyResolverTests: XCTestCase {
         )
         
         // Retrieve the link information from the dependency, as if '--enable-experimental-external-link-support' was passed to DocC
-        let dependencyConverter = DocumentationContextConverter(bundle: dependencyBundle, context: dependencyContext, renderContext: .init(documentationContext: dependencyContext, bundle: dependencyBundle))
+        let dependencyConverter = DocumentationContextConverter(context: dependencyContext, renderContext: .init(documentationContext: dependencyContext))
         
         let linkSummaries: [LinkDestinationSummary] = try dependencyContext.knownPages.flatMap { reference in
             let entity = try dependencyContext.entity(with: reference)
@@ -715,7 +715,7 @@ class ExternalPathHierarchyResolverTests: XCTestCase {
             
             return entity.externallyLinkableElementSummaries(context: dependencyContext, renderNode: renderNode, includeTaskGroups: false)
         }
-        let linkResolutionInformation = try dependencyContext.linkResolver.localResolver.prepareForSerialization(bundleID: dependencyBundle.id)
+        let linkResolutionInformation = try dependencyContext.linkResolver.localResolver.prepareForSerialization(bundleID: dependencyContext.inputs.id)
         
         XCTAssertEqual(linkResolutionInformation.pathHierarchy.nodes.count - linkResolutionInformation.nonSymbolPaths.count, 5 /* 4 symbols & 1 module */)
         XCTAssertEqual(linkSummaries.count, 5 /* 4 symbols & 1 module */)
@@ -724,7 +724,7 @@ class ExternalPathHierarchyResolverTests: XCTestCase {
         configuration.externalDocumentationConfiguration.dependencyArchives = [URL(fileURLWithPath: "/Dependency.doccarchive")]
         
         // After building the dependency,
-        let (mainBundle, mainContext) = try await loadBundle(
+        let mainContext = try await load(
             catalog: Folder(name: "Main.docc", content: [
                 JSONFile(name: "Main.symbols.json", content: makeSymbolGraph(
                     moduleName: "Main",
@@ -794,11 +794,11 @@ class ExternalPathHierarchyResolverTests: XCTestCase {
         
         XCTAssertEqual(mainContext.knownPages.count, 3 /* 2 symbols & 1 module*/)
         
-        let mainConverter = DocumentationContextConverter(bundle: mainBundle, context: mainContext, renderContext: .init(documentationContext: mainContext, bundle: mainBundle))
+        let mainConverter = DocumentationContextConverter(context: mainContext, renderContext: .init(documentationContext: mainContext))
         
         // Check the relationships of 'SomeClass'
         do {
-            let reference = ResolvedTopicReference(bundleID: mainBundle.id, path: "/documentation/Main/SomeClass", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: mainContext.inputs.id, path: "/documentation/Main/SomeClass", sourceLanguage: .swift)
             let entity = try mainContext.entity(with: reference)
             let renderNode = try XCTUnwrap(mainConverter.renderNode(for: entity))
             
@@ -822,7 +822,7 @@ class ExternalPathHierarchyResolverTests: XCTestCase {
         
         // Check the declaration of 'someFunction'
         do {
-            let reference = ResolvedTopicReference(bundleID: mainBundle.id, path: "/documentation/Main/SomeClass/someFunction(parameter:)", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: mainContext.inputs.id, path: "/documentation/Main/SomeClass/someFunction(parameter:)", sourceLanguage: .swift)
             let entity = try mainContext.entity(with: reference)
             let renderNode = try XCTUnwrap(mainConverter.renderNode(for: entity))
             
@@ -990,17 +990,17 @@ class ExternalPathHierarchyResolverTests: XCTestCase {
     }
     
     private func makeLinkResolversForTestBundle(named testBundleName: String, configuration: DocumentationContext.Configuration = .init()) async throws -> LinkResolvers {
-        let bundleURL = try XCTUnwrap(Bundle.module.url(forResource: testBundleName, withExtension: "docc", subdirectory: "Test Bundles"))
-        let (_, bundle, context) = try await loadBundle(from: bundleURL, configuration: configuration)
+        let catalogURL = try XCTUnwrap(Bundle.module.url(forResource: testBundleName, withExtension: "docc", subdirectory: "Test Bundles"))
+        let context = try await loadFromDisk(catalogURL: catalogURL, configuration: configuration)
         
         let localResolver = try XCTUnwrap(context.linkResolver.localResolver)
         
-        let resolverInfo = try localResolver.prepareForSerialization(bundleID: bundle.id)
+        let resolverInfo = try localResolver.prepareForSerialization(bundleID: context.inputs.id)
         let resolverData = try JSONEncoder().encode(resolverInfo)
         let roundtripResolverInfo = try JSONDecoder().decode(SerializableLinkResolutionInformation.self, from: resolverData)
         
         var entitySummaries = [LinkDestinationSummary]()
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
         for reference in context.knownPages {
             let node = try context.entity(with: reference)
             let renderNode = converter.convert(node)
diff --git a/Tests/SwiftDocCTests/Infrastructure/ExternalReferenceResolverTests.swift b/Tests/SwiftDocCTests/Infrastructure/ExternalReferenceResolverTests.swift
index 13b47f6743..840c74ee89 100644
--- a/Tests/SwiftDocCTests/Infrastructure/ExternalReferenceResolverTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/ExternalReferenceResolverTests.swift
@@ -16,7 +16,7 @@ import SwiftDocCTestUtilities
 
 class ExternalReferenceResolverTests: XCTestCase {
     class TestExternalReferenceResolver: ExternalDocumentationSource {
-        var bundleID: DocumentationBundle.Identifier = "com.external.testbundle"
+        var bundleID: DocumentationContext.Inputs.Identifier = "com.external.testbundle"
         var expectedReferencePath = "/externally/resolved/path"
         var expectedFragment: String? = nil
         var resolvedEntityTitle = "Externally Resolved Title"
@@ -59,8 +59,8 @@ class ExternalReferenceResolverTests: XCTestCase {
     }
     
     func testResolveExternalReference() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(
-            copying: "LegacyBundle_DoNotUseInNewTests",
+        let (_, context) = try await loadFromDisk(
+            copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests",
             externalResolvers: ["com.external.testbundle" : TestExternalReferenceResolver()]
         ) { url in
             let myClassExtensionFile = url.appendingPathComponent("documentation").appendingPathComponent("myclass.md")
@@ -70,7 +70,7 @@ class ExternalReferenceResolverTests: XCTestCase {
         }
         
         let unresolved = UnresolvedTopicReference(topicURL: ValidatedURL(parsingExact: "doc://com.external.testbundle/article")!)
-        let parent = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyClass", sourceLanguage: .swift)
+        let parent = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyClass", sourceLanguage: .swift)
 
         guard case let .success(resolved) = context.resolve(.unresolved(unresolved), in: parent) else {
             XCTFail("Couldn't resolve \(unresolved)")
@@ -97,8 +97,8 @@ class ExternalReferenceResolverTests: XCTestCase {
         // Set the language of the externally resolved entity to 'data'.
         externalResolver.resolvedEntityLanguage = .data
         
-        let (_, bundle, context) = try await testBundleAndContext(
-            copying: "LegacyBundle_DoNotUseInNewTests",
+        let (_, context) = try await loadFromDisk(
+            copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests",
             externalResolvers: [externalResolver.bundleID: externalResolver]
         ) { url in
             let sideClassExtension = """
@@ -119,9 +119,9 @@ class ExternalReferenceResolverTests: XCTestCase {
             try sideClassExtension.write(to: sideClassExtensionURL, atomically: true, encoding: .utf8)
         }
         
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
         let sideClassReference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/SideKit/SideClass",
             sourceLanguage: .swift
         )
@@ -155,7 +155,7 @@ class ExternalReferenceResolverTests: XCTestCase {
     }
     
     func testLoadEntityForExternalReference() async throws {
-        let (_, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests", externalResolvers: ["com.external.testbundle" : TestExternalReferenceResolver()])
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests", externalResolvers: ["com.external.testbundle" : TestExternalReferenceResolver()])
         let identifier = ResolvedTopicReference(bundleID: "com.external.testbundle", path: "/externally/resolved/path", sourceLanguage: .swift)
         
         XCTAssertThrowsError(try context.entity(with: ResolvedTopicReference(bundleID: "some.other.bundle", path: identifier.path, sourceLanguage: .swift)))
@@ -186,10 +186,10 @@ class ExternalReferenceResolverTests: XCTestCase {
             externalResolver.resolvedEntityTitle = "ClassName"
             externalResolver.resolvedEntityKind = resolvedEntityKind
             
-            let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [externalResolver.bundleID: externalResolver])
+            let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [externalResolver.bundleID: externalResolver])
             
-            let converter = DocumentationNodeConverter(bundle: bundle, context: context)
-            let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/Test-Bundle/TestTutorial", sourceLanguage: .swift))
+            let converter = DocumentationNodeConverter(context: context)
+            let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/Test-Bundle/TestTutorial", sourceLanguage: .swift))
             
             guard let fileURL = context.documentURL(for: node.reference) else {
                 XCTFail("Unable to find the file for \(node.reference.path)")
@@ -228,7 +228,7 @@ class ExternalReferenceResolverTests: XCTestCase {
             .init(kind: .identifier, spelling: "ClassName", preciseIdentifier: nil),
         ])
         
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [externalResolver.bundleID: externalResolver]) { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [externalResolver.bundleID: externalResolver]) { url in
             try """
             # ``SideKit/SideClass``
 
@@ -242,8 +242,8 @@ class ExternalReferenceResolverTests: XCTestCase {
             """.write(to: url.appendingPathComponent("documentation/sideclass.md"), atomically: true, encoding: .utf8)
         }
         
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClass", sourceLanguage: .swift))
+        let converter = DocumentationNodeConverter(context: context)
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClass", sourceLanguage: .swift))
         
         let renderNode = converter.convert(node)
         
@@ -285,10 +285,10 @@ class ExternalReferenceResolverTests: XCTestCase {
         
         var configuration = DocumentationContext.Configuration()
         configuration.externalDocumentationConfiguration.sources = [externalResolver.bundleID: externalResolver]
-        let (bundle, context) = try await loadBundle(catalog: tempFolder, configuration: configuration)
+        let context = try await load(catalog: tempFolder, configuration: configuration)
         
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/article", sourceLanguage: .swift))
+        let converter = DocumentationNodeConverter(context: context)
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/article", sourceLanguage: .swift))
         
         let renderNode = converter.convert(node)
         
@@ -320,7 +320,7 @@ class ExternalReferenceResolverTests: XCTestCase {
         externalResolver.resolvedEntityTitle = "Name of Sample"
         externalResolver.resolvedEntityKind = .sampleCode
         
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [externalResolver.bundleID: externalResolver]) { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [externalResolver.bundleID: externalResolver]) { url in
             try """
             # ``SideKit/SideClass``
 
@@ -334,8 +334,8 @@ class ExternalReferenceResolverTests: XCTestCase {
             """.write(to: url.appendingPathComponent("documentation/sideclass.md"), atomically: true, encoding: .utf8)
         }
         
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClass", sourceLanguage: .swift))
+        let converter = DocumentationNodeConverter(context: context)
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClass", sourceLanguage: .swift))
         
         let renderNode = converter.convert(node)
         
@@ -408,7 +408,7 @@ class ExternalReferenceResolverTests: XCTestCase {
             ),
         ]
         
-        let (_, bundle, context) = try await testBundleAndContext(copying: "SampleBundle", excludingPaths: ["MySample.md", "MyLocalSample.md"], externalResolvers: [externalResolver.bundleID: externalResolver]) { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "SampleBundle", excludingPaths: ["MySample.md", "MyLocalSample.md"], externalResolvers: [externalResolver.bundleID: externalResolver]) { url in
             try """
             # SomeSample
 
@@ -433,8 +433,8 @@ class ExternalReferenceResolverTests: XCTestCase {
             """.write(to: url.appendingPathComponent("SomeSample.md"), atomically: true, encoding: .utf8)
         }
         
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SomeSample", sourceLanguage: .swift))
+        let converter = DocumentationNodeConverter(context: context)
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SomeSample", sourceLanguage: .swift))
         
         let renderNode = converter.convert(node)
         
@@ -530,7 +530,7 @@ class ExternalReferenceResolverTests: XCTestCase {
             "/externally/resolved/path/to/article2": .success(.init(referencePath: "/externally/resolved/path/to/article2")),
         ]
         
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [
             "com.external.testbundle" : resolver
         ]) { url in
             // Add external links to the MyKit Topics.
@@ -547,7 +547,7 @@ class ExternalReferenceResolverTests: XCTestCase {
         }
         
         // Get MyKit symbol
-        let entity = try context.entity(with: .init(bundleID: bundle.id, path: "/documentation/MyKit", sourceLanguage: .swift))
+        let entity = try context.entity(with: .init(bundleID: context.inputs.id, path: "/documentation/MyKit", sourceLanguage: .swift))
         let taskGroupLinks = try XCTUnwrap((entity.semantic as? Symbol)?.topics?.taskGroups.first?.links.compactMap({ $0.destination }))
         
         // Verify the task group links have been resolved and are still present in the link list.
@@ -562,7 +562,7 @@ class ExternalReferenceResolverTests: XCTestCase {
     // Tests that external references are resolved in tutorial content
     func testResolveExternalReferenceInTutorials() async throws {
         let resolver = TestExternalReferenceResolver()
-        let (_, _, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", externalResolvers: ["com.external.bundle": resolver, "com.external.testbundle": resolver], configureBundle: { (bundleURL) in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", externalResolvers: ["com.external.bundle": resolver, "com.external.testbundle": resolver], configureBundle: { (bundleURL) in
             // Replace TestTutorial.tutorial with a copy that includes a bunch of external links
             try FileManager.default.removeItem(at: bundleURL.appendingPathComponent("TestTutorial.tutorial"))
             try FileManager.default.copyItem(
@@ -652,7 +652,7 @@ class ExternalReferenceResolverTests: XCTestCase {
 
         // Copy the test bundle and add external links to the MyKit See Also.
         // We're using a See Also group, because external links aren't rendered in Topics groups.
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", externalResolvers: ["com.external.testbundle" : resolver]) { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", externalResolvers: ["com.external.testbundle" : resolver]) { url in
             try """
             # ``MyKit``
             MyKit module root symbol <doc://com.external.testbundle/not-resolvable-2>
@@ -704,8 +704,8 @@ class ExternalReferenceResolverTests: XCTestCase {
                   "The external reference resolver error message is included in that problem's error summary.")
         
         // Get MyKit symbol
-        let entity = try context.entity(with: .init(bundleID: bundle.id, path: "/documentation/MyKit", sourceLanguage: .swift))
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let entity = try context.entity(with: .init(bundleID: context.inputs.id, path: "/documentation/MyKit", sourceLanguage: .swift))
+        let converter = DocumentationNodeConverter(context: context)
         let renderNode = converter.convert(entity)
         
         let taskGroupLinks = try XCTUnwrap(renderNode.seeAlsoSections.first?.identifiers)
@@ -738,7 +738,7 @@ class ExternalReferenceResolverTests: XCTestCase {
         resolver.expectedFragment = "67890"
         
         // Prepare a test bundle
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", externalResolvers: ["com.external.testbundle" : resolver], externalSymbolResolver: nil, configureBundle: { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", externalResolvers: ["com.external.testbundle" : resolver], externalSymbolResolver: nil, configureBundle: { url in
             // Add external link with fragment
             let myClassMDURL = url.appendingPathComponent("documentation").appendingPathComponent("myclass.md")
             try String(contentsOf: myClassMDURL)
@@ -746,7 +746,7 @@ class ExternalReferenceResolverTests: XCTestCase {
                 .write(to: myClassMDURL, atomically: true, encoding: .utf8)
         })
 
-        let myClassRef = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift)
+        let myClassRef = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift)
         let documentationNode = try context.entity(with: myClassRef)
         
         // Verify the external link was resolved in markup.
@@ -805,8 +805,8 @@ class ExternalReferenceResolverTests: XCTestCase {
             )
         )
         
-        let (_, bundle, context) = try await testBundleAndContext(
-            copying: "MixedLanguageFramework",
+        let (_, context) = try await loadFromDisk(
+            copyingCatalogNamed: "MixedLanguageFramework",
             externalResolvers: [externalResolver.bundleID: externalResolver]
         ) { url in
             let mixedLanguageFrameworkExtension = """
@@ -825,12 +825,8 @@ class ExternalReferenceResolverTests: XCTestCase {
                 """
             try mixedLanguageFrameworkExtension.write(to: url.appendingPathComponent("/MixedLanguageFramework.md"), atomically: true, encoding: .utf8)
         }
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
-        let mixedLanguageFrameworkReference = ResolvedTopicReference(
-            bundleID: bundle.id,
-            path: "/documentation/MixedLanguageFramework",
-            sourceLanguage: .swift
-        )
+        let converter = DocumentationNodeConverter(context: context)
+        let mixedLanguageFrameworkReference = try XCTUnwrap(context.soleRootModuleReference)
         let node = try context.entity(with: mixedLanguageFrameworkReference)
         let renderNode = converter.convert(node)
         // Topic identifiers in the Swift variant of the `MixedLanguageFramework` symbol
@@ -899,12 +895,12 @@ class ExternalReferenceResolverTests: XCTestCase {
         
         var configuration = DocumentationContext.Configuration()
         configuration.externalDocumentationConfiguration.sources = [resolver.bundleID: resolver]
-        let (bundle, context) = try await loadBundle(catalog: catalog, configuration: configuration)
+        let context = try await load(catalog: catalog, configuration: configuration)
         
         XCTAssert(context.problems.isEmpty, "Unexpected problems:\n\(context.problems.map(\.diagnostic.summary).joined(separator: "\n"))")
         
         do {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleName/SymbolName", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleName/SymbolName", sourceLanguage: .swift)
             let node = try context.entity(with: reference)
             
             let deprecatedSection = try XCTUnwrap((node.semantic as? Symbol)?.deprecatedSummary)
@@ -913,7 +909,7 @@ class ExternalReferenceResolverTests: XCTestCase {
         }
         
         do {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/unit-test/Article", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/unit-test/Article", sourceLanguage: .swift)
             let node = try context.entity(with: reference)
             
             let deprecatedSection = try XCTUnwrap((node.semantic as? Article)?.deprecationSummary)
@@ -956,7 +952,7 @@ class ExternalReferenceResolverTests: XCTestCase {
         
         var configuration = DocumentationContext.Configuration()
         configuration.externalDocumentationConfiguration.sources = [resolver.bundleID: resolver]
-        let (bundle, context) = try await loadBundle(catalog: catalog, configuration: configuration)
+        let context = try await load(catalog: catalog, configuration: configuration)
         
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
         
@@ -972,10 +968,10 @@ class ExternalReferenceResolverTests: XCTestCase {
         ])
         
         // Check the rendered SeeAlso sections for the two curated articles.
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
         
         do {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/unit-test/First", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/unit-test/First", sourceLanguage: .swift)
             let node = try context.entity(with: reference)
             let rendered = converter.convert(node)
             
@@ -989,7 +985,7 @@ class ExternalReferenceResolverTests: XCTestCase {
         }
         
         do {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/unit-test/Second", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/unit-test/Second", sourceLanguage: .swift)
             let node = try context.entity(with: reference)
             let rendered = converter.convert(node)
             
@@ -1024,7 +1020,7 @@ class ExternalReferenceResolverTests: XCTestCase {
         
         var configuration = DocumentationContext.Configuration()
         configuration.externalDocumentationConfiguration.sources = [resolver.bundleID: resolver]
-        let (bundle, context) = try await loadBundle(catalog: catalog, configuration: configuration)
+        let context = try await load(catalog: catalog, configuration: configuration)
         
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
         
@@ -1032,7 +1028,7 @@ class ExternalReferenceResolverTests: XCTestCase {
         // Check the curation on the root page
         let reference = try XCTUnwrap(context.soleRootModuleReference)
         let node = try context.entity(with: reference)
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
         let rendered = converter.convert(node)
         
         XCTAssertEqual(rendered.seeAlsoSections.count, 1, "The page should only have the authored See Also section.")
@@ -1110,12 +1106,12 @@ class ExternalReferenceResolverTests: XCTestCase {
 
         var configuration = DocumentationContext.Configuration()
         configuration.externalDocumentationConfiguration.sources = [resolver.bundleID: resolver]
-        let (bundle, context) = try await loadBundle(catalog: catalog, configuration: configuration)
+        let context = try await load(catalog: catalog, configuration: configuration)
 
         XCTAssert(context.problems.isEmpty, "Unexpected problems:\n\(context.problems.map(\.diagnostic.summary).joined(separator: "\n"))")
 
         // Load the DocumentationNode for the artist dictionary keys symbol.
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleName/SymbolName", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleName/SymbolName", sourceLanguage: .swift)
         let node = try context.entity(with: reference)
 
         // Get the semantic symbol and the variants of the dictionary keys section.
@@ -1141,8 +1137,8 @@ class ExternalReferenceResolverTests: XCTestCase {
 
     func exampleDocumentation(copying bundleName: String, documentationExtension: TextFile, path: String, file: StaticString = #filePath, line: UInt = #line) async throws -> Symbol {
         let externalResolver = TestExternalReferenceResolver()
-        let (_, bundle, context) = try await testBundleAndContext(
-            copying: bundleName,
+        let (_, context) = try await loadFromDisk(
+            copyingCatalogNamed: bundleName,
             externalResolvers: [externalResolver.bundleID: externalResolver]
         ) { url in
             try documentationExtension.utf8Content.write(
@@ -1154,7 +1150,7 @@ class ExternalReferenceResolverTests: XCTestCase {
         XCTAssert(context.problems.isEmpty, "Unexpected problems:\n\(context.problems.map(\.diagnostic.summary).joined(separator: "\n"))", file: file, line: line)
 
         // Load the DocumentationNode for the artist dictionary keys symbol.
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: path, sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: path, sourceLanguage: .swift)
         let node = try context.entity(with: reference)
 
         // Get the semantic symbol and the variants of the dictionary keys section.
diff --git a/Tests/SwiftDocCTests/Infrastructure/InheritIntroducedAvailabilityTests.swift b/Tests/SwiftDocCTests/Infrastructure/InheritIntroducedAvailabilityTests.swift
index 1602d4dee3..bda3d30929 100644
--- a/Tests/SwiftDocCTests/Infrastructure/InheritIntroducedAvailabilityTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/InheritIntroducedAvailabilityTests.swift
@@ -38,7 +38,7 @@ class InheritIntroducedAvailabilityTests: XCTestCase {
     
     override func setUp() async throws {
         try await super.setUp()
-        (_, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        (_, context) = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
     }
     
     override func tearDown() {
diff --git a/Tests/SwiftDocCTests/Infrastructure/Input Discovery/DocumentationInputsProviderTests.swift b/Tests/SwiftDocCTests/Infrastructure/Input Discovery/DocumentationInputsProviderTests.swift
index 2d6edd7e57..16b8e7f8a5 100644
--- a/Tests/SwiftDocCTests/Infrastructure/Input Discovery/DocumentationInputsProviderTests.swift	
+++ b/Tests/SwiftDocCTests/Infrastructure/Input Discovery/DocumentationInputsProviderTests.swift	
@@ -74,7 +74,7 @@ class DocumentationInputsProviderTests: XCTestCase {
         
         for fileManager in [FileManager.default as FileManagerProtocol, testFileSystem as FileManagerProtocol] {
             let inputsProvider = DocumentationContext.InputsProvider(fileManager: fileManager)
-            let options = BundleDiscoveryOptions(fallbackIdentifier: "com.example.test", additionalSymbolGraphFiles: [
+            let options = CatalogDiscoveryOptions(fallbackIdentifier: "com.example.test", additionalSymbolGraphFiles: [
                 tempDirectory.appendingPathComponent("/path/to/SomethingAdditional.symbols.json")
             ])
             let (bundle, _) = try XCTUnwrap(inputsProvider.inputsAndDataProvider(startingPoint: tempDirectory.appendingPathComponent("/one/two"), options: options))
diff --git a/Tests/SwiftDocCTests/Infrastructure/NodeTagsTests.swift b/Tests/SwiftDocCTests/Infrastructure/NodeTagsTests.swift
index 37157b55c9..b469e360d1 100644
--- a/Tests/SwiftDocCTests/Infrastructure/NodeTagsTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/NodeTagsTests.swift
@@ -14,37 +14,33 @@ import SwiftDocCTestUtilities
 
 class NodeTagsTests: XCTestCase {
     func testSPIMetadata() async throws {
-        let spiSGURL = Bundle.module.url(
-            forResource: "SPI.symbols", withExtension: "json", subdirectory: "Test Resources")!
-        
-        let bundleFolder = Folder(name: "unit-tests.docc", content: [
+        let spiSGURL = Bundle.module.url(forResource: "SPI.symbols", withExtension: "json", subdirectory: "Test Resources")!
+        let catalog = Folder(name: "unit-tests.docc", content: [
             InfoPlist(displayName: "spi", identifier: "com.tests.spi"),
             CopyOfFile(original: spiSGURL),
         ])
-        let tempURL = try createTemporaryDirectory().appendingPathComponent("unit-tests.docc")
-        try bundleFolder.write(to: tempURL)
         
-        let (_, bundle, context) = try await loadBundle(from: tempURL)
+        let context = try await load(catalog: catalog)
         
         // Verify that `Test` is marked as SPI.
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Minimal_docs/Test", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Minimal_docs/Test", sourceLanguage: .swift)
         let node = try XCTUnwrap(context.entity(with: reference))
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
         XCTAssertTrue(symbol.isSPI)
 
         // Verify the render node contains the SPI tag.
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = try XCTUnwrap(translator.visit(symbol) as? RenderNode)
 
         XCTAssertEqual(renderNode.metadata.tags, [.spi])
 
         // Verify that the link to the node contains the SPI tag.
-        let moduleReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Minimal_docs", sourceLanguage: .swift)
+        let moduleReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Minimal_docs", sourceLanguage: .swift)
         let moduleNode = try XCTUnwrap(context.entity(with: moduleReference))
         let moduleSymbol = try XCTUnwrap(moduleNode.semantic as? Symbol)
 
         // Verify the render node contains the SPI tag.
-        var moduleTranslator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var moduleTranslator = RenderNodeTranslator(context: context, identifier: node.reference)
         let moduleRenderNode = try XCTUnwrap(moduleTranslator.visit(moduleSymbol) as? RenderNode)
         let linkReference = try XCTUnwrap(moduleRenderNode.references["doc://com.tests.spi/documentation/Minimal_docs/Test"] as? TopicRenderReference)
         
diff --git a/Tests/SwiftDocCTests/Infrastructure/PathHierarchyBasedLinkResolverTests.swift b/Tests/SwiftDocCTests/Infrastructure/PathHierarchyBasedLinkResolverTests.swift
index 4c82a540a7..0d8e516e34 100644
--- a/Tests/SwiftDocCTests/Infrastructure/PathHierarchyBasedLinkResolverTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/PathHierarchyBasedLinkResolverTests.swift
@@ -16,7 +16,7 @@ class PathHierarchyBasedLinkResolverTests: XCTestCase {
     func testOverloadedSymbolsWithOverloadGroups() async throws {
         enableFeatureFlag(\.isExperimentalOverloadedSymbolPresentationEnabled)
         
-        let (_, context) = try await testBundleAndContext(named: "OverloadedSymbols")
+        let context = try await loadFromDisk(catalogName: "OverloadedSymbols")
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
         
         // Returns nil for all non-overload groups
diff --git a/Tests/SwiftDocCTests/Infrastructure/PathHierarchyTests.swift b/Tests/SwiftDocCTests/Infrastructure/PathHierarchyTests.swift
index 2f3a3014ed..20160fe19b 100644
--- a/Tests/SwiftDocCTests/Infrastructure/PathHierarchyTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/PathHierarchyTests.swift
@@ -17,7 +17,7 @@ import Markdown
 class PathHierarchyTests: XCTestCase {
     
     func testFindingUnambiguousAbsolutePaths() async throws {
-        let (_, context) = try await testBundleAndContext(named: "MixedLanguageFrameworkWithLanguageRefinements")
+        let context = try await loadFromDisk(catalogName: "MixedLanguageFrameworkWithLanguageRefinements")
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         try assertFindsPath("/MixedFramework", in: tree, asSymbolID: "MixedFramework")
@@ -289,7 +289,7 @@ class PathHierarchyTests: XCTestCase {
     func testAmbiguousPaths() async throws {
         enableFeatureFlag(\.isExperimentalLinkHierarchySerializationEnabled)
         
-        let (_, context) = try await testBundleAndContext(named: "MixedLanguageFrameworkWithLanguageRefinements")
+        let context = try await loadFromDisk(catalogName: "MixedLanguageFrameworkWithLanguageRefinements")
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         // Symbol name not found. Suggestions only include module names (search is not relative to a known page)
@@ -575,7 +575,7 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testRedundantKindDisambiguation() async throws {
-        let (_, context) = try await testBundleAndContext(named: "MixedLanguageFrameworkWithLanguageRefinements")
+        let context = try await loadFromDisk(catalogName: "MixedLanguageFrameworkWithLanguageRefinements")
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         try assertFindsPath("/MixedFramework-module", in: tree, asSymbolID: "MixedFramework")
@@ -627,7 +627,7 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testBothRedundantDisambiguations() async throws {
-        let (_, context) = try await testBundleAndContext(named: "MixedLanguageFrameworkWithLanguageRefinements")
+        let context = try await loadFromDisk(catalogName: "MixedLanguageFrameworkWithLanguageRefinements")
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         try assertFindsPath("/MixedFramework-module-9r7pl", in: tree, asSymbolID: "MixedFramework")
@@ -691,7 +691,7 @@ class PathHierarchyTests: XCTestCase {
         // ---- Outer
         // @_exported import Inner
         // public typealias Something = Inner.Something
-        let (_, context) = try await testBundleAndContext(named: "DefaultImplementationsWithExportedImport")
+        let context = try await loadFromDisk(catalogName: "DefaultImplementationsWithExportedImport")
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         // The @_export imported protocol can be found
@@ -713,7 +713,7 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testDisambiguatedPaths() async throws {
-        let (_, context) = try await testBundleAndContext(named: "MixedLanguageFrameworkWithLanguageRefinements")
+        let context = try await loadFromDisk(catalogName: "MixedLanguageFrameworkWithLanguageRefinements")
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         let paths = tree.caseInsensitiveDisambiguatedPaths()
@@ -850,7 +850,7 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testDisambiguatedOperatorPaths() async throws {
-        let (_, context) = try await testBundleAndContext(named: "InheritedOperators")
+        let context = try await loadFromDisk(catalogName: "InheritedOperators")
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         let paths = tree.caseInsensitiveDisambiguatedPaths()
@@ -920,7 +920,7 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testFindingRelativePaths() async throws {
-        let (_, context) = try await testBundleAndContext(named: "MixedLanguageFrameworkWithLanguageRefinements")
+        let context = try await loadFromDisk(catalogName: "MixedLanguageFrameworkWithLanguageRefinements")
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         let moduleID = try tree.find(path: "/MixedFramework", onlyFindSymbols: true)
@@ -1092,7 +1092,7 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testPathWithDocumentationPrefix() async throws {
-        let (_, context) = try await testBundleAndContext(named: "MixedLanguageFrameworkWithLanguageRefinements")
+        let context = try await loadFromDisk(catalogName: "MixedLanguageFrameworkWithLanguageRefinements")
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         let moduleID = try tree.find(path: "/MixedFramework", onlyFindSymbols: true)
@@ -1107,12 +1107,12 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testUnrealisticMixedTestCatalog() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let (_, context) = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         let linkResolver = try XCTUnwrap(context.linkResolver.localResolver)
         let tree = try XCTUnwrap(linkResolver.pathHierarchy)
         
         // Test finding the parent via the `fromTopicReference` integration shim.
-        let parentID = linkResolver.resolvedReferenceMap[ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit", sourceLanguage: .swift)]!
+        let parentID = linkResolver.resolvedReferenceMap[ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit", sourceLanguage: .swift)]!
         XCTAssertNotNil(parentID)
         XCTAssertEqual(try tree.findSymbol(path: "globalFunction(_:considering:)", parent: parentID).identifier.precise, "s:5MyKit14globalFunction_11consideringy10Foundation4DataV_SitF")
         XCTAssertEqual(try tree.findSymbol(path: "MyKit/globalFunction(_:considering:)", parent: parentID).identifier.precise, "s:5MyKit14globalFunction_11consideringy10Foundation4DataV_SitF")
@@ -1173,7 +1173,7 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testMixedLanguageFramework() async throws {
-        let (_, context) = try await testBundleAndContext(named: "MixedLanguageFramework")
+        let context = try await loadFromDisk(catalogName: "MixedLanguageFramework")
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         try assertFindsPath("MixedLanguageFramework/Bar/myStringFunction(_:)", in: tree, asSymbolID: "c:objc(cs)Bar(cm)myStringFunction:error:")
@@ -1227,7 +1227,7 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testArticleAndSymbolCollisions() async throws {
-        let (_, _, context) = try await testBundleAndContext(copying: "MixedLanguageFramework") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "MixedLanguageFramework") { url in
             try """
             # An article
             
@@ -1244,7 +1244,7 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testArticleSelfAnchorLinks() async throws {
-        let (_, _, context) = try await testBundleAndContext(copying: "MixedLanguageFramework") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "MixedLanguageFramework") { url in
             try """
             # ArticleWithHeading
 
@@ -1267,7 +1267,7 @@ class PathHierarchyTests: XCTestCase {
     }
 
     func testOverloadedSymbols() async throws {
-        let (_, context) = try await testBundleAndContext(named: "OverloadedSymbols")
+        let context = try await loadFromDisk(catalogName: "OverloadedSymbols")
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         let paths = tree.caseInsensitiveDisambiguatedPaths()
@@ -1331,7 +1331,7 @@ class PathHierarchyTests: XCTestCase {
     func testOverloadedSymbolsWithOverloadGroups() async throws {
         enableFeatureFlag(\.isExperimentalOverloadedSymbolPresentationEnabled)
 
-        let (_, context) = try await testBundleAndContext(named: "OverloadedSymbols")
+        let context = try await loadFromDisk(catalogName: "OverloadedSymbols")
         let tree = context.linkResolver.localResolver.pathHierarchy
 
         let paths = tree.caseInsensitiveDisambiguatedPaths()
@@ -1956,7 +1956,7 @@ class PathHierarchyTests: XCTestCase {
                 ))
             })),
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         XCTAssert(context.problems.isEmpty, "Unexpected problems \(context.problems.map(\.diagnostic.summary))")
@@ -2005,7 +2005,7 @@ class PathHierarchyTests: XCTestCase {
                 ))
             })),
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         XCTAssert(context.problems.isEmpty, "Unexpected problems \(context.problems.map(\.diagnostic.summary))")
@@ -2040,7 +2040,7 @@ class PathHierarchyTests: XCTestCase {
     func testOverloadGroupSymbolsResolveLinksWithoutHash() async throws {
         enableFeatureFlag(\.isExperimentalOverloadedSymbolPresentationEnabled)
 
-        let (_, context) = try await testBundleAndContext(named: "OverloadedSymbols")
+        let context = try await loadFromDisk(catalogName: "OverloadedSymbols")
         let tree = context.linkResolver.localResolver.pathHierarchy
 
         // The enum case should continue to resolve by kind, since it has no hash collision
@@ -2058,7 +2058,7 @@ class PathHierarchyTests: XCTestCase {
 
     func testAmbiguousPathsForOverloadedGroupSymbols() async throws {
         enableFeatureFlag(\.isExperimentalOverloadedSymbolPresentationEnabled)
-        let (_, context) = try await testBundleAndContext(named: "OverloadedSymbols")
+        let context = try await loadFromDisk(catalogName: "OverloadedSymbols")
         let tree = context.linkResolver.localResolver.pathHierarchy
         try assertPathRaisesErrorMessage("/ShapeKit/OverloadedProtocol/fourthTestMemberName(test:)-abc123", in: tree, context: context, expectedErrorMessage: """
         'abc123' isn't a disambiguation for 'fourthTestMemberName(test:)' at '/ShapeKit/OverloadedProtocol'
@@ -2076,7 +2076,7 @@ class PathHierarchyTests: XCTestCase {
     }
 
     func testDoesNotSuggestBundleNameForSymbolLink() async throws {
-        let exampleDocumentation = Folder(name: "Something.docc", content: [
+        let catalog = Folder(name: "Something.docc", content: [
             JSONFile(name: "ModuleName.symbols.json", content: makeSymbolGraph(moduleName: "ModuleName")),
             
             InfoPlist(displayName: "ModuleNaem"), // The bundle name is intentionally misspelled.
@@ -2088,8 +2088,8 @@ class PathHierarchyTests: XCTestCase {
             A documentation extension file with a misspelled link that happens to match the, also misspelled, bundle name.
             """),
         ])
-        let catalogURL = try exampleDocumentation.write(inside: createTemporaryDirectory())
-        let (_, _, context) = try await loadBundle(from: catalogURL)
+        
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         // This link is intentionally misspelled
@@ -2102,7 +2102,7 @@ class PathHierarchyTests: XCTestCase {
     }
         
     func testSymbolsWithSameNameAsModule() async throws {
-        let (_, context) = try await testBundleAndContext(named: "SymbolsWithSameNameAsModule")
+        let context = try await loadFromDisk(catalogName: "SymbolsWithSameNameAsModule")
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         // /* in a module named "Something "*/
@@ -2163,7 +2163,7 @@ class PathHierarchyTests: XCTestCase {
         // public extension InnerClass {
         //     func something() {}
         // }
-        let (_, context) = try await testBundleAndContext(named: "ShadowExtendedModuleWithLocalSymbol")
+        let context = try await loadFromDisk(catalogName: "ShadowExtendedModuleWithLocalSymbol")
         let tree = context.linkResolver.localResolver.pathHierarchy
 
         try assertPathCollision("Outer/Inner", in: tree, collisions: [
@@ -2238,7 +2238,7 @@ class PathHierarchyTests: XCTestCase {
             ),
         ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
 
         let paths = tree.caseInsensitiveDisambiguatedPaths()
@@ -2264,7 +2264,7 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testContinuesSearchingIfNonSymbolMatchesSymbolLink() async throws {
-        let exampleDocumentation = Folder(name: "CatalogName.docc", content: [
+        let catalog = Folder(name: "CatalogName.docc", content: [
             JSONFile(name: "ModuleName.symbols.json", content: makeSymbolGraph(moduleName: "ModuleName", symbols: [
                 makeSymbol(id: "some-class-id", kind: .class, pathComponents: ["SomeClass"])
             ])),
@@ -2281,8 +2281,7 @@ class PathHierarchyTests: XCTestCase {
              ### OtherHeading
              """),
         ])
-        let catalogURL = try exampleDocumentation.write(inside: createTemporaryDirectory())
-        let (_, _, context) = try await loadBundle(from: catalogURL)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         XCTAssert(context.problems.isEmpty, "Unexpected problems \(context.problems.map(\.diagnostic.summary))")
@@ -2307,14 +2306,13 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testDiagnosticDoesNotSuggestReplacingPartOfSymbolName() async throws {
-        let exampleDocumentation = Folder(name: "CatalogName.docc", content: [
+        let catalog = Folder(name: "CatalogName.docc", content: [
             JSONFile(name: "ModuleName.symbols.json", content: makeSymbolGraph(moduleName: "ModuleName", symbols: [
                 makeSymbol(id: "some-class-id-1", kind: .class, pathComponents: ["SomeClass-(Something)"]),
                 makeSymbol(id: "some-class-id-2", kind: .class, pathComponents: ["SomeClass-(Something)"]),
             ])),
         ])
-        let catalogURL = try exampleDocumentation.write(inside: createTemporaryDirectory())
-        let (_, _, context) = try await loadBundle(from: catalogURL)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         XCTAssert(context.problems.isEmpty, "Unexpected problems \(context.problems.map(\.diagnostic.summary))")
@@ -2338,7 +2336,7 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testSnippets() async throws {
-        let (_, context) = try await testBundleAndContext(named: "Snippets")
+        let context = try await loadFromDisk(catalogName: "Snippets")
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         try assertFindsPath("/Snippets/Snippets/MySnippet", in: tree, asSymbolID: "$snippet__Test.Snippets.MySnippet")
@@ -2363,7 +2361,7 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testInheritedOperators() async throws {
-        let (_, context) = try await testBundleAndContext(named: "InheritedOperators")
+        let context = try await loadFromDisk(catalogName: "InheritedOperators")
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         // public struct MyNumber: SignedNumeric, Comparable, Equatable, Hashable {
@@ -2465,7 +2463,7 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testSameNameForSymbolAndContainer() async throws {
-        let (_, context) = try await testBundleAndContext(named: "BundleWithSameNameForSymbolAndContainer")
+        let context = try await loadFromDisk(catalogName: "BundleWithSameNameForSymbolAndContainer")
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         // public struct Something {
@@ -2499,7 +2497,7 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testPrefersNonSymbolsWhenOnlyFindSymbolIsFalse() async throws {
-        let (_, _, context) = try await testBundleAndContext(copying: "SymbolsWithSameNameAsModule") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "SymbolsWithSameNameAsModule") { url in
             // This bundle has a top-level struct named "Wrapper". Adding an article named "Wrapper.md" introduces a possibility for a link collision
             try """
             # An article
@@ -2531,15 +2529,13 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testOneSymbolPathsWithKnownDisambiguation() async throws {
-        let exampleDocumentation = Folder(name: "MyKit.docc", content: [
+        let catalog = Folder(name: "MyKit.docc", content: [
             CopyOfFile(original: Bundle.module.url(forResource: "mykit-one-symbol.symbols", withExtension: "json", subdirectory: "Test Resources")!),
             InfoPlist(displayName: "MyKit", identifier: "com.test.MyKit"),
         ])
-        let tempURL = try createTemporaryDirectory()
-        let bundleURL = try exampleDocumentation.write(inside: tempURL)
 
         do {
-            let (_, _, context) = try await loadBundle(from: bundleURL)
+            let context = try await load(catalog: catalog)
             let tree = context.linkResolver.localResolver.pathHierarchy
             
             try assertFindsPath("/MyKit/MyClass/myFunction()", in: tree, asSymbolID: "s:5MyKit0A5ClassC10myFunctionyyF")
@@ -2558,7 +2554,7 @@ class PathHierarchyTests: XCTestCase {
             configuration.convertServiceConfiguration.knownDisambiguatedSymbolPathComponents = [
                 "s:5MyKit0A5ClassC10myFunctionyyF": ["MyClass-swift.class", "myFunction()"]
             ]
-            let (_, _, context) = try await loadBundle(from: bundleURL, configuration: configuration)
+            let context = try await load(catalog: catalog, configuration: configuration)
             let tree = context.linkResolver.localResolver.pathHierarchy
             
             try assertFindsPath("/MyKit/MyClass-swift.class/myFunction()", in: tree, asSymbolID: "s:5MyKit0A5ClassC10myFunctionyyF")
@@ -2577,7 +2573,7 @@ class PathHierarchyTests: XCTestCase {
             configuration.convertServiceConfiguration.knownDisambiguatedSymbolPathComponents = [
                 "s:5MyKit0A5ClassC10myFunctionyyF": ["MyClass-swift.class-hash", "myFunction()"]
             ]
-            let (_, _, context) = try await loadBundle(from: bundleURL, configuration: configuration)
+            let context = try await load(catalog: catalog, configuration: configuration)
             let tree = context.linkResolver.localResolver.pathHierarchy
             
             try assertFindsPath("/MyKit/MyClass-swift.class-hash/myFunction()", in: tree, asSymbolID: "s:5MyKit0A5ClassC10myFunctionyyF")
@@ -2594,7 +2590,7 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testArticleWithDisambiguationLookingName() async throws {
-        let exampleDocumentation = Folder(name: "MyKit.docc", content: [
+        let catalog = Folder(name: "MyKit.docc", content: [
             CopyOfFile(original: Bundle.module.url(forResource: "BaseKit.symbols", withExtension: "json", subdirectory: "Test Resources")!),
             InfoPlist(displayName: "BaseKit", identifier: "com.test.BaseKit"),
             TextFile(name: "basekit.md", utf8Content: """
@@ -2613,11 +2609,10 @@ class PathHierarchyTests: XCTestCase {
             An article with a file name that resembles a disambiguated symbol name.
             """),
         ])
-        let tempURL = try createTemporaryDirectory()
-        let bundleURL = try exampleDocumentation.write(inside: tempURL)
+        
 
         do {
-            let (_, _, context) = try await loadBundle(from: bundleURL)
+            let context = try await load(catalog: catalog)
             XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map { DiagnosticConsoleWriter.formattedDescription(for: $0) })")
             
             let tree = context.linkResolver.localResolver.pathHierarchy
@@ -2634,7 +2629,7 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testGeometricalShapes() async throws {
-        let (_, context) = try await testBundleAndContext(named: "GeometricalShapes")
+        let context = try await loadFromDisk(catalogName: "GeometricalShapes")
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         let paths = tree.caseInsensitiveDisambiguatedPaths().values.sorted()
@@ -2664,7 +2659,7 @@ class PathHierarchyTests: XCTestCase {
             ["X", "Y"],
             ["X", "Y2", "Z", "W"],
         ]
-        let exampleDocumentation = Folder(name: "unit-test.docc", content: [
+        let catalog = Folder(name: "unit-test.docc", content: [
             JSONFile(name: "Module.symbols.json", content: makeSymbolGraph(
                 moduleName: "Module",
                 symbols: symbolPaths.map { 
@@ -2672,10 +2667,7 @@ class PathHierarchyTests: XCTestCase {
                 }
             )),
         ])
-        let tempURL = try createTemporaryDirectory()
-        let bundleURL = try exampleDocumentation.write(inside: tempURL)
-        
-        let (_, _, context) = try await loadBundle(from: bundleURL)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         try assertPathNotFound("/Module/A", in: tree)
@@ -2731,7 +2723,7 @@ class PathHierarchyTests: XCTestCase {
             ])
         ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         let paths = tree.caseInsensitiveDisambiguatedPaths()
@@ -2773,7 +2765,7 @@ class PathHierarchyTests: XCTestCase {
             ])
         ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         let paths = tree.caseInsensitiveDisambiguatedPaths()
@@ -2813,7 +2805,7 @@ class PathHierarchyTests: XCTestCase {
             ])
         ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         let paths = tree.caseInsensitiveDisambiguatedPaths()
@@ -2861,7 +2853,7 @@ class PathHierarchyTests: XCTestCase {
             })
         ])
 
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
 
         let resolvedSwiftContainerID = try tree.find(path: "/ModuleName/ContainerName-struct", onlyFindSymbols: true)
@@ -2939,7 +2931,7 @@ class PathHierarchyTests: XCTestCase {
             ])
         ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         let paths = tree.caseInsensitiveDisambiguatedPaths()
@@ -2966,7 +2958,7 @@ class PathHierarchyTests: XCTestCase {
             ))
         ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         let paths = tree.caseInsensitiveDisambiguatedPaths(includeDisambiguationForUnambiguousChildren: true)
@@ -3020,7 +3012,7 @@ class PathHierarchyTests: XCTestCase {
             """)
         ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         let moduleID = try tree.find(path: "/ModuleName", onlyFindSymbols: true)
@@ -3094,7 +3086,7 @@ class PathHierarchyTests: XCTestCase {
             """)
         ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         let paths = tree.caseInsensitiveDisambiguatedPaths(includeDisambiguationForUnambiguousChildren: true)
@@ -3127,7 +3119,7 @@ class PathHierarchyTests: XCTestCase {
             makeSymbolGraphFile(platformName: "PlatformTwo"),
         ])
         
-        let (_, context) = try await loadBundle(catalog: multiPlatformCatalog)
+        let context = try await load(catalog: multiPlatformCatalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         let paths = tree.caseInsensitiveDisambiguatedPaths()
@@ -3138,14 +3130,14 @@ class PathHierarchyTests: XCTestCase {
         let singlePlatformCatalog = Folder(name: "unit-test.docc", content: [
             makeSymbolGraphFile(platformName: "PlatformOne"),
         ])
-        let (_, singlePlatformContext) = try await loadBundle(catalog: singlePlatformCatalog)
+        let singlePlatformContext = try await load(catalog: singlePlatformCatalog)
         let singlePlatformPaths = singlePlatformContext.linkResolver.localResolver.pathHierarchy.caseInsensitiveDisambiguatedPaths()
         XCTAssertEqual(paths[protocolRequirementID], singlePlatformPaths[protocolRequirementID])
         XCTAssertEqual(paths[defaultImplementationID], singlePlatformPaths[defaultImplementationID])
     }
     
     func testMultiPlatformModuleWithExtension() async throws {
-        let (_, context) = try await testBundleAndContext(named: "MultiPlatformModuleWithExtension")
+        let context = try await loadFromDisk(catalogName: "MultiPlatformModuleWithExtension")
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         try assertFindsPath("/MainModule/TopLevelProtocol/extensionMember(_:)", in: tree, asSymbolID: "extensionMember1")
@@ -3179,7 +3171,7 @@ class PathHierarchyTests: XCTestCase {
             })
         ])
 
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
 
         let container = try tree.findNode(path: "/ModuleName/ContainerName-struct", onlyFindSymbols: true)
@@ -3237,7 +3229,7 @@ class PathHierarchyTests: XCTestCase {
             })
         ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         let swiftSpecificNode = try tree.findNode(path: "/ModuleName/OuterContainerName-struct/MiddleContainerName-struct/InnerContainerName-struct/swiftSpecificMember()", onlyFindSymbols: true, parent: nil)
@@ -3321,7 +3313,7 @@ class PathHierarchyTests: XCTestCase {
             ))
         })
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         try assertFindsPath("/ModuleName/ContainerName/memberName", in: tree, asSymbolID: memberID)
@@ -3371,7 +3363,7 @@ class PathHierarchyTests: XCTestCase {
             ))
         ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         let link = "/ModuleName/doSomething(with:and:)"
@@ -3448,7 +3440,7 @@ class PathHierarchyTests: XCTestCase {
             })
         ])
 
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         let paths = tree.caseInsensitiveDisambiguatedPaths()
@@ -3466,7 +3458,7 @@ class PathHierarchyTests: XCTestCase {
     }
     
     func testLinksToCxxOperators() async throws {
-        let (_, context) = try await testBundleAndContext(named: "CxxOperators")
+        let context = try await loadFromDisk(catalogName: "CxxOperators")
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         // MyClass operator+() const;                     // unary plus
@@ -3779,7 +3771,7 @@ class PathHierarchyTests: XCTestCase {
                 ))
             ])
             
-            let (_, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
             let tree = context.linkResolver.localResolver.pathHierarchy
             
             try assertPathCollision("ModuleName/doSomething(first:second:third:)", in: tree, collisions: [
@@ -3829,7 +3821,7 @@ class PathHierarchyTests: XCTestCase {
                 ))
             ])
             
-            let (_, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
             let tree = context.linkResolver.localResolver.pathHierarchy
             
             try assertPathCollision("ModuleName/doSomething(first:second:third:)", in: tree, collisions: [
@@ -3879,7 +3871,7 @@ class PathHierarchyTests: XCTestCase {
                 ))
             ])
             
-            let (_, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
             let tree = context.linkResolver.localResolver.pathHierarchy
             
             try assertPathCollision("ModuleName/doSomething(first:second:)", in: tree, collisions: [
@@ -3916,7 +3908,7 @@ class PathHierarchyTests: XCTestCase {
                 ))
             ])
             
-            let (_, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
             let tree = context.linkResolver.localResolver.pathHierarchy
             
             try assertPathCollision("ModuleName/doSomething(with:)", in: tree, collisions: [
@@ -3958,7 +3950,7 @@ class PathHierarchyTests: XCTestCase {
                 ))
             ])
             
-            let (_, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
             let tree = context.linkResolver.localResolver.pathHierarchy
             
             try assertPathCollision("ModuleName/doSomething(first:second:third:)", in: tree, collisions: [
@@ -4057,7 +4049,7 @@ class PathHierarchyTests: XCTestCase {
                 ))
             ])
             
-            let (_, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
             let tree = context.linkResolver.localResolver.pathHierarchy
             
             try assertPathCollision("ModuleName/doSomething(first:second:third:fourth:fifth:sixth:)", in: tree, collisions: [
@@ -4123,7 +4115,7 @@ class PathHierarchyTests: XCTestCase {
                 ))
             ])
             
-            let (_, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
             let tree = context.linkResolver.localResolver.pathHierarchy
             
             try assertPathCollision("ModuleName/doSomething(first:second:)", in: tree, collisions: [
@@ -4173,7 +4165,7 @@ class PathHierarchyTests: XCTestCase {
                 ))
             ])
             
-            let (_, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
             let tree = context.linkResolver.localResolver.pathHierarchy
             
             try assertPathCollision("ModuleName/doSomething(first:)", in: tree, collisions: [
@@ -4218,7 +4210,7 @@ class PathHierarchyTests: XCTestCase {
                 ))
             ])
             
-            let (_, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
             let tree = context.linkResolver.localResolver.pathHierarchy
             
             try assertPathCollision("ModuleName/doSomething(...)", in: tree, collisions: [
@@ -4245,7 +4237,7 @@ class PathHierarchyTests: XCTestCase {
                 ))
             ])
             
-            let (_, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
             let tree = context.linkResolver.localResolver.pathHierarchy
             
             try assertPathCollision("ModuleName/doSomething(...)", in: tree, collisions: [
@@ -4272,7 +4264,7 @@ class PathHierarchyTests: XCTestCase {
                 ))
             ])
             
-            let (_, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
             let tree = context.linkResolver.localResolver.pathHierarchy
             
             try assertPathCollision("ModuleName/doSomething(...)", in: tree, collisions: [
@@ -4442,7 +4434,7 @@ class PathHierarchyTests: XCTestCase {
             """),
         ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let tree = context.linkResolver.localResolver.pathHierarchy
         
         let rootIdentifier = try XCTUnwrap(tree.modules.first?.identifier)
diff --git a/Tests/SwiftDocCTests/Infrastructure/PresentationURLGeneratorTests.swift b/Tests/SwiftDocCTests/Infrastructure/PresentationURLGeneratorTests.swift
index 96adc54726..e541568777 100644
--- a/Tests/SwiftDocCTests/Infrastructure/PresentationURLGeneratorTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/PresentationURLGeneratorTests.swift
@@ -14,23 +14,23 @@ import Foundation
 
 class PresentationURLGeneratorTests: XCTestCase {
     func testInternalURLs() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let (_, context) = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         let generator = PresentationURLGenerator(context: context, baseURL: URL(string: "https://host:1024/webPrefix")!)
         
         // Test resolved tutorial reference
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/Test-Bundle/TestTutorial", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/Test-Bundle/TestTutorial", sourceLanguage: .swift)
         XCTAssertEqual(generator.presentationURLForReference(reference).absoluteString, "https://host:1024/webPrefix/tutorials/test-bundle/testtutorial")
         
         // Test resolved symbol reference
-        let symbol = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift)
+        let symbol = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift)
         XCTAssertEqual(generator.presentationURLForReference(symbol).absoluteString, "https://host:1024/webPrefix/documentation/mykit/myclass")
         
         // Test root
-        let root = ResolvedTopicReference(bundleID: bundle.id, path: "/", sourceLanguage: .swift)
+        let root = ResolvedTopicReference(bundleID: context.inputs.id, path: "/", sourceLanguage: .swift)
         XCTAssertEqual(generator.presentationURLForReference(root).absoluteString, "https://host:1024/webPrefix/documentation")
         
         // Fragment
-        let fragment = ResolvedTopicReference(bundleID: bundle.id, path: "/path", fragment: "test URL! FRAGMENT", sourceLanguage: .swift)
+        let fragment = ResolvedTopicReference(bundleID: context.inputs.id, path: "/path", fragment: "test URL! FRAGMENT", sourceLanguage: .swift)
         XCTAssertEqual(generator.presentationURLForReference(fragment).absoluteString, "https://host:1024/webPrefix/path#test-URL-FRAGMENT")
     }
 }
diff --git a/Tests/SwiftDocCTests/Infrastructure/ReferenceResolverTests.swift b/Tests/SwiftDocCTests/Infrastructure/ReferenceResolverTests.swift
index 3067845fe9..9218819e08 100644
--- a/Tests/SwiftDocCTests/Infrastructure/ReferenceResolverTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/ReferenceResolverTests.swift
@@ -24,11 +24,11 @@ class ReferenceResolverTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, context) = try await testBundleAndContext()
+        let context = try await makeEmptyContext()
         var problems = [Problem]()
-        let intro = Intro(from: directive, source: nil, for: bundle, problems: &problems)!
+        let intro = Intro(from: directive, source: nil, for: context.inputs, problems: &problems)!
         
-        var resolver = ReferenceResolver(context: context, bundle: bundle)
+        var resolver = ReferenceResolver(context: context)
         _ = resolver.visitIntro(intro)
         XCTAssertEqual(resolver.problems.count, 1)
     }
@@ -43,11 +43,11 @@ class ReferenceResolverTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, context) = try await testBundleAndContext()
+        let context = try await makeEmptyContext()
         var problems = [Problem]()
-        let contentAndMedia = ContentAndMedia(from: directive, source: nil, for: bundle, problems: &problems)!
+        let contentAndMedia = ContentAndMedia(from: directive, source: nil, for: context.inputs, problems: &problems)!
         
-        var resolver = ReferenceResolver(context: context, bundle: bundle)
+        var resolver = ReferenceResolver(context: context)
         _ = resolver.visit(contentAndMedia)
         XCTAssertEqual(resolver.problems.count, 1)
     }
@@ -60,11 +60,11 @@ class ReferenceResolverTests: XCTestCase {
     """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, context) = try await testBundleAndContext()
+        let context = try await makeEmptyContext()
         var problems = [Problem]()
-        let intro = Intro(from: directive, source: nil, for: bundle, problems: &problems)!
+        let intro = Intro(from: directive, source: nil, for: context.inputs, problems: &problems)!
         
-        var resolver = ReferenceResolver(context: context, bundle: bundle)
+        var resolver = ReferenceResolver(context: context)
         
         guard let container = resolver.visit(intro).children.first as? MarkupContainer,
               let firstElement = container.elements.first,
@@ -78,7 +78,7 @@ class ReferenceResolverTests: XCTestCase {
     
     // Tests all reference syntax formats to a child symbol
     func testReferencesToChildFromFramework() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             /// Article that curates `SideClass`
             try """
             # ``SideKit``
@@ -101,7 +101,7 @@ class ReferenceResolverTests: XCTestCase {
         
         // Get a translated render node
         let node = try context.entity(with: ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/SideKit", sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
         
         // Verify resolved links
@@ -111,7 +111,7 @@ class ReferenceResolverTests: XCTestCase {
 
     // Test relative paths to non-child symbol
     func testReferencesToGrandChildFromFramework() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             /// Article that curates `SideClass`
             try """
             # ``SideKit``
@@ -127,7 +127,7 @@ class ReferenceResolverTests: XCTestCase {
         
         // Get a translated render node
         let node = try context.entity(with: ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/SideKit", sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
         
         // Verify resolved links
@@ -137,7 +137,7 @@ class ReferenceResolverTests: XCTestCase {
     
     // Test references to a sibling symbol
     func testReferencesToSiblingFromFramework() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             /// Article that curates `SideClass`
             try """
             # ``SideKit/SideClass/myFunction()``
@@ -153,7 +153,7 @@ class ReferenceResolverTests: XCTestCase {
         
         // Get a translated render node
         let node = try context.entity(with: ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/SideKit/SideClass/myFunction()", sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
         
         // Verify resolved links
@@ -163,7 +163,7 @@ class ReferenceResolverTests: XCTestCase {
 
     // Test references to symbols in root paths
     func testReferencesToTutorial() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             /// Article that curates `SideClass`
             try """
             # ``SideKit/SideClass/myFunction()``
@@ -179,7 +179,7 @@ class ReferenceResolverTests: XCTestCase {
         
         // Get a translated render node
         let node = try context.entity(with: ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/SideKit/SideClass/myFunction()", sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
         
         // Verify resolved links
@@ -189,7 +189,7 @@ class ReferenceResolverTests: XCTestCase {
 
     // Test references to technology pages
     func testReferencesToTechnologyPages() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             /// Article that curates `SideClass`
             try """
             # ``SideKit/SideClass/myFunction()``
@@ -204,7 +204,7 @@ class ReferenceResolverTests: XCTestCase {
         
         // Get a translated render node
         let node = try context.entity(with: ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/SideKit/SideClass/myFunction()", sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
         
         // Verify resolved links
@@ -214,7 +214,7 @@ class ReferenceResolverTests: XCTestCase {
 
     // Test external references
     func testExternalReferencesConsiderBundleIdentifier() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             /// Article that curates `SideClass`
             try """
             # ``SideKit/SideClass/myFunction()``
@@ -230,7 +230,7 @@ class ReferenceResolverTests: XCTestCase {
         
         // Get a translated render node
         let node = try context.entity(with: ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/SideKit/SideClass/myFunction()", sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
         
         // Verify resolved links
@@ -321,7 +321,7 @@ class ReferenceResolverTests: XCTestCase {
         """
         
         // TestBundle has more than one module, so automatic registration and curation won't happen
-        let (_, _, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             referencingArticleURL = root.appendingPathComponent("article.md")
             try source.write(to: referencingArticleURL, atomically: true, encoding: .utf8)
             
@@ -346,7 +346,7 @@ class ReferenceResolverTests: XCTestCase {
     }
     
     func testRelativeReferencesToExtensionSymbols() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "BundleWithRelativePathAmbiguity") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "BundleWithRelativePathAmbiguity") { root in
             // We don't want the external target to be part of the archive as that is not
             // officially supported yet.
             try FileManager.default.removeItem(at: root.appendingPathComponent("Dependency.symbols.json"))
@@ -378,7 +378,7 @@ class ReferenceResolverTests: XCTestCase {
         
         // Get a translated render node
         let node = try context.entity(with: ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/BundleWithRelativePathAmbiguity/Dependency", sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
         
         let content = try XCTUnwrap(renderNode.primaryContentSections.first as? ContentRenderSection).content
@@ -407,10 +407,10 @@ class ReferenceResolverTests: XCTestCase {
     }
 
     func testCuratedExtensionRemovesEmptyPage() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "ModuleWithSingleExtension")
+        let context = try await loadFromDisk(catalogName: "ModuleWithSingleExtension")
 
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleWithSingleExtension", sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleWithSingleExtension", sourceLanguage: .swift))
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
 
         // The only children of the root topic should be the `MyNamespace` enum - i.e. the Swift
@@ -421,11 +421,11 @@ class ReferenceResolverTests: XCTestCase {
 
         // Make sure that the symbol added in the extension is still present in the topic graph,
         // even though its synthetic "extended symbol" parents are not
-        XCTAssertNoThrow(try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleWithSingleExtension/Swift/Array/asdf", sourceLanguage: .swift)))
+        XCTAssertNoThrow(try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleWithSingleExtension/Swift/Array/asdf", sourceLanguage: .swift)))
     }
 
     func testCuratedExtensionWithDanglingReference() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "ModuleWithSingleExtension") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "ModuleWithSingleExtension") { root in
             let topLevelArticle = root.appendingPathComponent("ModuleWithSingleExtension.md")
             try FileManager.default.removeItem(at: topLevelArticle)
 
@@ -445,16 +445,16 @@ class ReferenceResolverTests: XCTestCase {
         XCTAssertEqual(replacement.replacement, "`Swift/Array`")
 
         // Also make sure that the extension pages are still gone
-        let extendedModule = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleWithSingleExtension/Swift", sourceLanguage: .swift)
+        let extendedModule = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleWithSingleExtension/Swift", sourceLanguage: .swift)
         XCTAssertFalse(context.knownPages.contains(where: { $0 == extendedModule }))
 
-        let extendedStructure = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleWithSingleExtension/Swift/Array", sourceLanguage: .swift)
+        let extendedStructure = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleWithSingleExtension/Swift/Array", sourceLanguage: .swift)
         XCTAssertFalse(context.knownPages.contains(where: { $0 == extendedStructure }))
 
         // Load the RenderNode for the root article and make sure that the `Swift/Array` symbol link
         // is not rendered as a link
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleWithSingleExtension", sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleWithSingleExtension", sourceLanguage: .swift))
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
 
         XCTAssertEqual(renderNode.abstract, [
@@ -465,7 +465,7 @@ class ReferenceResolverTests: XCTestCase {
     }
 
     func testCuratedExtensionWithDanglingReferenceToFragment() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "ModuleWithSingleExtension") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "ModuleWithSingleExtension") { root in
             let topLevelArticle = root.appendingPathComponent("ModuleWithSingleExtension.md")
             try FileManager.default.removeItem(at: topLevelArticle)
 
@@ -485,15 +485,15 @@ class ReferenceResolverTests: XCTestCase {
         XCTAssertEqual(replacement.replacement, "`Swift/Array`")
 
         // Also make sure that the extension pages are still gone
-        let extendedModule = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleWithSingleExtension/Swift", sourceLanguage: .swift)
+        let extendedModule = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleWithSingleExtension/Swift", sourceLanguage: .swift)
         XCTAssertFalse(context.knownPages.contains(where: { $0 == extendedModule }))
 
-        let extendedStructure = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleWithSingleExtension/Swift/Array", sourceLanguage: .swift)
+        let extendedStructure = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleWithSingleExtension/Swift/Array", sourceLanguage: .swift)
         XCTAssertFalse(context.knownPages.contains(where: { $0 == extendedStructure }))
     }
 
     func testCuratedExtensionWithDocumentationExtension() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "ModuleWithSingleExtension") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "ModuleWithSingleExtension") { root in
             let topLevelArticle = root.appendingPathComponent("ModuleWithSingleExtension.md")
             try FileManager.default.removeItem(at: topLevelArticle)
 
@@ -514,18 +514,18 @@ class ReferenceResolverTests: XCTestCase {
         XCTAssertFalse(context.problems.contains(where: { $0.diagnostic.identifier == "org.swift.docc.removedExtensionLinkDestination" || $0.diagnostic.identifier == "org.swift.docc.unresolvedTopicReference" }))
 
         // Because the `Swift/Array` extension has an extension article, the pages should not be marked as virtual
-        let extendedModule = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleWithSingleExtension/Swift", sourceLanguage: .swift)
+        let extendedModule = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleWithSingleExtension/Swift", sourceLanguage: .swift)
         XCTAssert(context.knownPages.contains(where: { $0 == extendedModule }))
 
-        let extendedStructure = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleWithSingleExtension/Swift/Array", sourceLanguage: .swift)
+        let extendedStructure = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleWithSingleExtension/Swift/Array", sourceLanguage: .swift)
         XCTAssert(context.knownPages.contains(where: { $0 == extendedStructure }))
     }
 
     func testCuratedExtensionWithAdditionalConformance() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "ModuleWithConformanceAndExtension")
+        let context = try await loadFromDisk(catalogName: "ModuleWithConformanceAndExtension")
 
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleWithConformanceAndExtension/MyProtocol", sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleWithConformanceAndExtension/MyProtocol", sourceLanguage: .swift))
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
 
         let conformanceSection = try XCTUnwrap(renderNode.relationshipSections.first(where: { $0.type == RelationshipsGroup.Kind.conformingTypes.rawValue }))
@@ -538,10 +538,10 @@ class ReferenceResolverTests: XCTestCase {
     }
 
     func testExtensionWithEmptyDeclarationFragments() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "ModuleWithEmptyDeclarationFragments")
+        let context = try await loadFromDisk(catalogName: "ModuleWithEmptyDeclarationFragments")
 
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleWithEmptyDeclarationFragments", sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleWithEmptyDeclarationFragments", sourceLanguage: .swift))
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
 
         // Despite having an extension to Float, there are no symbols added by that extension, so
@@ -560,11 +560,11 @@ class ReferenceResolverTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, context) = try await testBundleAndContext()
+        let context = try await makeEmptyContext()
         var problems = [Problem]()
 
-        let chapter = try XCTUnwrap(Chapter(from: directive, source: nil, for: bundle, problems: &problems))
-        var resolver = ReferenceResolver(context: context, bundle: bundle)
+        let chapter = try XCTUnwrap(Chapter(from: directive, source: nil, for: context.inputs, problems: &problems))
+        var resolver = ReferenceResolver(context: context)
         _ = resolver.visitChapter(chapter)
         XCTAssertFalse(resolver.problems.containsErrors)
         XCTAssertEqual(resolver.problems.count, 1)
@@ -580,11 +580,11 @@ class ReferenceResolverTests: XCTestCase {
         Discussion link to ``SideKit``.
         """
         
-        let (bundle, context) = try await testBundleAndContext()
+        let context = try await makeEmptyContext()
         let document = Document(parsing: source, options: [.parseBlockDirectives, .parseSymbolLinks])
         let article = try XCTUnwrap(Article(markup: document, metadata: nil, redirects: nil, options: [:]))
         
-        var resolver = ReferenceResolver(context: context, bundle: bundle)
+        var resolver = ReferenceResolver(context: context)
         let resolvedArticle = try XCTUnwrap(resolver.visitArticle(article) as? Article)
         let abstractSection = try XCTUnwrap(resolvedArticle.abstractSection)
         
@@ -612,9 +612,9 @@ class ReferenceResolverTests: XCTestCase {
     }
     
     func testForwardsSymbolPropertiesThatAreUnmodifiedDuringLinkResolution() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         
-        var resolver = ReferenceResolver(context: context, bundle: bundle)
+        var resolver = ReferenceResolver(context: context)
         
         let symbol = try XCTUnwrap(context.documentationCache["s:5MyKit0A5ClassC"]?.semantic as? Symbol)
         
@@ -768,7 +768,7 @@ class ReferenceResolverTests: XCTestCase {
             mixins: [:]
         )
         
-        let (bundle, context) = try await testBundleAndContext()
+        let context = try await makeEmptyContext()
         
         let documentationExtensionContent = """
         # ``Something``
@@ -785,7 +785,7 @@ class ReferenceResolverTests: XCTestCase {
         let article = Article(
             from: Document(parsing: documentationExtensionContent, source: documentationExtensionURL, options: [.parseSymbolLinks, .parseBlockDirectives]),
             source: documentationExtensionURL,
-            for: bundle,
+            for: context.inputs,
             problems: &ignoredProblems
         )
         XCTAssert(ignoredProblems.isEmpty, "Unexpected problems creating article")
@@ -801,7 +801,7 @@ class ReferenceResolverTests: XCTestCase {
         
         XCTAssertEqual(node.docChunks.count, 2, "This node has content from both the in-source comment and the documentation extension file.")
         
-        var resolver = ReferenceResolver(context: context, bundle: bundle)
+        var resolver = ReferenceResolver(context: context)
         _ = resolver.visitSymbol(node.semantic as! Symbol)
         
         let problems = resolver.problems.sorted(by: \.diagnostic.summary)
diff --git a/Tests/SwiftDocCTests/Infrastructure/SymbolBreadcrumbTests.swift b/Tests/SwiftDocCTests/Infrastructure/SymbolBreadcrumbTests.swift
index d1d8f14fae..70c0e9d52d 100644
--- a/Tests/SwiftDocCTests/Infrastructure/SymbolBreadcrumbTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/SymbolBreadcrumbTests.swift
@@ -13,7 +13,7 @@ import XCTest
 
 class SymbolBreadcrumbTests: XCTestCase {
     func testLanguageSpecificBreadcrumbs() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "GeometricalShapes")
+        let context = try await loadFromDisk(catalogName: "GeometricalShapes")
         let resolver = try XCTUnwrap(context.linkResolver.localResolver)
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
         
@@ -34,7 +34,7 @@ class SymbolBreadcrumbTests: XCTestCase {
                 "/documentation/GeometricalShapes/Circle", // named TLACircle in Objective-C
             ])
             
-            assertNoVariantsForRenderHierarchy(reference, context, bundle) // Same breadcrumbs in both languages
+            assertNoVariantsForRenderHierarchy(reference, context) // Same breadcrumbs in both languages
         }
         
         // extern const TLACircle TLACircleZero NS_SWIFT_NAME(Circle.zero);
@@ -50,7 +50,7 @@ class SymbolBreadcrumbTests: XCTestCase {
                 "/documentation/GeometricalShapes", // The Objective-C representation is a top-level function
             ])
             
-            assertHasSomeVariantsForRenderHierarchy(reference, context, bundle) // Different breadcrumbs in different languages
+            assertHasSomeVariantsForRenderHierarchy(reference, context) // Different breadcrumbs in different languages
         }
         
         // BOOL TLACircleIntersects(TLACircle circle, TLACircle otherCircle) NS_SWIFT_NAME(Circle.intersects(self:_:));
@@ -66,7 +66,7 @@ class SymbolBreadcrumbTests: XCTestCase {
                 "/documentation/GeometricalShapes", // The Objective-C representation is a top-level function
             ])
             
-            assertHasSomeVariantsForRenderHierarchy(reference, context, bundle) // Different breadcrumbs in different languages
+            assertHasSomeVariantsForRenderHierarchy(reference, context) // Different breadcrumbs in different languages
         }
 
         // TLACircle TLACircleMake(CGPoint center, CGFloat radius) NS_SWIFT_UNAVAILABLE("Use 'Circle.init(center:radius:)' instead.");
@@ -79,7 +79,7 @@ class SymbolBreadcrumbTests: XCTestCase {
                 "/documentation/GeometricalShapes", // The Objective-C representation is a top-level function
             ])
             
-            assertNoVariantsForRenderHierarchy(reference, context, bundle) // Only has one language representation
+            assertNoVariantsForRenderHierarchy(reference, context) // Only has one language representation
         }
         
         do {
@@ -92,12 +92,12 @@ class SymbolBreadcrumbTests: XCTestCase {
             ])
             XCTAssertEqual(resolver.breadcrumbs(of: reference, in: .objectiveC)?.map(\.path), nil) // There is no Objective-C representation
             
-            assertNoVariantsForRenderHierarchy(reference, context, bundle) // Only has one language representation
+            assertNoVariantsForRenderHierarchy(reference, context) // Only has one language representation
         }
     }
     
     func testMixedLanguageSpecificBreadcrumbs() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "MixedLanguageFramework")
+        let context = try await loadFromDisk(catalogName: "MixedLanguageFramework")
         let resolver = try XCTUnwrap(context.linkResolver.localResolver)
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
         
@@ -114,7 +114,7 @@ class SymbolBreadcrumbTests: XCTestCase {
                 "/documentation/MixedLanguageFramework/MixedLanguageProtocol",
             ])
             
-            assertNoVariantsForRenderHierarchy(reference, context, bundle) // Same breadcrumbs in both languages
+            assertNoVariantsForRenderHierarchy(reference, context) // Same breadcrumbs in both languages
         }
         do {
             let reference = try XCTUnwrap(context.knownPages.first(where: { $0.path == "\(moduleReference.path)/MixedLanguageProtocol" }))
@@ -127,7 +127,7 @@ class SymbolBreadcrumbTests: XCTestCase {
                 "/documentation/MixedLanguageFramework",
             ])
             
-            assertNoVariantsForRenderHierarchy(reference, context, bundle) // Same breadcrumbs in both languages
+            assertNoVariantsForRenderHierarchy(reference, context) // Same breadcrumbs in both languages
         }
     }
     
@@ -136,11 +136,10 @@ class SymbolBreadcrumbTests: XCTestCase {
     private func assertNoVariantsForRenderHierarchy(
         _ reference: ResolvedTopicReference,
         _ context: DocumentationContext,
-        _ bundle: DocumentationBundle,
         file: StaticString = #filePath,
         line: UInt = #line
     ) {
-        var hierarchyTranslator = RenderHierarchyTranslator(context: context, bundle: bundle)
+        var hierarchyTranslator = RenderHierarchyTranslator(context: context)
         let hierarchyVariants = hierarchyTranslator.visitSymbol(reference)
         
         XCTAssertNotNil(hierarchyVariants.defaultValue, "Should always have default breadcrumbs", file: file, line: line)
@@ -150,11 +149,10 @@ class SymbolBreadcrumbTests: XCTestCase {
     private func assertHasSomeVariantsForRenderHierarchy(
         _ reference: ResolvedTopicReference,
         _ context: DocumentationContext,
-        _ bundle: DocumentationBundle,
         file: StaticString = #filePath,
         line: UInt = #line
     ) {
-        var hierarchyTranslator = RenderHierarchyTranslator(context: context, bundle: bundle)
+        var hierarchyTranslator = RenderHierarchyTranslator(context: context)
         let hierarchyVariants = hierarchyTranslator.visitSymbol(reference)
         
         XCTAssertNotNil(hierarchyVariants.defaultValue, "Should always have default breadcrumbs", file: file, line: line)
diff --git a/Tests/SwiftDocCTests/Infrastructure/SymbolDisambiguationTests.swift b/Tests/SwiftDocCTests/Infrastructure/SymbolDisambiguationTests.swift
index 797ac40e49..11ebf3863d 100644
--- a/Tests/SwiftDocCTests/Infrastructure/SymbolDisambiguationTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/SymbolDisambiguationTests.swift
@@ -189,12 +189,12 @@ class SymbolDisambiguationTests: XCTestCase {
     }
     
     func testMixedLanguageFramework() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "MixedLanguageFramework")
+        let context = try await loadFromDisk(catalogName: "MixedLanguageFramework")
         
-        var loader = SymbolGraphLoader(bundle: bundle, dataProvider: context.dataProvider)
+        var loader = SymbolGraphLoader(inputs: context.inputs, dataProvider: context.dataProvider)
         try loader.loadAll()
         
-        let references = context.linkResolver.localResolver.referencesForSymbols(in: loader.unifiedGraphs, bundle: bundle, context: context).mapValues(\.path)
+        let references = context.linkResolver.localResolver.referencesForSymbols(in: loader.unifiedGraphs, context: context).mapValues(\.path)
         XCTAssertEqual(Set(references.keys), [
             SymbolGraph.Symbol.Identifier(precise: "c:@CM@TestFramework@objc(cs)MixedLanguageClassConformingToProtocol(im)mixedLanguageMethod", interfaceLanguage: "swift"),
             .init(precise: "c:@E@Foo", interfaceLanguage: "swift"),
@@ -321,8 +321,8 @@ class SymbolDisambiguationTests: XCTestCase {
         let uniqueSymbolCount = Set(swiftSymbols.map(\.preciseID) + objectiveCSymbols.map(\.preciseID)).count
         XCTAssertEqual(unified.symbols.count, uniqueSymbolCount)
         
-        let bundle = DocumentationBundle(
-            info: DocumentationBundle.Info(
+        let inputs = DocumentationContext.Inputs(
+            info: DocumentationContext.Inputs.Info(
                 displayName: "SymbolDisambiguationTests",
                 id: "com.test.SymbolDisambiguationTests"),
             symbolGraphURLs: [swiftSymbolGraphURL, objcSymbolGraphURL],
@@ -335,8 +335,8 @@ class SymbolDisambiguationTests: XCTestCase {
             objcSymbolGraphURL: try JSONEncoder().encode(graph2),
         ], fallback: nil)
         
-        let context = try await DocumentationContext(bundle: bundle, dataProvider: provider)
+        let context = try await DocumentationContext(inputs: inputs, dataProvider: provider)
         
-        return context.linkResolver.localResolver.referencesForSymbols(in: ["SymbolDisambiguationTests": unified], bundle: bundle, context: context)
+        return context.linkResolver.localResolver.referencesForSymbols(in: ["SymbolDisambiguationTests": unified], context: context)
     }
 }
diff --git a/Tests/SwiftDocCTests/Infrastructure/SymbolGraph/SymbolGraphLoaderTests.swift b/Tests/SwiftDocCTests/Infrastructure/SymbolGraph/SymbolGraphLoaderTests.swift
index 39ad7e8482..2aa384c610 100644
--- a/Tests/SwiftDocCTests/Infrastructure/SymbolGraph/SymbolGraphLoaderTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/SymbolGraph/SymbolGraphLoaderTests.swift
@@ -147,8 +147,8 @@ class SymbolGraphLoaderTests: XCTestCase {
     
     /// Tests if we detect correctly a Mac Catalyst graph
     func testLoadingiOSAndCatalystGraphs() async throws {
-        func testBundleCopy(iOSSymbolGraphName: String, catalystSymbolGraphName: String) async throws -> (URL, DocumentationBundle, DocumentationContext) {
-            return try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", configureBundle: { bundleURL in
+        func loadContextCopy(iOSSymbolGraphName: String, catalystSymbolGraphName: String) async throws -> (URL, DocumentationContext) {
+            return try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", configureBundle: { bundleURL in
                 // Create an iOS symbol graph file
                 let iOSGraphURL = bundleURL.appendingPathComponent("mykit-iOS.symbols.json")
                 let renamediOSGraphURL = bundleURL.appendingPathComponent(iOSSymbolGraphName)
@@ -177,7 +177,7 @@ class SymbolGraphLoaderTests: XCTestCase {
         do {
             // We rename the iOS graph file to contain a "@" which makes it being loaded after main symbol graphs
             // to simulate the loading order we want to test.
-            let (_, _, context) = try await testBundleCopy(iOSSymbolGraphName: "faux@MyKit.symbols.json", catalystSymbolGraphName: "MyKit.symbols.json")
+            let (_, context) = try await loadContextCopy(iOSSymbolGraphName: "faux@MyKit.symbols.json", catalystSymbolGraphName: "MyKit.symbols.json")
 
             guard let availability = (context.documentationCache["s:5MyKit0A5ClassC"]?.semantic as? Symbol)?.availability?.availability else {
                 XCTFail("Did not find availability for symbol 's:5MyKit0A5ClassC'")
@@ -197,7 +197,7 @@ class SymbolGraphLoaderTests: XCTestCase {
         do {
             // We rename the Mac Catalyst graph file to contain a "@" which makes it being loaded after main symbol graphs
             // to simulate the loading order we want to test.
-            let (_, _, context) = try await testBundleCopy(iOSSymbolGraphName: "MyKit.symbols.json", catalystSymbolGraphName: "faux@MyKit.symbols.json")
+            let (_, context) = try await loadContextCopy(iOSSymbolGraphName: "MyKit.symbols.json", catalystSymbolGraphName: "faux@MyKit.symbols.json")
             
             guard let availability = (context.documentationCache["s:5MyKit0A5ClassC"]?.semantic as? Symbol)?.availability?.availability else {
                 XCTFail("Did not find availability for symbol 's:5MyKit0A5ClassC'")
@@ -214,13 +214,13 @@ class SymbolGraphLoaderTests: XCTestCase {
     
     // Tests if main and bystanders graphs are loaded
     func testLoadingModuleBystanderExtensions() async throws {
-        let (_, bundle, _) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [:]) { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [:]) { url in
             let bystanderSymbolGraphURL = Bundle.module.url(
                 forResource: "MyKit@Foundation@_MyKit_Foundation.symbols", withExtension: "json", subdirectory: "Test Resources")!
             try FileManager.default.copyItem(at: bystanderSymbolGraphURL, to: url.appendingPathComponent("MyKit@Foundation@_MyKit_Foundation.symbols.json"))
         }
 
-        var loader = try makeSymbolGraphLoader(symbolGraphURLs: bundle.symbolGraphURLs)
+        var loader = try makeSymbolGraphLoader(symbolGraphURLs: context.inputs.symbolGraphURLs)
         try loader.loadAll()
 
         // Verify both main and bystanders graphs are loaded
@@ -381,7 +381,7 @@ class SymbolGraphLoaderTests: XCTestCase {
         )
     }
 
-    func testDefaulAvailabilityWhenMissingSGFs() async throws {
+    func testDefaultAvailabilityWhenMissingSGFs() async throws {
         // Symbol from SGF
         let symbol = """
         {
@@ -453,7 +453,7 @@ class SymbolGraphLoaderTests: XCTestCase {
         let infoPlistURL = targetURL.appendingPathComponent("Info.plist")
         try infoPlist.write(to: infoPlistURL, atomically: true, encoding: .utf8)
         // Load the bundle & reference resolve symbol graph docs
-        var (_, _, context) = try await loadBundle(from: targetURL)
+        var context = try await loadFromDisk(catalogURL: targetURL)
         guard let availability = (context.documentationCache["c:@F@A"]?.semantic as? Symbol)?.availability?.availability else {
             XCTFail("Did not find availability for symbol 'c:@F@A'")
             return
@@ -478,7 +478,7 @@ class SymbolGraphLoaderTests: XCTestCase {
         """
         try infoPlist.write(to: infoPlistURL, atomically: true, encoding: .utf8)
         // Load the bundle & reference resolve symbol graph docs
-        (_, _, context) = try await loadBundle(from: targetURL)
+        context = try await loadFromDisk(catalogURL: targetURL)
         guard let availability = (context.documentationCache["c:@F@A"]?.semantic as? Symbol)?.availability?.availability else {
             XCTFail("Did not find availability for symbol 'c:@F@A'")
             return
@@ -519,7 +519,7 @@ class SymbolGraphLoaderTests: XCTestCase {
         """
         try infoPlist.write(to: infoPlistURL, atomically: true, encoding: .utf8)
         // Load the bundle & reference resolve symbol graph docs
-        (_, _, context) = try await loadBundle(from: targetURL)
+        context = try await loadFromDisk(catalogURL: targetURL)
         guard let availability = (context.documentationCache["c:@F@A"]?.semantic as? Symbol)?.availability?.availability else {
             XCTFail("Did not find availability for symbol 'c:@F@A'")
             return
@@ -532,57 +532,18 @@ class SymbolGraphLoaderTests: XCTestCase {
     }
     
     func testFallbackAvailabilityVersion() async throws {
-        // Symbol from SG
-        let symbol = """
-        {
-            "kind": {
-                "displayName" : "Instance Property",
-                "identifier" : "swift.property"
-            },
-            "identifier": {
-                "precise": "c:@F@A",
-                "interfaceLanguage": "swift"
-            },
-            "pathComponents": [
-                "Foo"
-            ],
-            "names": {
-                "title": "Foo",
-            },
-            "accessLevel": "public",
-            "availability" : [
-                {
-                  "domain" : "iOS",
-                  "introduced" : {
-                    "major" : 12,
-                    "minor" : 0,
-                    "patch" : 0
-                  }
-                }
-            ]
-        }
-        """
-        let symbolGraphString = makeSymbolGraphString(
-            moduleName: "MyModule",
-            symbols: symbol,
-            platform: """
-            "operatingSystem" : {
-               "minimumVersion" : {
-                 "major" : 12,
-                 "minor" : 0,
-                 "patch" : 0
-               },
-               "name" : "ios"
-             }
-            """
-        )
-        // Create an empty bundle
-        let targetURL = try createTemporaryDirectory(named: "test.docc")
-        // Create symbol graph
-        let symbolGraphURL = targetURL.appendingPathComponent("MyModule.symbols.json")
-        try symbolGraphString.write(to: symbolGraphURL, atomically: true, encoding: .utf8)
-        // Load the bundle & reference resolve symbol graph docs
-        let (_, _, context) = try await loadBundle(from: targetURL)
+        let catalog = Folder(name: "test.docc", content: [
+            JSONFile(name: "MyModule.symbols.json", content: makeSymbolGraph(
+                moduleName: "MyModule",
+                platform: .init(operatingSystem: .init(name: "ios", minimumVersion: .init(major: 12, minor: 0, patch: 0))),
+                symbols: [
+                    makeSymbol(id: "c:@F@A", kind: .property, pathComponents: ["Foo"], availability: [
+                        .init(domain: .init(rawValue: "iOS"), introducedVersion: .init(major: 12, minor: 0, patch: 0), deprecatedVersion: nil, obsoletedVersion: nil, message: nil, renamed: nil, isUnconditionallyDeprecated: false, isUnconditionallyUnavailable: false, willEventuallyBeDeprecated: false)
+                    ])
+                ]
+            ))
+        ])
+        let context = try await load(catalog: catalog)
         guard let availability = (context.documentationCache["c:@F@A"]?.semantic as? Symbol)?.availability?.availability else {
             XCTFail("Did not find availability for symbol 'c:@F@A'")
             return
@@ -687,7 +648,7 @@ class SymbolGraphLoaderTests: XCTestCase {
         try symbolGraphStringiOS.write(to: targetURL.appendingPathComponent("MyModule-ios.symbols.json"), atomically: true, encoding: .utf8)
         try symbolGraphStringCatalyst.write(to: targetURL.appendingPathComponent("MyModule-catalyst.symbols.json"), atomically: true, encoding: .utf8)
         // Load the bundle & reference resolve symbol graph docs
-        let (_, _, context) = try await loadBundle(from: targetURL)
+        let context = try await loadFromDisk(catalogURL: targetURL)
         guard let availability = (context.documentationCache["c:@F@A"]?.semantic as? Symbol)?.availability?.availability else {
             XCTFail("Did not find availability for symbol 'c:@F@A'")
             return
@@ -824,7 +785,7 @@ class SymbolGraphLoaderTests: XCTestCase {
         let infoPlistURL = targetURL.appendingPathComponent("Info.plist")
         try infoPlist.write(to: infoPlistURL, atomically: true, encoding: .utf8)
         // Load the bundle & reference resolve symbol graph docs
-        let (_, _, context) = try await loadBundle(from: targetURL)
+        let context = try await loadFromDisk(catalogURL: targetURL)
         guard let availability = (context.documentationCache["c:@F@A"]?.semantic as? Symbol)?.availability?.availability else {
             XCTFail("Did not find availability for symbol 'c:@F@A'")
             return
@@ -921,7 +882,7 @@ class SymbolGraphLoaderTests: XCTestCase {
         let infoPlistURL = targetURL.appendingPathComponent("Info.plist")
         try infoPlist.write(to: infoPlistURL, atomically: true, encoding: .utf8)
         // Load the bundle & reference resolve symbol graph docs
-        let (_, _, context) = try await loadBundle(from: targetURL)
+        let context = try await loadFromDisk(catalogURL: targetURL)
         guard let availability = (context.documentationCache["c:@F@A"]?.semantic as? Symbol)?.availability?.availability else {
             XCTFail("Did not find availability for symbol 'c:@F@A'")
             return
@@ -1050,7 +1011,7 @@ class SymbolGraphLoaderTests: XCTestCase {
         let infoPlistURL = targetURL.appendingPathComponent("Info.plist")
         try infoPlist.write(to: infoPlistURL, atomically: true, encoding: .utf8)
         // Load the bundle & reference resolve symbol graph docs
-        var (_, _, context) = try await loadBundle(from: targetURL)
+        var context = try await loadFromDisk(catalogURL: targetURL)
         guard let availability = (context.documentationCache["c:@F@A"]?.semantic as? Symbol)?.availability?.availability else {
             XCTFail("Did not find availability for symbol 'c:@F@A'")
             return
@@ -1070,7 +1031,7 @@ class SymbolGraphLoaderTests: XCTestCase {
             platform: """
             """
         ).write(to: targetURL.appendingPathComponent("MyModule-catalyst.symbols.json"), atomically: true, encoding: .utf8)
-        (_, _, context) = try await loadBundle(from: targetURL)
+        context = try await loadFromDisk(catalogURL: targetURL)
         guard let availability = (context.documentationCache["c:@F@A"]?.semantic as? Symbol)?.availability?.availability else {
             XCTFail("Did not find availability for symbol 'c:@F@A'")
             return
@@ -1192,7 +1153,7 @@ class SymbolGraphLoaderTests: XCTestCase {
             """
         ).write(to: targetURL.appendingPathComponent("MyModule-catalyst.symbols.json"), atomically: true, encoding: .utf8)
         // Load the bundle & reference resolve symbol graph docs
-        var (_, _, context) = try await loadBundle(from: targetURL)
+        var context = try await loadFromDisk(catalogURL: targetURL)
         guard let availabilityFoo = (context.documentationCache["c:@F@A"]?.semantic as? Symbol)?.availability?.availability else {
             XCTFail("Did not find availability for symbol 'c:@F@A'")
             return
@@ -1245,7 +1206,7 @@ class SymbolGraphLoaderTests: XCTestCase {
         // Create info list
         let infoPlistURL = targetURL.appendingPathComponent("Info.plist")
         try infoPlist.write(to: infoPlistURL, atomically: true, encoding: .utf8)
-        (_, _, context) = try await loadBundle(from: targetURL)
+        context = try await loadFromDisk(catalogURL: targetURL)
         guard let availabilityFoo = (context.documentationCache["c:@F@A"]?.semantic as? Symbol)?.availability?.availability else {
             XCTFail("Did not find availability for symbol 'c:@F@A'")
             return
@@ -1319,7 +1280,7 @@ class SymbolGraphLoaderTests: XCTestCase {
         """
         let infoPlistURL = targetURL.appendingPathComponent("Info.plist")
         try infoPlist.write(to: infoPlistURL, atomically: true, encoding: .utf8)
-        let (_, _, context) = try await loadBundle(from: targetURL)
+        let context = try await loadFromDisk(catalogURL: targetURL)
         guard let availability = (context.documentationCache["c:@F@A"]?.semantic as? Symbol)?.availability?.availability else {
             XCTFail("Did not find availability for symbol 'c:@F@A'")
             return
@@ -1444,7 +1405,7 @@ class SymbolGraphLoaderTests: XCTestCase {
         ])
         let tempURL = try createTemporaryDirectory()
         let bundleURL = try testBundle.write(inside: tempURL)
-        let (_, _, context) = try await loadBundle(from: bundleURL)
+        let context = try await loadFromDisk(catalogURL: bundleURL)
         guard let availability = (context.documentationCache["c:@F@A"]?.semantic as? Symbol)?.availability?.availability else {
             XCTFail("Did not find availability for symbol 'c:@F@A'")
             return
@@ -1568,7 +1529,7 @@ class SymbolGraphLoaderTests: XCTestCase {
         try symbolGraphStringCatalyst.write(to: targetURL.appendingPathComponent("MyModule-catalyst.symbols.json"), atomically: true, encoding: .utf8)
         try infoPlist.write(to: targetURL.appendingPathComponent("Info.plist"), atomically: true, encoding: .utf8)
         // Load the bundle & reference resolve symbol graph docs
-        let (_, _, context) = try await loadBundle(from: targetURL)
+        let context = try await loadFromDisk(catalogURL: targetURL)
         let availability = try XCTUnwrap((context.documentationCache["c:@F@A"]?.semantic as? Symbol)?.availability?.availability)
         // Verify we fallback to iOS even if there's default availability for the Catalyst platform.
         XCTAssertNotNil(availability.first(where: { $0.domain?.rawValue == "iOS" }))
@@ -1641,7 +1602,7 @@ class SymbolGraphLoaderTests: XCTestCase {
         try symbolGraphStringCatalyst.write(to: targetURL.appendingPathComponent("MyModule-catalyst.symbols.json"), atomically: true, encoding: .utf8)
         try infoPlist.write(to: targetURL.appendingPathComponent("Info.plist"), atomically: true, encoding: .utf8)
         // Load the bundle & reference resolve symbol graph docs
-        let (_, _, context) = try await loadBundle(from: targetURL)
+        let context = try await loadFromDisk(catalogURL: targetURL)
         guard let availability = (context.documentationCache["c:@F@A"]?.semantic as? Symbol)?.availability?.availability else {
             XCTFail("Did not find availability for symbol 'c:@F@A'")
             return
@@ -1769,7 +1730,7 @@ class SymbolGraphLoaderTests: XCTestCase {
         let infoPlistURL = targetURL.appendingPathComponent("Info.plist")
         try infoPlist.write(to: infoPlistURL, atomically: true, encoding: .utf8)
         // Load the bundle & reference resolve symbol graph docs
-        let (_, _, context) = try await loadBundle(from: targetURL)
+        let context = try await loadFromDisk(catalogURL: targetURL)
         guard let availability = (context.documentationCache["c:@F@Bar"]?.semantic as? Symbol)?.availability?.availability else {
             XCTFail("Did not find availability for symbol 'c:@F@Bar'")
             return
@@ -1788,8 +1749,8 @@ class SymbolGraphLoaderTests: XCTestCase {
         symbolGraphURLs: [URL],
         configureSymbolGraph: ((inout SymbolGraph) -> ())? = nil
     ) throws -> SymbolGraphLoader {
-        let bundle = DocumentationBundle(
-            info: DocumentationBundle.Info(
+        let inputs = DocumentationContext.Inputs(
+            info: DocumentationContext.Inputs.Info(
                 displayName: "Test",
                 id: "com.example.test"
             ),
@@ -1800,7 +1761,7 @@ class SymbolGraphLoaderTests: XCTestCase {
         )
         
         return SymbolGraphLoader(
-            bundle: bundle,
+            inputs: inputs,
             dataProvider: FileManager.default,
             symbolGraphTransformer: configureSymbolGraph
         )
diff --git a/Tests/SwiftDocCTests/Infrastructure/SymbolGraph/SymbolGraphRelationshipsBuilderTests.swift b/Tests/SwiftDocCTests/Infrastructure/SymbolGraph/SymbolGraphRelationshipsBuilderTests.swift
index 329a53f3b9..0d8e0f653d 100644
--- a/Tests/SwiftDocCTests/Infrastructure/SymbolGraph/SymbolGraphRelationshipsBuilderTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/SymbolGraph/SymbolGraphRelationshipsBuilderTests.swift
@@ -17,17 +17,17 @@ class SymbolGraphRelationshipsBuilderTests: XCTestCase {
     
     private func createSymbols(
         documentationCache: inout DocumentationContext.ContentCache<DocumentationNode>,
-        bundle: DocumentationBundle,
+        inputs: DocumentationContext.Inputs,
         sourceType: SymbolGraph.Symbol.Kind,
         targetType: SymbolGraph.Symbol.Kind
     ) -> SymbolGraph.Relationship {
         let sourceIdentifier = SymbolGraph.Symbol.Identifier(precise: "A", interfaceLanguage: SourceLanguage.swift.id)
         let targetIdentifier = SymbolGraph.Symbol.Identifier(precise: "B", interfaceLanguage: SourceLanguage.swift.id)
         
-        let sourceRef = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SomeModuleName/A", sourceLanguage: .swift)
-        let targetRef = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SomeModuleName/B", sourceLanguage: .swift)
+        let sourceRef = ResolvedTopicReference(bundleID: inputs.id, path: "/documentation/SomeModuleName/A", sourceLanguage: .swift)
+        let targetRef = ResolvedTopicReference(bundleID: inputs.id, path: "/documentation/SomeModuleName/B", sourceLanguage: .swift)
         
-        let moduleRef = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SomeModuleName", sourceLanguage: .swift)
+        let moduleRef = ResolvedTopicReference(bundleID: inputs.id, path: "/documentation/SomeModuleName", sourceLanguage: .swift)
         
         let sourceSymbol = SymbolGraph.Symbol(identifier: sourceIdentifier, names: SymbolGraph.Symbol.Names(title: "A", navigator: nil, subHeading: nil, prose: nil), pathComponents: ["SomeModuleName", "A"], docComment: nil, accessLevel: .init(rawValue: "public"), kind: sourceType, mixins: [:])
         let targetSymbol = SymbolGraph.Symbol(identifier: targetIdentifier, names: SymbolGraph.Symbol.Names(title: "B", navigator: nil, subHeading: nil, prose: nil), pathComponents: ["SomeModuleName", "B"], docComment: nil, accessLevel: .init(rawValue: "public"), kind: targetType, mixins: [:])
@@ -51,21 +51,21 @@ class SymbolGraphRelationshipsBuilderTests: XCTestCase {
     private let swiftSelector = UnifiedSymbolGraph.Selector(interfaceLanguage: "swift", platform: nil)
     
     func testImplementsRelationship() async throws {
-        let (bundle, context) = try await testBundleAndContext()
+        let context = try await makeEmptyContext()
         var documentationCache = DocumentationContext.ContentCache<DocumentationNode>()
         let engine = DiagnosticEngine()
         
-        let edge = createSymbols(documentationCache: &documentationCache, bundle: bundle, sourceType: .init(parsedIdentifier: .class, displayName: "Class"), targetType: .init(parsedIdentifier: .protocol, displayName: "Protocol"))
+        let edge = createSymbols(documentationCache: &documentationCache, inputs: context.inputs, sourceType: .init(parsedIdentifier: .class, displayName: "Class"), targetType: .init(parsedIdentifier: .protocol, displayName: "Protocol"))
         
         // Adding the relationship
-        SymbolGraphRelationshipsBuilder.addImplementationRelationship(edge: edge, selector: swiftSelector, in: bundle, context: context, localCache: documentationCache, engine: engine)
+        SymbolGraphRelationshipsBuilder.addImplementationRelationship(edge: edge, selector: swiftSelector, context: context, localCache: documentationCache, engine: engine)
         
         // Test default implementation was added
         XCTAssertFalse((documentationCache["B"]!.semantic as! Symbol).defaultImplementations.implementations.isEmpty)
     }
 
     func testMultipleImplementsRelationships() async throws {
-        let (bundle, context) = try await testBundleAndContext()
+        let context = try await makeEmptyContext()
         var documentationCache = DocumentationContext.ContentCache<DocumentationNode>()
         let engine = DiagnosticEngine()
 
@@ -73,10 +73,10 @@ class SymbolGraphRelationshipsBuilderTests: XCTestCase {
         let identifierB = SymbolGraph.Symbol.Identifier(precise: "B", interfaceLanguage: SourceLanguage.swift.id)
         let identifierC = SymbolGraph.Symbol.Identifier(precise: "C", interfaceLanguage: SourceLanguage.swift.id)
 
-        let symbolRefA = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SomeModuleName/A", sourceLanguage: .swift)
-        let symbolRefB = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SomeModuleName/B", sourceLanguage: .swift)
-        let symbolRefC = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SomeModuleName/C", sourceLanguage: .swift)
-        let moduleRef = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SomeModuleName", sourceLanguage: .swift)
+        let symbolRefA = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SomeModuleName/A", sourceLanguage: .swift)
+        let symbolRefB = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SomeModuleName/B", sourceLanguage: .swift)
+        let symbolRefC = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SomeModuleName/C", sourceLanguage: .swift)
+        let moduleRef = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SomeModuleName", sourceLanguage: .swift)
 
         let symbolA = SymbolGraph.Symbol(identifier: identifierA, names: SymbolGraph.Symbol.Names(title: "A", navigator: nil, subHeading: nil, prose: nil), pathComponents: ["SomeModuleName", "A"], docComment: nil, accessLevel: .init(rawValue: "public"), kind: SymbolGraph.Symbol.Kind(parsedIdentifier: .func, displayName: "Function"), mixins: [:])
         let symbolB = SymbolGraph.Symbol(identifier: identifierB, names: SymbolGraph.Symbol.Names(title: "B", navigator: nil, subHeading: nil, prose: nil), pathComponents: ["SomeModuleName", "B"], docComment: nil, accessLevel: .init(rawValue: "public"), kind: SymbolGraph.Symbol.Kind(parsedIdentifier: .func, displayName: "Function"), mixins: [:])
@@ -102,21 +102,21 @@ class SymbolGraphRelationshipsBuilderTests: XCTestCase {
         let edge1 = SymbolGraph.Relationship(source: identifierB.precise, target: identifierA.precise, kind: .defaultImplementationOf, targetFallback: nil)
         let edge2 = SymbolGraph.Relationship(source: identifierC.precise, target: identifierA.precise, kind: .defaultImplementationOf, targetFallback: nil)
 
-        SymbolGraphRelationshipsBuilder.addImplementationRelationship(edge: edge1, selector: swiftSelector, in: bundle, context: context, localCache: documentationCache, engine: engine)
-        SymbolGraphRelationshipsBuilder.addImplementationRelationship(edge: edge2, selector: swiftSelector, in: bundle, context: context, localCache: documentationCache, engine: engine)
+        SymbolGraphRelationshipsBuilder.addImplementationRelationship(edge: edge1, selector: swiftSelector, context: context, localCache: documentationCache, engine: engine)
+        SymbolGraphRelationshipsBuilder.addImplementationRelationship(edge: edge2, selector: swiftSelector, context: context, localCache: documentationCache, engine: engine)
 
         XCTAssertEqual((documentationCache["A"]!.semantic as! Symbol).defaultImplementations.groups.first?.references.map(\.url?.lastPathComponent), ["B", "C"])
     }
 
     func testConformsRelationship() async throws {
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var documentationCache = DocumentationContext.ContentCache<DocumentationNode>()
         let engine = DiagnosticEngine()
         
-        let edge = createSymbols(documentationCache: &documentationCache, bundle: bundle, sourceType: .init(parsedIdentifier: .class, displayName: "Class"), targetType: .init(parsedIdentifier: .protocol, displayName: "Protocol"))
+        let edge = createSymbols(documentationCache: &documentationCache, inputs: inputs, sourceType: .init(parsedIdentifier: .class, displayName: "Class"), targetType: .init(parsedIdentifier: .protocol, displayName: "Protocol"))
         
         // Adding the relationship
-        SymbolGraphRelationshipsBuilder.addConformanceRelationship(edge: edge, selector: swiftSelector, in: bundle, localCache: documentationCache, externalCache: .init(), engine: engine)
+        SymbolGraphRelationshipsBuilder.addConformanceRelationship(edge: edge, selector: swiftSelector, in: inputs, localCache: documentationCache, externalCache: .init(), engine: engine)
         
         // Test default conforms to was added
         guard let conformsTo = (documentationCache["A"]!.semantic as! Symbol).relationships.groups.first(where: { group -> Bool in
@@ -138,14 +138,14 @@ class SymbolGraphRelationshipsBuilderTests: XCTestCase {
     }
 
     func testInheritanceRelationship() async throws {
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var documentationCache = DocumentationContext.ContentCache<DocumentationNode>()
         let engine = DiagnosticEngine()
         
-        let edge = createSymbols(documentationCache: &documentationCache, bundle: bundle, sourceType: .init(parsedIdentifier: .class, displayName: "Class"), targetType: .init(parsedIdentifier: .protocol, displayName: "Protocol"))
+        let edge = createSymbols(documentationCache: &documentationCache, inputs: inputs, sourceType: .init(parsedIdentifier: .class, displayName: "Class"), targetType: .init(parsedIdentifier: .protocol, displayName: "Protocol"))
         
         // Adding the relationship
-        SymbolGraphRelationshipsBuilder.addInheritanceRelationship(edge: edge, selector: swiftSelector, in: bundle, localCache: documentationCache, externalCache: .init(), engine: engine)
+        SymbolGraphRelationshipsBuilder.addInheritanceRelationship(edge: edge, selector: swiftSelector, in: inputs, localCache: documentationCache, externalCache: .init(), engine: engine)
         
         // Test inherits was added
         guard let inherits = (documentationCache["A"]!.semantic as! Symbol).relationships.groups.first(where: { group -> Bool in
@@ -167,15 +167,15 @@ class SymbolGraphRelationshipsBuilderTests: XCTestCase {
     }
     
     func testInheritanceRelationshipFromOtherFramework() async throws {
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var documentationCache = DocumentationContext.ContentCache<DocumentationNode>()
         let engine = DiagnosticEngine()
         
         let sourceIdentifier = SymbolGraph.Symbol.Identifier(precise: "A", interfaceLanguage: SourceLanguage.swift.id)
         let targetIdentifier = SymbolGraph.Symbol.Identifier(precise: "B", interfaceLanguage: SourceLanguage.swift.id)
         
-        let sourceRef = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SomeModuleName/A", sourceLanguage: .swift)
-        let moduleRef = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SomeModuleName", sourceLanguage: .swift)
+        let sourceRef = ResolvedTopicReference(bundleID: inputs.id, path: "/documentation/SomeModuleName/A", sourceLanguage: .swift)
+        let moduleRef = ResolvedTopicReference(bundleID: inputs.id, path: "/documentation/SomeModuleName", sourceLanguage: .swift)
         
         let sourceSymbol = SymbolGraph.Symbol(identifier: sourceIdentifier, names: SymbolGraph.Symbol.Names(title: "A", navigator: nil, subHeading: nil, prose: nil), pathComponents: ["SomeModuleName", "A"], docComment: nil, accessLevel: .init(rawValue: "public"), kind: SymbolGraph.Symbol.Kind(parsedIdentifier: .class, displayName: "Class"), mixins: [:])
         
@@ -188,7 +188,7 @@ class SymbolGraphRelationshipsBuilderTests: XCTestCase {
         
         let edge = SymbolGraph.Relationship(source: sourceIdentifier.precise, target: targetIdentifier.precise, kind: .inheritsFrom, targetFallback: "MyOtherKit.B")
         
-        SymbolGraphRelationshipsBuilder.addInheritanceRelationship(edge: edge, selector: swiftSelector, in: bundle, localCache: documentationCache, externalCache: .init(), engine: engine)
+        SymbolGraphRelationshipsBuilder.addInheritanceRelationship(edge: edge, selector: swiftSelector, in: inputs, localCache: documentationCache, externalCache: .init(), engine: engine)
         
         let relationships = (documentationCache["A"]!.semantic as! Symbol).relationships
         guard let inheritsShouldHaveFallback = relationships.groups.first(where: { group -> Bool in
@@ -204,11 +204,11 @@ class SymbolGraphRelationshipsBuilderTests: XCTestCase {
     }
     
     func testRequirementRelationship() async throws {
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var documentationCache = DocumentationContext.ContentCache<DocumentationNode>()
         let engine = DiagnosticEngine()
         
-        let edge = createSymbols(documentationCache: &documentationCache, bundle: bundle, sourceType: .init(parsedIdentifier: .method, displayName: "Method"), targetType: .init(parsedIdentifier: .protocol, displayName: "Protocol"))
+        let edge = createSymbols(documentationCache: &documentationCache, inputs: inputs, sourceType: .init(parsedIdentifier: .method, displayName: "Method"), targetType: .init(parsedIdentifier: .protocol, displayName: "Protocol"))
         
         // Adding the relationship
         SymbolGraphRelationshipsBuilder.addRequirementRelationship(edge: edge, localCache: documentationCache, engine: engine)
@@ -218,11 +218,11 @@ class SymbolGraphRelationshipsBuilderTests: XCTestCase {
     }
     
     func testOptionalRequirementRelationship() async throws {
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var documentationCache = DocumentationContext.ContentCache<DocumentationNode>()
         let engine = DiagnosticEngine()
         
-        let edge = createSymbols(documentationCache: &documentationCache, bundle: bundle, sourceType: .init(parsedIdentifier: .method, displayName: "Method"), targetType: .init(parsedIdentifier: .protocol, displayName: "Protocol"))
+        let edge = createSymbols(documentationCache: &documentationCache, inputs: inputs, sourceType: .init(parsedIdentifier: .method, displayName: "Method"), targetType: .init(parsedIdentifier: .protocol, displayName: "Protocol"))
         
         // Adding the relationship
         SymbolGraphRelationshipsBuilder.addOptionalRequirementRelationship(edge: edge, localCache: documentationCache, engine: engine)
@@ -233,11 +233,11 @@ class SymbolGraphRelationshipsBuilderTests: XCTestCase {
 
     func testRequiredAndOptionalRequirementRelationships() async throws {
         do {
-            let (bundle, _) = try await testBundleAndContext()
+            let inputs = try await makeEmptyContext().inputs
             var documentationCache = DocumentationContext.ContentCache<DocumentationNode>()
             let engine = DiagnosticEngine()
 
-            let edge = createSymbols(documentationCache: &documentationCache, bundle: bundle, sourceType: .init(parsedIdentifier: .method, displayName: "Method"), targetType: .init(parsedIdentifier: .protocol, displayName: "Protocol"))
+            let edge = createSymbols(documentationCache: &documentationCache, inputs: inputs, sourceType: .init(parsedIdentifier: .method, displayName: "Method"), targetType: .init(parsedIdentifier: .protocol, displayName: "Protocol"))
 
             // Adding the "required" relationship before the "optional" one
             SymbolGraphRelationshipsBuilder.addRequirementRelationship(edge: edge, localCache: documentationCache, engine: engine)
@@ -248,11 +248,11 @@ class SymbolGraphRelationshipsBuilderTests: XCTestCase {
         }
 
         do {
-            let (bundle, _) = try await testBundleAndContext()
+            let inputs = try await makeEmptyContext().inputs
             var documentationCache = DocumentationContext.ContentCache<DocumentationNode>()
             let engine = DiagnosticEngine()
 
-            let edge = createSymbols(documentationCache: &documentationCache, bundle: bundle, sourceType: .init(parsedIdentifier: .method, displayName: "Method"), targetType: .init(parsedIdentifier: .protocol, displayName: "Protocol"))
+            let edge = createSymbols(documentationCache: &documentationCache, inputs: inputs, sourceType: .init(parsedIdentifier: .method, displayName: "Method"), targetType: .init(parsedIdentifier: .protocol, displayName: "Protocol"))
 
             // Adding the "optional" relationship before the "required" one
             SymbolGraphRelationshipsBuilder.addOptionalRequirementRelationship(edge: edge, localCache: documentationCache, engine: engine)
diff --git a/Tests/SwiftDocCTests/Infrastructure/SymbolReferenceTests.swift b/Tests/SwiftDocCTests/Infrastructure/SymbolReferenceTests.swift
index 49d4985b93..103b1362b5 100644
--- a/Tests/SwiftDocCTests/Infrastructure/SymbolReferenceTests.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/SymbolReferenceTests.swift
@@ -198,7 +198,7 @@ class SymbolReferenceTests: XCTestCase {
             ]),
         ])
         
-        let (_, context) = try await loadBundle(catalog: testCatalog)
+        let context = try await load(catalog: testCatalog)
         
         // The overloads are sorted and all dupes get a hash suffix.
         XCTAssertEqual(
diff --git a/Tests/SwiftDocCTests/Infrastructure/TestExternalReferenceResolvers.swift b/Tests/SwiftDocCTests/Infrastructure/TestExternalReferenceResolvers.swift
index c875b07f60..8f889ad79b 100644
--- a/Tests/SwiftDocCTests/Infrastructure/TestExternalReferenceResolvers.swift
+++ b/Tests/SwiftDocCTests/Infrastructure/TestExternalReferenceResolvers.swift
@@ -17,7 +17,7 @@ import Markdown
 // instead to verify a mix of successes and failures in the same test.
 
 class TestMultiResultExternalReferenceResolver: ExternalDocumentationSource {
-    var bundleID: DocumentationBundle.Identifier = "com.external.testbundle"
+    var bundleID: DocumentationContext.Inputs.Identifier = "com.external.testbundle"
     
     // The minimal information that the test resolver needs to create a resolved reference and documentation node
     struct EntityInfo {
diff --git a/Tests/SwiftDocCTests/LinkTargets/LinkDestinationSummaryTests.swift b/Tests/SwiftDocCTests/LinkTargets/LinkDestinationSummaryTests.swift
index 8d1752b75b..fec8574a99 100644
--- a/Tests/SwiftDocCTests/LinkTargets/LinkDestinationSummaryTests.swift
+++ b/Tests/SwiftDocCTests/LinkTargets/LinkDestinationSummaryTests.swift
@@ -94,11 +94,11 @@ class ExternalLinkableTests: XCTestCase {
     ])
     
     func testSummaryOfTutorialPage() async throws {
-        let (bundle, context) = try await loadBundle(catalog: catalogHierarchy)
+        let context = try await load(catalog: catalogHierarchy)
         
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
         
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/TestBundle/Tutorial", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/TestBundle/Tutorial", sourceLanguage: .swift))
         let renderNode = converter.convert(node)
         
         let summaries = node.externallyLinkableElementSummaries(context: context, renderNode: renderNode)
@@ -151,8 +151,8 @@ class ExternalLinkableTests: XCTestCase {
     }
 
     func testSymbolSummaries() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let converter = DocumentationNodeConverter(context: context)
         do {
             let symbolReference = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/MyKit/MyClass", sourceLanguage: .swift)
             let node = try context.entity(with: symbolReference)
@@ -313,7 +313,7 @@ class ExternalLinkableTests: XCTestCase {
     }
     
     func testTopicImageReferences() async throws {
-        let (url, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { url in
+        let (url, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { url in
             let extensionFile = """
             # ``MyKit/MyClass/myFunction()``
 
@@ -328,7 +328,7 @@ class ExternalLinkableTests: XCTestCase {
             let fileURL = url.appendingPathComponent("documentation").appendingPathComponent("myFunction.md")
             try extensionFile.write(to: fileURL, atomically: true, encoding: .utf8)
         }
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
         
         do {
             let symbolReference = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift)
@@ -415,24 +415,24 @@ class ExternalLinkableTests: XCTestCase {
             summary.references = summary.references?.compactMap { (original: RenderReference) -> (any RenderReference)? in
                 guard var imageRef = original as? ImageReference else { return nil }
                 imageRef.asset.variants = imageRef.asset.variants.mapValues { variant in
-                    return imageRef.destinationURL(for: variant.lastPathComponent, prefixComponent: bundle.id.rawValue)
+                    return imageRef.destinationURL(for: variant.lastPathComponent, prefixComponent: context.inputs.id.rawValue)
                 }
                 imageRef.asset.metadata = .init(uniqueKeysWithValues: imageRef.asset.metadata.map { key, value in
-                    return (imageRef.destinationURL(for: key.lastPathComponent, prefixComponent: bundle.id.rawValue), value)
+                    return (imageRef.destinationURL(for: key.lastPathComponent, prefixComponent: context.inputs.id.rawValue), value)
                 })
                 return imageRef as (any RenderReference)
             }
             
             
-            let encoded = try RenderJSONEncoder.makeEncoder(assetPrefixComponent: bundle.id.rawValue).encode(summary)
+            let encoded = try RenderJSONEncoder.makeEncoder(assetPrefixComponent: context.inputs.id.rawValue).encode(summary)
             let decoded = try JSONDecoder().decode(LinkDestinationSummary.self, from: encoded)
             XCTAssertEqual(decoded, summary)
         }
     }
     
     func testVariantSummaries() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "MixedLanguageFramework")
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let context = try await loadFromDisk(catalogName: "MixedLanguageFramework")
+        let converter = DocumentationNodeConverter(context: context)
         
         // Check a symbol that's represented as a class in both Swift and Objective-C
         do {
@@ -723,11 +723,11 @@ class ExternalLinkableTests: XCTestCase {
             JSONFile(name: "MyModule.symbols.json", content: symbolGraph),
             InfoPlist(displayName: "MyModule", identifier: "com.example.mymodule")
         ])
-        let (bundle, context) = try await loadBundle(catalog: catalogHierarchy)
+        let context = try await load(catalog: catalogHierarchy)
         
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
 
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyModule/MyClass/myFunc()", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyModule/MyClass/myFunc()", sourceLanguage: .swift))
         let renderNode = converter.convert(node)
 
         let summaries = node.externallyLinkableElementSummaries(context: context, renderNode: renderNode)
diff --git a/Tests/SwiftDocCTests/Model/IdentifierTests.swift b/Tests/SwiftDocCTests/Model/IdentifierTests.swift
index c83c3c564a..3fbc6a60a1 100644
--- a/Tests/SwiftDocCTests/Model/IdentifierTests.swift
+++ b/Tests/SwiftDocCTests/Model/IdentifierTests.swift
@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021-2024 Apple Inc. and the Swift project authors
+ Copyright (c) 2021-2025 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See https://swift.org/LICENSE.txt for license information
@@ -65,7 +65,7 @@ class IdentifierTests: XCTestCase {
     }
     
     func testReusingReferences() {
-        let bundleID: DocumentationBundle.Identifier = #function
+        let bundleID: DocumentationContext.Inputs.Identifier = #function
         XCTAssertNil(ResolvedTopicReference._numberOfCachedReferences(bundleID: bundleID), "Cache for this bundle shouldn't exist because caching is not enabled by default")
         
         // Add one reference
@@ -96,7 +96,7 @@ class IdentifierTests: XCTestCase {
     }
     
     func testReferencesAreNotCachedByDefault() {
-        let bundleID: DocumentationBundle.Identifier = #function
+        let bundleID: DocumentationContext.Inputs.Identifier = #function
         XCTAssertNil(ResolvedTopicReference._numberOfCachedReferences(bundleID: bundleID), "References for this bundle shouldn't exist because caching is not enabled by default")
         
         _ = ResolvedTopicReference(bundleID: bundleID, path: "/path/to/page", sourceLanguage: .swift)
diff --git a/Tests/SwiftDocCTests/Model/LineHighlighterTests.swift b/Tests/SwiftDocCTests/Model/LineHighlighterTests.swift
index c63d951a60..de2e18ddf7 100644
--- a/Tests/SwiftDocCTests/Model/LineHighlighterTests.swift
+++ b/Tests/SwiftDocCTests/Model/LineHighlighterTests.swift
@@ -14,7 +14,7 @@ import Markdown
 import SwiftDocCTestUtilities
 
 class LineHighlighterTests: XCTestCase {
-    static let bundleID: DocumentationBundle.Identifier = "org.swift.docc.LineHighlighterTests"
+    static let bundleID: DocumentationContext.Inputs.Identifier = "org.swift.docc.LineHighlighterTests"
     static let defaultOverview = TextFile(name: "TechnologyX.tutorial", utf8Content: """
         @Technology(name: "TechnologyX") {
            @Intro(title: "Technology X") {
@@ -49,9 +49,9 @@ class LineHighlighterTests: XCTestCase {
     
     func highlights(tutorialFile: TextFile, codeFiles: [TextFile]) async throws -> [LineHighlighter.Result] {
         let catalog = Self.makeCatalog(tutorial: tutorialFile, codeFiles: codeFiles)
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
-        let tutorialReference = ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/Line-Highlighter-Tests/Tutorial", fragment: nil, sourceLanguage: .swift)
+        let tutorialReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/Line-Highlighter-Tests/Tutorial", fragment: nil, sourceLanguage: .swift)
         let tutorial = try context.entity(with: tutorialReference).semantic as! Tutorial
         let section = tutorial.sections.first!
         return LineHighlighter(context: context, tutorialSection: section, tutorialReference: tutorialReference).highlights
diff --git a/Tests/SwiftDocCTests/Model/ParametersAndReturnValidatorTests.swift b/Tests/SwiftDocCTests/Model/ParametersAndReturnValidatorTests.swift
index 912ac6fdb3..977d00c970 100644
--- a/Tests/SwiftDocCTests/Model/ParametersAndReturnValidatorTests.swift
+++ b/Tests/SwiftDocCTests/Model/ParametersAndReturnValidatorTests.swift
@@ -18,7 +18,7 @@ import SwiftDocCTestUtilities
 class ParametersAndReturnValidatorTests: XCTestCase {
     
     func testFiltersParameters() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "ErrorParameters")
+        let context = try await loadFromDisk(catalogName: "ErrorParameters")
         
         // /// - Parameters:
         // ///   - someValue: Some value.
@@ -26,7 +26,7 @@ class ParametersAndReturnValidatorTests: XCTestCase {
         // /// - Returns: `YES` if doing something was successful, or `NO` if an error occurred.
         // - (void)doSomethingWith:(NSInteger)someValue error:(NSError **)error;
         do {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ErrorParameters/MyClassInObjectiveC/doSomething(with:)", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ErrorParameters/MyClassInObjectiveC/doSomething(with:)", sourceLanguage: .swift)
             let node = try context.entity(with: reference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
             
@@ -47,7 +47,7 @@ class ParametersAndReturnValidatorTests: XCTestCase {
         // /// - Returns: Some string. If an error occurs, this method returns `nil` and assigns an appropriate error object to the `error` parameter.
         // - (nullable NSString *)returnSomethingAndReturnError:(NSError **)error;
         do {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ErrorParameters/MyClassInObjectiveC/returnSomething()", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ErrorParameters/MyClassInObjectiveC/returnSomething()", sourceLanguage: .swift)
             let node = try context.entity(with: reference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
             
@@ -68,7 +68,7 @@ class ParametersAndReturnValidatorTests: XCTestCase {
         // /// - Throws: Some error if something does wrong
         // @objc public func doSomething(with someValue: Int) throws { }
         do {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ErrorParameters/MyClassInSwift/doSomething(with:)", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ErrorParameters/MyClassInSwift/doSomething(with:)", sourceLanguage: .swift)
             let node = try context.entity(with: reference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
             
@@ -93,7 +93,7 @@ class ParametersAndReturnValidatorTests: XCTestCase {
         // /// - Throws: Some error if something does wrong
         // @objc public func returnSomething() throws -> String { "" }
         do {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ErrorParameters/MyClassInSwift/returnSomething()", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ErrorParameters/MyClassInSwift/returnSomething()", sourceLanguage: .swift)
             let node = try context.entity(with: reference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
             
@@ -153,11 +153,11 @@ class ParametersAndReturnValidatorTests: XCTestCase {
                 ])
             ])
             
-            let (bundle, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
             
             XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
             
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleName/functionName(...)", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleName/functionName(...)", sourceLanguage: .swift)
             let node = try context.entity(with: reference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
             
@@ -178,7 +178,7 @@ class ParametersAndReturnValidatorTests: XCTestCase {
     }
     
     func testParametersWithAlternateSignatures() async throws {
-        let (_, _, context) = try await testBundleAndContext(copying: "AlternateDeclarations") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "AlternateDeclarations") { url in
             try """
             # ``MyClass/present(completion:)``
             
@@ -208,7 +208,7 @@ class ParametersAndReturnValidatorTests: XCTestCase {
     }
     
     func testParameterDiagnosticsInDocumentationExtension() async throws {
-        let (url, _, context) = try await testBundleAndContext(copying: "ErrorParameters") { url in
+        let (url, context) = try await loadFromDisk(copyingCatalogNamed: "ErrorParameters") { url in
             try """
             # ``MyClassInObjectiveC/doSomethingWith:error:``
             
@@ -293,7 +293,7 @@ class ParametersAndReturnValidatorTests: XCTestCase {
     }
     
     func testFunctionsThatCorrespondToPropertiesInAnotherLanguage() async throws {
-        let (_, _, context) = try await testBundleAndContext(named: "GeometricalShapes")
+        let (_, context) = try await loadFromDisk(catalogName: "GeometricalShapes")
         XCTAssertEqual(context.problems.map(\.diagnostic.summary), [])
         
         let reference = try XCTUnwrap(context.knownPages.first(where: { $0.lastPathComponent == "isEmpty" }))
@@ -321,7 +321,7 @@ class ParametersAndReturnValidatorTests: XCTestCase {
     }
     
     func testCanDocumentInitializerReturnValue() async throws {
-        let (_, _, context) = try await testBundleAndContext(copying: "GeometricalShapes") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "GeometricalShapes") { url in
             try """
             # ``Circle/init(center:radius:)``
             
@@ -365,7 +365,7 @@ class ParametersAndReturnValidatorTests: XCTestCase {
         let catalog = Folder(name: "unit-test.docc", content: [
             JSONFile(name: "ModuleName.symbols.json", content: symbolGraph)
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         XCTAssertEqual(context.problems.count, 0)
     }
@@ -380,7 +380,7 @@ class ParametersAndReturnValidatorTests: XCTestCase {
         let catalog = Folder(name: "unit-test.docc", content: [
             JSONFile(name: "ModuleName.symbols.json", content: symbolGraph)
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         XCTAssertEqual(context.problems.count, 0)
     }
@@ -396,7 +396,7 @@ class ParametersAndReturnValidatorTests: XCTestCase {
         let catalog = Folder(name: "unit-test.docc", content: [
             JSONFile(name: "ModuleName.symbols.json", content: symbolGraph)
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         XCTAssertEqual(context.problems.count, 2)
         let endOfParameterSectionLocation = SourceLocation(line: start.line + 5, column: start.character + 40, source: symbolURL)
@@ -435,7 +435,7 @@ class ParametersAndReturnValidatorTests: XCTestCase {
         let catalog = Folder(name: "unit-test.docc", content: [
             JSONFile(name: "ModuleName.symbols.json", content: symbolGraph)
         ])
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         XCTAssertEqual(context.problems.count, 2)
         let endOfParameterSectionLocation = SourceLocation(line: start.line + 4, column: start.character + 48, source: symbolURL)
@@ -490,11 +490,11 @@ class ParametersAndReturnValidatorTests: XCTestCase {
                     ))
                 ])
             ])
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
         
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleName/functionName(...)", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleName/functionName(...)", sourceLanguage: .swift)
         let node = try context.entity(with: reference)
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
         
@@ -550,11 +550,11 @@ class ParametersAndReturnValidatorTests: XCTestCase {
                 """)
             ])
         
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
         
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleName/functionName(...)", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleName/functionName(...)", sourceLanguage: .swift)
         let node = try context.entity(with: reference)
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
         
@@ -594,11 +594,11 @@ class ParametersAndReturnValidatorTests: XCTestCase {
                 ])
             ])
         
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
         
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleName/functionName(...)", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleName/functionName(...)", sourceLanguage: .swift)
         let node = try context.entity(with: reference)
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
         
@@ -768,11 +768,11 @@ class ParametersAndReturnValidatorTests: XCTestCase {
             ))
         ])
         
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
         
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleName/functionName(...)", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleName/functionName(...)", sourceLanguage: .swift)
         let node = try context.entity(with: reference)
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
         
@@ -828,11 +828,11 @@ class ParametersAndReturnValidatorTests: XCTestCase {
                         returnValue: .init(kind: .typeIdentifier, spelling: "Void", preciseIdentifier: "s:s4Voida")
                     ))
                 ])
-                let (bundle, context) = try await loadBundle(catalog: catalog)
+                let context = try await load(catalog: catalog)
                 
                 XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
                 
-                let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleName/functionName(...)", sourceLanguage: .swift)
+                let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleName/functionName(...)", sourceLanguage: .swift)
                 let node = try context.entity(with: reference)
                 let symbol = try XCTUnwrap(node.semantic as? Symbol)
                 
@@ -939,7 +939,7 @@ class ParametersAndReturnValidatorTests: XCTestCase {
         let (bundle, dataProvider) = try DocumentationContext.InputsProvider(fileManager: fileSystem)
             .inputsAndDataProvider(startingPoint: URL(fileURLWithPath: "/unit-test.docc"), options: .init())
 
-        _ = try await DocumentationContext(bundle: bundle, dataProvider: dataProvider, diagnosticEngine: diagnosticEngine)
+        _ = try await DocumentationContext(inputs: bundle, dataProvider: dataProvider, diagnosticEngine: diagnosticEngine)
         
         diagnosticEngine.flush()
         return logStorage.text.trimmingCharacters(in: .newlines)
diff --git a/Tests/SwiftDocCTests/Model/PropertyListPossibleValuesSectionTests.swift b/Tests/SwiftDocCTests/Model/PropertyListPossibleValuesSectionTests.swift
index 4547e14f40..a673bab199 100644
--- a/Tests/SwiftDocCTests/Model/PropertyListPossibleValuesSectionTests.swift
+++ b/Tests/SwiftDocCTests/Model/PropertyListPossibleValuesSectionTests.swift
@@ -19,7 +19,7 @@ class PropertyListPossibleValuesSectionTests: XCTestCase {
     
     func testPossibleValuesDiagnostics() async throws {
         // Check that a problem is emitted when extra possible values are documented.
-        var (url, _, context) = try await testBundleAndContext(copying: "DictionaryData") { url in
+        var (url, context) = try await loadFromDisk(copyingCatalogNamed: "DictionaryData") { url in
             try """
             #  ``Month``
             
@@ -44,7 +44,7 @@ class PropertyListPossibleValuesSectionTests: XCTestCase {
         }
         
         // Check that no problems are emitted if no extra possible values are documented.
-        (url, _, context) = try await testBundleAndContext(copying: "DictionaryData") { url in
+        (url, context) = try await loadFromDisk(copyingCatalogNamed: "DictionaryData") { url in
             try """
             #  ``Month``
             
@@ -61,7 +61,7 @@ class PropertyListPossibleValuesSectionTests: XCTestCase {
         }
         
         // Check that a problem is emitted with possible solutions.
-        (url, _, context) = try await testBundleAndContext(copying: "DictionaryData") { url in
+        (url, context) = try await loadFromDisk(copyingCatalogNamed: "DictionaryData") { url in
             try """
             #  ``Month``
             
@@ -82,18 +82,18 @@ class PropertyListPossibleValuesSectionTests: XCTestCase {
     }
     
     func testAbsenceOfPossibleValues() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "DictionaryData")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/DictionaryData/Artist", sourceLanguage: .swift))
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "DictionaryData")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/DictionaryData/Artist", sourceLanguage: .swift))
+        let converter = DocumentationNodeConverter(context: context)
         
         // Check that the `Possible Values` section is not rendered if the symbol don't define any possible value.
         XCTAssertNil(converter.convert(node).primaryContentSections.first(where: { $0.kind == .possibleValues}) as? PossibleValuesRenderSection)
     }
     
     func testUndocumentedPossibleValues() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "DictionaryData")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/DictionaryData/Month", sourceLanguage: .swift))
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "DictionaryData")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/DictionaryData/Month", sourceLanguage: .swift))
+        let converter = DocumentationNodeConverter(context: context)
         let possibleValuesSection = try XCTUnwrap(converter.convert(node).primaryContentSections.first(where: { $0.kind == .possibleValues}) as? PossibleValuesRenderSection)
         let possibleValues: [PossibleValuesRenderSection.NamedValue] = possibleValuesSection.values
         
@@ -102,7 +102,7 @@ class PropertyListPossibleValuesSectionTests: XCTestCase {
     }
     
     func testDocumentedPossibleValuesMatchSymbolGraphPossibleValues() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "DictionaryData") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "DictionaryData") { url in
             try """
             #  ``Month``
             
@@ -116,7 +116,7 @@ class PropertyListPossibleValuesSectionTests: XCTestCase {
             """.write(to: url.appendingPathComponent("Month.md"), atomically: true, encoding: .utf8)
         }
 
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/DictionaryData/Month", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/DictionaryData/Month", sourceLanguage: .swift))
         let symbol = node.semantic as! Symbol
         let possibleValues = try XCTUnwrap(symbol.possibleValuesSection?.possibleValues)
         
@@ -126,7 +126,7 @@ class PropertyListPossibleValuesSectionTests: XCTestCase {
     }
     
     func testDocumentedPossibleValues() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "DictionaryData") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "DictionaryData") { url in
             try """
             #  ``Month``
             
@@ -136,7 +136,7 @@ class PropertyListPossibleValuesSectionTests: XCTestCase {
             """.write(to: url.appendingPathComponent("Month.md"), atomically: true, encoding: .utf8)
         }
         
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/DictionaryData/Month", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/DictionaryData/Month", sourceLanguage: .swift))
         let symbol = node.semantic as! Symbol
         let possibleValues = try XCTUnwrap(symbol.possibleValuesSection?.possibleValues)
         
@@ -150,7 +150,7 @@ class PropertyListPossibleValuesSectionTests: XCTestCase {
     }
     
     func testUnresolvedLinkWarnings() async throws {
-        let (_, _, context) = try await testBundleAndContext(copying: "DictionaryData") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "DictionaryData") { url in
             try """
             #  ``Month``
             
@@ -172,7 +172,7 @@ class PropertyListPossibleValuesSectionTests: XCTestCase {
     }
     
     func testResolvedLins() async throws {
-        let (_, _, context) = try await testBundleAndContext(copying: "DictionaryData") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "DictionaryData") { url in
             try """
             #  ``Month``
             
diff --git a/Tests/SwiftDocCTests/Model/RenderContentMetadataTests.swift b/Tests/SwiftDocCTests/Model/RenderContentMetadataTests.swift
index 23da7c1241..a5486ec6d0 100644
--- a/Tests/SwiftDocCTests/Model/RenderContentMetadataTests.swift
+++ b/Tests/SwiftDocCTests/Model/RenderContentMetadataTests.swift
@@ -67,8 +67,8 @@ class RenderContentMetadataTests: XCTestCase {
     }
     
     func testRenderingTables() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        var renderContentCompiler = RenderContentCompiler(context: context, bundle: bundle, identifier: ResolvedTopicReference(bundleID: bundle.id, path: "/path", fragment: nil, sourceLanguage: .swift))
+        let context = try await makeEmptyContext()
+        var renderContentCompiler = RenderContentCompiler(context: context,  identifier: ResolvedTopicReference(bundleID: context.inputs.id, path: "/path", fragment: nil, sourceLanguage: .swift))
         
         let source = """
         | Column 1  | Column 2 |
@@ -108,8 +108,8 @@ class RenderContentMetadataTests: XCTestCase {
     }
 
     func testRenderingTableSpans() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        var renderContentCompiler = RenderContentCompiler(context: context, bundle: bundle, identifier: ResolvedTopicReference(bundleID: bundle.id, path: "/path", fragment: nil, sourceLanguage: .swift))
+        let context = try await makeEmptyContext()
+        var renderContentCompiler = RenderContentCompiler(context: context,  identifier: ResolvedTopicReference(bundleID: context.inputs.id, path: "/path", fragment: nil, sourceLanguage: .swift))
 
         let source = """
         | one | two | three |
@@ -161,8 +161,8 @@ class RenderContentMetadataTests: XCTestCase {
     }
 
     func testRenderingTableColumnAlignments() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        var renderContentCompiler = RenderContentCompiler(context: context, bundle: bundle, identifier: ResolvedTopicReference(bundleID: bundle.id, path: "/path", fragment: nil, sourceLanguage: .swift))
+        let context = try await makeEmptyContext()
+        var renderContentCompiler = RenderContentCompiler(context: context,  identifier: ResolvedTopicReference(bundleID: context.inputs.id, path: "/path", fragment: nil, sourceLanguage: .swift))
 
         let source = """
         | one | two | three | four |
@@ -203,8 +203,8 @@ class RenderContentMetadataTests: XCTestCase {
 
     /// Verifies that a table with `nil` alignments and a table with all-unset alignments still compare as equal.
     func testRenderedTableEquality() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        var renderContentCompiler = RenderContentCompiler(context: context, bundle: bundle, identifier: ResolvedTopicReference(bundleID: bundle.id, path: "/path", fragment: nil, sourceLanguage: .swift))
+        let context = try await makeEmptyContext()
+        var renderContentCompiler = RenderContentCompiler(context: context,  identifier: ResolvedTopicReference(bundleID: context.inputs.id, path: "/path", fragment: nil, sourceLanguage: .swift))
 
         let source = """
         | Column 1  | Column 2 |
@@ -229,8 +229,8 @@ class RenderContentMetadataTests: XCTestCase {
 
     /// Verifies that two tables with otherwise-identical contents but different column alignments compare as unequal.
     func testRenderedTableInequality() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        var renderContentCompiler = RenderContentCompiler(context: context, bundle: bundle, identifier: ResolvedTopicReference(bundleID: bundle.id, path: "/path", fragment: nil, sourceLanguage: .swift))
+        let context = try await makeEmptyContext()
+        var renderContentCompiler = RenderContentCompiler(context: context,  identifier: ResolvedTopicReference(bundleID: context.inputs.id, path: "/path", fragment: nil, sourceLanguage: .swift))
 
         let decodedTableWithUnsetColumns: RenderBlockContent.Table
         do {
@@ -276,8 +276,8 @@ class RenderContentMetadataTests: XCTestCase {
     }
     
     func testStrikethrough() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        var renderContentCompiler = RenderContentCompiler(context: context, bundle: bundle, identifier: ResolvedTopicReference(bundleID: bundle.id, path: "/path", fragment: nil, sourceLanguage: .swift))
+        let context = try await makeEmptyContext()
+        var renderContentCompiler = RenderContentCompiler(context: context,  identifier: ResolvedTopicReference(bundleID: context.inputs.id, path: "/path", fragment: nil, sourceLanguage: .swift))
         
         let source = """
         ~~Striken~~ text.
@@ -299,8 +299,8 @@ class RenderContentMetadataTests: XCTestCase {
     }
     
     func testHeadingAnchorShouldBeEncoded() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        var renderContentCompiler = RenderContentCompiler(context: context, bundle: bundle, identifier: ResolvedTopicReference(bundleID: bundle.id, path: "/path", fragment: nil, sourceLanguage: .swift))
+        let context = try await makeEmptyContext()
+        var renderContentCompiler = RenderContentCompiler(context: context,  identifier: ResolvedTopicReference(bundleID: context.inputs.id, path: "/path", fragment: nil, sourceLanguage: .swift))
         
         let source = """
         ## テスト
diff --git a/Tests/SwiftDocCTests/Model/RenderHierarchyTranslatorTests.swift b/Tests/SwiftDocCTests/Model/RenderHierarchyTranslatorTests.swift
index 6fe80c94f4..783f987a07 100644
--- a/Tests/SwiftDocCTests/Model/RenderHierarchyTranslatorTests.swift
+++ b/Tests/SwiftDocCTests/Model/RenderHierarchyTranslatorTests.swift
@@ -13,10 +13,10 @@ import XCTest
 
 class RenderHierarchyTranslatorTests: XCTestCase {
     func test() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let technologyReference = ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/TestOverview", sourceLanguage: .swift)
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let technologyReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/TestOverview", sourceLanguage: .swift)
         
-        var translator = RenderHierarchyTranslator(context: context, bundle: bundle)
+        var translator = RenderHierarchyTranslator(context: context)
         let renderHierarchyVariants = translator.visitTutorialTableOfContentsNode(technologyReference)?.hierarchyVariants
         XCTAssertEqual(renderHierarchyVariants?.variants, [], "Unexpected variant hierarchies for tutorial table of content page")
         let renderHierarchy = renderHierarchyVariants?.defaultValue
@@ -89,7 +89,7 @@ class RenderHierarchyTranslatorTests: XCTestCase {
     
     func testMultiplePaths() async throws {
         // Curate "TestTutorial" under MyKit as well as TechnologyX.
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             let myKitURL = root.appendingPathComponent("documentation/mykit.md")
             let text = try String(contentsOf: myKitURL).replacingOccurrences(of: "## Topics", with: """
             ## Topics
@@ -104,7 +104,7 @@ class RenderHierarchyTranslatorTests: XCTestCase {
         // Get a translated render node
         let identifier = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/tutorials/Test-Bundle/TestTutorial", sourceLanguage: .swift)
         let node = try context.entity(with: identifier)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: identifier)
+        var translator = RenderNodeTranslator(context: context, identifier: identifier)
         let renderNode = translator.visit(node.semantic) as! RenderNode
 
         guard case .tutorials(let hierarchy) = renderNode.hierarchyVariants.defaultValue else {
@@ -129,7 +129,7 @@ class RenderHierarchyTranslatorTests: XCTestCase {
     }
     
     func testLanguageSpecificHierarchies() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "GeometricalShapes")
+        let context = try await loadFromDisk(catalogName: "GeometricalShapes")
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
         
         // An inner function to assert the rendered hierarchy values for a given reference
@@ -141,7 +141,7 @@ class RenderHierarchyTranslatorTests: XCTestCase {
             line: UInt = #line
         ) throws {
             let documentationNode = try context.entity(with: reference)
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+            var translator = RenderNodeTranslator(context: context, identifier: reference)
             let renderNode = try XCTUnwrap(translator.visit(documentationNode.semantic) as? RenderNode, file: file, line: line)
             
             if let expectedSwiftPaths {
diff --git a/Tests/SwiftDocCTests/Model/RenderNodeDiffingBundleTests.swift b/Tests/SwiftDocCTests/Model/RenderNodeDiffingBundleTests.swift
index 35c8d22a56..f3bcd9e71f 100644
--- a/Tests/SwiftDocCTests/Model/RenderNodeDiffingBundleTests.swift
+++ b/Tests/SwiftDocCTests/Model/RenderNodeDiffingBundleTests.swift
@@ -13,7 +13,7 @@ import XCTest
 
 class RenderNodeDiffingBundleTests: XCTestCase {
     let testBundleName = "LegacyBundle_DoNotUseInNewTests"
-    let testBundleID: DocumentationBundle.Identifier = "org.swift.docc.example"
+    let testBundleID: DocumentationContext.Inputs.Identifier = "org.swift.docc.example"
     
     func testDiffSymbolFromBundleWithDiscussionSectionRemoved() async throws {
         let pathToSymbol = "/documentation/MyKit"
@@ -284,9 +284,9 @@ class RenderNodeDiffingBundleTests: XCTestCase {
     }
     
     func testNoDiffsWhenReconvertingSameBundle() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: testBundleName)
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
-        let converter = DocumentationContextConverter(bundle: bundle, context: context, renderContext: renderContext)
+        let context = try await loadFromDisk(catalogName: testBundleName)
+        let renderContext = RenderContext(documentationContext: context)
+        let converter = DocumentationContextConverter(context: context, renderContext: renderContext)
         
         for identifier in context.knownPages {
             let entity = try context.entity(with: identifier)
@@ -299,28 +299,28 @@ class RenderNodeDiffingBundleTests: XCTestCase {
     }
     
     func getDiffsFromModifiedDocument(bundleName: String,
-                                      bundleID: DocumentationBundle.Identifier,
+                                      bundleID: DocumentationContext.Inputs.Identifier,
                                       topicReferencePath: String,
                                       modification: @escaping (URL) throws -> ()
     ) async throws -> JSONPatchDifferences {
-        let (bundleOriginal, contextOriginal) = try await testBundleAndContext(named: bundleName)
+        let contextOriginal = try await loadFromDisk(catalogName: bundleName)
         let nodeOriginal = try contextOriginal.entity(with: ResolvedTopicReference(bundleID: bundleID,
                                                                                    path: topicReferencePath,
                                                                                    sourceLanguage: .swift))
-        var renderContext = RenderContext(documentationContext: contextOriginal, bundle: bundleOriginal)
-        var converter = DocumentationContextConverter(bundle: bundleOriginal, context: contextOriginal, renderContext: renderContext)
+        var renderContext = RenderContext(documentationContext: contextOriginal)
+        var converter = DocumentationContextConverter(context: contextOriginal, renderContext: renderContext)
         
         let renderNodeOriginal = try XCTUnwrap(converter.renderNode(for: nodeOriginal))
         
         // Make copy of the bundle on disk, modify the document, and write it
-        let (_, bundleModified, contextModified) = try await testBundleAndContext(copying: bundleName) { url in
+        let (_, contextModified) = try await loadFromDisk(copyingCatalogNamed: bundleName) { url in
             try modification(url)
         }
         let nodeModified = try contextModified.entity(with: ResolvedTopicReference(bundleID: bundleID,
                                                                                    path: topicReferencePath,
                                                                                    sourceLanguage: .swift))
-        renderContext = RenderContext(documentationContext: contextModified, bundle: bundleModified)
-        converter = DocumentationContextConverter(bundle: bundleModified, context: contextModified, renderContext: renderContext)
+        renderContext = RenderContext(documentationContext: contextModified)
+        converter = DocumentationContextConverter(context: contextModified, renderContext: renderContext)
         
         let renderNodeModified = try XCTUnwrap(converter.renderNode(for: nodeModified))
         
diff --git a/Tests/SwiftDocCTests/Model/RenderNodeSerializationTests.swift b/Tests/SwiftDocCTests/Model/RenderNodeSerializationTests.swift
index d539531a31..cfeea1912e 100644
--- a/Tests/SwiftDocCTests/Model/RenderNodeSerializationTests.swift
+++ b/Tests/SwiftDocCTests/Model/RenderNodeSerializationTests.swift
@@ -92,8 +92,8 @@ class RenderNodeSerializationTests: XCTestCase {
     }
     
     func testBundleRoundTrip() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/Test-Bundle/TestTutorial", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/Test-Bundle/TestTutorial", sourceLanguage: .swift))
         
         guard let tutorialDirective = node.markup as? BlockDirective else {
             XCTFail("Unexpected document structure, tutorial not found as first child.")
@@ -101,22 +101,22 @@ class RenderNodeSerializationTests: XCTestCase {
         }
         
         var problems = [Problem]()
-        guard let tutorial = Tutorial(from: tutorialDirective, source: nil, for: bundle, problems: &problems) else {
+        guard let tutorial = Tutorial(from: tutorialDirective, source: nil, for: context.inputs, problems: &problems) else {
             XCTFail("Couldn't create tutorial from markup: \(problems)")
             return
         }
         
         XCTAssertEqual(problems.count, 1, "Found problems \(problems.map { DiagnosticConsoleWriter.formattedDescription(for: $0.diagnostic) }) analyzing tutorial markup")
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = translator.visit(tutorial) as! RenderNode
         checkRoundTrip(renderNode)
     }
     
     func testTutorialArticleRoundTrip() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/Test-Bundle/TestTutorialArticle", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/Test-Bundle/TestTutorialArticle", sourceLanguage: .swift))
         
         guard let articleDirective = node.markup as? BlockDirective else {
             XCTFail("Unexpected document structure, article not found as first child.")
@@ -124,14 +124,14 @@ class RenderNodeSerializationTests: XCTestCase {
         }
         
         var problems = [Problem]()
-        guard let article = TutorialArticle(from: articleDirective, source: nil, for: bundle, problems: &problems) else {
+        guard let article = TutorialArticle(from: articleDirective, source: nil, for: context.inputs, problems: &problems) else {
             XCTFail("Couldn't create article from markup: \(problems)")
             return
         }
         
         XCTAssertEqual(problems.count, 0, "Found problems \(problems.map { DiagnosticConsoleWriter.formattedDescription(for: $0.diagnostic) }) analyzing article markup")
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = translator.visit(article) as! RenderNode
         checkRoundTrip(renderNode)
@@ -140,8 +140,8 @@ class RenderNodeSerializationTests: XCTestCase {
     func testAssetReferenceDictionary() async throws {
         typealias JSONDictionary = [String: Any]
         
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/Test-Bundle/TestTutorial", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/Test-Bundle/TestTutorial", sourceLanguage: .swift))
         
         guard let tutorialDirective = node.markup as? BlockDirective else {
             XCTFail("Unexpected document structure, tutorial not found as first child.")
@@ -149,14 +149,14 @@ class RenderNodeSerializationTests: XCTestCase {
         }
         
         var problems = [Problem]()
-        guard let tutorial = Tutorial(from: tutorialDirective, source: nil, for: bundle, problems: &problems) else {
+        guard let tutorial = Tutorial(from: tutorialDirective, source: nil, for: context.inputs, problems: &problems) else {
             XCTFail("Couldn't create tutorial from markup: \(problems)")
             return
         }
         
         XCTAssertEqual(problems.count, 1, "Found problems \(problems.map { DiagnosticConsoleWriter.formattedDescription(for: $0.diagnostic) }) analyzing tutorial markup")
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = translator.visit(tutorial) as! RenderNode
         let data = try encode(renderNode: renderNode)
@@ -192,8 +192,8 @@ class RenderNodeSerializationTests: XCTestCase {
     }
 
     func testDiffAvailability() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/Test-Bundle/TestTutorialArticle", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/Test-Bundle/TestTutorialArticle", sourceLanguage: .swift))
         
         guard let articleDirective = node.markup as? BlockDirective else {
             XCTFail("Unexpected document structure, article not found as first child.")
@@ -201,12 +201,12 @@ class RenderNodeSerializationTests: XCTestCase {
         }
         
         var problems = [Problem]()
-        guard let article = TutorialArticle(from: articleDirective, source: nil, for: bundle, problems: &problems) else {
+        guard let article = TutorialArticle(from: articleDirective, source: nil, for: context.inputs, problems: &problems) else {
             XCTFail("Couldn't create article from markup: \(problems)")
             return
         }
 
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
 
         var renderNode = translator.visit(article) as! RenderNode
 
diff --git a/Tests/SwiftDocCTests/Model/SemaToRenderNodeDictionaryDataTests.swift b/Tests/SwiftDocCTests/Model/SemaToRenderNodeDictionaryDataTests.swift
index b0335f9745..83a5810c91 100644
--- a/Tests/SwiftDocCTests/Model/SemaToRenderNodeDictionaryDataTests.swift
+++ b/Tests/SwiftDocCTests/Model/SemaToRenderNodeDictionaryDataTests.swift
@@ -15,7 +15,7 @@ import XCTest
 
 class SemaToRenderNodeDictionaryDataTests: XCTestCase {
     func testBaseRenderNodeFromDictionaryData() async throws {
-        let (_, context) = try await testBundleAndContext(named: "DictionaryData")
+        let context = try await loadFromDisk(catalogName: "DictionaryData")
         
         let expectedPageUSRsAndLangs: [String : Set<SourceLanguage>] = [
             // Artist dictionary - ``Artist``:
diff --git a/Tests/SwiftDocCTests/Model/SemaToRenderNodeHTTPRequestTests.swift b/Tests/SwiftDocCTests/Model/SemaToRenderNodeHTTPRequestTests.swift
index 6ebf753a32..a248b0d5a1 100644
--- a/Tests/SwiftDocCTests/Model/SemaToRenderNodeHTTPRequestTests.swift
+++ b/Tests/SwiftDocCTests/Model/SemaToRenderNodeHTTPRequestTests.swift
@@ -15,7 +15,7 @@ import XCTest
 
 class SemaToRenderNodeHTTPRequestTests: XCTestCase {
     func testBaseRenderNodeFromHTTPRequest() async throws {
-        let (_, context) = try await testBundleAndContext(named: "HTTPRequests")
+        let context = try await loadFromDisk(catalogName: "HTTPRequests")
         
         let expectedPageUSRsAndLanguages: [String : Set<SourceLanguage>] = [
             // Get Artist endpoint - ``Get_Artist``:
diff --git a/Tests/SwiftDocCTests/Model/SemaToRenderNodeMultiLanguageTests.swift b/Tests/SwiftDocCTests/Model/SemaToRenderNodeMultiLanguageTests.swift
index 02638bd029..b7c6ca96bf 100644
--- a/Tests/SwiftDocCTests/Model/SemaToRenderNodeMultiLanguageTests.swift
+++ b/Tests/SwiftDocCTests/Model/SemaToRenderNodeMultiLanguageTests.swift
@@ -16,7 +16,7 @@ import XCTest
 
 class SemaToRenderNodeMixedLanguageTests: XCTestCase {
     func testBaseRenderNodeFromMixedLanguageFramework() async throws {
-        let (_, context) = try await testBundleAndContext(named: "MixedLanguageFramework")
+        let context = try await loadFromDisk(catalogName: "MixedLanguageFramework")
         
         for (_, documentationNode) in context.documentationCache where documentationNode.kind.isSymbol {
             let symbolUSR = try XCTUnwrap((documentationNode.semantic as? Symbol)?.externalID)
@@ -449,7 +449,7 @@ class SemaToRenderNodeMixedLanguageTests: XCTestCase {
     }
     
     func testSymbolLinkWorkInMultipleLanguages() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "MixedLanguageFramework") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "MixedLanguageFramework") { url in
             try """
             # ``MixedLanguageFramework/Bar``
             
@@ -466,12 +466,12 @@ class SemaToRenderNodeMixedLanguageTests: XCTestCase {
             """.write(to: url.appendingPathComponent("bar.md"), atomically: true, encoding: .utf8)
         }
         
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MixedLanguageFramework/Bar", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MixedLanguageFramework/Bar", sourceLanguage: .swift))
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
         
         XCTAssert(context.problems.isEmpty, "Encountered unexpected problems: \(context.problems)")
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = try XCTUnwrap(translator.visit(symbol) as? RenderNode)
         
         XCTAssert(context.problems.isEmpty, "Encountered unexpected problems: \(context.problems)")
@@ -962,7 +962,7 @@ class SemaToRenderNodeMixedLanguageTests: XCTestCase {
     }
 
     func testAutomaticSeeAlsoSectionElementLimit() async throws {
-        let (bundle, context) = try await loadBundle(catalog:
+        let context = try await load(catalog:
             Folder(name: "unit-test.docc", content: [
                 JSONFile(name: "ModuleName.symbols.json", content: makeSymbolGraph(moduleName: "ModuleName", symbols: (1...50).map {
                     makeSymbol(id: "symbol-id-\($0)", kind: .class, pathComponents: ["SymbolName\($0)"])
@@ -984,7 +984,7 @@ class SemaToRenderNodeMixedLanguageTests: XCTestCase {
 
         XCTAssert(context.problems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary))")
 
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
 
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
         let moduleNode = try converter.convert(context.entity(with: moduleReference))
diff --git a/Tests/SwiftDocCTests/Model/SemaToRenderNodeTests.swift b/Tests/SwiftDocCTests/Model/SemaToRenderNodeTests.swift
index 355ae1c327..9e07cd9d07 100644
--- a/Tests/SwiftDocCTests/Model/SemaToRenderNodeTests.swift
+++ b/Tests/SwiftDocCTests/Model/SemaToRenderNodeTests.swift
@@ -16,8 +16,8 @@ import SwiftDocCTestUtilities
 
 class SemaToRenderNodeTests: XCTestCase {
     func testCompileTutorial() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/Test-Bundle/TestTutorial", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/Test-Bundle/TestTutorial", sourceLanguage: .swift))
         
         guard let tutorialDirective = node.markup as? BlockDirective else {
             XCTFail("Unexpected document structure, tutorial not found as first child.")
@@ -25,14 +25,14 @@ class SemaToRenderNodeTests: XCTestCase {
         }
         
         var problems = [Problem]()
-        guard let tutorial = Tutorial(from: tutorialDirective, source: nil, for: bundle, problems: &problems) else {
+        guard let tutorial = Tutorial(from: tutorialDirective, source: nil, for: context.inputs, problems: &problems) else {
             XCTFail("Couldn't create tutorial from markup: \(problems)")
             return
         }
         
         XCTAssertEqual(problems.count, 1, "Found problems \(DiagnosticConsoleWriter.formattedDescription(for: problems)) analyzing tutorial markup")
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = translator.visit(tutorial) as! RenderNode
         
@@ -401,10 +401,10 @@ class SemaToRenderNodeTests: XCTestCase {
     }
     
     func testTutorialBackgroundComesFromImageOrVideoPoster() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         
         func assertTutorialWithPath(_ tutorialPath: String, hasBackground backgroundIdentifier: String) throws {
-            let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: tutorialPath, sourceLanguage: .swift))
+            let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: tutorialPath, sourceLanguage: .swift))
             
             guard let tutorialDirective = node.markup as? BlockDirective else {
                 XCTFail("Unexpected document structure, tutorial not found as first child.")
@@ -412,12 +412,12 @@ class SemaToRenderNodeTests: XCTestCase {
             }
             
             var problems = [Problem]()
-            guard let tutorial = Tutorial(from: tutorialDirective, source: nil, for: bundle, problems: &problems) else {
+            guard let tutorial = Tutorial(from: tutorialDirective, source: nil, for: context.inputs, problems: &problems) else {
                 XCTFail("Couldn't create tutorial from markup: \(problems)")
                 return
             }
             
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(tutorial) as! RenderNode
             let intro = renderNode.sections.compactMap { $0 as? IntroRenderSection }.first!
             XCTAssertEqual(RenderReferenceIdentifier(backgroundIdentifier), intro.backgroundImage)
@@ -431,12 +431,12 @@ class SemaToRenderNodeTests: XCTestCase {
     }
     
     func testCompileTutorialArticle() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/Test-Bundle/TestTutorialArticle", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/Test-Bundle/TestTutorialArticle", sourceLanguage: .swift))
         
         let article = node.semantic as! TutorialArticle
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = translator.visit(article) as! RenderNode
         
@@ -492,12 +492,12 @@ class SemaToRenderNodeTests: XCTestCase {
     }
     
     func testCompileOverviewWithNoVolumes() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        try assertCompileOverviewWithNoVolumes(bundle: bundle, context: context)
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        try assertCompileOverviewWithNoVolumes(context: context)
     }
     
     func testCompileOverviewWithEmptyChapter() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { url in
             try """
             @Tutorials(name: "Technology X") {
                @Intro(title: "Technology X") {
@@ -562,15 +562,14 @@ class SemaToRenderNodeTests: XCTestCase {
         }
         
         try assertCompileOverviewWithNoVolumes(
-            bundle: bundle,
             context: context,
             // Expect one problem for the empty chapter.
             expectedProblemsCount: 1
         )
     }
     
-    private func assertCompileOverviewWithNoVolumes(bundle: DocumentationBundle, context: DocumentationContext, expectedProblemsCount: Int = 0) throws {
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/TestOverview", sourceLanguage: .swift))
+    private func assertCompileOverviewWithNoVolumes(context: DocumentationContext, expectedProblemsCount: Int = 0) throws {
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/TestOverview", sourceLanguage: .swift))
         
         guard let tutorialTableOfContentsDirective = node.markup as? BlockDirective else {
             XCTFail("Unexpected document structure, tutorial not found as first child.")
@@ -578,7 +577,7 @@ class SemaToRenderNodeTests: XCTestCase {
         }
         
         var problems = [Problem]()
-        guard let tutorialTableOfContents = TutorialTableOfContents(from: tutorialTableOfContentsDirective, source: nil, for: bundle, problems: &problems) else {
+        guard let tutorialTableOfContents = TutorialTableOfContents(from: tutorialTableOfContentsDirective, source: nil, for: context.inputs, problems: &problems) else {
             XCTFail("Couldn't create tutorial from markup: \(problems)")
             return
         }
@@ -586,7 +585,7 @@ class SemaToRenderNodeTests: XCTestCase {
         // Verify we emit a diagnostic for the chapter with no tutorial references.
         XCTAssertEqual(problems.count, expectedProblemsCount, "Found problems \(DiagnosticConsoleWriter.formattedDescription(for: problems)) analyzing tutorial markup")
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = translator.visit(tutorialTableOfContents) as! RenderNode
         
@@ -718,7 +717,7 @@ class SemaToRenderNodeTests: XCTestCase {
     }
     
     func testCompileOverviewWithVolumes() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             let overviewURL = root.appendingPathComponent("TestOverview.tutorial")
             let text = """
             @Tutorials(name: "Technology X") {
@@ -807,7 +806,7 @@ class SemaToRenderNodeTests: XCTestCase {
             try text.write(to: overviewURL, atomically: true, encoding: .utf8)
         }
     
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/TestOverview", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/TestOverview", sourceLanguage: .swift))
         
         guard let tutorialTableOfContentsDirective = node.markup as? BlockDirective else {
             XCTFail("Unexpected document structure, tutorial table-of-contents not found as first child.")
@@ -815,14 +814,14 @@ class SemaToRenderNodeTests: XCTestCase {
         }
         
         var problems = [Problem]()
-        guard let tutorialTableOfContents = TutorialTableOfContents(from: tutorialTableOfContentsDirective, source: nil, for: bundle, problems: &problems) else {
+        guard let tutorialTableOfContents = TutorialTableOfContents(from: tutorialTableOfContentsDirective, source: nil, for: context.inputs, problems: &problems) else {
             XCTFail("Couldn't create tutorial from markup: \(problems)")
             return
         }
         
         XCTAssertEqual(problems.count, 0, "Found problems \(DiagnosticConsoleWriter.formattedDescription(for: problems)) analyzing tutorial markup")
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = translator.visit(tutorialTableOfContents) as! RenderNode
 
@@ -927,7 +926,7 @@ class SemaToRenderNodeTests: XCTestCase {
     }
     
     func testCompileSymbol() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { url in
             // Remove the SideClass sub heading to match the expectations of this test
             let graphURL = url.appendingPathComponent("sidekit.symbols.json")
             var graph = try JSONDecoder().decode(SymbolGraph.self, from: try Data(contentsOf: graphURL))
@@ -941,7 +940,7 @@ class SemaToRenderNodeTests: XCTestCase {
             try JSONEncoder().encode(graph).write(to: graphURL)
         }
         
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyProtocol", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyProtocol", sourceLanguage: .swift))
         
         // Verify that `MyProtocol` the symbol is loaded in the topic graph, but the `MyProtocol` sidecar article was removed.
         let matches = context.knownPages.filter({ reference -> Bool in
@@ -958,7 +957,7 @@ class SemaToRenderNodeTests: XCTestCase {
         
         let symbol = node.semantic as! Symbol
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = translator.visit(symbol) as! RenderNode
         guard renderNode.primaryContentSections.count == 4 else {
@@ -1225,10 +1224,10 @@ class SemaToRenderNodeTests: XCTestCase {
             }
         }
         
-        let testBundleURL = Bundle.module.url(
+        let legacyCatalogURL = Bundle.module.url(
             forResource: "LegacyBundle_DoNotUseInNewTests", withExtension: "docc", subdirectory: "Test Bundles")!
-        let (_, bundle, context) = try await loadBundle(
-            from: testBundleURL,
+        let context = try await loadFromDisk(
+            catalogURL: legacyCatalogURL,
             externalResolvers: ["com.test.external": TestReferenceResolver()],
             externalSymbolResolver: TestSymbolResolver()
         )
@@ -1247,7 +1246,7 @@ class SemaToRenderNodeTests: XCTestCase {
         XCTAssertNotNil(context.externalCache["s:10Foundation4DataV"])
         XCTAssertNotNil(context.externalCache["s:5Foundation0A5NSCodableP"])
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: myProtocol.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: myProtocol.reference)
 
         let renderNode = translator.visit(myProtocolSymbol) as! RenderNode
         guard renderNode.primaryContentSections.count == 4 else {
@@ -1327,11 +1326,11 @@ class SemaToRenderNodeTests: XCTestCase {
         
         // Check for constraints in render node
         
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift))
         
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = translator.visit(symbol) as! RenderNode
         guard let conf = renderNode.metadata.conformance else {
@@ -1348,10 +1347,10 @@ class SemaToRenderNodeTests: XCTestCase {
         }.joined(), "Label is Text, Observer inherits NSObject, and S conforms to StringProtocol.")
         
         // Check for constraints in render references
-        let parent = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
+        let parent = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
         
         let parentSymbol = parent.semantic as! Symbol
-        var parentTranslator = RenderNodeTranslator(context: context, bundle: bundle, identifier: parent.reference)
+        var parentTranslator = RenderNodeTranslator(context: context, identifier: parent.reference)
         
         let parentRenderNode = parentTranslator.visit(parentSymbol) as! RenderNode
         guard let functionReference = parentRenderNode.references["doc://org.swift.docc.example/documentation/MyKit/MyClass/myFunction()"] as? TopicRenderReference else {
@@ -1380,10 +1379,10 @@ class SemaToRenderNodeTests: XCTestCase {
     }
     
     func testRenderConditionalConstraintsOnConformingType() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyProtocol", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyProtocol", sourceLanguage: .swift))
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(symbol) as! RenderNode
         
         // Test conditional conformance for the conforming type
@@ -1402,10 +1401,10 @@ class SemaToRenderNodeTests: XCTestCase {
     }
     
     func testRenderConditionalConstraintsOnProtocol() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(symbol) as! RenderNode
         
         // Test conditional conformance for the conforming type
@@ -1424,12 +1423,12 @@ class SemaToRenderNodeTests: XCTestCase {
     }
     
     func testRenderReferenceResolving() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
         
         // Compile docs and verify contents
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
 
         let renderNode = translator.visit(symbol) as! RenderNode
 
@@ -1489,12 +1488,12 @@ class SemaToRenderNodeTests: XCTestCase {
     }
     
     func testAvailabilityMetadata() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
         
         // Compile docs and verify contents
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = translator.visit(symbol) as! RenderNode
         
@@ -1537,7 +1536,7 @@ class SemaToRenderNodeTests: XCTestCase {
         
         // Override with both a low and a high value
         for version in [SymbolGraph.SemanticVersion(major: 1, minor: 1, patch: 1), SymbolGraph.SemanticVersion(major: 99, minor: 99, patch: 99)] {
-            let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], configureBundle: { url in
+            let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], configureBundle: { url in
                 // Duplicate the symbol graph
                 let myKitURL = url.appendingPathComponent("mykit-iOS.symbols.json")
                 let myClassUSR = "s:5MyKit0A5ClassC"
@@ -1563,11 +1562,11 @@ class SemaToRenderNodeTests: XCTestCase {
                 }
             })
             
-            let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
+            let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
             
             // Compile docs and verify contents
             let symbol = node.semantic as! Symbol
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             
             let renderNode = translator.visit(symbol) as! RenderNode
             
@@ -1589,8 +1588,8 @@ class SemaToRenderNodeTests: XCTestCase {
     }
     
     func testMediaReferencesWithSpaces() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/Test-Bundle/TutorialMediaWithSpaces", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/Test-Bundle/TutorialMediaWithSpaces", sourceLanguage: .swift))
         
         guard let tutorialDirective = node.markup as? BlockDirective else {
             XCTFail("Unexpected document structure, tutorial not found as first child.")
@@ -1598,14 +1597,14 @@ class SemaToRenderNodeTests: XCTestCase {
         }
         
         var problems = [Problem]()
-        guard let tutorial = Tutorial(from: tutorialDirective, source: nil, for: bundle, problems: &problems) else {
+        guard let tutorial = Tutorial(from: tutorialDirective, source: nil, for: context.inputs, problems: &problems) else {
             XCTFail("Couldn't create tutorial from markup: \(problems)")
             return
         }
         
         XCTAssertTrue(problems.isEmpty)
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = translator.visit(tutorial) as! RenderNode
         
@@ -1650,8 +1649,8 @@ Document @1:1-11:19
 """,
                        markup.debugDescription(options: .printSourceLocations))
         
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        var contentTranslator = RenderContentCompiler(context: context, bundle: bundle, identifier: ResolvedTopicReference(bundleID: bundle.id, path: "/TestTutorial", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        var contentTranslator = RenderContentCompiler(context: context,  identifier: ResolvedTopicReference(bundleID: context.inputs.id, path: "/TestTutorial", sourceLanguage: .swift))
         let renderContent = try XCTUnwrap(markup.children.reduce(into: [], { result, item in result.append(contentsOf: contentTranslator.visit(item))}) as? [RenderBlockContent])
         let expectedContent: [RenderBlockContent] = [
             .paragraph(.init(inlineContent: [
@@ -1692,8 +1691,8 @@ Document
 """,
                        markup.debugDescription())
 
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        var contentTranslator = RenderContentCompiler(context: context, bundle: bundle, identifier: ResolvedTopicReference(bundleID: bundle.id, path: "/TestTutorial", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        var contentTranslator = RenderContentCompiler(context: context,  identifier: ResolvedTopicReference(bundleID: context.inputs.id, path: "/TestTutorial", sourceLanguage: .swift))
         let renderContent = try XCTUnwrap(markup.children.reduce(into: [], { result, item in result.append(contentsOf: contentTranslator.visit(item))}) as? [RenderBlockContent])
         let expectedContent: [RenderBlockContent] = [
                 .paragraph(.init(inlineContent: [
@@ -1717,19 +1716,19 @@ Document
         
         let document = Document(parsing: markupSource, options: [])
         let node = DocumentationNode(reference: ResolvedTopicReference(bundleID: "org.swift.docc", path: "/blah", sourceLanguage: .swift), kind: .article, sourceLanguage: .swift, name: .conceptual(title: "Title"), markup: document, semantic: Semantic())
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         XCTAssertNotNil(translator.visit(MarkupContainer(document.children)))
         }
         
     func testCompileSymbolMetadata() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyProtocol", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyProtocol", sourceLanguage: .swift))
         
         // Compile docs and verify contents
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = translator.visit(symbol) as! RenderNode
         
@@ -1831,10 +1830,10 @@ Document
 
         try content.write(to: targetURL.appendingPathComponent("article2.md"), atomically: true, encoding: .utf8)
 
-        let (_, bundle, context) = try await loadBundle(from: targetURL)
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Test-Bundle/article2", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogURL: targetURL)
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Test-Bundle/article2", sourceLanguage: .swift))
         let article = node.semantic as! Article
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         return translator.visit(article) as! RenderNode
     }
     
@@ -1918,7 +1917,7 @@ Document
             """),
         ])
         
-        let (_, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         XCTAssertEqual(context.problems.filter({ $0.diagnostic.identifier == "org.swift.docc.InvalidDocumentationLink" }).count, 1)
         XCTAssertNotNil(context.problems.first(where: { problem -> Bool in
@@ -1928,7 +1927,7 @@ Document
     }
     
     func testRendersBetaViolators() async throws {
-        func makeTestBundle(currentPlatforms: [String : PlatformVersion]?, file: StaticString = #filePath, line: UInt = #line, referencePath: String) async throws -> (DocumentationBundle, DocumentationContext, ResolvedTopicReference) {
+        func makeTestContext(currentPlatforms: [String : PlatformVersion]?, file: StaticString = #filePath, line: UInt = #line, referencePath: String) async throws -> (DocumentationContext, ResolvedTopicReference) {
             var configuration = DocumentationContext.Configuration()
             // Add missing platforms if their fallback platform is present.
             var currentPlatforms = currentPlatforms ?? [:]
@@ -1937,33 +1936,33 @@ Document
             }
             configuration.externalMetadata.currentPlatforms = currentPlatforms
             
-            let (_, bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests", configuration: configuration)
+            let (_, context) = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests", configuration: configuration)
             
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: referencePath, sourceLanguage: .swift)
-            return (bundle, context, reference)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: referencePath, sourceLanguage: .swift)
+            return (context, reference)
         }
         
         // Not a beta platform
         do {
-            let (bundle, context, reference) = try await makeTestBundle(currentPlatforms: nil, referencePath: "/documentation/MyKit/globalFunction(_:considering:)")
+            let (context, reference) = try await makeTestContext(currentPlatforms: nil, referencePath: "/documentation/MyKit/globalFunction(_:considering:)")
             
             let node = try context.entity(with: reference)
-            let renderNode = DocumentationNodeConverter(bundle: bundle, context: context).convert(node)
+            let renderNode = DocumentationNodeConverter(context: context).convert(node)
             
             // Verify platform beta was plumbed all the way to the render JSON
             XCTAssertEqual(renderNode.metadata.platforms?.first?.isBeta, false)
         }
         
-        // Symbol with an empty set of availbility items.
+        // Symbol with an empty set of availability items.
         
         do {
             
-            let (bundle, context, reference) = try await makeTestBundle(currentPlatforms: [
+            let (context, reference) = try await makeTestContext(currentPlatforms: [
                 "Custom Name": PlatformVersion(VersionTriplet(100, 0, 0), beta: true)
             ], referencePath: "/documentation/MyKit/globalFunction(_:considering:)")
             let node = try context.entity(with: reference)
             (node.semantic as? Symbol)?.availability = SymbolGraph.Symbol.Availability(availability: [])
-            let documentationContentRendered = DocumentationContentRenderer(documentationContext: context, bundle: bundle)
+            let documentationContentRendered = DocumentationContentRenderer(documentationContext: context)
             let isBeta = documentationContentRendered.isBeta(node)
             // Verify that the symbol is not beta since it does not contains availability info.
             XCTAssertFalse(isBeta)
@@ -1971,12 +1970,12 @@ Document
         
         // Different platform is beta
         do {
-            let (bundle, context, reference) = try await makeTestBundle(currentPlatforms: [
+            let (context, reference) = try await makeTestContext(currentPlatforms: [
                 "tvOS": PlatformVersion(VersionTriplet(100, 0, 0), beta: true)
             ], referencePath: "/documentation/MyKit/globalFunction(_:considering:)")
             
             let node = try context.entity(with: reference)
-            let renderNode = DocumentationNodeConverter(bundle: bundle, context: context).convert(node)
+            let renderNode = DocumentationNodeConverter(context: context).convert(node)
             
             // Verify platform beta was plumbed all the way to the render JSON
             XCTAssertEqual(renderNode.metadata.platforms?.first?.isBeta, false)
@@ -1985,12 +1984,12 @@ Document
         // Beta platform but *not* matching the introduced version
         
         do {
-            let (bundle, context, reference) = try await makeTestBundle(currentPlatforms: [
+            let (context, reference) = try await makeTestContext(currentPlatforms: [
                 "macOS": PlatformVersion(VersionTriplet(100, 0, 0), beta: true)
             ], referencePath: "/documentation/MyKit/globalFunction(_:considering:)")
             
             let node = try context.entity(with: reference)
-            let renderNode = DocumentationNodeConverter(bundle: bundle, context: context).convert(node)
+            let renderNode = DocumentationNodeConverter(context: context).convert(node)
             
             // Verify platform beta was plumbed all the way to the render JSON
             XCTAssertEqual(renderNode.metadata.platforms?.first?.isBeta, false)
@@ -1999,12 +1998,12 @@ Document
         // Beta platform matching the introduced version
 
         do {
-            let (bundle, context, reference) = try await makeTestBundle(currentPlatforms: [
+            let (context, reference) = try await makeTestContext(currentPlatforms: [
                 "macOS": PlatformVersion(VersionTriplet(10, 15, 0), beta: true)
             ], referencePath: "/documentation/MyKit/globalFunction(_:considering:)")
             
             let node = try context.entity(with: reference)
-            let renderNode = DocumentationNodeConverter(bundle: bundle, context: context).convert(node)
+            let renderNode = DocumentationNodeConverter(context: context).convert(node)
 
             // Verify platform beta was plumbed all the way to the render JSON
             XCTAssertEqual(renderNode.metadata.platforms?.first(where: { $0.name == "macOS"})?.isBeta, true)
@@ -2013,12 +2012,12 @@ Document
         // Beta platform earlier than the introduced version
         
         do {
-            let (bundle, context, reference) = try await makeTestBundle(currentPlatforms: [
+            let (context, reference) = try await makeTestContext(currentPlatforms: [
                 "macOS": PlatformVersion(VersionTriplet(10, 14, 0), beta: true)
             ], referencePath: "/documentation/MyKit/globalFunction(_:considering:)")
             
             let node = try context.entity(with: reference)
-            let renderNode = DocumentationNodeConverter(bundle: bundle, context: context).convert(node)
+            let renderNode = DocumentationNodeConverter(context: context).convert(node)
             
             // Verify platform beta was plumbed all the way to the render JSON
             XCTAssertEqual(renderNode.metadata.platforms?.first(where: { $0.name == "macOS" })?.isBeta, true)
@@ -2027,14 +2026,14 @@ Document
         // Set only some platforms to beta & the exact version globalFunction is being introduced at
         
         do {
-            let (bundle, context, reference) = try await makeTestBundle(currentPlatforms: [
+            let (context, reference) = try await makeTestContext(currentPlatforms: [
                 "macOS": PlatformVersion(VersionTriplet(10, 15, 0), beta: true),
                 "watchOS": PlatformVersion(VersionTriplet(9, 0, 0), beta: true),
                 "tvOS": PlatformVersion(VersionTriplet(1, 0, 0), beta: true),
             ], referencePath: "/documentation/MyKit/globalFunction(_:considering:)")
             
             let node = try context.entity(with: reference)
-            let renderNode = DocumentationNodeConverter(bundle: bundle, context: context).convert(node)
+            let renderNode = DocumentationNodeConverter(context: context).convert(node)
             
             // Verify task group link is not in beta betas "iOS" is not being marked as beta
             XCTAssertEqual((renderNode.references["doc://org.swift.docc.example/documentation/MyKit/globalFunction(_:considering:)"] as? TopicRenderReference)?.isBeta, false)
@@ -2042,7 +2041,7 @@ Document
 
         // Set all platforms to beta & the exact version globalFunction is being introduced at to test beta SDK documentation
         do {
-            let (bundle, context, reference) = try await makeTestBundle(currentPlatforms: [
+            let (context, reference) = try await makeTestContext(currentPlatforms: [
                 "macOS": PlatformVersion(VersionTriplet(10, 15, 0), beta: true),
                 "watchOS": PlatformVersion(VersionTriplet(6, 0, 0), beta: true),
                 "tvOS": PlatformVersion(VersionTriplet(13, 0, 0), beta: true),
@@ -2050,7 +2049,7 @@ Document
             ], referencePath: "/documentation/MyKit/globalFunction(_:considering:)")
             
             let node = try context.entity(with: reference)
-            let renderNode = try XCTUnwrap(DocumentationNodeConverter(bundle: bundle, context: context).convert(node))
+            let renderNode = try XCTUnwrap(DocumentationNodeConverter(context: context).convert(node))
             
             // Verify task group link is beta
             XCTAssertEqual((renderNode.references["doc://org.swift.docc.example/documentation/MyKit/globalFunction(_:considering:)"] as? TopicRenderReference)?.isBeta, true)
@@ -2058,7 +2057,7 @@ Document
 
         // Set all platforms to beta where the symbol is available,
         // some platforms not beta but the symbol is not available there.
-        let (bundle, context, reference) = try await makeTestBundle(currentPlatforms: [
+        let (context, reference) = try await makeTestContext(currentPlatforms: [
             "macOS": PlatformVersion(VersionTriplet(10, 15, 0), beta: true),
             "watchOS": PlatformVersion(VersionTriplet(6, 0, 0), beta: true),
             "tvOS": PlatformVersion(VersionTriplet(13, 0, 0), beta: true),
@@ -2068,7 +2067,7 @@ Document
         ], referencePath: "/documentation/MyKit/globalFunction(_:considering:)")
         
         let node = try context.entity(with: reference)
-        let renderNode = try XCTUnwrap(DocumentationNodeConverter(bundle: bundle, context: context).convert(node))
+        let renderNode = try XCTUnwrap(DocumentationNodeConverter(context: context).convert(node))
         
         // Verify task group link is beta
         XCTAssertEqual((renderNode.references["doc://org.swift.docc.example/documentation/MyKit/globalFunction(_:considering:)"] as? TopicRenderReference)?.isBeta, true)
@@ -2081,16 +2080,16 @@ Document
             renderReferenceSymbol.availability?.availability.append(SymbolGraph.Symbol.Availability.AvailabilityItem(domain: SymbolGraph.Symbol.Availability.Domain(rawValue: "ImaginaryOS"), introducedVersion: nil, deprecatedVersion: nil, obsoletedVersion: nil, message: nil, renamed: nil, isUnconditionallyDeprecated: false, isUnconditionallyUnavailable: true, willEventuallyBeDeprecated: false))
 
             // Verify the rendered reference
-            let renderNode = try XCTUnwrap(DocumentationNodeConverter(bundle: bundle, context: context).convert(node))
+            let renderNode = try XCTUnwrap(DocumentationNodeConverter(context: context).convert(node))
             
             // Verify task group link is beta
             XCTAssertEqual((renderNode.references["doc://org.swift.docc.example/documentation/MyKit/globalFunction(_:considering:)"] as? TopicRenderReference)?.isBeta, true)
         }
         
         // Set all platforms to beta & the exact version MyClass is being introduced.
-        // Expect the symbol to no be in beta sinceit does not have an introduced version for iOS
+        // Expect the symbol to no be in beta since it does not have an introduced version for iOS
         do {
-            let (bundle, context, reference) = try await makeTestBundle(currentPlatforms: [
+            let (context, reference) = try await makeTestContext(currentPlatforms: [
                 "macOS": PlatformVersion(VersionTriplet(10, 15, 0), beta: true),
                 "watchOS": PlatformVersion(VersionTriplet(6, 0, 0), beta: true),
                 "tvOS": PlatformVersion(VersionTriplet(13, 0, 0), beta: true),
@@ -2098,7 +2097,7 @@ Document
             ], referencePath: "/documentation/MyKit")
             
             let node = try context.entity(with: reference)
-            let renderNode = try XCTUnwrap(DocumentationNodeConverter(bundle: bundle, context: context).convert(node))
+            let renderNode = try XCTUnwrap(DocumentationNodeConverter(context: context).convert(node))
             
             // Verify task group link is not in beta because `iOS` does not have an introduced version
             XCTAssertEqual((renderNode.references["doc://org.swift.docc.example/documentation/MyKit/MyClass"] as? TopicRenderReference)?.isBeta, false)
@@ -2106,12 +2105,12 @@ Document
         
         // Set all platforms as unconditionally unavailable and test that the symbol is not marked as beta.
         do {
-            let (bundle, context, reference) = try await makeTestBundle(currentPlatforms: [
+            let (context, reference) = try await makeTestContext(currentPlatforms: [
                 "iOS": PlatformVersion(VersionTriplet(100, 0, 0), beta: true)
             ], referencePath: "/documentation/MyKit/MyClass")
             let node = try context.entity(with: reference)
             (node.semantic as? Symbol)?.availability = SymbolGraph.Symbol.Availability(availability: [.init(domain: SymbolGraph.Symbol.Availability.Domain(rawValue: "iOS"), introducedVersion: nil, deprecatedVersion: nil, obsoletedVersion: nil, message: nil, renamed: nil, isUnconditionallyDeprecated: false, isUnconditionallyUnavailable: true, willEventuallyBeDeprecated: false)])
-            let documentationContentRendered = DocumentationContentRenderer(documentationContext: context, bundle: bundle)
+            let documentationContentRendered = DocumentationContentRenderer(documentationContext: context)
             let isBeta = documentationContentRendered.isBeta(node)
             // Verify that the symbol is not beta since it's unavailable in all the platforms.
             XCTAssertFalse(isBeta)
@@ -2119,22 +2118,22 @@ Document
     }
     
     func testRendersDeprecatedViolator() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
 
         // Make the referenced symbol deprecated
         do {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift)
             let node = try context.entity(with: reference)
             (node.semantic as? Symbol)?.availability = SymbolGraph.Symbol.Availability(availability: [
                 SymbolGraph.Symbol.Availability.AvailabilityItem(domain: .init(rawValue: "iOS"), introducedVersion: nil, deprecatedVersion: .init(major: 13, minor: 0, patch: 0), obsoletedVersion: nil, message: nil, renamed: nil, isUnconditionallyDeprecated: false, isUnconditionallyUnavailable: false, willEventuallyBeDeprecated: false),
             ])
         }
         
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift)
         let node = try context.entity(with: reference)
         let symbol = node.semantic as! Symbol
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = translator.visitSymbol(symbol) as! RenderNode
         
         // The reference is deprecated on all platforms
@@ -2142,11 +2141,11 @@ Document
     }
 
     func testDoesNotRenderDeprecatedViolator() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
 
         // Make the referenced symbol deprecated
         do {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift)
             let node = try context.entity(with: reference)
             (node.semantic as? Symbol)?.availability = SymbolGraph.Symbol.Availability(availability: [
                 SymbolGraph.Symbol.Availability.AvailabilityItem(domain: .init(rawValue: "iOS"), introducedVersion: .init(major: 13, minor: 0, patch: 0), deprecatedVersion: nil, obsoletedVersion: nil, message: nil, renamed: nil, isUnconditionallyDeprecated: false, isUnconditionallyUnavailable: false, willEventuallyBeDeprecated: false),
@@ -2154,11 +2153,11 @@ Document
             ])
         }
     
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift)
         let node = try context.entity(with: reference)
         let symbol = node.semantic as! Symbol
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = translator.visitSymbol(symbol) as! RenderNode
         
         // The reference is not deprecated on all platforms
@@ -2166,11 +2165,11 @@ Document
     }
     
     func testRendersDeprecatedViolatorForUnconditionallyDeprecatedReference() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
 
         // Make the referenced symbol deprecated
         do {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift)
             let node = try context.entity(with: reference)
             (node.semantic as? Symbol)?.availability = SymbolGraph.Symbol.Availability(availability: [
                 SymbolGraph.Symbol.Availability.AvailabilityItem(domain: .init(rawValue: "iOS"), introducedVersion: .init(major: 13, minor: 0, patch: 0), deprecatedVersion: nil, obsoletedVersion: nil, message: nil, renamed: nil, isUnconditionallyDeprecated: true, isUnconditionallyUnavailable: false, willEventuallyBeDeprecated: false),
@@ -2178,11 +2177,11 @@ Document
             ])
         }
 
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift)
         let node = try context.entity(with: reference)
         let symbol = node.semantic as! Symbol
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = translator.visitSymbol(symbol) as! RenderNode
         
         // Verify that the reference is deprecated on all platforms
@@ -2192,11 +2191,11 @@ Document
     func testRenderMetadataFragments() async throws {
         
         // Check for fragments in metadata in render node
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
         
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = translator.visit(symbol) as! RenderNode
         guard let fragments = renderNode.metadata.fragments else {
@@ -2212,24 +2211,24 @@ Document
     }
     
     func testRenderMetadataExtendedModule() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift))
         
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = try XCTUnwrap(translator.visit(symbol) as? RenderNode)
         XCTAssertEqual(renderNode.metadata.extendedModule, "MyKit")
     }
     
     func testDefaultImplementations() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         
         // Verify that the render reference to a required symbol includes the 'required' key and the number of default implementations provided.
         do {
-            let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideProtocol", sourceLanguage: .swift))
+            let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideProtocol", sourceLanguage: .swift))
             let symbol = node.semantic as! Symbol
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(symbol) as! RenderNode
 
             let requiredFuncReference = try XCTUnwrap(renderNode.references["doc://org.swift.docc.example/documentation/SideKit/SideProtocol/func()"])
@@ -2240,9 +2239,9 @@ Document
 
         // Verify that a required symbol includes a required metadata and default implementations
         do {
-            let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideProtocol/func()", sourceLanguage: .swift))
+            let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideProtocol/func()", sourceLanguage: .swift))
             let symbol = node.semantic as! Symbol
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(symbol) as! RenderNode
 
             // Verify that the render reference to a required symbol includes the 'required' key and the number of default implementations provided.
@@ -2256,13 +2255,13 @@ Document
     }
 
     func testDefaultImplementationsNotListedInTopics() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         
         // Verify that a required symbol does not include default implementations in Topics groups
         do {
-            let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideProtocol/func()", sourceLanguage: .swift))
+            let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideProtocol/func()", sourceLanguage: .swift))
             let symbol = node.semantic as! Symbol
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(symbol) as! RenderNode
 
             // Test that default implementations are listed ONLY under Default Implementations and not Topics
@@ -2274,11 +2273,11 @@ Document
     func testNoStringMetadata() async throws {
         
         // Check for fragments in metadata in render node
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
         
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = translator.visit(symbol) as! RenderNode
         let encoded = try JSONEncoder().encode(renderNode)
@@ -2303,11 +2302,11 @@ Document
     func testRenderDeclarations() async throws {
         
         // Check for fragments in metadata in render node
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
         
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = translator.visit(symbol) as! RenderNode
         
@@ -2322,11 +2321,11 @@ Document
 
     func testDocumentationRenderReferenceRoles() async throws {
         // Check for fragments in metadata in render node
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit", sourceLanguage: .swift))
         
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = translator.visit(symbol) as! RenderNode
 
@@ -2342,11 +2341,11 @@ Document
 
     func testTutorialsRenderReferenceRoles() async throws {
         // Check for fragments in metadata in render node
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/TestOverview", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/TestOverview", sourceLanguage: .swift))
         
         let symbol = node.semantic as! TutorialTableOfContents
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = translator.visit(symbol) as! RenderNode
 
@@ -2361,9 +2360,9 @@ Document
     
     func testRemovingTrailingNewLinesInDeclaration() async throws {
         // Check for fragments in metadata in render node
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
 
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/globalFunction(_:considering:)", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/globalFunction(_:considering:)", sourceLanguage: .swift))
         let symbol = node.semantic as! Symbol
 
         // Subheading with trailing "\n"
@@ -2372,7 +2371,7 @@ Document
         // Navigator title with trailing "\n"
         XCTAssertEqual(symbol.navigator?.count, 11)
 
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(symbol) as! RenderNode
 
         // Verify trailing newline removed from subheading
@@ -2384,11 +2383,11 @@ Document
     
     func testRenderManualSeeAlsoInArticles() async throws {
         // Check for fragments in metadata in render node
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Test-Bundle/article", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Test-Bundle/article", sourceLanguage: .swift))
         
         let article = node.semantic as! Article
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = translator.visit(article) as! RenderNode
         
@@ -2407,10 +2406,10 @@ Document
     
     func testSafeSectionAnchorNames() async throws {
         // Check that heading's anchor was safe-ified
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift))
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = translator.visit(symbol) as! RenderNode
         
@@ -2427,13 +2426,13 @@ Document
     }
     
     func testDuplicateNavigatorTitleIsRemoved() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
 
-        let myFuncReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/globalFunction(_:considering:)", sourceLanguage: .swift)
+        let myFuncReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/globalFunction(_:considering:)", sourceLanguage: .swift)
         let node = try context.entity(with: myFuncReference)
         let symbol = node.semantic as! Symbol
 
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         translator.collectedTopicReferences.append(myFuncReference)
         let renderNode = translator.visit(symbol) as! RenderNode
 
@@ -2443,13 +2442,13 @@ Document
     }
 
     func testNonDuplicateNavigatorTitleIsRendered() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
 
-        let myFuncReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyProtocol", sourceLanguage: .swift)
+        let myFuncReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyProtocol", sourceLanguage: .swift)
         let node = try context.entity(with: myFuncReference)
         let symbol = node.semantic as! Symbol
 
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(symbol) as! RenderNode
 
         let renderReference = try XCTUnwrap(renderNode.references[myFuncReference.absoluteString] as? TopicRenderReference)
@@ -2486,7 +2485,7 @@ Document
     ]
     
     func testBareTechnology() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { url in
             try """
             @Tutorials(name: "<#text#>") {
               @Intro(title: "<#text#>") {
@@ -2502,7 +2501,7 @@ Document
             """.write(to: url.appendingPathComponent("TestOverview.tutorial"), atomically: true, encoding: .utf8)
         }
         
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/TestOverview", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/TestOverview", sourceLanguage: .swift))
         
         guard let tutorialTableOfContentsDirective = node.markup as? BlockDirective else {
             XCTFail("Unexpected document structure, tutorial table-of-contents not found as first child.")
@@ -2510,38 +2509,38 @@ Document
         }
         
         var problems = [Problem]()
-        guard let tutorialTableOfContents = TutorialTableOfContents(from: tutorialTableOfContentsDirective, source: nil, for: bundle, problems: &problems) else {
+        guard let tutorialTableOfContents = TutorialTableOfContents(from: tutorialTableOfContentsDirective, source: nil, for: context.inputs, problems: &problems) else {
             XCTFail("Couldn't create tutorial from markup: \(problems)")
             return
         }
         
         XCTAssert(problems.filter { $0.diagnostic.severity == .error }.isEmpty, "Found errors when analyzing Tutorials overview.")
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         // Verify we don't crash.
         _ = translator.visit(tutorialTableOfContents)
         
         do {
-            let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/Test-Bundle/TestTutorial", sourceLanguage: .swift))
+            let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/Test-Bundle/TestTutorial", sourceLanguage: .swift))
             
             guard let technologyDirective = node.markup as? BlockDirective else {
                 XCTFail("Unexpected document structure, tutorial not found as first child.")
                 return
             }
             
-            guard let tutorial = Tutorial(from: technologyDirective, source: nil, for: bundle, problems: &problems) else {
+            guard let tutorial = Tutorial(from: technologyDirective, source: nil, for: context.inputs, problems: &problems) else {
                 XCTFail("Couldn't create tutorial from markup: \(problems)")
                 return
             }
         
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             XCTAssertNil(translator.visit(tutorial), "Render node for uncurated tutorial should not have been produced")
         }
     }
 
     func testBareTutorial() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { url in
             try """
             @Tutorial(time: <#number#>, projectFiles: <#.zip#>) {
               @Intro(title: "<#text#>") {
@@ -2594,7 +2593,7 @@ Document
             """.write(to: url.appendingPathComponent("TestTutorial.tutorial"), atomically: true, encoding: .utf8)
         }
         
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/Test-Bundle/TestTutorial", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/Test-Bundle/TestTutorial", sourceLanguage: .swift))
         
         guard let technologyDirective = node.markup as? BlockDirective else {
             XCTFail("Unexpected document structure, tutorial not found as first child.")
@@ -2602,14 +2601,14 @@ Document
         }
         
         var problems = [Problem]()
-        guard let tutorial = Tutorial(from: technologyDirective, source: nil, for: bundle, problems: &problems) else {
+        guard let tutorial = Tutorial(from: technologyDirective, source: nil, for: context.inputs, problems: &problems) else {
             XCTFail("Couldn't create tutorial from markup: \(problems)")
             return
         }
         
         XCTAssert(problems.filter { $0.diagnostic.severity == .error }.isEmpty, "Found errors when analyzing tutorial.")
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         // Verify we don't crash.
         _ = translator.visit(tutorial)
@@ -2619,7 +2618,7 @@ Document
     func testRenderAsides() async throws {
         let asidesSGFURL = Bundle.module.url(
             forResource: "Asides.symbols", withExtension: "json", subdirectory: "Test Resources")!
-        let (bundleURL, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { url in
+        let (bundleURL, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { url in
             try? FileManager.default.copyItem(at: asidesSGFURL, to: url.appendingPathComponent("Asides.symbols.json"))
         }
         defer {
@@ -2631,15 +2630,15 @@ Document
             let node = try context.entity(with: myFuncReference)
             let symbol = node.semantic as! Symbol
             
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(symbol) as! RenderNode
             let asides = try XCTUnwrap(renderNode.primaryContentSections.first(where: { $0.kind == .content }) as? ContentRenderSection)
             
             XCTAssertEqual(Array(asides.content.dropFirst()), self.asidesStressTest)
         }
         
-        let dashReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Asides/dashAsides()", sourceLanguage: .swift)
-        let quoteReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Asides/quoteAsides()", sourceLanguage: .swift)
+        let dashReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Asides/dashAsides()", sourceLanguage: .swift)
+        let quoteReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Asides/quoteAsides()", sourceLanguage: .swift)
         
         try testReference(dashReference)
         try testReference(quoteReference)
@@ -2647,9 +2646,9 @@ Document
 
     /// Tests parsing origin data from symbol graph.
     func testOriginMetadata() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let (_, context) = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
 
-        let myFuncReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClass/Element/inherited()", sourceLanguage: .swift)
+        let myFuncReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClass/Element/inherited()", sourceLanguage: .swift)
         let node = try context.entity(with: myFuncReference)
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
         let origin = try XCTUnwrap(symbol.origin)
@@ -2664,20 +2663,20 @@ Document
         let sgURL = Bundle.module.url(
             forResource: "LegacyBundle_DoNotUseInNewTests.docc/sidekit.symbols", withExtension: "json", subdirectory: "Test Bundles")!
 
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], externalResolvers: [:], externalSymbolResolver: nil, configureBundle: { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", configureBundle: { url in
             // Replace the out-of-bundle origin with a symbol from the same bundle.
             try String(contentsOf: sgURL)
                 .replacingOccurrences(of: #"identifier" : "s:OriginalUSR"#, with: #"identifier" : "s:5MyKit0A5MyProtocol0Afunc()"#)
                 .write(to: url.appendingPathComponent("sidekit.symbols.json"), atomically: true, encoding: .utf8)
         })
 
-        let myFuncReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClass/Element/inherited()", sourceLanguage: .swift)
+        let myFuncReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClass/Element/inherited()", sourceLanguage: .swift)
         let node = try context.entity(with: myFuncReference)
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
         
         // Verify that by default we inherit docs.
         do {
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = try XCTUnwrap(translator.visit(symbol) as? RenderNode)
 
             // Verify the expected inherited abstract text.
@@ -2690,7 +2689,7 @@ Document
         let sgURL = Bundle.module.url(
             forResource: "LegacyBundle_DoNotUseInNewTests.docc/sidekit.symbols", withExtension: "json", subdirectory: "Test Bundles")!
 
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], externalResolvers: [:], externalSymbolResolver: nil, configureBundle: { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", configureBundle: { url in
             // Replace the out-of-bundle origin with a symbol from the same bundle but
             // from the MyKit module.
             try String(contentsOf: sgURL)
@@ -2698,13 +2697,13 @@ Document
                 .write(to: url.appendingPathComponent("sidekit.symbols.json"), atomically: true, encoding: .utf8)
         })
 
-        let myFuncReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClass/Element/inherited()", sourceLanguage: .swift)
+        let myFuncReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClass/Element/inherited()", sourceLanguage: .swift)
         let node = try context.entity(with: myFuncReference)
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
         
         // Verify that by default we inherit docs.
         do {
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = try XCTUnwrap(translator.visit(symbol) as? RenderNode)
 
             // Verify the expected default abstract text.
@@ -2713,7 +2712,7 @@ Document
     }
     /// Tests that we generated an automatic abstract and remove source docs.
     func testDisabledDocInheritance() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
 
         // Verify that the inherited docs which should be ignored are not reference resolved.
         // Verify inherited docs are reference resolved and their problems are recorded.
@@ -2724,13 +2723,13 @@ Document
             return p.diagnostic.summary == "Resource 'my-inherited-image.png' couldn't be found"
         }))
 
-        let myFuncReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClass/Element/inherited()", sourceLanguage: .swift)
+        let myFuncReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClass/Element/inherited()", sourceLanguage: .swift)
         let node = try context.entity(with: myFuncReference)
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
         
         // Verify that by default we don't inherit docs and we generate default abstract.
         do {
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = try XCTUnwrap(translator.visit(symbol) as? RenderNode)
 
             // Verify the expected default abstract text.
@@ -2744,7 +2743,7 @@ Document
 
     /// Tests doc extensions are matched to inherited symbols
     func testInheritedSymbolDocExtension() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], externalResolvers: [:], externalSymbolResolver: nil, configureBundle: { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", configureBundle: { url in
             try? """
             # ``SideKit/SideClass/Element/inherited()``
             Doc extension abstract.
@@ -2753,13 +2752,13 @@ Document
             """.write(to: url.appendingPathComponent("inherited.md"), atomically: true, encoding: .utf8)
         })
         
-        let myFuncReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClass/Element/inherited()", sourceLanguage: .swift)
+        let myFuncReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClass/Element/inherited()", sourceLanguage: .swift)
         let node = try context.entity(with: myFuncReference)
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
         
         // Verify the doc extension was matched to the inherited symbol.
         do {
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = try XCTUnwrap(translator.visit(symbol) as? RenderNode)
 
             // Verify the expected default abstract text.
@@ -2887,7 +2886,7 @@ Document
         for testData in testData {
             let sgURL = Bundle.module.url(forResource: "LegacyBundle_DoNotUseInNewTests.docc/sidekit.symbols", withExtension: "json", subdirectory: "Test Bundles")!
          
-            let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], externalResolvers: [:], externalSymbolResolver: nil, configureBundle: { url in
+            let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", configureBundle: { url in
                 // Replace the out-of-bundle origin with a symbol from the same bundle but
                 // from the MyKit module.
                 var graph = try JSONDecoder().decode(SymbolGraph.self, from: Data(contentsOf: sgURL))
@@ -2898,13 +2897,13 @@ Document
                     .write(to: url.appendingPathComponent("sidekit.symbols.json"))
             })
             
-            let myFuncReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClass/Element/inherited()", sourceLanguage: .swift)
+            let myFuncReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClass/Element/inherited()", sourceLanguage: .swift)
             let node = try context.entity(with: myFuncReference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
             
             // Verify the doc extension was matched to the inherited symbol.
             do {
-                var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+                var translator = RenderNodeTranslator(context: context, identifier: node.reference)
                 let renderNode = try XCTUnwrap(translator.visit(symbol) as? RenderNode)
                 
                 // Verify the expected default abstract text.
@@ -2921,20 +2920,20 @@ Document
         var configuration = DocumentationContext.Configuration()
         configuration.externalMetadata.inheritDocs = true
         
-        let (_, bundle, context) = try await loadBundle(from: bundleURL, configuration: configuration)
+        let context = try await loadFromDisk(catalogURL: bundleURL, configuration: configuration)
 
         // Verify that we don't reference resolve inherited docs.
         XCTAssertFalse(context.diagnosticEngine.problems.contains(where: { problem in
             problem.diagnostic.summary.contains("my-inherited-image.png")
         }))
 
-        let myFuncReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClass/Element/inherited()", sourceLanguage: .swift)
+        let myFuncReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClass/Element/inherited()", sourceLanguage: .swift)
         let node = try context.entity(with: myFuncReference)
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
         
         // Verify that by default we don't inherit docs and we generate default abstract.
         do {
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = try XCTUnwrap(translator.visit(symbol) as? RenderNode)
 
             // Verify the expected default abstract text.
@@ -2961,13 +2960,13 @@ Document
     
     // Verifies that undocumented symbol gets a nil abstract.
     func testNonDocumentedSymbolNilAbstract() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
 
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/globalFunction(_:considering:)", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/globalFunction(_:considering:)", sourceLanguage: .swift)
         let node = try context.entity(with: reference)
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
 
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = try XCTUnwrap(translator.visit(symbol) as? RenderNode)
 
         // Verify that an undocumented symbol gets a nil abstract.
@@ -3069,7 +3068,7 @@ Document
 
     /// Tests links to symbols that have deprecation summary in markdown appear deprecated.
     func testLinkToDeprecatedSymbolViaDirectiveIsDeprecated() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], externalResolvers: [:], externalSymbolResolver: nil, configureBundle: { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", configureBundle: { url in
             try """
             # ``MyKit/MyProtocol``
             @DeprecationSummary {
@@ -3078,10 +3077,10 @@ Document
             """.write(to: url.appendingPathComponent("documentation").appendingPathComponent("myprotocol.md"), atomically: true, encoding: .utf8)
         })
         
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit", sourceLanguage: .swift))
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = try XCTUnwrap(translator.visit(symbol) as? RenderNode)
         
         let reference = try XCTUnwrap(renderNode.references["doc://org.swift.docc.example/documentation/MyKit/MyProtocol"] as? TopicRenderReference)
@@ -3089,7 +3088,7 @@ Document
     }
     
     func testCustomSymbolDisplayNames() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], externalResolvers: [:], externalSymbolResolver: nil, configureBundle: { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", configureBundle: { url in
             try """
             # ``MyKit``
             
@@ -3119,9 +3118,9 @@ Document
             """.write(to: url.appendingPathComponent("documentation").appendingPathComponent("myprotocol.md"), atomically: true, encoding: .utf8)
         })
          
-        let moduleReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit", sourceLanguage: .swift)
-        let protocolReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyProtocol", sourceLanguage: .swift)
-        let functionReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift)
+        let moduleReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit", sourceLanguage: .swift)
+        let protocolReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyProtocol", sourceLanguage: .swift)
+        let functionReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift)
         
         // Verify the MyKit module
         
@@ -3134,7 +3133,7 @@ Document
             XCTAssertEqual(titleVariant.variant, "My custom conceptual name")
         }
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: moduleNode.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: moduleNode.reference)
         let moduleRenderNode = try XCTUnwrap(translator.visit(moduleSymbol) as? RenderNode)
         
         XCTAssertEqual(moduleRenderNode.metadata.title, "My custom conceptual name")
@@ -3180,7 +3179,7 @@ Document
         
         let functionNode = try context.entity(with: functionReference)
         let functionSymbol = try XCTUnwrap(functionNode.semantic as? Symbol)
-        translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: functionNode.reference)
+        translator = RenderNodeTranslator(context: context, identifier: functionNode.reference)
         let functionRenderNode = try XCTUnwrap(translator.visit(functionSymbol) as? RenderNode)
         XCTAssertTrue(functionRenderNode.metadata.modulesVariants.variants.isEmpty)
         // Test that the symbol name `MyKit` is not added as a related module.
@@ -3198,18 +3197,18 @@ Document
         //   │ ╰ doc://com.test.TestBed/documentation/Minimal_docs/A/B-swift.struct/Equatable-Implementations
         //   │   ╰ doc://com.test.TestBed/documentation/Minimal_docs/A/B-swift.struct/!=(_:_:)
         //   ╰ doc://com.test.TestBed/documentation/Minimal_docs/A/b-swift.property
-        let (bundle, context) = try await testBundleAndContext(named: "InheritedUnderCollision")
+        let context = try await loadFromDisk(catalogName: "InheritedUnderCollision")
 
         // Verify that the inherited symbol got a path that accounts for the collision between
         // the struct `B` and the property `b`.
         
-        let inheritedSymbolReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Minimal_docs/A/B-swift.struct/!=(_:_:)", sourceLanguage: .swift)
+        let inheritedSymbolReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Minimal_docs/A/B-swift.struct/!=(_:_:)", sourceLanguage: .swift)
         XCTAssertNoThrow(try context.entity(with: inheritedSymbolReference))
         
         // Verify that the inherited symbol is automatically curated with its correct
         // reference path under the inherited symbols API collection
         
-        let equatableImplementationsReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Minimal_docs/A/B-swift.struct/Equatable-Implementations", sourceLanguage: .swift)
+        let equatableImplementationsReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Minimal_docs/A/B-swift.struct/Equatable-Implementations", sourceLanguage: .swift)
         let equatableImplementationsNode = try context.entity(with: equatableImplementationsReference)
         let equatableImplementationsArticle = try XCTUnwrap(equatableImplementationsNode.semantic as? Article)
         let group = try XCTUnwrap(equatableImplementationsArticle.automaticTaskGroups.first)
@@ -3219,7 +3218,7 @@ Document
     }
     
     func testVisitTutorialMediaWithoutExtension() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { url in
             try """
             @Tutorials(name: "Technology X") {
                @Intro(title: "Technology X") {
@@ -3241,17 +3240,17 @@ Document
             }
             """.write(to: url.appendingPathComponent("TestOverview.tutorial"), atomically: true, encoding: .utf8)
         }
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/TestOverview", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/TestOverview", sourceLanguage: .swift))
         guard let technologyDirective = node.markup as? BlockDirective else {
             XCTFail("Unexpected document structure, tutorial not found as first child.")
             return
         }
         var problems = [Problem]()
-        guard let tutorialTableOfContents = TutorialTableOfContents(from: technologyDirective, source: nil, for: bundle, problems: &problems) else {
+        guard let tutorialTableOfContents = TutorialTableOfContents(from: technologyDirective, source: nil, for: context.inputs, problems: &problems) else {
             XCTFail("Couldn't create technology from markup: \(problems)")
             return
         }
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = try XCTUnwrap(translator.visit(tutorialTableOfContents) as? RenderNode)
         XCTAssertEqual(renderNode.references.count, 5)
         XCTAssertNotNil(renderNode.references["doc://org.swift.docc.example/tutorials/Test-Bundle/TestTutorial"] as? TopicRenderReference)
@@ -3265,8 +3264,8 @@ Document
     }
     
     func testTopicsSectionWithAnonymousTopicGroup() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(
-            copying: "LegacyBundle_DoNotUseInNewTests",
+        let (_, context) = try await loadFromDisk(
+            copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests",
             configureBundle: { url in
                 try """
                 # Article
@@ -3286,14 +3285,14 @@ Document
         )
          
         let moduleReference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/Test-Bundle/article",
             sourceLanguage: .swift
         )
         
         let moduleNode = try context.entity(with: moduleReference)
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: moduleNode.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: moduleNode.reference)
         let moduleRenderNode = try XCTUnwrap(translator.visit(moduleNode.semantic) as? RenderNode)
         
         XCTAssertEqual(
@@ -3329,18 +3328,18 @@ Document
             """),
         ])
         
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
          
         let articleReference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/unit-test/Article",
             sourceLanguage: .swift
         )
         
         let articleNode = try context.entity(with: articleReference)
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: articleNode.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: articleNode.reference)
         let articleRenderNode = try XCTUnwrap(translator.visit(articleNode.semantic) as? RenderNode)
         
         XCTAssertEqual(
@@ -3356,7 +3355,7 @@ Document
     }
     
     func testLanguageSpecificTopicSections() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "MixedLanguageFrameworkWithLanguageRefinements") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "MixedLanguageFrameworkWithLanguageRefinements") { url in
             try """
             # ``MixedFramework/MyObjectiveCClassObjectiveCName``
             
@@ -3393,7 +3392,7 @@ Document
         let documentationNode = try context.entity(with: reference)
         XCTAssertEqual(documentationNode.availableVariantTraits.count, 2, "This page has Swift and Objective-C variants")
         
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
         let renderNode = converter.convert(documentationNode)
         
         let topicSectionsVariants = renderNode.topicSectionsVariants
@@ -3447,7 +3446,7 @@ Document
             - ``SomeClass4``
             """),
         ])
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         XCTAssert(context.problems.isEmpty, "\(context.problems.map(\.diagnostic.summary))")
         
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
@@ -3479,13 +3478,12 @@ Document
             ], file: file, line: line)
         }
         
-        let nodeConverter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let nodeConverter = DocumentationNodeConverter(context: context)
         assertExpectedTopicSections(nodeConverter.convert(documentationNode))
         
         let contextConverter = DocumentationContextConverter(
-            bundle: bundle,
             context: context,
-            renderContext: RenderContext(documentationContext: context, bundle: bundle)
+            renderContext: RenderContext(documentationContext: context)
         )
         try assertExpectedTopicSections(XCTUnwrap(contextConverter.renderNode(for: documentationNode)))
     }
@@ -3521,14 +3519,14 @@ Document
         let tempURL = try createTemporaryDirectory()
         let bundleURL = try exampleDocumentation.write(inside: tempURL)
         
-        let (_, bundle, context) = try await loadBundle(from: bundleURL, diagnosticEngine: .init() /* no diagnostic consumers */)
+        let context = try await loadFromDisk(catalogURL: bundleURL, diagnosticEngine: .init() /* no diagnostic consumers */)
         
         let reference = try XCTUnwrap(context.soleRootModuleReference)
         
         let documentationNode = try context.entity(with: reference)
         XCTAssertEqual(documentationNode.availableVariantTraits.count, 1)
         
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
         let renderNode = converter.convert(documentationNode)
         
         let topicSection = renderNode.topicSectionsVariants.defaultValue
@@ -3541,13 +3539,13 @@ Document
     }
     
     func testAutomaticCurationForRefinedSymbols() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(named: "GeometricalShapes")
+        let (_, context) = try await loadFromDisk(catalogName: "GeometricalShapes")
         
         do {
             let root = try XCTUnwrap(context.soleRootModuleReference)
             let node = try context.entity(with: root)
             
-            let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+            let converter = DocumentationNodeConverter(context: context)
             let renderNode = converter.convert(node)
             
             let swiftTopicSections = renderNode.topicSectionsVariants.defaultValue
@@ -3577,10 +3575,10 @@ Document
         }
         
         do {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/GeometricalShapes/Circle", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/GeometricalShapes/Circle", sourceLanguage: .swift)
             let node = try context.entity(with: reference)
             
-            let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+            let converter = DocumentationNodeConverter(context: context)
             let renderNode = converter.convert(node)
             
             let swiftTopicSections = renderNode.topicSectionsVariants.defaultValue
@@ -3626,9 +3624,9 @@ Document
         
         XCTAssertEqual(markup.childCount, 1)
         
-        let (bundle, context) = try await testBundleAndContext()
+        let context = try await makeEmptyContext()
         
-        var contentTranslator = RenderContentCompiler(context: context, bundle: bundle, identifier: ResolvedTopicReference(bundleID: bundle.id, path: "/TestThematicBreak", sourceLanguage: .swift))
+        var contentTranslator = RenderContentCompiler(context: context,  identifier: ResolvedTopicReference(bundleID: context.inputs.id, path: "/TestThematicBreak", sourceLanguage: .swift))
         
         let renderContent = try XCTUnwrap(markup.children.reduce(into: [], { result, item in result.append(contentsOf: contentTranslator.visit(item))}) as? [RenderBlockContent])
         let expectedContent: [RenderBlockContent] = [
@@ -3659,7 +3657,7 @@ Document
             ))
         ])
         
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         XCTAssertEqual(context.knownPages.map(\.path).sorted(), [
             "/documentation/ModuleName",
@@ -3672,7 +3670,7 @@ Document
         let unnamedStructReference = try XCTUnwrap(context.soleRootModuleReference).appendingPath("SomeContainer/struct_(unnamed)")
         let node = try context.entity(with: unnamedStructReference)
         
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
         let renderNode = converter.convert(node)
         
         XCTAssertEqual(renderNode.metadata.title, "struct (unnamed)")
diff --git a/Tests/SwiftDocCTests/Rendering/AutomaticSeeAlsoTests.swift b/Tests/SwiftDocCTests/Rendering/AutomaticSeeAlsoTests.swift
index 5ed6806cc6..89f28c018c 100644
--- a/Tests/SwiftDocCTests/Rendering/AutomaticSeeAlsoTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/AutomaticSeeAlsoTests.swift
@@ -18,7 +18,7 @@ class AutomaticSeeAlsoTests: XCTestCase {
     /// Test that a symbol with no authored See Also and with no curated siblings
     /// does not have a See Also section.
     func testNoSeeAlso() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             /// Extension that curates `SideClass`
             try """
             # ``SideKit``
@@ -31,7 +31,7 @@ class AutomaticSeeAlsoTests: XCTestCase {
         
         // Get a translated render node
         let node = try context.entity(with: ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/SideKit/SideClass", sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
         
         // Verify there is no See Also
@@ -41,7 +41,7 @@ class AutomaticSeeAlsoTests: XCTestCase {
     /// Test that a symbol with authored See Also and with no curated siblings
     /// does include an authored See Also section
     func testAuthoredSeeAlso() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             /// Extension that curates `SideClass`
             try """
             # ``SideKit``
@@ -62,7 +62,7 @@ class AutomaticSeeAlsoTests: XCTestCase {
         
         // Get a translated render node
         let node = try context.entity(with: ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/SideKit/SideClass", sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
         
         // Verify there is an authored See Also from markdown
@@ -77,7 +77,7 @@ class AutomaticSeeAlsoTests: XCTestCase {
     /// Test that a symbol with authored See Also and with curated siblings
     /// does include both in See Also with authored section first
     func testAuthoredAndAutomaticSeeAlso() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             /// Extension that curates `SideClass`
             try """
             # ``SideKit``
@@ -105,7 +105,7 @@ class AutomaticSeeAlsoTests: XCTestCase {
         
         // Get a translated render node
         let node = try context.entity(with: ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/SideKit/SideClass", sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
         
         // Verify there is an authored See Also & automatically created See Also
@@ -122,7 +122,7 @@ class AutomaticSeeAlsoTests: XCTestCase {
         // Verify that articles get same automatic See Also sections as symbols
         do {
             let node = try context.entity(with: ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/Test-Bundle/sidearticle", sourceLanguage: .swift))
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(node.semantic as! Article) as! RenderNode
             
             // Verify there is an automacially created See Also
@@ -138,7 +138,7 @@ class AutomaticSeeAlsoTests: XCTestCase {
     // Duplicate of the `testAuthoredAndAutomaticSeeAlso()` test above
     // but with automatic see also creation disabled
     func testAuthoredSeeAlsoWithDisabledAutomaticSeeAlso() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             /// Article that curates `SideClass`
             try """
             # ``SideKit``
@@ -172,7 +172,7 @@ class AutomaticSeeAlsoTests: XCTestCase {
         
         // Get a translated render node
         let node = try context.entity(with: ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/SideKit/SideClass", sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
         
         // Verify there is an authored See Also but no automatically created See Also
@@ -185,7 +185,7 @@ class AutomaticSeeAlsoTests: XCTestCase {
         // Verify that article without options directive still gets automatic See Also sections
         do {
             let node = try context.entity(with: ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/Test-Bundle/sidearticle", sourceLanguage: .swift))
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(node.semantic as! Article) as! RenderNode
             
             // Verify there is an automacially created See Also
@@ -201,7 +201,7 @@ class AutomaticSeeAlsoTests: XCTestCase {
     // Duplicate of the `testAuthoredAndAutomaticSeeAlso()` test above
     // but with automatic see also creation globally disabled
     func testAuthoredSeeAlsoWithGloballyDisabledAutomaticSeeAlso() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { root in
             /// Article that curates `SideClass`
             try """
             # ``SideKit``
@@ -236,7 +236,7 @@ class AutomaticSeeAlsoTests: XCTestCase {
         
         // Get a translated render node
         let node = try context.entity(with: ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/SideKit/SideClass", sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
         
         // Verify there is an authored See Also but no automatically created See Also
@@ -249,7 +249,7 @@ class AutomaticSeeAlsoTests: XCTestCase {
         // Verify that article without options directive still gets automatic See Also sections
         do {
             let node = try context.entity(with: ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/Test-Bundle/sidearticle", sourceLanguage: .swift))
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(node.semantic as! Article) as! RenderNode
             
             // Verify there is an automacially created See Also
@@ -283,11 +283,11 @@ class AutomaticSeeAlsoTests: XCTestCase {
         let tempURL = try createTemporaryDirectory()
         let bundleURL = try exampleDocumentation.write(inside: tempURL)
 
-        let (_, bundle, context) = try await loadBundle(from: bundleURL)
+        let context = try await loadFromDisk(catalogURL: bundleURL)
         
         // Get a translated render node
         let node = try context.entity(with: ResolvedTopicReference(bundleID: "MyKit", path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
         
         // Verify there is a See Also with the resolved tutorial reference
diff --git a/Tests/SwiftDocCTests/Rendering/AvailabilityRenderOrderTests.swift b/Tests/SwiftDocCTests/Rendering/AvailabilityRenderOrderTests.swift
index da55f59b47..04aaeec4f6 100644
--- a/Tests/SwiftDocCTests/Rendering/AvailabilityRenderOrderTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/AvailabilityRenderOrderTests.swift
@@ -18,7 +18,7 @@ class AvailabilityRenderOrderTests: XCTestCase {
         forResource: "Availability.symbols", withExtension: "json", subdirectory: "Test Resources")!
     
     func testSortingAtRenderTime() async throws {
-        let (bundleURL, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { url in
             let availabilitySymbolGraphURL = url.appendingPathComponent("Availability.symbols.json")
             try? FileManager.default.copyItem(at: self.availabilitySGFURL, to: availabilitySymbolGraphURL)
 
@@ -61,13 +61,10 @@ class AvailabilityRenderOrderTests: XCTestCase {
             let data = try jsonEncoder.encode(availabilitySymbolGraph)
             try data.write(to: availabilitySymbolGraphURL)
         }
-        defer {
-            try? FileManager.default.removeItem(at: bundleURL)
-        }
 
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Availability/MyStruct", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Availability/MyStruct", sourceLanguage: .swift))
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
         
         // Verify that all the symbol's availabilities were sorted into the order
diff --git a/Tests/SwiftDocCTests/Rendering/ConstraintsRenderSectionTests.swift b/Tests/SwiftDocCTests/Rendering/ConstraintsRenderSectionTests.swift
index cf83b6b49f..41baf26114 100644
--- a/Tests/SwiftDocCTests/Rendering/ConstraintsRenderSectionTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/ConstraintsRenderSectionTests.swift
@@ -19,7 +19,7 @@ fileprivate let jsonEncoder = JSONEncoder()
 class ConstraintsRenderSectionTests: XCTestCase {
     
     func testSingleConstraint() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { bundleURL in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { bundleURL in
             // Add constraints to `MyClass`
             let graphURL = bundleURL.appendingPathComponent("mykit-iOS.symbols.json")
             var graph = try jsonDecoder.decode(SymbolGraph.self, from: try Data(contentsOf: graphURL))
@@ -40,16 +40,16 @@ class ConstraintsRenderSectionTests: XCTestCase {
         }
 
         // Compile docs and verify contents
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visitSymbol(symbol) as! RenderNode
         
         XCTAssertEqual(renderNode.metadata.conformance?.constraints.map(flattenInlineElements).joined(), "Label is Text.")
     }
 
     func testSingleRedundantConstraint() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { bundleURL in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { bundleURL in
             // Add constraints to `MyClass`
             let graphURL = bundleURL.appendingPathComponent("mykit-iOS.symbols.json")
             var graph = try jsonDecoder.decode(SymbolGraph.self, from: try Data(contentsOf: graphURL))
@@ -70,15 +70,15 @@ class ConstraintsRenderSectionTests: XCTestCase {
         }
 
         // Compile docs and verify contents
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visitSymbol(symbol) as! RenderNode
         XCTAssertNil(renderNode.metadata.conformance)
     }
 
     func testSingleRedundantConstraintForLeaves() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { bundleURL in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { bundleURL in
             // Add constraints to `MyClass`
             let graphURL = bundleURL.appendingPathComponent("mykit-iOS.symbols.json")
             var graph = try jsonDecoder.decode(SymbolGraph.self, from: try Data(contentsOf: graphURL))
@@ -99,15 +99,15 @@ class ConstraintsRenderSectionTests: XCTestCase {
         }
 
         // Compile docs and verify contents
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift))
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visitSymbol(symbol) as! RenderNode
         XCTAssertNil(renderNode.metadata.conformance)
     }
 
     func testPreservesNonRedundantConstraints() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { bundleURL in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { bundleURL in
             // Add constraints to `MyClass`
             let graphURL = bundleURL.appendingPathComponent("mykit-iOS.symbols.json")
             var graph = try jsonDecoder.decode(SymbolGraph.self, from: try Data(contentsOf: graphURL))
@@ -129,15 +129,15 @@ class ConstraintsRenderSectionTests: XCTestCase {
         }
 
         // Compile docs and verify contents
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift))
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visitSymbol(symbol) as! RenderNode
         XCTAssertEqual(renderNode.metadata.conformance?.constraints.map(flattenInlineElements).joined(), "Element is MyClass.")
     }
 
     func testGroups2Constraints() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { bundleURL in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { bundleURL in
             // Add constraints to `MyClass`
             let graphURL = bundleURL.appendingPathComponent("mykit-iOS.symbols.json")
             var graph = try jsonDecoder.decode(SymbolGraph.self, from: try Data(contentsOf: graphURL))
@@ -159,15 +159,15 @@ class ConstraintsRenderSectionTests: XCTestCase {
         }
 
         // Compile docs and verify contents
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift))
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visitSymbol(symbol) as! RenderNode
         XCTAssertEqual(renderNode.metadata.conformance?.constraints.map(flattenInlineElements).joined(), "Element conforms to MyProtocol and Equatable.")
     }
 
     func testGroups3Constraints() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { bundleURL in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { bundleURL in
             // Add constraints to `MyClass`
             let graphURL = bundleURL.appendingPathComponent("mykit-iOS.symbols.json")
             var graph = try jsonDecoder.decode(SymbolGraph.self, from: try Data(contentsOf: graphURL))
@@ -190,15 +190,15 @@ class ConstraintsRenderSectionTests: XCTestCase {
         }
 
         // Compile docs and verify contents
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass/myFunction()", sourceLanguage: .swift))
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visitSymbol(symbol) as! RenderNode
         XCTAssertEqual(renderNode.metadata.conformance?.constraints.map(flattenInlineElements).joined(), "Element conforms to MyProtocol, Equatable, and Hashable.")
     }
 
     func testRenderReferences() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { bundleURL in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { bundleURL in
             // Add constraints to `MyClass`
             let graphURL = bundleURL.appendingPathComponent("mykit-iOS.symbols.json")
             var graph = try jsonDecoder.decode(SymbolGraph.self, from: try Data(contentsOf: graphURL))
@@ -220,9 +220,9 @@ class ConstraintsRenderSectionTests: XCTestCase {
         }
 
         // Compile docs and verify contents
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visitSymbol(symbol) as! RenderNode
         
         guard let renderReference = renderNode.references.first(where: { (key, value) -> Bool in
@@ -236,7 +236,7 @@ class ConstraintsRenderSectionTests: XCTestCase {
     }
 
     func testRenderReferencesWithNestedTypeInSelf() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { bundleURL in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { bundleURL in
             // Add constraints to `MyClass`
             let graphURL = bundleURL.appendingPathComponent("mykit-iOS.symbols.json")
             var graph = try jsonDecoder.decode(SymbolGraph.self, from: try Data(contentsOf: graphURL))
@@ -258,9 +258,9 @@ class ConstraintsRenderSectionTests: XCTestCase {
         }
 
         // Compile docs and verify contents
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass", sourceLanguage: .swift))
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visitSymbol(symbol) as! RenderNode
         
         guard let renderReference = renderNode.references.first(where: { (key, value) -> Bool in
diff --git a/Tests/SwiftDocCTests/Rendering/DeclarationsRenderSectionTests.swift b/Tests/SwiftDocCTests/Rendering/DeclarationsRenderSectionTests.swift
index 42c72aef04..aedae54126 100644
--- a/Tests/SwiftDocCTests/Rendering/DeclarationsRenderSectionTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/DeclarationsRenderSectionTests.swift
@@ -134,9 +134,9 @@ class DeclarationsRenderSectionTests: XCTestCase {
     }
 
     func testAlternateDeclarations() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "AlternateDeclarations")
+        let context = try await loadFromDisk(catalogName: "AlternateDeclarations")
         let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/AlternateDeclarations/MyClass/present(completion:)",
             sourceLanguage: .swift
         )
@@ -152,7 +152,7 @@ class DeclarationsRenderSectionTests: XCTestCase {
         }))
         
         // Verify that the rendered symbol displays both signatures
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode)
         let declarationsSection = try XCTUnwrap(renderNode.primaryContentSections.compactMap({ $0 as? DeclarationsRenderSection }).first)
 
@@ -210,15 +210,15 @@ class DeclarationsRenderSectionTests: XCTestCase {
                 JSONFile(name: "symbols\(forwards ? "2" : "1").symbols.json", content: symbolGraph2),
             ])
 
-            let (bundle, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
 
             let reference = ResolvedTopicReference(
-                bundleID: bundle.id,
+                bundleID: context.inputs.id,
                 path: "/documentation/PlatformSpecificDeclarations/myInit",
                 sourceLanguage: .swift
             )
             let symbol = try XCTUnwrap(context.entity(with: reference).semantic as? Symbol)
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+            var translator = RenderNodeTranslator(context: context, identifier: reference)
             let renderNode = try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode)
             let declarationsSection = try XCTUnwrap(renderNode.primaryContentSections.compactMap({ $0 as? DeclarationsRenderSection }).first)
             XCTAssertEqual(declarationsSection.declarations.count, 2)
@@ -249,7 +249,7 @@ class DeclarationsRenderSectionTests: XCTestCase {
             CopyOfFile(original: symbolGraphFile),
         ])
 
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
 
         // Make sure that type decorators like arrays, dictionaries, and optionals are correctly highlighted.
         do {
@@ -260,12 +260,12 @@ class DeclarationsRenderSectionTests: XCTestCase {
             // func overload1(param: Set<Int>) {}
             // func overload1(param: [Int: Int]) {}
             let reference = ResolvedTopicReference(
-                bundleID: bundle.id,
+                bundleID: context.inputs.id,
                 path: "/documentation/FancyOverloads/overload1(param:)",
                 sourceLanguage: .swift
             )
             let symbol = try XCTUnwrap(context.entity(with: reference).semantic as? Symbol)
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+            var translator = RenderNodeTranslator(context: context, identifier: reference)
             let renderNode = try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode)
             let declarationsSection = try XCTUnwrap(renderNode.primaryContentSections.compactMap({ $0 as? DeclarationsRenderSection }).first)
             XCTAssertEqual(declarationsSection.declarations.count, 1)
@@ -311,12 +311,12 @@ class DeclarationsRenderSectionTests: XCTestCase {
             // func overload2(p1: (Int) -> Int?, p2: Int) {}
             // func overload2(p1: ((Int) -> Int)?, p2: Int) {} // <- overload group
             let reference = ResolvedTopicReference(
-                bundleID: bundle.id,
+                bundleID: context.inputs.id,
                 path: "/documentation/FancyOverloads/overload2(p1:p2:)",
                 sourceLanguage: .swift
             )
             let symbol = try XCTUnwrap(context.entity(with: reference).semantic as? Symbol)
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+            var translator = RenderNodeTranslator(context: context, identifier: reference)
             let renderNode = try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode)
             let declarationsSection = try XCTUnwrap(renderNode.primaryContentSections.compactMap({ $0 as? DeclarationsRenderSection }).first)
             XCTAssertEqual(declarationsSection.declarations.count, 1)
@@ -366,12 +366,12 @@ class DeclarationsRenderSectionTests: XCTestCase {
             // func overload3<T: Hashable>(_ p: [T: T]) {}
             // func overload3<K: Hashable, V>(_ p: [K: V]) {}
             let reference = ResolvedTopicReference(
-                bundleID: bundle.id,
+                bundleID: context.inputs.id,
                 path: "/documentation/FancyOverloads/overload3(_:)",
                 sourceLanguage: .swift
             )
             let symbol = try XCTUnwrap(context.entity(with: reference).semantic as? Symbol)
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+            var translator = RenderNodeTranslator(context: context, identifier: reference)
             let renderNode = try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode)
             let declarationsSection = try XCTUnwrap(renderNode.primaryContentSections.compactMap({ $0 as? DeclarationsRenderSection }).first)
             XCTAssertEqual(declarationsSection.declarations.count, 1)
@@ -451,19 +451,16 @@ class DeclarationsRenderSectionTests: XCTestCase {
                     otherMixins: [reverseDeclarations ? declaration1 : declaration2]),
             ]
         })
-        let symbolGraph = makeSymbolGraph(moduleName: "FancierOverloads", symbols: symbols)
-
         let catalog = Folder(name: "unit-test.docc", content: [
             InfoPlist(displayName: "FancierOverloads", identifier: "com.test.example"),
-            JSONFile(name: "FancierOverloads.symbols.json", content: symbolGraph),
+            JSONFile(name: "FancierOverloads.symbols.json", content: makeSymbolGraph(moduleName: "FancierOverloads", symbols: symbols)),
         ])
-
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
 
         func assertDeclarations(for USR: String, file: StaticString = #filePath, line: UInt = #line) throws {
             let reference = try XCTUnwrap(context.documentationCache.reference(symbolID: USR), file: file, line: line)
             let symbol = try XCTUnwrap(context.entity(with: reference).semantic as? Symbol, file: file, line: line)
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+            var translator = RenderNodeTranslator(context: context, identifier: reference)
             let renderNode = try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode, file: file, line: line)
             let declarationsSection = try XCTUnwrap(renderNode.primaryContentSections.compactMap({ $0 as? DeclarationsRenderSection }).first, file: file, line: line)
             XCTAssertEqual(declarationsSection.declarations.count, 1, file: file, line: line)
@@ -495,16 +492,16 @@ class DeclarationsRenderSectionTests: XCTestCase {
             CopyOfFile(original: symbolGraphFile),
         ])
 
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
 
         for hash in ["7eht8", "8p1lo", "858ja"] {
             let reference = ResolvedTopicReference(
-                bundleID: bundle.id,
+                bundleID: context.inputs.id,
                 path: "/documentation/FancyOverloads/overload3(_:)-\(hash)",
                 sourceLanguage: .swift
             )
             let symbol = try XCTUnwrap(context.entity(with: reference).semantic as? Symbol)
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+            var translator = RenderNodeTranslator(context: context, identifier: reference)
             let renderNode = try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode)
             let declarationsSection = try XCTUnwrap(renderNode.primaryContentSections.compactMap({ $0 as? DeclarationsRenderSection }).first)
             XCTAssertEqual(declarationsSection.declarations.count, 1)
@@ -528,18 +525,18 @@ class DeclarationsRenderSectionTests: XCTestCase {
             CopyOfFile(original: symbolGraphFile),
         ])
 
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
 
         // MyClass<T>
         // - myFunc() where T: Equatable
         // - myFunc() where T: Hashable // <- overload group
         let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/ConformanceOverloads/MyClass/myFunc()",
             sourceLanguage: .swift
         )
         let symbol = try XCTUnwrap(context.entity(with: reference).semantic as? Symbol)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode)
         let declarationsSection = try XCTUnwrap(renderNode.primaryContentSections.compactMap({ $0 as? DeclarationsRenderSection }).first)
         XCTAssertEqual(declarationsSection.declarations.count, 1)
diff --git a/Tests/SwiftDocCTests/Rendering/DefaultAvailabilityTests.swift b/Tests/SwiftDocCTests/Rendering/DefaultAvailabilityTests.swift
index 597ecbd05b..2e99b28fa2 100644
--- a/Tests/SwiftDocCTests/Rendering/DefaultAvailabilityTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/DefaultAvailabilityTests.swift
@@ -18,8 +18,8 @@ class DefaultAvailabilityTests: XCTestCase {
 
     // Test whether missing default availability key correctly produces nil availability
     func testBundleWithoutDefaultAvailability() async throws {
-        let bundle = try await testBundle(named: "BundleWithoutAvailability")
-        XCTAssertNil(bundle.info.defaultAvailability)
+        let inputs = try await loadFromDisk(catalogName: "BundleWithoutAvailability").inputs
+        XCTAssertNil(inputs.info.defaultAvailability)
     }
 
     // Test resource with default availability included
@@ -34,7 +34,7 @@ class DefaultAvailabilityTests: XCTestCase {
     // Test whether the default availability is loaded from Info.plist and applied during render time
     func testBundleWithDefaultAvailability() async throws {
         // Copy an Info.plist with default availability
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { (url) in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { (url) in
             try? FileManager.default.removeItem(at: url.appendingPathComponent("Info.plist"))
             try? FileManager.default.copyItem(at: self.infoPlistAvailabilityURL, to: url.appendingPathComponent("Info.plist"))
             
@@ -57,7 +57,7 @@ class DefaultAvailabilityTests: XCTestCase {
         
         // Verify the bundle has loaded the default availability
         XCTAssertEqual(
-            bundle.info.defaultAvailability?
+            context.inputs.info.defaultAvailability?
                 .modules["MyKit"]?
                 .map({ "\($0.platformName.displayName) \($0.introducedVersion ?? "")" })
                 .sorted(),
@@ -65,7 +65,7 @@ class DefaultAvailabilityTests: XCTestCase {
         )
         
         // Bail the rendering part of the test if the availability hasn't been loaded
-        guard bundle.info.defaultAvailability != nil else {
+        guard context.inputs.info.defaultAvailability != nil else {
             return
         }
         
@@ -73,7 +73,7 @@ class DefaultAvailabilityTests: XCTestCase {
         do {
             let identifier = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/MyKit", fragment: nil, sourceLanguage: .swift)
             let node = try context.entity(with: identifier)
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(node.semantic) as! RenderNode
             
             XCTAssertEqual(renderNode.metadata.platforms?.map({ "\($0.name ?? "") \($0.introduced ?? "")" }).sorted(), expectedDefaultAvailability)
@@ -83,7 +83,7 @@ class DefaultAvailabilityTests: XCTestCase {
         do {
             let identifier = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/MyKit/MyClass/init()-3743d", fragment: nil, sourceLanguage: .swift)
             let node = try context.entity(with: identifier)
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(node.semantic) as! RenderNode
             
             XCTAssertEqual(renderNode.metadata.platforms?.map({ "\($0.name ?? "") \($0.introduced ?? "")" }).sorted(), ["Mac Catalyst ", "iOS ", "iPadOS ", "macOS 10.15.1"])
@@ -93,7 +93,7 @@ class DefaultAvailabilityTests: XCTestCase {
         do {
             let identifier = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/MyKit/MyClass", fragment: nil, sourceLanguage: .swift)
             let node = try context.entity(with: identifier)
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(node.semantic) as! RenderNode
             
             XCTAssertNotEqual(renderNode.metadata.platforms?.map({ "\($0.name ?? "") \($0.introduced ?? "")" }), expectedDefaultAvailability)
@@ -131,14 +131,14 @@ class DefaultAvailabilityTests: XCTestCase {
             JSONFile(name: "MyKit.symbols.json", content: makeSymbolGraph(moduleName: "MyKit")),
         ])
         
-        let (bundle, context) = try await loadBundle(catalog: catalog, configuration: configuration)
+        let context = try await load(catalog: catalog, configuration: configuration)
         let reference = try XCTUnwrap(context.soleRootModuleReference, file: file, line: line)
         
         // Test whether we:
         // 1) Fallback on iOS when Mac Catalyst availability is missing
         // 2) Render [Beta] or not for Mac Catalyst's inherited iOS availability
         let node = try context.entity(with: reference)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = translator.visit(node.semantic) as! RenderNode
         
         XCTAssertEqual(renderNode.metadata.platforms?.map({ "\($0.name ?? "") \($0.introduced ?? "")\($0.isBeta == true ? "(beta)" : "")" }).sorted(), expected, file: (file), line: line)
@@ -177,7 +177,7 @@ class DefaultAvailabilityTests: XCTestCase {
         // Set a beta status for the docs (which would normally be set via command line argument)
         configuration.externalMetadata.currentPlatforms = ["macOS": PlatformVersion(VersionTriplet(10, 16, 0), beta: true)]
         
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", configuration: configuration) { (url) in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", configuration: configuration) { (url) in
             // Copy an Info.plist with default availability of macOS 10.15.1
             try? FileManager.default.removeItem(at: url.appendingPathComponent("Info.plist"))
             try? FileManager.default.copyItem(at: self.infoPlistAvailabilityURL, to: url.appendingPathComponent("Info.plist"))
@@ -187,7 +187,7 @@ class DefaultAvailabilityTests: XCTestCase {
         do {
             let identifier = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/MyKit", fragment: nil, sourceLanguage: .swift)
             let node = try context.entity(with: identifier)
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(node.semantic) as! RenderNode
             
             XCTAssertEqual(renderNode.metadata.platforms?.map({ "\($0.name ?? "") \($0.introduced ?? "")\($0.isBeta == true ? "(beta)" : "")" }).sorted(), [
@@ -202,7 +202,7 @@ class DefaultAvailabilityTests: XCTestCase {
         var configuration = DocumentationContext.Configuration()
         // Set a beta status for the docs (which would normally be set via command line argument)
         configuration.externalMetadata.currentPlatforms = ["iOS": PlatformVersion(VersionTriplet(14, 0, 0), beta: true)]
-        let (_, bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests", configuration: configuration)
+        let (_, context) = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests", configuration: configuration)
         
         do {
             let identifier = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/MyKit/MyClass/myFunction()", fragment: nil, sourceLanguage: .swift)
@@ -218,7 +218,7 @@ class DefaultAvailabilityTests: XCTestCase {
                 SymbolGraph.Symbol.Availability.AvailabilityItem(domain: .init(rawValue: "macOS"), introducedVersion: nil, deprecatedVersion: nil, obsoletedVersion: nil, message: nil, renamed: nil, isUnconditionallyDeprecated: false, isUnconditionallyUnavailable: true, willEventuallyBeDeprecated: false),
             ])
             
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+            var translator = RenderNodeTranslator(context: context, identifier: node.reference)
             let renderNode = translator.visit(node.semantic) as! RenderNode
             
             // Verify that the 'watchOS' & 'tvOS' platforms are filtered out because the symbol is unavailable
@@ -329,14 +329,14 @@ class DefaultAvailabilityTests: XCTestCase {
     // Test that setting default availability doesn't prevent symbols with "universal" deprecation
     // (i.e. a platform of '*' and unconditional deprecation) from showing up as deprecated.
     func testUniversalDeprecationWithDefaultAvailability() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "BundleWithLonelyDeprecationDirective", excludingPaths: []) { (url) in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "BundleWithLonelyDeprecationDirective", excludingPaths: []) { (url) in
             try? FileManager.default.removeItem(at: url.appendingPathComponent("Info.plist"))
             try? FileManager.default.copyItem(at: self.infoPlistAvailabilityURL, to: url.appendingPathComponent("Info.plist"))
         }
         
         let node = try context.entity(
             with: ResolvedTopicReference(
-                bundleID: bundle.id,
+                bundleID: context.inputs.id,
                 path: "/documentation/CoolFramework/CoolClass/doUncoolThings(with:)",
                 sourceLanguage: .swift
             )
@@ -344,7 +344,7 @@ class DefaultAvailabilityTests: XCTestCase {
         
         // Compile docs and verify contents
         let symbol = node.semantic as! Symbol
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         guard let renderNode = translator.visit(symbol) as? RenderNode else {
             XCTFail("Could not compile the node")
@@ -409,7 +409,7 @@ class DefaultAvailabilityTests: XCTestCase {
             </plist>
             """
         
-        let decodedInfo = try DocumentationBundle.Info(from: Data(infoPlist.utf8))
+        let decodedInfo = try DocumentationContext.Inputs.Info(from: Data(infoPlist.utf8))
         let reEncodedInfo = try PropertyListEncoder().encode(decodedInfo.defaultAvailability)
         let defaultAvailability = try PropertyListDecoder().decode(
             DefaultAvailability.self,
@@ -565,7 +565,7 @@ class DefaultAvailabilityTests: XCTestCase {
         }
         func setupContext(
             defaultAvailability: String
-        ) async throws -> (DocumentationBundle, DocumentationContext) {
+        ) async throws -> DocumentationContext {
             // Create an empty bundle
             let targetURL = try createTemporaryDirectory(named: "test.docc")
             // Create symbol graph
@@ -575,9 +575,8 @@ class DefaultAvailabilityTests: XCTestCase {
             let infoPlistURL = targetURL.appendingPathComponent("Info.plist")
             let infoPlist = makeInfoPlist(defaultAvailability: defaultAvailability)
             try infoPlist.write(to: infoPlistURL, atomically: true, encoding: .utf8)
-            // Load the bundle & reference resolve symbol graph docs
-            let (_, bundle, context) = try await loadBundle(from: targetURL)
-            return (bundle, context)
+            let context = try await loadFromDisk(catalogURL: targetURL)
+            return context
         }
         
         let symbols = """
@@ -641,7 +640,7 @@ class DefaultAvailabilityTests: XCTestCase {
         
         // Don't use default availability version.
         
-        var (bundle, context) = try await setupContext(
+        var context = try await setupContext(
             defaultAvailability: """
                <dict>
                    <key>name</key>
@@ -667,14 +666,14 @@ class DefaultAvailabilityTests: XCTestCase {
         // Verify we remove the version from the module availability information.
         var identifier = ResolvedTopicReference(bundleID: "test", path: "/documentation/MyModule", fragment: nil, sourceLanguage: .swift)
         var node = try context.entity(with: identifier)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: identifier)
+        var translator = RenderNodeTranslator(context: context, identifier: identifier)
         var renderNode = translator.visit(node.semantic) as! RenderNode
         XCTAssertEqual(renderNode.metadata.platforms?.count, 1)
         XCTAssertEqual(renderNode.metadata.platforms?.first?.name, "iOS")
         XCTAssertEqual(renderNode.metadata.platforms?.first?.introduced, nil)
         
         // Add an extra default availability to test behaviour when mixin in source with default behaviour.
-        (bundle, context) = try await setupContext(defaultAvailability: """
+        context = try await setupContext(defaultAvailability: """
                <dict>
                    <key>name</key>
                    <string>iOS</string>
@@ -710,7 +709,7 @@ class DefaultAvailabilityTests: XCTestCase {
         // Verify the module availability shows as expected.
         identifier = ResolvedTopicReference(bundleID: "test", path: "/documentation/MyModule", fragment: nil, sourceLanguage: .swift)
         node = try context.entity(with: identifier)
-        translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: identifier)
+        translator = RenderNodeTranslator(context: context, identifier: identifier)
         renderNode = translator.visit(node.semantic) as! RenderNode
         XCTAssertEqual(renderNode.metadata.platforms?.count, 4)
         var moduleAvailability = try XCTUnwrap(renderNode.metadata.platforms?.first(where: {$0.name == "iOS"}))
diff --git a/Tests/SwiftDocCTests/Rendering/DefaultCodeListingSyntaxTests.swift b/Tests/SwiftDocCTests/Rendering/DefaultCodeListingSyntaxTests.swift
index 5f13c40852..bbf0951d52 100644
--- a/Tests/SwiftDocCTests/Rendering/DefaultCodeListingSyntaxTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/DefaultCodeListingSyntaxTests.swift
@@ -11,105 +11,62 @@
 import Foundation
 import XCTest
 @testable import SwiftDocC
+import SwiftDocCTestUtilities
 
 class DefaultCodeBlockSyntaxTests: XCTestCase {
-    enum Errors: Error {
-        case noCodeBlockFound
+    func testCodeBlockWithoutAnyLanguageOrDefault() async throws {
+        let codeListing = try await makeCodeBlock(fenceLanguage: nil, infoPlistLanguage: nil)
+        XCTAssertEqual(codeListing.language, nil)
     }
     
-    var renderSectionWithLanguageDefault: ContentRenderSection!
-    var renderSectionWithoutLanguageDefault: ContentRenderSection!
-
-    var testBundleWithLanguageDefault: DocumentationBundle!
-    var testBundleWithoutLanguageDefault: DocumentationBundle!
-
-    override func setUp() async throws {
-        try await super.setUp()
-        
-        func renderSection(for bundle: DocumentationBundle, in context: DocumentationContext) throws -> ContentRenderSection {
-            let identifier = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/Test-Bundle/Default-Code-Listing-Syntax", fragment: nil, sourceLanguage: .swift)
-
-            let node = try context.entity(with: identifier)
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
-            let renderNode = translator.visit(node.semantic) as! RenderNode
-
-            return renderNode.primaryContentSections.first! as! ContentRenderSection
-        }
-
-        let (_, bundleWithLanguageDefault, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests")
-
-        testBundleWithLanguageDefault = bundleWithLanguageDefault
-
-        // Copy the bundle but explicitly set `defaultCodeListingLanguage` to `nil` to mimic having no default language set.
-        testBundleWithoutLanguageDefault = DocumentationBundle(
-            info: DocumentationBundle.Info(
-                displayName: testBundleWithLanguageDefault.displayName,
-                id: testBundleWithLanguageDefault.id,
-                defaultCodeListingLanguage: nil
-            ),
-            baseURL: testBundleWithLanguageDefault.baseURL,
-            symbolGraphURLs: testBundleWithLanguageDefault.symbolGraphURLs,
-            markupURLs: testBundleWithLanguageDefault.markupURLs,
-            miscResourceURLs: testBundleWithLanguageDefault.miscResourceURLs
-        )
-
-        renderSectionWithLanguageDefault = try renderSection(for: testBundleWithLanguageDefault, in: context)
-        renderSectionWithoutLanguageDefault = try renderSection(for: testBundleWithoutLanguageDefault, in: context)
-    }
-
-    struct CodeListing {
-        var language: String?
-        var lines: [String]
+    func testExplicitFencedCodeBlockLanguage() async throws {
+        let codeListing = try await makeCodeBlock(fenceLanguage: "swift", infoPlistLanguage: nil)
+        XCTAssertEqual(codeListing.language, "swift")
     }
 
-    private func codeListing(at index: Int, in renderSection: ContentRenderSection, file: StaticString = #filePath, line: UInt = #line) throws -> CodeListing {
-        if case let .codeListing(l) = renderSection.content[index] {
-            return CodeListing(language: l.syntax, lines: l.code)
-        }
-
-        XCTFail("Expected code listing at index \(index)", file: (file), line: line)
-        throw Errors.noCodeBlockFound
+    func testDefaultCodeBlockLanguage() async throws {
+        let codeListing = try await makeCodeBlock(fenceLanguage: nil, infoPlistLanguage: "swift")
+        XCTAssertEqual(codeListing.language, "swift")
     }
 
-    func testDefaultCodeBlockSyntaxForFencedCodeListingWithoutExplicitLanguage() throws {
-        let fencedCodeListing = try codeListing(at: 1, in: renderSectionWithLanguageDefault)
-
-        XCTAssertEqual("swift", fencedCodeListing.language, "Default a language of 'CDDefaultCodeListingLanguage' if  it is set in the 'Info.plist'")
-
-        XCTAssertEqual(fencedCodeListing.lines, [
-            "// With no language set, this should highlight to 'swift' because the 'CDDefaultCodeListingLanguage' key is set to 'swift'.",
-            "func foo()",
-        ])
+    func testExplicitlySetLanguageOverridesDefaultLanguage() async throws {
+        let codeListing = try await makeCodeBlock(fenceLanguage: "objective-c", infoPlistLanguage: "swift")
+        XCTAssertEqual(codeListing.language, "objective-c", "The explicit language of the code listing should override the bundle's default language")
     }
 
-    func testDefaultCodeBlockSyntaxForNonFencedCodeListing() throws {
-        let indentedCodeListing = try codeListing(at: 2, in: renderSectionWithLanguageDefault)
-
-        XCTAssertEqual("swift", indentedCodeListing.language, "Default a language of 'CDDefaultCodeListingLanguage' if  it is set in the 'Info.plist'")
-        XCTAssertEqual(indentedCodeListing.lines, [
-            "/// This is a non fenced code listing and should also default to the 'CDDefaultCodeListingLanguage' language.",
-            "func foo()",
-        ])
+    private struct CodeListing {
+        var language: String?
+        var lines: [String]
     }
-
-    func testExplicitlySetLanguageOverridesBundleDefault() throws {
-        let explicitlySetLanguageCodeListing = try codeListing(at: 3, in: renderSectionWithLanguageDefault)
-
-        XCTAssertEqual("objective-c", explicitlySetLanguageCodeListing.language, "The explicit language of the code listing should override the bundle's default language")
-
-        XCTAssertEqual(explicitlySetLanguageCodeListing.lines, [
-            "/// This is a fenced code block with an explicit language set, and it should override the default language for the bundle.",
-            "- (void)foo;",
+    
+    private func makeCodeBlock(fenceLanguage: String?, infoPlistLanguage: String?) async throws -> CodeListing {
+        let catalog = Folder(name: "Something.docc", content: [
+            InfoPlist(defaultCodeListingLanguage: infoPlistLanguage),
+            
+            TextFile(name: "Root.md", utf8Content: """
+            # Root
+                
+            This article contains a code block
+            
+            ```\(fenceLanguage ?? "")
+            Some code goes 
+            ```
+            """)
         ])
-    }
-
-    func testHasNoLanguageWhenNoPlistKeySetAndNoExplicitLanguageProvided() throws {
-        let fencedCodeListing = try codeListing(at: 1, in: renderSectionWithoutLanguageDefault)
-        let indentedCodeListing = try codeListing(at: 2, in: renderSectionWithoutLanguageDefault)
-        let explicitlySetLanguageCodeListing = try codeListing(at: 3, in: renderSectionWithoutLanguageDefault)
-
-        XCTAssertEqual(fencedCodeListing.language, nil)
-        XCTAssertEqual(indentedCodeListing.language, nil)
-        XCTAssertEqual(explicitlySetLanguageCodeListing.language, "objective-c")
+        
+        let context = try await load(catalog: catalog)
+        let reference = try XCTUnwrap(context.soleRootModuleReference)
+        let converter = DocumentationNodeConverter(context: context)
+        
+        let renderNode = converter.convert(try context.entity(with: reference))
+        let renderSection = try XCTUnwrap(renderNode.primaryContentSections.first as? ContentRenderSection)
+        
+        guard case .codeListing(let codeListing)? = renderSection.content.last else {
+            struct Error: DescribedError {
+                let errorDescription = "Didn't fide code block is known markup"
+            }
+            throw Error()
+        }
+        return CodeListing(language: codeListing.syntax, lines: codeListing.code)
     }
 }
diff --git a/Tests/SwiftDocCTests/Rendering/DeprecationSummaryTests.swift b/Tests/SwiftDocCTests/Rendering/DeprecationSummaryTests.swift
index 9b6e4864fc..55a7a334e4 100644
--- a/Tests/SwiftDocCTests/Rendering/DeprecationSummaryTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/DeprecationSummaryTests.swift
@@ -31,12 +31,12 @@ class DeprecationSummaryTests: XCTestCase {
     /// This test verifies that a symbol's deprecation summary comes from its sidecar doc
     /// and it's preferred over the original deprecation note in the code docs.
     func testAuthoredDeprecatedSummary() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClass/init()", sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClass/init()", sourceLanguage: .swift))
         
         // Compile docs and verify contents
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = try XCTUnwrap(translator.visit(symbol) as? RenderNode, "Could not compile the node")
         XCTAssertEqual(renderNode.deprecationSummary?.firstParagraph, [.text("This initializer has been deprecated.")])
@@ -44,7 +44,7 @@ class DeprecationSummaryTests: XCTestCase {
 
     /// Test for a warning when symbol is not deprecated
     func testIncorrectlyAuthoredDeprecatedSummary() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], configureBundle: { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", configureBundle: { url in
             // Add a sidecar file with wrong deprecated summary
             try """
             # ``SideKit/SideClass``
@@ -63,11 +63,11 @@ class DeprecationSummaryTests: XCTestCase {
         })
         
         // Verify the deprecation is still rendered.
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClass", sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClass", sourceLanguage: .swift))
         
         // Compile docs and verify contents
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = try XCTUnwrap(translator.visit(symbol) as? RenderNode, "Could not compile the node")
         XCTAssertEqual(renderNode.deprecationSummary?.firstParagraph, [.text("This class has been deprecated.")])
@@ -80,10 +80,10 @@ class DeprecationSummaryTests: XCTestCase {
     /// and it's preferred over the original deprecation note in the code docs.
     /// (r69719494)
     func testAuthoredDeprecatedSummaryAsSoleItemInFile() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "BundleWithLonelyDeprecationDirective")
+        let context = try await loadFromDisk(catalogName: "BundleWithLonelyDeprecationDirective")
         let node = try context.entity(
             with: ResolvedTopicReference(
-                bundleID: bundle.id,
+                bundleID: context.inputs.id,
                 path: "/documentation/CoolFramework/CoolClass",
                 sourceLanguage: .swift
             )
@@ -91,7 +91,7 @@ class DeprecationSummaryTests: XCTestCase {
 
         // Compile docs and verify contents
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
 
         guard let renderNode = translator.visit(symbol) as? RenderNode else {
             XCTFail("Could not compile the node")
@@ -112,10 +112,10 @@ class DeprecationSummaryTests: XCTestCase {
     }
     
     func testSymbolDeprecatedSummary() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "BundleWithLonelyDeprecationDirective")
+        let context = try await loadFromDisk(catalogName: "BundleWithLonelyDeprecationDirective")
         let node = try context.entity(
             with: ResolvedTopicReference(
-                bundleID: bundle.id,
+                bundleID: context.inputs.id,
                 path: "/documentation/CoolFramework/CoolClass/doUncoolThings(with:)",
                 sourceLanguage: .swift
             )
@@ -123,7 +123,7 @@ class DeprecationSummaryTests: XCTestCase {
         
         // Compile docs and verify contents
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = try XCTUnwrap(translator.visit(symbol) as? RenderNode, "Could not compile the node")
 
@@ -134,39 +134,39 @@ class DeprecationSummaryTests: XCTestCase {
     }
   
     func testDeprecationOverride() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "BundleWithLonelyDeprecationDirective")
-      let node = try context.entity(
-          with: ResolvedTopicReference(
-            bundleID: bundle.id,
-              path: "/documentation/CoolFramework/CoolClass/init()",
-              sourceLanguage: .swift
-          )
-      )
-      
-      // Compile docs and verify contents
-      let symbol = try XCTUnwrap(node.semantic as? Symbol)
-      var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
-      
-      let renderNode = try XCTUnwrap(translator.visit(symbol) as? RenderNode, "Could not compile the node")
-
-      // `init()` has deprecation information in both the symbol graph and the documentation extension; when there are extra headings in an extension file, we need to make sure we correctly parse out the deprecation message from the extension and display that
-      XCTAssertEqual(renderNode.deprecationSummary?.firstParagraph, [
-        .text("Use the "),
-        .reference(
-            identifier: SwiftDocC.RenderReferenceIdentifier("doc://org.swift.docc.example/documentation/CoolFramework/CoolClass/init(config:cache:)"),
-            isActive: true,
-            overridingTitle: nil,
-            overridingTitleInlineContent: nil
-        ),
-        .text(" initializer instead."),
-    ])
-  }
+        let context = try await loadFromDisk(catalogName: "BundleWithLonelyDeprecationDirective")
+        let node = try context.entity(
+            with: ResolvedTopicReference(
+                bundleID: context.inputs.id,
+                path: "/documentation/CoolFramework/CoolClass/init()",
+                sourceLanguage: .swift
+            )
+        )
+        
+        // Compile docs and verify contents
+        let symbol = try XCTUnwrap(node.semantic as? Symbol)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
+        
+        let renderNode = try XCTUnwrap(translator.visit(symbol) as? RenderNode, "Could not compile the node")
+        
+        // `init()` has deprecation information in both the symbol graph and the documentation extension; when there are extra headings in an extension file, we need to make sure we correctly parse out the deprecation message from the extension and display that
+        XCTAssertEqual(renderNode.deprecationSummary?.firstParagraph, [
+            .text("Use the "),
+            .reference(
+                identifier: SwiftDocC.RenderReferenceIdentifier("doc://org.swift.docc.example/documentation/CoolFramework/CoolClass/init(config:cache:)"),
+                isActive: true,
+                overridingTitle: nil,
+                overridingTitleInlineContent: nil
+            ),
+            .text(" initializer instead."),
+        ])
+    }
     
     func testDeprecationSummaryInDiscussionSection() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "BundleWithLonelyDeprecationDirective")
+        let context = try await loadFromDisk(catalogName: "BundleWithLonelyDeprecationDirective")
         let node = try context.entity(
             with: ResolvedTopicReference(
-                bundleID: bundle.id,
+                bundleID: context.inputs.id,
                 path: "/documentation/CoolFramework/CoolClass/coolFunc()",
                 sourceLanguage: .swift
             )
@@ -174,7 +174,7 @@ class DeprecationSummaryTests: XCTestCase {
         
         // Compile docs and verify contents
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = try XCTUnwrap(translator.visit(symbol) as? RenderNode, "Could not compile the node")
 
@@ -192,10 +192,10 @@ class DeprecationSummaryTests: XCTestCase {
     }
     
     func testDeprecationSummaryWithMultiLineCommentSymbol() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "BundleWithLonelyDeprecationDirective")
+        let context = try await loadFromDisk(catalogName: "BundleWithLonelyDeprecationDirective")
         let node = try context.entity(
             with: ResolvedTopicReference(
-                bundleID: bundle.id,
+                bundleID: context.inputs.id,
                 path: "/documentation/CoolFramework/CoolClass/init(config:cache:)",
                 sourceLanguage: .swift
             )
@@ -203,7 +203,7 @@ class DeprecationSummaryTests: XCTestCase {
         
         // Compile docs and verify contents
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         
         let renderNode = try XCTUnwrap(translator.visit(symbol) as? RenderNode, "Could not compile the node")
         
diff --git a/Tests/SwiftDocCTests/Rendering/DocumentationContentRendererTests.swift b/Tests/SwiftDocCTests/Rendering/DocumentationContentRendererTests.swift
index 09ca5e064a..c24c9058f7 100644
--- a/Tests/SwiftDocCTests/Rendering/DocumentationContentRendererTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/DocumentationContentRendererTests.swift
@@ -139,8 +139,8 @@ private extension DocumentationDataVariantsTrait {
 
 private extension DocumentationContentRendererTests {
     func makeDocumentationContentRenderer() async throws -> DocumentationContentRenderer {
-        let (bundle, context) = try await testBundleAndContext()
-        return DocumentationContentRenderer(documentationContext: context, bundle: bundle)
+        let context = try await makeEmptyContext()
+        return DocumentationContentRenderer(documentationContext: context)
     }
     
     var nodeWithSubheadingAndNavigatorVariants: DocumentationNode {
diff --git a/Tests/SwiftDocCTests/Rendering/ExternalLinkTitleTests.swift b/Tests/SwiftDocCTests/Rendering/ExternalLinkTitleTests.swift
index 704d560817..4a7c56403f 100644
--- a/Tests/SwiftDocCTests/Rendering/ExternalLinkTitleTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/ExternalLinkTitleTests.swift
@@ -24,8 +24,8 @@ class ExternalLinkTitleTests: XCTestCase {
                                      semantic: Semantic())
         
         
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        let context = try await makeEmptyContext()
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let result = translator.visit(MarkupContainer(document.children)) as! [RenderBlockContent]
         
         return (translator, result)
diff --git a/Tests/SwiftDocCTests/Rendering/HeadingAnchorTests.swift b/Tests/SwiftDocCTests/Rendering/HeadingAnchorTests.swift
index 7565ed4c4a..71e5942024 100644
--- a/Tests/SwiftDocCTests/Rendering/HeadingAnchorTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/HeadingAnchorTests.swift
@@ -34,12 +34,12 @@ class HeadingAnchorTests: XCTestCase {
                 """),
             ])
         
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         
         let reference = try XCTUnwrap(context.soleRootModuleReference)
         let node = try context.entity(with: reference)
-        let renderContext = RenderContext(documentationContext: context, bundle: bundle)
-        let converter = DocumentationContextConverter(bundle: bundle, context: context, renderContext: renderContext)
+        let renderContext = RenderContext(documentationContext: context)
+        let converter = DocumentationContextConverter(context: context, renderContext: renderContext)
         let renderNode = try XCTUnwrap(converter.renderNode(for: node))
 
         // Check heading anchors are encoded
diff --git a/Tests/SwiftDocCTests/Rendering/LinkTitleResolverTests.swift b/Tests/SwiftDocCTests/Rendering/LinkTitleResolverTests.swift
index a4f52acfbd..2f5dc6b419 100644
--- a/Tests/SwiftDocCTests/Rendering/LinkTitleResolverTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/LinkTitleResolverTests.swift
@@ -14,7 +14,7 @@ import XCTest
 
 class LinkTitleResolverTests: XCTestCase {
     func testSymbolTitleResolving() async throws {
-        let (_, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         let resolver = LinkTitleResolver(context: context, source: nil)
         guard let reference = context.knownIdentifiers.filter({ ref -> Bool in
             return ref.path.hasSuffix("MyProtocol")
diff --git a/Tests/SwiftDocCTests/Rendering/MentionsRenderSectionTests.swift b/Tests/SwiftDocCTests/Rendering/MentionsRenderSectionTests.swift
index 3f981b3ca0..5134400450 100644
--- a/Tests/SwiftDocCTests/Rendering/MentionsRenderSectionTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/MentionsRenderSectionTests.swift
@@ -17,19 +17,19 @@ class MentionsRenderSectionTests: XCTestCase {
     /// pointing to the correct article.
     func testMentionedInSectionFull() async throws {
         enableFeatureFlag(\.isMentionedInEnabled)
-        let (bundle, context) = try await createMentionedInTestBundle()
+        let context = try await createMentionedInTestBundle()
         let identifier = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/MentionedIn/MyClass",
             sourceLanguage: .swift
         )
         let mentioningArticle = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/MentionedIn/ArticleMentioningSymbol",
             sourceLanguage: .swift
         )
         let node = try context.entity(with: identifier)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic) as! RenderNode
         let mentionsSection = try XCTUnwrap(renderNode.primaryContentSections.mapFirst { $0 as? MentionsRenderSection })
         XCTAssertEqual(1, mentionsSection.mentions.count)
@@ -40,14 +40,14 @@ class MentionsRenderSectionTests: XCTestCase {
     /// If there are no qualifying mentions of a symbol, the Mentioned In section should not appear.
     func testMentionedInSectionEmpty() async throws {
         enableFeatureFlag(\.isMentionedInEnabled)
-        let (bundle, context) = try await createMentionedInTestBundle()
+        let context = try await createMentionedInTestBundle()
         let identifier = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/MentionedIn/MyClass/myFunction()",
             sourceLanguage: .swift
         )
         let node = try context.entity(with: identifier)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic) as! RenderNode
         let mentionsSection = renderNode.primaryContentSections.mapFirst { $0 as? MentionsRenderSection }
         XCTAssertNil(mentionsSection)
diff --git a/Tests/SwiftDocCTests/Rendering/PageKindTests.swift b/Tests/SwiftDocCTests/Rendering/PageKindTests.swift
index 2f8c794c85..1775ec157e 100644
--- a/Tests/SwiftDocCTests/Rendering/PageKindTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/PageKindTests.swift
@@ -16,14 +16,14 @@ import XCTest
 class PageKindTests: XCTestCase {
     
     private func generateRenderNodeFromBundle(bundleName: String, resolvedTopicPath: String) async throws -> RenderNode {
-        let (bundle, context) = try await testBundleAndContext(named: bundleName)
+        let context = try await loadFromDisk(catalogName: bundleName)
         let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: resolvedTopicPath,
             sourceLanguage: .swift
         )
         let article = try XCTUnwrap(context.entity(with: reference).semantic as? Article)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         return try XCTUnwrap(translator.visitArticle(article) as? RenderNode)
     }
     
@@ -75,12 +75,12 @@ class PageKindTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
 
-        let (bundle, _) = try await testBundleAndContext(named: "SampleBundle")
+        let inputs = try await loadFromDisk(catalogName: "SampleBundle").inputs
 
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(Metadata.directiveName, directive.name)
-            let metadata = Metadata(from: directive, source: nil, for: bundle, problems: &problems)
+            let metadata = Metadata(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(metadata)
             XCTAssertNotNil(metadata?.pageKind)
             XCTAssertEqual(metadata?.pageKind?.kind, .article)
diff --git a/Tests/SwiftDocCTests/Rendering/PlatformAvailabilityTests.swift b/Tests/SwiftDocCTests/Rendering/PlatformAvailabilityTests.swift
index 59e48df45a..710e3cfcd8 100644
--- a/Tests/SwiftDocCTests/Rendering/PlatformAvailabilityTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/PlatformAvailabilityTests.swift
@@ -34,14 +34,14 @@ class PlatformAvailabilityTests: XCTestCase {
 
     /// Ensure that adding `@Available` directives in an article causes the final RenderNode to contain the appropriate availability data.
     func testPlatformAvailabilityFromArticle() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "AvailabilityBundle")
+        let context = try await loadFromDisk(catalogName: "AvailabilityBundle")
         let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/AvailableArticle",
             sourceLanguage: .swift
         )
         let article = try XCTUnwrap(context.entity(with: reference).semantic as? Article)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = try XCTUnwrap(translator.visitArticle(article) as? RenderNode)
         let availability = try XCTUnwrap(renderNode.metadata.platformsVariants.defaultValue)
         XCTAssertEqual(availability.count, 1)
@@ -53,14 +53,14 @@ class PlatformAvailabilityTests: XCTestCase {
 
     /// Ensure that adding `@Available` directives in an extension file overrides the symbol's availability.
     func testPlatformAvailabilityFromExtension() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "AvailabilityBundle")
+        let context = try await loadFromDisk(catalogName: "AvailabilityBundle")
         let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/MyKit/MyClass",
             sourceLanguage: .swift
         )
         let symbol = try XCTUnwrap(context.entity(with: reference).semantic as? Symbol)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode)
         let availability = try XCTUnwrap(renderNode.metadata.platformsVariants.defaultValue)
         XCTAssertEqual(availability.count, 1)
@@ -71,14 +71,14 @@ class PlatformAvailabilityTests: XCTestCase {
     }
 
     func testMultiplePlatformAvailabilityFromArticle() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "AvailabilityBundle")
+        let context = try await loadFromDisk(catalogName: "AvailabilityBundle")
         let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/AvailabilityBundle/ComplexAvailable",
             sourceLanguage: .swift
         )
         let article = try XCTUnwrap(context.entity(with: reference).semantic as? Article)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = try XCTUnwrap(translator.visitArticle(article) as? RenderNode)
         let availability = try XCTUnwrap(renderNode.metadata.platformsVariants.defaultValue)
         XCTAssertEqual(availability.count, 3)
@@ -99,14 +99,14 @@ class PlatformAvailabilityTests: XCTestCase {
     }
 
     func testArbitraryPlatformAvailability() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "AvailabilityBundle")
+        let context = try await loadFromDisk(catalogName: "AvailabilityBundle")
         let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/AvailabilityBundle/ArbitraryPlatforms",
             sourceLanguage: .swift
         )
         let article = try XCTUnwrap(context.entity(with: reference).semantic as? Article)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = try XCTUnwrap(translator.visitArticle(article) as? RenderNode)
         let availability = try XCTUnwrap(renderNode.metadata.platformsVariants.defaultValue)
         XCTAssertEqual(availability.count, 2)
@@ -124,15 +124,15 @@ class PlatformAvailabilityTests: XCTestCase {
     
     // Test that the Info.plist default availability does not affect the deprecated/unavailable availabilities provided by the symbol graph.
     func testAvailabilityParserWithInfoPlistDefaultAvailability() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "AvailabilityOverrideBundle")
+        let context = try await loadFromDisk(catalogName: "AvailabilityOverrideBundle")
 
         let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/MyKit/MyClass",
             sourceLanguage: .swift
         )
         let symbol = try XCTUnwrap(context.entity(with: reference).semantic as? Symbol)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode)
         let availability = try XCTUnwrap(renderNode.metadata.platformsVariants.defaultValue)
         XCTAssertEqual(availability.count, 5)
@@ -164,14 +164,14 @@ class PlatformAvailabilityTests: XCTestCase {
         let platformMetadata = [
             "iOS": PlatformVersion(VersionTriplet(16, 0, 0), beta: true),
         ]
-        let (bundle, context) = try await testBundleWithConfiguredPlatforms(named: "AvailabilityBundle", platformMetadata: platformMetadata)
+        let context = try await loadContextConfiguredPlatforms(named: "AvailabilityBundle", platformMetadata: platformMetadata)
         let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/AvailableArticle",
             sourceLanguage: .swift
         )
         let article = try XCTUnwrap(context.entity(with: reference).semantic as? Article)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = try XCTUnwrap(translator.visitArticle(article) as? RenderNode)
         let availability = try XCTUnwrap(renderNode.metadata.platformsVariants.defaultValue)
         XCTAssertEqual(availability.count, 1)
@@ -187,14 +187,14 @@ class PlatformAvailabilityTests: XCTestCase {
             "macOS": PlatformVersion(VersionTriplet(12, 0, 0), beta: true),
             "watchOS": PlatformVersion(VersionTriplet(7, 0, 0), beta: true),
         ]
-        let (bundle, context) = try await testBundleWithConfiguredPlatforms(named: "AvailabilityBundle", platformMetadata: platformMetadata)
+        let context = try await loadContextConfiguredPlatforms(named: "AvailabilityBundle", platformMetadata: platformMetadata)
         let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/AvailabilityBundle/ComplexAvailable",
             sourceLanguage: .swift
         )
         let article = try XCTUnwrap(context.entity(with: reference).semantic as? Article)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = try XCTUnwrap(translator.visitArticle(article) as? RenderNode)
         let availability = try XCTUnwrap(renderNode.metadata.platformsVariants.defaultValue)
         XCTAssertEqual(availability.count, 3)
@@ -219,14 +219,14 @@ class PlatformAvailabilityTests: XCTestCase {
         let platformMetadata = [
             "iOS": PlatformVersion(VersionTriplet(16, 0, 0), beta: true),
         ]
-        let (bundle, context) = try await testBundleWithConfiguredPlatforms(named: "AvailabilityBundle", platformMetadata: platformMetadata)
+        let context = try await loadContextConfiguredPlatforms(named: "AvailabilityBundle", platformMetadata: platformMetadata)
         let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/MyKit/MyClass",
             sourceLanguage: .swift
         )
         let symbol = try XCTUnwrap(context.entity(with: reference).semantic as? Symbol)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode)
         let availability = try XCTUnwrap(renderNode.metadata.platformsVariants.defaultValue)
         XCTAssertEqual(availability.count, 1)
@@ -236,13 +236,10 @@ class PlatformAvailabilityTests: XCTestCase {
         XCTAssert(iosAvailability.isBeta == true)
     }
 
-    
-    func testBundleWithConfiguredPlatforms(named testBundleName: String, platformMetadata: [String : PlatformVersion]) async throws -> (DocumentationBundle, DocumentationContext) {
-        let bundleURL = try XCTUnwrap(Bundle.module.url(forResource: testBundleName, withExtension: "docc", subdirectory: "Test Bundles"))
+    private func loadContextConfiguredPlatforms(named catalogName: String, platformMetadata: [String : PlatformVersion]) async throws -> DocumentationContext {
+        let catalogURL = try XCTUnwrap(Bundle.module.url(forResource: catalogName, withExtension: "docc", subdirectory: "Test Bundles"))
         var configuration = DocumentationContext.Configuration()
         configuration.externalMetadata.currentPlatforms = platformMetadata
-        let (_, bundle, context) = try await loadBundle(from: bundleURL, configuration: configuration)
-        return (bundle, context)
+        return try await loadFromDisk(catalogURL: catalogURL, configuration: configuration)
     }
-
 }
diff --git a/Tests/SwiftDocCTests/Rendering/PropertyListDetailsRenderSectionTests.swift b/Tests/SwiftDocCTests/Rendering/PropertyListDetailsRenderSectionTests.swift
index bfe5eddd00..f2f22d7701 100644
--- a/Tests/SwiftDocCTests/Rendering/PropertyListDetailsRenderSectionTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/PropertyListDetailsRenderSectionTests.swift
@@ -55,9 +55,9 @@ class PropertyListDetailsRenderSectionTests: XCTestCase {
             let catalog = Folder(name: "unit-test.docc", content: [
                 TextFile(name: "MyModule.symbols.json", utf8Content: symbolGraphString)
             ])
-            let (bundle, context) = try await loadBundle(catalog: catalog)
+            let context = try await load(catalog: catalog)
             let node = try XCTUnwrap(context.documentationCache["plist:propertylistkey"])
-            let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+            let converter = DocumentationNodeConverter(context: context)
             let renderNode = converter.convert(node)
             return try XCTUnwrap(renderNode.primaryContentSections.mapFirst(where: { $0 as? PropertyListDetailsRenderSection }))
         }
diff --git a/Tests/SwiftDocCTests/Rendering/RESTSymbolsTests.swift b/Tests/SwiftDocCTests/Rendering/RESTSymbolsTests.swift
index 8bb0b2c915..61289f9ae7 100644
--- a/Tests/SwiftDocCTests/Rendering/RESTSymbolsTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/RESTSymbolsTests.swift
@@ -330,10 +330,10 @@ class RESTSymbolsTests: XCTestCase {
                     )),
                 ] + extraFiles
             )
-            let (bundle, context) = try await loadBundle(catalog: catalog)
-            let moduleReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleName", sourceLanguage: .swift)
+            let context = try await load(catalog: catalog)
+            let moduleReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleName", sourceLanguage: .swift)
             let moduleSymbol = try XCTUnwrap((try context.entity(with: moduleReference)).semantic as? Symbol)
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: moduleReference)
+            var translator = RenderNodeTranslator(context: context, identifier: moduleReference)
             let renderNode = translator.visit(moduleSymbol) as! RenderNode
             return try XCTUnwrap((renderNode.references["doc://unit-test/documentation/ModuleName/plist-key-symbolname"] as? TopicRenderReference))
         }
diff --git a/Tests/SwiftDocCTests/Rendering/RenderBlockContent_ThematicBreakTests.swift b/Tests/SwiftDocCTests/Rendering/RenderBlockContent_ThematicBreakTests.swift
index 0ec1d9c8db..c37213bf92 100644
--- a/Tests/SwiftDocCTests/Rendering/RenderBlockContent_ThematicBreakTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/RenderBlockContent_ThematicBreakTests.swift
@@ -38,9 +38,9 @@ class RenderBlockContent_ThematicBreakTests: XCTestCase {
         
         XCTAssertEqual(markup.childCount, 3)
         
-        let (bundle, context) = try await testBundleAndContext()
+        let context = try await makeEmptyContext()
         
-        var contentTranslator = RenderContentCompiler(context: context, bundle: bundle, identifier: ResolvedTopicReference(bundleID: bundle.id, path: "/TestThematicBreak", sourceLanguage: .swift))
+        var contentTranslator = RenderContentCompiler(context: context, identifier: ResolvedTopicReference(bundleID: context.inputs.id, path: "/TestThematicBreak", sourceLanguage: .swift))
         
         let renderContent = try XCTUnwrap(markup.children.reduce(into: [], { result, item in result.append(contentsOf: contentTranslator.visit(item))}) as? [RenderBlockContent])
         let expectedContent: [RenderBlockContent] = [
@@ -65,9 +65,9 @@ class RenderBlockContent_ThematicBreakTests: XCTestCase {
         
         XCTAssertEqual(markup.childCount, 3)
         
-        let (bundle, context) = try await testBundleAndContext()
+        let context = try await makeEmptyContext()
         
-        var contentTranslator = RenderContentCompiler(context: context, bundle: bundle, identifier: ResolvedTopicReference(bundleID: bundle.id, path: "/TestThematicBreak", sourceLanguage: .swift))
+        var contentTranslator = RenderContentCompiler(context: context, identifier: ResolvedTopicReference(bundleID: context.inputs.id, path: "/TestThematicBreak", sourceLanguage: .swift))
         
         let renderContent = try XCTUnwrap(markup.children.reduce(into: [], { result, item in result.append(contentsOf: contentTranslator.visit(item))}) as? [RenderBlockContent])
         let expectedContent: [RenderBlockContent] = [
@@ -95,9 +95,9 @@ class RenderBlockContent_ThematicBreakTests: XCTestCase {
         
         XCTAssertEqual(markup.childCount, 6)
         
-        let (bundle, context) = try await testBundleAndContext()
+        let context = try await makeEmptyContext()
         
-        var contentTranslator = RenderContentCompiler(context: context, bundle: bundle, identifier: ResolvedTopicReference(bundleID: bundle.id, path: "/TestThematicBreak", sourceLanguage: .swift))
+        var contentTranslator = RenderContentCompiler(context: context, identifier: ResolvedTopicReference(bundleID: context.inputs.id, path: "/TestThematicBreak", sourceLanguage: .swift))
         
         let renderContent = try XCTUnwrap(markup.children.reduce(into: [], { result, item in result.append(contentsOf: contentTranslator.visit(item))}) as? [RenderBlockContent])
         let expectedContent: [RenderBlockContent] = [
diff --git a/Tests/SwiftDocCTests/Rendering/RenderContentCompilerTests.swift b/Tests/SwiftDocCTests/Rendering/RenderContentCompilerTests.swift
index 8a23b1324a..9324097cb3 100644
--- a/Tests/SwiftDocCTests/Rendering/RenderContentCompilerTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/RenderContentCompilerTests.swift
@@ -15,8 +15,8 @@ import XCTest
 
 class RenderContentCompilerTests: XCTestCase {
     func testLinkOverrideTitle() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        var compiler = RenderContentCompiler(context: context, bundle: bundle, identifier: ResolvedTopicReference(bundleID: bundle.id, path: "/path", fragment: nil, sourceLanguage: .swift))
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
+        var compiler = RenderContentCompiler(context: context, identifier: ResolvedTopicReference(bundleID: context.inputs.id, path: "/path", fragment: nil, sourceLanguage: .swift))
 
         let source = """
         [Example](http://example.com)
@@ -133,8 +133,8 @@ class RenderContentCompilerTests: XCTestCase {
     }
     
     func testLineBreak() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        var compiler = RenderContentCompiler(context: context, bundle: bundle, identifier: ResolvedTopicReference(bundleID: bundle.id, path: "/path", fragment: nil, sourceLanguage: .swift))
+        let context = try await makeEmptyContext()
+        var compiler = RenderContentCompiler(context: context, identifier: ResolvedTopicReference(bundleID: context.inputs.id, path: "/path", fragment: nil, sourceLanguage: .swift))
 
         let source = #"""
         Backslash before new line\
@@ -198,8 +198,8 @@ class RenderContentCompilerTests: XCTestCase {
     }
     
     func testThematicBreak() async throws {
-        let (bundle, context) = try await testBundleAndContext()
-        var compiler = RenderContentCompiler(context: context, bundle: bundle, identifier: ResolvedTopicReference(bundleID: bundle.id, path: "/path", fragment: nil, sourceLanguage: .swift))
+        let context = try await makeEmptyContext()
+        var compiler = RenderContentCompiler(context: context, identifier: ResolvedTopicReference(bundleID: context.inputs.id, path: "/path", fragment: nil, sourceLanguage: .swift))
         
 
         let source = #"""
diff --git a/Tests/SwiftDocCTests/Rendering/RenderMetadataTests.swift b/Tests/SwiftDocCTests/Rendering/RenderMetadataTests.swift
index d07e2e629f..9d52f4e4dd 100644
--- a/Tests/SwiftDocCTests/Rendering/RenderMetadataTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/RenderMetadataTests.swift
@@ -73,10 +73,10 @@ class RenderMetadataTests: XCTestCase {
         var typesOfPages = [Tutorial.self, TutorialTableOfContents.self, Article.self, TutorialArticle.self, Symbol.self]
         
         for bundleName in ["LegacyBundle_DoNotUseInNewTests"] {
-            let (bundle, context) = try await testBundleAndContext(named: bundleName)
+            let context = try await loadFromDisk(catalogName: bundleName)
             
-            let renderContext = RenderContext(documentationContext: context, bundle: bundle)
-            let converter = DocumentationContextConverter(bundle: bundle, context: context, renderContext: renderContext)
+            let renderContext = RenderContext(documentationContext: context)
+            let converter = DocumentationContextConverter(context: context, renderContext: renderContext)
             for identifier in context.knownPages {
                 let entity = try context.entity(with: identifier)
                 let renderNode = try XCTUnwrap(converter.renderNode(for: entity))
@@ -93,14 +93,14 @@ class RenderMetadataTests: XCTestCase {
     /// Test that a bystanders symbol graph is loaded, symbols are merged into the main module
     /// and the bystanders are included in the render node metadata.
     func testRendersBystandersFromSymbolGraph() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [:]) { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [:]) { url in
             let bystanderSymbolGraphURL = Bundle.module.url(
                 forResource: "MyKit@Foundation@_MyKit_Foundation.symbols", withExtension: "json", subdirectory: "Test Resources")!
             try FileManager.default.copyItem(at: bystanderSymbolGraphURL, to: url.appendingPathComponent("MyKit@Foundation@_MyKit_Foundation.symbols.json"))
         }
 
         // Verify the symbol from bystanders graph is present in the documentation context.
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/MyKit/MyClass/myFunction1()", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/MyKit/MyClass/myFunction1()", sourceLanguage: .swift)
         let entity = try XCTUnwrap(try? context.entity(with: reference))
         let symbol = try XCTUnwrap(entity.semantic as? Symbol)
         
@@ -108,7 +108,7 @@ class RenderMetadataTests: XCTestCase {
         XCTAssertEqual(symbol.crossImportOverlayModule?.bystanderModules, ["Foundation"])
         
         // Verify the rendered metadata contains the bystanders
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
         let renderNode = converter.convert(entity)
         XCTAssertEqual(renderNode.metadata.modules?.first?.name, "MyKit")
         XCTAssertEqual(renderNode.metadata.modules?.first?.relatedModules, ["Foundation"])
@@ -119,7 +119,7 @@ class RenderMetadataTests: XCTestCase {
     func testRendersBystanderExtensionsFromSymbolGraph() async throws {
         throw XCTSkip("Fails in CI. rdar://159615046")
 
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [:]) { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", externalResolvers: [:]) { url in
             let baseSymbolGraphURL = Bundle.module.url(
                 forResource: "BaseKit.symbols", withExtension: "json", subdirectory: "Test Resources")!
             try FileManager.default.copyItem(at: baseSymbolGraphURL, to: url.appendingPathComponent("BaseKit.symbols.json"))
@@ -129,7 +129,7 @@ class RenderMetadataTests: XCTestCase {
         }
 
         // Verify the symbol from bystanders graph is present in the documentation context.
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/BaseKit/OtherStruct/someFunc()", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/BaseKit/OtherStruct/someFunc()", sourceLanguage: .swift)
         let entity = try XCTUnwrap(try? context.entity(with: reference))
         let symbol = try XCTUnwrap(entity.semantic as? Symbol)
 
@@ -137,14 +137,14 @@ class RenderMetadataTests: XCTestCase {
         XCTAssertEqual(symbol.crossImportOverlayModule?.bystanderModules, ["BaseKit"])
 
         // Verify the rendered metadata contains the bystanders
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
         let renderNode = converter.convert(entity)
         XCTAssertEqual(renderNode.metadata.modules?.first?.name, "OverlayTest")
         XCTAssertEqual(renderNode.metadata.modules?.first?.relatedModules, ["BaseKit"])
     }
 
     func testRendersExtensionSymbolsWithBystanderModules() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "BundleWithRelativePathAmbiguity") { root in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "BundleWithRelativePathAmbiguity") { root in
             // We don't want the external target to be part of the archive as that is not
             // officially supported yet.
             try FileManager.default.removeItem(at: root.appendingPathComponent("Dependency.symbols.json"))
@@ -152,7 +152,7 @@ class RenderMetadataTests: XCTestCase {
 
         // Get a translated render node
         let node = try context.entity(with: ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/BundleWithRelativePathAmbiguity/Dependency/AmbiguousType", sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
         XCTAssertEqual(renderNode.metadata.modules?.first?.name, "BundleWithRelativePathAmbiguity")
         XCTAssertEqual(renderNode.metadata.modules?.first?.relatedModules, ["Dependency"])
diff --git a/Tests/SwiftDocCTests/Rendering/RenderNodeTranslatorSymbolVariantsTests.swift b/Tests/SwiftDocCTests/Rendering/RenderNodeTranslatorSymbolVariantsTests.swift
index 31504330f9..977efbdef9 100644
--- a/Tests/SwiftDocCTests/Rendering/RenderNodeTranslatorSymbolVariantsTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/RenderNodeTranslatorSymbolVariantsTests.swift
@@ -510,7 +510,7 @@ class RenderNodeTranslatorSymbolVariantsTests: XCTestCase {
             ]))
         ])
         
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let moduleReference = try XCTUnwrap(context.soleRootModuleReference)
         let dictionaryReference = moduleReference.appendingPath("SomeDictionary")
         
@@ -521,7 +521,7 @@ class RenderNodeTranslatorSymbolVariantsTests: XCTestCase {
             symbol.dictionaryKeysSection = dictionaryKeysSection
             context.documentationCache[dictionaryReference] = node
             
-            let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+            let converter = DocumentationNodeConverter(context: context)
             let renderNode = converter.convert(node)
             
             return try XCTUnwrap(renderNode.primaryContentSections.mapFirst(where: { $0 as? PropertiesRenderSection }))
@@ -1167,10 +1167,10 @@ class RenderNodeTranslatorSymbolVariantsTests: XCTestCase {
         assertAfterApplyingVariant: (RenderNode) throws -> () = { _ in },
         assertDataAfterApplyingVariant: (Data) throws -> () = { _ in }
     ) async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: bundleName)
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: bundleName)
         
         let identifier = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/MyKit/MyClass",
             sourceLanguage: .swift
         )
@@ -1187,7 +1187,6 @@ class RenderNodeTranslatorSymbolVariantsTests: XCTestCase {
         try assertMultiLanguageSemantic(
             symbol,
             context: context,
-            bundle: bundle,
             identifier: identifier,
             configureRenderNodeTranslator: configureRenderNodeTranslator,
             assertOriginalRenderNode: assertOriginalRenderNode,
@@ -1204,10 +1203,10 @@ class RenderNodeTranslatorSymbolVariantsTests: XCTestCase {
         assertAfterApplyingVariant: (RenderNode) throws -> () = { _ in },
         assertDataAfterApplyingVariant: (Data) throws -> () = { _ in }
     ) async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests")
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests")
         
         let identifier = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/Test-Bundle/article",
             sourceLanguage: .swift
         )
@@ -1224,7 +1223,6 @@ class RenderNodeTranslatorSymbolVariantsTests: XCTestCase {
         try assertMultiLanguageSemantic(
             article,
             context: context,
-            bundle: bundle,
             identifier: identifier,
             assertOriginalRenderNode: assertOriginalRenderNode,
             assertAfterApplyingVariant: assertAfterApplyingVariant,
@@ -1235,14 +1233,13 @@ class RenderNodeTranslatorSymbolVariantsTests: XCTestCase {
     private func assertMultiLanguageSemantic(
         _ semantic: Semantic,
         context: DocumentationContext,
-        bundle: DocumentationBundle,
         identifier: ResolvedTopicReference,
         configureRenderNodeTranslator: (inout RenderNodeTranslator) -> () = { _ in },
         assertOriginalRenderNode: (RenderNode) throws -> (),
         assertAfterApplyingVariant: (RenderNode) throws -> (),
         assertDataAfterApplyingVariant: (Data) throws -> () = { _ in }
     ) throws {
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: identifier)
+        var translator = RenderNodeTranslator(context: context, identifier: identifier)
         
         configureRenderNodeTranslator(&translator)
         
@@ -1306,7 +1303,7 @@ class RenderNodeTranslatorSymbolVariantsTests: XCTestCase {
     
     private func makeSymbolAvailableInSwiftAndObjectiveC(
         symbolPath: String,
-        id: DocumentationBundle.Identifier,
+        id: DocumentationContext.Inputs.Identifier,
         context: DocumentationContext
     ) throws {
         let reference = ResolvedTopicReference(bundleID: id, path: symbolPath, sourceLanguage: .swift)
diff --git a/Tests/SwiftDocCTests/Rendering/RenderNodeTranslatorTests.swift b/Tests/SwiftDocCTests/Rendering/RenderNodeTranslatorTests.swift
index c2fe00d4fe..fee5213126 100644
--- a/Tests/SwiftDocCTests/Rendering/RenderNodeTranslatorTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/RenderNodeTranslatorTests.swift
@@ -17,11 +17,11 @@ import SymbolKit
 
 class RenderNodeTranslatorTests: XCTestCase {
     private func findDiscussion(forSymbolPath: String, configureBundle: ((URL) throws -> Void)? = nil) async throws -> ContentRenderSection? {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", configureBundle: configureBundle)
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", configureBundle: configureBundle)
         
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: forSymbolPath, sourceLanguage: .swift))
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: forSymbolPath, sourceLanguage: .swift))
         
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic as! Symbol) as! RenderNode
         
         guard let section = renderNode.primaryContentSections.last(where: { section -> Bool in
@@ -223,7 +223,7 @@ class RenderNodeTranslatorTests: XCTestCase {
     }
             
     func testArticleRoles() async throws {
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests").inputs
         var problems = [Problem]()
         
         // Verify article's role
@@ -236,7 +236,7 @@ class RenderNodeTranslatorTests: XCTestCase {
             """
             let document = Document(parsing: source, options: .parseBlockDirectives)
             let article = try XCTUnwrap(
-                Article(from: document.root, source: nil, for: bundle, problems: &problems)
+                Article(from: document.root, source: nil, for: inputs, problems: &problems)
             )
             XCTAssertEqual(RenderMetadata.Role.article, DocumentationContentRenderer.roleForArticle(article, nodeKind: .article))
         }
@@ -256,7 +256,7 @@ class RenderNodeTranslatorTests: XCTestCase {
 
             // Verify a collection group
             let article1 = try XCTUnwrap(
-                Article(from: document.root, source: nil, for: bundle, problems: &problems)
+                Article(from: document.root, source: nil, for: inputs, problems: &problems)
             )
             XCTAssertEqual(RenderMetadata.Role.collectionGroup, DocumentationContentRenderer.roleForArticle(article1, nodeKind: .article))
             
@@ -272,7 +272,7 @@ class RenderNodeTranslatorTests: XCTestCase {
 
             // Verify a collection
             let article2 = try XCTUnwrap(
-                Article(from: metadataDocument.root, source: nil, for: bundle, problems: &problems)
+                Article(from: metadataDocument.root, source: nil, for: inputs, problems: &problems)
             )
             XCTAssertEqual(RenderMetadata.Role.collection, DocumentationContentRenderer.roleForArticle(article2, nodeKind: .article))
         }
@@ -281,7 +281,7 @@ class RenderNodeTranslatorTests: XCTestCase {
     // Verifies that links to sections include their container's abstract rdar://72110558
     func testSectionAbstracts() async throws {
         // Create an article including a link to a tutorial section
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], configureBundle: { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], configureBundle: { url in
             try """
             # Article
             Article abstract
@@ -291,10 +291,10 @@ class RenderNodeTranslatorTests: XCTestCase {
             """.write(to: url.appendingPathComponent("article.md"), atomically: true, encoding: .utf8)
         })
 
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Test-Bundle/article", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Test-Bundle/article", sourceLanguage: .swift)
         let node = try context.entity(with: reference)
         let article = try XCTUnwrap(node.semantic as? Article)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderedNode = translator.visit(article) as! RenderNode
 
         // Verify that the render reference to a section includes the container symbol's abstract
@@ -303,7 +303,7 @@ class RenderNodeTranslatorTests: XCTestCase {
     }
 
     func testEmptyTaskGroupsNotRendered() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         var problems = [Problem]()
         
         let source = """
@@ -339,14 +339,14 @@ class RenderNodeTranslatorTests: XCTestCase {
             """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let article = try XCTUnwrap(
-            Article(from: document.root, source: nil, for: bundle, problems: &problems)
+            Article(from: document.root, source: nil, for: context.inputs, problems: &problems)
         )
         let reference = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/Test-Bundle/taskgroups", fragment: nil, sourceLanguage: .swift)
         context.documentationCache[reference] = try DocumentationNode(reference: reference, article: article)
         let topicGraphNode = TopicGraph.Node(reference: reference, kind: .article, source: .file(url: URL(fileURLWithPath: "/path/to/article.md")), title: "My Article")
         context.topicGraph.addNode(topicGraphNode)
     
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let node = try XCTUnwrap(translator.visitArticle(article) as? RenderNode)
         XCTAssertEqual(node.topicSections.count, 2)
         
@@ -365,7 +365,7 @@ class RenderNodeTranslatorTests: XCTestCase {
     
     /// Tests the ordering of automatic groups for symbols
     func testAutomaticTaskGroupsOrderingInSymbols() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], externalResolvers: [:], externalSymbolResolver: nil, configureBundle: { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", configureBundle: { url in
             try """
             # ``SideKit/SideClass``
             SideClass abstract
@@ -375,8 +375,8 @@ class RenderNodeTranslatorTests: XCTestCase {
             """.write(to: url.appendingPathComponent("sideclass.md"), atomically: true, encoding: .utf8)
         })
         
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClass", sourceLanguage: .swift)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClass", sourceLanguage: .swift)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let node = try XCTUnwrap(try? context.entity(with: reference))
         
         // Test manual task groups and automatic symbol groups ordering
@@ -406,7 +406,7 @@ class RenderNodeTranslatorTests: XCTestCase {
                     title: "Articles",
                     references: [
                         ResolvedTopicReference(
-                            bundleID: bundle.id,
+                            bundleID: context.inputs.id,
                             path: "/documentation/MyKit/MyProtocol",
                             sourceLanguage: .swift
                         ),
@@ -440,7 +440,7 @@ class RenderNodeTranslatorTests: XCTestCase {
                     title: "Articles",
                     references: [
                         ResolvedTopicReference(
-                            bundleID: bundle.id,
+                            bundleID: context.inputs.id,
                             path: "/documentation/MyKit/MyProtocol",
                             sourceLanguage: .swift
                         ),
@@ -451,7 +451,7 @@ class RenderNodeTranslatorTests: XCTestCase {
                     title: "Default Implementations",
                     references: [
                         ResolvedTopicReference(
-                            bundleID: bundle.id,
+                            bundleID: context.inputs.id,
                             path: "/documentation/MyKit/MyProtocol",
                             sourceLanguage: .swift
                         ),
@@ -462,7 +462,7 @@ class RenderNodeTranslatorTests: XCTestCase {
                     title: "Another Task Group",
                     references: [
                         ResolvedTopicReference(
-                            bundleID: bundle.id,
+                            bundleID: context.inputs.id,
                             path: "/documentation/MyKit/MyProtocol",
                             sourceLanguage: .swift
                         ),
@@ -492,7 +492,7 @@ class RenderNodeTranslatorTests: XCTestCase {
     
     /// Tests the ordering of automatic groups for articles
     func testAutomaticTaskGroupsOrderingInArticles() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], externalResolvers: [:], externalSymbolResolver: nil, configureBundle: { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", configureBundle: { url in
             try """
             # Article
             Article abstract
@@ -502,8 +502,8 @@ class RenderNodeTranslatorTests: XCTestCase {
             """.write(to: url.appendingPathComponent("article.md"), atomically: true, encoding: .utf8)
         })
         
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Test-Bundle/article", sourceLanguage: .swift)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Test-Bundle/article", sourceLanguage: .swift)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let node = try XCTUnwrap(try? context.entity(with: reference))
         
         // Test the manual curation task groups
@@ -525,7 +525,7 @@ class RenderNodeTranslatorTests: XCTestCase {
                     title: "Articles",
                     references: [
                         ResolvedTopicReference(
-                            bundleID: bundle.id,
+                            bundleID: context.inputs.id,
                             path: "/documentation/MyKit/MyProtocol",
                             sourceLanguage: .swift
                         ),
@@ -553,7 +553,7 @@ class RenderNodeTranslatorTests: XCTestCase {
                     title: "Articles",
                     references: [
                         ResolvedTopicReference(
-                            bundleID: bundle.id,
+                            bundleID: context.inputs.id,
                             path: "/documentation/MyKit/MyProtocol",
                             sourceLanguage: .swift
                         ),
@@ -564,7 +564,7 @@ class RenderNodeTranslatorTests: XCTestCase {
                     title: "Default Implementations",
                     references: [
                         ResolvedTopicReference(
-                            bundleID: bundle.id,
+                            bundleID: context.inputs.id,
                             path: "/documentation/MyKit/MyProtocol",
                             sourceLanguage: .swift
                         ),
@@ -575,7 +575,7 @@ class RenderNodeTranslatorTests: XCTestCase {
                     title: "Another Task Group",
                     references: [
                         ResolvedTopicReference(
-                            bundleID: bundle.id,
+                            bundleID: context.inputs.id,
                             path: "/documentation/MyKit/MyProtocol",
                             sourceLanguage: .swift
                         ),
@@ -599,14 +599,14 @@ class RenderNodeTranslatorTests: XCTestCase {
 
     /// Tests the ordering of automatic groups in defining protocol
     func testOrderingOfAutomaticGroupsInDefiningProtocol() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], externalResolvers: [:], externalSymbolResolver: nil, configureBundle: { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", configureBundle: { url in
             //
         })
         
         // Verify "Default Implementations" group on the implementing type
         do {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClass/Element", sourceLanguage: .swift)
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClass/Element", sourceLanguage: .swift)
+            var translator = RenderNodeTranslator(context: context, identifier: reference)
             let node = try XCTUnwrap(try? context.entity(with: reference))
             
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
@@ -624,8 +624,8 @@ class RenderNodeTranslatorTests: XCTestCase {
         
         // Verify automatically generated api collection
         do {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClass/Element/Protocol-Implementations", sourceLanguage: .swift)
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClass/Element/Protocol-Implementations", sourceLanguage: .swift)
+            var translator = RenderNodeTranslator(context: context, identifier: reference)
             let node = try XCTUnwrap(try? context.entity(with: reference))
             
             let article = try XCTUnwrap(node.semantic as? Article)
@@ -649,12 +649,12 @@ class RenderNodeTranslatorTests: XCTestCase {
             forResource: "FancyProtocol.symbols", withExtension: "json", subdirectory: "Test Resources")!
 
         // Create a test bundle copy with the symbol graph from above
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", excludingPaths: []) { url in
             try? FileManager.default.copyItem(at: fancyProtocolSGFURL, to: url.appendingPathComponent("FancyProtocol.symbols.json"))
         }
 
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/FancyProtocol/SomeClass", sourceLanguage: .swift)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/FancyProtocol/SomeClass", sourceLanguage: .swift)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let node = try context.entity(with: reference)
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
         let renderNode = try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode)
@@ -853,25 +853,25 @@ class RenderNodeTranslatorTests: XCTestCase {
         XCTAssertEqual(references.map(\.title), expectedTitles, file: file, line: line)
     }
     
-    func loadRenderNode(at path: String, in bundleURL: URL) async throws -> RenderNode {
-        let (_, bundle, context) = try await loadBundle(from: bundleURL)
+    private func loadRenderNode(at path: String, in catalogURL: URL) async throws -> RenderNode {
+        let context = try await loadFromDisk(catalogURL: catalogURL)
 
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: path, sourceLanguage: .swift)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: path, sourceLanguage: .swift)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let node = try context.entity(with: reference)
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
         return try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode)
     }
     
     func testAutomaticTaskGroupTopicsAreSorted() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "DefaultImplementations")
-        let structReference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/DefaultImplementations/Foo", sourceLanguage: .swift)
+        let context = try await loadFromDisk(catalogName: "DefaultImplementations")
+        let structReference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/DefaultImplementations/Foo", sourceLanguage: .swift)
         let structNode = try context.entity(with: structReference)
         let symbol = try XCTUnwrap(structNode.semantic as? Symbol)
         
         // Verify that the ordering of default implementations is deterministic
         for _ in 0..<100 {
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: structReference)
+            var translator = RenderNodeTranslator(context: context, identifier: structReference)
             let renderNode = try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode)
             let section = renderNode.topicSections.first(where: { $0.title == "Default Implementations" })
             XCTAssertEqual(section?.identifiers, [
@@ -885,7 +885,7 @@ class RenderNodeTranslatorTests: XCTestCase {
     // Verifies we don't render links to non linkable nodes.
     func testNonLinkableNodes() async throws {
         // Create a bundle with variety absolute and relative links and symbol links to a non linkable node.
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], externalResolvers: [:], externalSymbolResolver: nil, configureBundle: { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", configureBundle: { url in
             try """
             # ``SideKit/SideClass``
             Abstract.
@@ -899,8 +899,8 @@ class RenderNodeTranslatorTests: XCTestCase {
             """.write(to: url.appendingPathComponent("sideclass.md"), atomically: true, encoding: .utf8)
         })
 
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit/SideClass", sourceLanguage: .swift)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit/SideClass", sourceLanguage: .swift)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let node = try XCTUnwrap(try? context.entity(with: reference))
         
         let symbol = try XCTUnwrap(node.semantic as? Symbol)
@@ -925,45 +925,45 @@ class RenderNodeTranslatorTests: XCTestCase {
     func testLinkInAbstract() async throws {
         do {
             // First verify that `SideKit` page does not contain render reference to `SideKit/SideClass/Element`.
-            let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+            let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
             
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit", sourceLanguage: .swift)
             let node = try context.entity(with: reference)
             
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+            var translator = RenderNodeTranslator(context: context, identifier: reference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
             let renderNode = try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode)
             
             // No render reference to `Element`
-            XCTAssertFalse(renderNode.references.keys.contains("doc://\(bundle.id)/documentation/SideKit/SideClass/Element"))
+            XCTAssertFalse(renderNode.references.keys.contains("doc://\(context.inputs.id)/documentation/SideKit/SideClass/Element"))
         }
         
         do {
             // Create a bundle with a link in abstract, then verify the render reference is present in `SideKit` render node references.
-            let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests", excludingPaths: [], externalResolvers: [:], externalSymbolResolver: nil, configureBundle: { url in
+            let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests", configureBundle: { url in
                 try """
                 # ``SideKit/SideClass``
                 This is a link to <doc:/documentation/SideKit/SideClass/Element>.
                 """.write(to: url.appendingPathComponent("sideclass.md"), atomically: true, encoding: .utf8)
             })
 
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/SideKit", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/SideKit", sourceLanguage: .swift)
             let node = try context.entity(with: reference)
             
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+            var translator = RenderNodeTranslator(context: context, identifier: reference)
             let symbol = try XCTUnwrap(node.semantic as? Symbol)
             let renderNode = try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode)
             
             // There is a render reference to `Element`
-            XCTAssertTrue(renderNode.references.keys.contains("doc://\(bundle.id)/documentation/SideKit/SideClass/Element"))
+            XCTAssertTrue(renderNode.references.keys.contains("doc://\(context.inputs.id)/documentation/SideKit/SideClass/Element"))
         }
     }
 
     func testSnippetToCodeListing() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "Snippets")
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Snippets/Snippets", sourceLanguage: .swift)
+        let context = try await loadFromDisk(catalogName: "Snippets")
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Snippets/Snippets", sourceLanguage: .swift)
         let article = try XCTUnwrap(context.entity(with: reference).semantic as? Article)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = try XCTUnwrap(translator.visitArticle(article) as? RenderNode)
         let discussion = try XCTUnwrap(renderNode.primaryContentSections.first(where: { $0.kind == .content }) as? ContentRenderSection)
         
@@ -990,10 +990,10 @@ class RenderNodeTranslatorTests: XCTestCase {
     }
     
     func testSnippetSliceToCodeListing() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "Snippets")
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Snippets/Snippets", sourceLanguage: .swift)
+        let context = try await loadFromDisk(catalogName: "Snippets")
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Snippets/Snippets", sourceLanguage: .swift)
         let article = try XCTUnwrap(context.entity(with: reference).semantic as? Article)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = try XCTUnwrap(translator.visitArticle(article) as? RenderNode)
         let discussion = try XCTUnwrap(renderNode.primaryContentSections.first(where: { $0.kind == .content }) as? ContentRenderSection)
         
@@ -1014,10 +1014,10 @@ class RenderNodeTranslatorTests: XCTestCase {
     }
 
     func testNestedSnippetSliceToCodeListing() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "Snippets")
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Snippets/Snippets", sourceLanguage: .swift)
+        let context = try await loadFromDisk(catalogName: "Snippets")
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Snippets/Snippets", sourceLanguage: .swift)
         let article = try XCTUnwrap(context.entity(with: reference).semantic as? Article)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = try XCTUnwrap(translator.visitArticle(article) as? RenderNode)
         let discussion = try XCTUnwrap(renderNode.primaryContentSections.first(where: { $0.kind == .content }) as? ContentRenderSection)
 
@@ -1045,10 +1045,10 @@ class RenderNodeTranslatorTests: XCTestCase {
     }
     
     func testSnippetSliceTrimsIndentation() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "Snippets")
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/Snippets/SliceIndentation", sourceLanguage: .swift)
+        let context = try await loadFromDisk(catalogName: "Snippets")
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/Snippets/SliceIndentation", sourceLanguage: .swift)
         let article = try XCTUnwrap(context.entity(with: reference).semantic as? Article)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = try XCTUnwrap(translator.visitArticle(article) as? RenderNode)
         let discussion = try XCTUnwrap(renderNode.primaryContentSections.first(where: { $0.kind == .content }) as? ContentRenderSection)
         
@@ -1070,14 +1070,14 @@ class RenderNodeTranslatorTests: XCTestCase {
     }
     
     func testRowAndColumn() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "BookLikeContent")
+        let context = try await loadFromDisk(catalogName: "BookLikeContent")
         let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/BestBook/MyArticle",
             sourceLanguage: .swift
         )
         let article = try XCTUnwrap(context.entity(with: reference).semantic as? Article)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = try XCTUnwrap(translator.visitArticle(article) as? RenderNode)
         
         let discussion = try XCTUnwrap(
@@ -1099,14 +1099,14 @@ class RenderNodeTranslatorTests: XCTestCase {
     }
     
     func testSmall() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "BookLikeContent")
+        let context = try await loadFromDisk(catalogName: "BookLikeContent")
         let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/BestBook/MyArticle",
             sourceLanguage: .swift
         )
         let article = try XCTUnwrap(context.entity(with: reference).semantic as? Article)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = try XCTUnwrap(translator.visitArticle(article) as? RenderNode)
         
         let discussion = try XCTUnwrap(
@@ -1127,14 +1127,14 @@ class RenderNodeTranslatorTests: XCTestCase {
     }
     
     func testTabNavigator() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "BookLikeContent")
+        let context = try await loadFromDisk(catalogName: "BookLikeContent")
         let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/BestBook/TabNavigatorArticle",
             sourceLanguage: .swift
         )
         let article = try XCTUnwrap(context.entity(with: reference).semantic as? Article)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = try XCTUnwrap(translator.visitArticle(article) as? RenderNode)
         
         let discussion = try XCTUnwrap(
@@ -1164,14 +1164,14 @@ class RenderNodeTranslatorTests: XCTestCase {
     }
     
     func testRenderNodeMetadata() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "BookLikeContent")
+        let context = try await loadFromDisk(catalogName: "BookLikeContent")
          let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
              path: "/documentation/BestBook/MyArticle",
              sourceLanguage: .swift
          )
          let article = try XCTUnwrap(context.entity(with: reference).semantic as? Article)
-         var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
          let renderNode = try XCTUnwrap(translator.visitArticle(article) as? RenderNode)
     
          let encodedArticle = try JSONEncoder().encode(renderNode)
@@ -1240,14 +1240,14 @@ class RenderNodeTranslatorTests: XCTestCase {
      }
     
     func testPageColorMetadataInSymbolExtension() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "MixedManualAutomaticCuration")
+        let context = try await loadFromDisk(catalogName: "MixedManualAutomaticCuration")
         let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/TestBed",
             sourceLanguage: .swift
         )
         let symbol = try XCTUnwrap(context.entity(with: reference).semantic as? Symbol)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode)
    
         let encodedSymbol = try JSONEncoder().encode(renderNode)
@@ -1256,14 +1256,14 @@ class RenderNodeTranslatorTests: XCTestCase {
     }
 
     func testTitleHeadingMetadataInSymbolExtension() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "MixedManualAutomaticCuration")
+        let context = try await loadFromDisk(catalogName: "MixedManualAutomaticCuration")
         let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/TestBed",
             sourceLanguage: .swift
         )
         let symbol = try XCTUnwrap(context.entity(with: reference).semantic as? Symbol)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let renderNode = try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode)
    
         let encodedSymbol = try JSONEncoder().encode(renderNode)
@@ -1334,14 +1334,14 @@ class RenderNodeTranslatorTests: XCTestCase {
                 ),
             ]
         )
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
 
         func renderNodeArticleFromReferencePath(
             referencePath: String
         ) throws -> RenderNode {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: referencePath, sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: referencePath, sourceLanguage: .swift)
             let symbol = try XCTUnwrap(context.entity(with: reference).semantic as? Article)
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+            var translator = RenderNodeTranslator(context: context, identifier: reference)
             return try XCTUnwrap(translator.visitArticle(symbol) as? RenderNode)
         }
         
@@ -1426,14 +1426,14 @@ class RenderNodeTranslatorTests: XCTestCase {
                 ),
             ]
         )
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
 
         func renderNodeArticleFromReferencePath(
             referencePath: String
         ) throws -> RenderNode {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: referencePath, sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: referencePath, sourceLanguage: .swift)
             let symbol = try XCTUnwrap(context.entity(with: reference).semantic as? Article)
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+            var translator = RenderNodeTranslator(context: context, identifier: reference)
             return try XCTUnwrap(translator.visitArticle(symbol) as? RenderNode)
         }
         
@@ -1461,7 +1461,7 @@ class RenderNodeTranslatorTests: XCTestCase {
     func testEncodesOverloadsInRenderNode() async throws {
         enableFeatureFlag(\.isExperimentalOverloadedSymbolPresentationEnabled)
 
-        let (bundle, context) = try await testBundleAndContext(named: "OverloadedSymbols")
+        let context = try await loadFromDisk(catalogName: "OverloadedSymbols")
         
         let overloadPreciseIdentifiers = ["s:8ShapeKit14OverloadedEnumO19firstTestMemberNameySdSiF",
                                    "s:8ShapeKit14OverloadedEnumO19firstTestMemberNameySdSfF",
@@ -1474,7 +1474,7 @@ class RenderNodeTranslatorTests: XCTestCase {
         for (index, reference) in overloadReferences.indexed() {
             let documentationNode = try context.entity(with: reference)
             
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+            var translator = RenderNodeTranslator(context: context, identifier: reference)
             let symbol = try XCTUnwrap(documentationNode.semantic as? Symbol)
             let renderNode = try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode)
             
@@ -1497,7 +1497,7 @@ class RenderNodeTranslatorTests: XCTestCase {
     }
     
     func testAlternateRepresentationsRenderedAsVariants() async throws {
-        let (bundle, context) = try await loadBundle(catalog: Folder(
+        let context = try await load(catalog: Folder(
             name: "unit-test.docc",
             content: [
                 TextFile(name: "Symbol.md", utf8Content: """
@@ -1547,9 +1547,9 @@ class RenderNodeTranslatorTests: XCTestCase {
         func renderNodeArticleFromReferencePath(
             referencePath: String
         ) throws -> RenderNode {
-            let reference = ResolvedTopicReference(bundleID: bundle.id, path: referencePath, sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: referencePath, sourceLanguage: .swift)
             let symbol = try XCTUnwrap(context.entity(with: reference).semantic as? Symbol)
-            var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+            var translator = RenderNodeTranslator(context: context, identifier: reference)
             return try XCTUnwrap(translator.visitSymbol(symbol) as? RenderNode)
         }
         
diff --git a/Tests/SwiftDocCTests/Rendering/RoleTests.swift b/Tests/SwiftDocCTests/Rendering/RoleTests.swift
index f05fe42e11..68beb47f3b 100644
--- a/Tests/SwiftDocCTests/Rendering/RoleTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/RoleTests.swift
@@ -25,14 +25,14 @@ class RoleTests: XCTestCase {
     ]
     
     func testNodeRoles() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests")
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests")
 
         // Compile docs and verify contents
         for (path, expectedRole) in expectedRoles {
             let identifier = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: path, fragment: nil, sourceLanguage: .swift)
             do {
                 let node = try context.entity(with: identifier)
-                var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+                var translator = RenderNodeTranslator(context: context, identifier: node.reference)
                 let renderNode = translator.visit(node.semantic) as! RenderNode
                 XCTAssertEqual(expectedRole, renderNode.metadata.role, "Unexpected role \(renderNode.metadata.role!.singleQuoted) for identifier \(identifier.path)")
             } catch {
@@ -43,11 +43,11 @@ class RoleTests: XCTestCase {
     }
     
     func testDocumentationRenderReferenceRoles() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests")
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests")
 
         let identifier = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/MyKit", fragment: nil, sourceLanguage: .swift)
         let node = try context.entity(with: identifier)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic) as! RenderNode
 
         XCTAssertEqual((renderNode.references["doc://org.swift.docc.example/documentation/MyKit"] as? TopicRenderReference)?.role, "collection")
@@ -56,11 +56,11 @@ class RoleTests: XCTestCase {
     }
 
     func testTutorialsRenderReferenceRoles() async throws {
-        let (_, bundle, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests")
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests")
 
         let identifier = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/tutorials/Test-Bundle/TestTutorial", fragment: nil, sourceLanguage: .swift)
         let node = try context.entity(with: identifier)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = translator.visit(node.semantic) as! RenderNode
 
         XCTAssertEqual((renderNode.references["doc://org.swift.docc.example/tutorials/TestOverview"] as? TopicRenderReference)?.role, "overview")
diff --git a/Tests/SwiftDocCTests/Rendering/SampleDownloadTests.swift b/Tests/SwiftDocCTests/Rendering/SampleDownloadTests.swift
index 39b7ab7d61..785f7cf8d1 100644
--- a/Tests/SwiftDocCTests/Rendering/SampleDownloadTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/SampleDownloadTests.swift
@@ -126,14 +126,14 @@ class SampleDownloadTests: XCTestCase {
     }
     
     private func renderNodeFromSampleBundle(at referencePath: String) async throws -> RenderNode {
-        let (bundle, context) = try await testBundleAndContext(named: "SampleBundle")
+        let context = try await loadFromDisk(catalogName: "SampleBundle")
         let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: referencePath,
             sourceLanguage: .swift
         )
         let article = try XCTUnwrap(context.entity(with: reference).semantic as? Article)
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         return try XCTUnwrap(translator.visitArticle(article) as? RenderNode)
     }
 
diff --git a/Tests/SwiftDocCTests/Rendering/SymbolAvailabilityTests.swift b/Tests/SwiftDocCTests/Rendering/SymbolAvailabilityTests.swift
index 239d352230..4ab22291b6 100644
--- a/Tests/SwiftDocCTests/Rendering/SymbolAvailabilityTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/SymbolAvailabilityTests.swift
@@ -37,10 +37,10 @@ class SymbolAvailabilityTests: XCTestCase {
                 )),
             ]
         )
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let reference = try XCTUnwrap(context.soleRootModuleReference).appendingPath(symbolName)
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: reference.path, sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: reference.path, sourceLanguage: .swift))
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         return try XCTUnwrap((translator.visit(node.semantic as! Symbol) as! RenderNode).metadata.platformsVariants.defaultValue)
     }
     
diff --git a/Tests/SwiftDocCTests/Rendering/TermListTests.swift b/Tests/SwiftDocCTests/Rendering/TermListTests.swift
index bb03e0c289..de59343fe5 100644
--- a/Tests/SwiftDocCTests/Rendering/TermListTests.swift
+++ b/Tests/SwiftDocCTests/Rendering/TermListTests.swift
@@ -86,12 +86,12 @@ class TermListTests: XCTestCase {
         
         var configuration = DocumentationContext.Configuration()
         configuration.externalDocumentationConfiguration.sources = ["com.external.testbundle": resolver]
-        let (bundle, context) = try await loadBundle(catalog: catalog, configuration: configuration)
+        let context = try await load(catalog: catalog, configuration: configuration)
         
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/unit-test/Article", sourceLanguage: .swift)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/unit-test/Article", sourceLanguage: .swift)
         let entity = try context.entity(with: reference)
         
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
         let renderNode = converter.convert(entity)
         
         let overviewSection = try XCTUnwrap(renderNode.primaryContentSections.first as? ContentRenderSection)
@@ -161,8 +161,8 @@ class TermListTests: XCTestCase {
             return
         }
         
-        let (bundle, context) = try await testBundleAndContext()
-        var renderContentCompiler = RenderContentCompiler(context: context, bundle: bundle, identifier: ResolvedTopicReference(bundleID: bundle.id, path: "/path", fragment: nil, sourceLanguage: .swift))
+        let context = try await makeEmptyContext()
+        var renderContentCompiler = RenderContentCompiler(context: context, identifier: ResolvedTopicReference(bundleID: context.inputs.id, path: "/path", fragment: nil, sourceLanguage: .swift))
         
         let source = """
         - term First term : A paragraph that
@@ -204,8 +204,8 @@ class TermListTests: XCTestCase {
             return
         }
         
-        let (bundle, context) = try await testBundleAndContext()
-        var renderContentCompiler = RenderContentCompiler(context: context, bundle: bundle, identifier: ResolvedTopicReference(bundleID: bundle.id, path: "/path", fragment: nil, sourceLanguage: .swift))
+        let context = try await makeEmptyContext()
+        var renderContentCompiler = RenderContentCompiler(context: context, identifier: ResolvedTopicReference(bundleID: context.inputs.id, path: "/path", fragment: nil, sourceLanguage: .swift))
         
         let source = """
         - Not a term list, and
diff --git a/Tests/SwiftDocCTests/Semantics/ArticleSymbolMentionsTests.swift b/Tests/SwiftDocCTests/Semantics/ArticleSymbolMentionsTests.swift
index 856a3908be..3e33f22657 100644
--- a/Tests/SwiftDocCTests/Semantics/ArticleSymbolMentionsTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/ArticleSymbolMentionsTests.swift
@@ -38,7 +38,7 @@ class ArticleSymbolMentionsTests: XCTestCase {
 
     // Test the sorting of articles mentioning a given symbol
     func testArticlesMentioningSorting() throws {
-        let bundleID: DocumentationBundle.Identifier = "org.swift.test"
+        let bundleID: DocumentationContext.Inputs.Identifier = "org.swift.test"
         let articles = ["a", "b", "c", "d", "e", "f"].map { letter in
             ResolvedTopicReference(
                 bundleID: bundleID,
@@ -87,18 +87,18 @@ class ArticleSymbolMentionsTests: XCTestCase {
     }
 
     func testSymbolLinkCollectorEnabled() async throws {
-        let (bundle, context) = try await createMentionedInTestBundle()
+        let context = try await createMentionedInTestBundle()
 
         // The test bundle currently only has one article with symbol mentions
         // in the abstract/discussion.
         XCTAssertEqual(1, context.articleSymbolMentions.mentions.count)
 
         let mentioningArticle = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/MentionedIn/ArticleMentioningSymbol",
             sourceLanguage: .swift)
         let mentionedSymbol = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/MentionedIn/MyClass",
             sourceLanguage: .swift)
         
@@ -116,11 +116,11 @@ class ArticleSymbolMentionsTests: XCTestCase {
         FeatureFlags.current.isMentionedInEnabled = false
         
         
-        let (bundle, context) = try await createMentionedInTestBundle()
+        let context = try await createMentionedInTestBundle()
         XCTAssertTrue(context.articleSymbolMentions.mentions.isEmpty)
 
         let mentionedSymbol = ResolvedTopicReference(
-            bundleID: bundle.id,
+            bundleID: context.inputs.id,
             path: "/documentation/MentionedIn/MyClass",
             sourceLanguage: .swift)
 
diff --git a/Tests/SwiftDocCTests/Semantics/ArticleTests.swift b/Tests/SwiftDocCTests/Semantics/ArticleTests.swift
index 18968e24c1..0a6b49479b 100644
--- a/Tests/SwiftDocCTests/Semantics/ArticleTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/ArticleTests.swift
@@ -22,9 +22,9 @@ class ArticleTests: XCTestCase {
         Here's an overview.
         """
         let document = Document(parsing: source, options: [])
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = Article(from: document, source: nil, for: bundle, problems: &problems)
+        let article = Article(from: document, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(article)
         XCTAssert(problems.isEmpty, "Unexpectedly found problems: \(DiagnosticConsoleWriter.formattedDescription(for: problems))")
         
@@ -44,9 +44,9 @@ class ArticleTests: XCTestCase {
         Here's an overview.
         """
         let document = Document(parsing: source, options: [])
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = Article(from: document, source: nil, for: bundle, problems: &problems)
+        let article = Article(from: document, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(article)
         XCTAssert(problems.isEmpty, "Unexpectedly found problems: \(DiagnosticConsoleWriter.formattedDescription(for: problems))")
         
@@ -73,9 +73,9 @@ class ArticleTests: XCTestCase {
         Here's an overview.
         """
         let document = Document(parsing: source, options: [])
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = Article(from: document, source: nil, for: bundle, problems: &problems)
+        let article = Article(from: document, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(article)
         XCTAssert(problems.isEmpty, "Unexpectedly found problems: \(DiagnosticConsoleWriter.formattedDescription(for: problems))")
         
@@ -97,9 +97,9 @@ class ArticleTests: XCTestCase {
         # This is my article
         """
         let document = Document(parsing: source, options: [])
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = Article(from: document, source: nil, for: bundle, problems: &problems)
+        let article = Article(from: document, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(article)
         XCTAssert(problems.isEmpty, "Unexpectedly found problems: \(DiagnosticConsoleWriter.formattedDescription(for: problems))")
         
@@ -115,9 +115,9 @@ class ArticleTests: XCTestCase {
         - This is not an abstract.
         """
         let document = Document(parsing: source, options: [])
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = Article(from: document, source: nil, for: bundle, problems: &problems)
+        let article = Article(from: document, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(article)
         XCTAssert(problems.isEmpty, "Unexpectedly found problems: \(DiagnosticConsoleWriter.formattedDescription(for: problems))")
         
@@ -133,9 +133,9 @@ class ArticleTests: XCTestCase {
          This is my article
          """
         let document = Document(parsing: source, options: [])
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = Article(from: document, source: nil, for: bundle, problems: &problems)
+        let article = Article(from: document, source: nil, for: inputs, problems: &problems)
 
         XCTAssertNil(article)
         XCTAssertEqual(problems.count, 1)
@@ -153,9 +153,9 @@ class ArticleTests: XCTestCase {
          
         """
         let document = Document(parsing: source, options: [])
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = Article(from: document, source: nil, for: bundle, problems: &problems)
+        let article = Article(from: document, source: nil, for: inputs, problems: &problems)
 
         XCTAssertNil(article)
         XCTAssertEqual(problems.count, 1)
@@ -185,9 +185,9 @@ class ArticleTests: XCTestCase {
         Here's an overview.
         """
         let document = Document(parsing: source, options: [.parseBlockDirectives])
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = Article(from: document, source: nil, for: bundle, problems: &problems)
+        let article = Article(from: document, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(article)
         XCTAssertEqual(
             problems.map(\.diagnostic.identifier),
@@ -222,9 +222,9 @@ class ArticleTests: XCTestCase {
         Adding @DisplayName to an article will result in a warning.
         """
         let document = Document(parsing: source, options: [.parseBlockDirectives])
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = Article(from: document, source: nil, for: bundle, problems: &problems)
+        let article = Article(from: document, source: nil, for: inputs, problems: &problems)
         
         XCTAssertEqual(problems.map(\.diagnostic.summary), [
             "A 'DisplayName' directive is only supported in documentation extension files. To customize the display name of an article, change the content of the level-1 heading."
diff --git a/Tests/SwiftDocCTests/Semantics/AssessmentsTests.swift b/Tests/SwiftDocCTests/Semantics/AssessmentsTests.swift
index 0d7e254769..12499db6c9 100644
--- a/Tests/SwiftDocCTests/Semantics/AssessmentsTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/AssessmentsTests.swift
@@ -19,12 +19,12 @@ class AssessmentsTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(Assessments.directiveName, directive.name)
-            let assessments = Assessments(from: directive, source: nil, for: bundle, problems: &problems)
+            let assessments = Assessments(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(assessments)
             XCTAssertEqual(1, problems.count)
             let diagnosticIdentifiers = Set(problems.map { $0.diagnostic.identifier })
diff --git a/Tests/SwiftDocCTests/Semantics/CallToActionTests.swift b/Tests/SwiftDocCTests/Semantics/CallToActionTests.swift
index 3c59b82ba7..befc1c1dce 100644
--- a/Tests/SwiftDocCTests/Semantics/CallToActionTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/CallToActionTests.swift
@@ -21,12 +21,12 @@ class CallToActionTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
 
-        let (bundle, _) = try await testBundleAndContext(named: "SampleBundle")
+        let inputs = try await loadFromDisk(catalogName: "SampleBundle").inputs
 
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(CallToAction.directiveName, directive.name)
-            let callToAction = CallToAction(from: directive, source: nil, for: bundle, problems: &problems)
+            let callToAction = CallToAction(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNil(callToAction)
             XCTAssertEqual(2, problems.count)
             let diagnosticIdentifiers = Set(problems.map { $0.diagnostic.identifier })
@@ -41,12 +41,12 @@ class CallToActionTests: XCTestCase {
             let directive = document.child(at: 0) as? BlockDirective
             XCTAssertNotNil(directive)
 
-            let (bundle, _) = try await testBundleAndContext(named: "SampleBundle")
+            let inputs = try await loadFromDisk(catalogName: "SampleBundle").inputs
 
             directive.map { directive in
                 var problems = [Problem]()
                 XCTAssertEqual(CallToAction.directiveName, directive.name)
-                let callToAction = CallToAction(from: directive, source: nil, for: bundle, problems: &problems)
+                let callToAction = CallToAction(from: directive, source: nil, for: inputs, problems: &problems)
                 XCTAssertNil(callToAction)
                 XCTAssertEqual(1, problems.count)
                 let diagnosticIdentifiers = Set(problems.map { $0.diagnostic.identifier })
@@ -63,12 +63,12 @@ class CallToActionTests: XCTestCase {
             let directive = document.child(at: 0) as? BlockDirective
             XCTAssertNotNil(directive)
 
-            let (bundle, _) = try await testBundleAndContext(named: "SampleBundle")
+            let inputs = try await loadFromDisk(catalogName: "SampleBundle").inputs
 
             directive.map { directive in
                 var problems = [Problem]()
                 XCTAssertEqual(CallToAction.directiveName, directive.name)
-                let callToAction = CallToAction(from: directive, source: nil, for: bundle, problems: &problems)
+                let callToAction = CallToAction(from: directive, source: nil, for: inputs, problems: &problems)
                 XCTAssertNil(callToAction)
                 XCTAssertEqual(1, problems.count)
                 let diagnosticIdentifiers = Set(problems.map { $0.diagnostic.identifier })
@@ -85,12 +85,12 @@ class CallToActionTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
 
-        let (bundle, _) = try await testBundleAndContext(named: "SampleBundle")
+        let inputs = try await loadFromDisk(catalogName: "SampleBundle").inputs
 
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(CallToAction.directiveName, directive.name)
-            let callToAction = CallToAction(from: directive, source: nil, for: bundle, problems: &problems)
+            let callToAction = CallToAction(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNil(callToAction)
             XCTAssertEqual(1, problems.count)
             let diagnosticIdentifiers = Set(problems.map { $0.diagnostic.identifier })
@@ -104,12 +104,12 @@ class CallToActionTests: XCTestCase {
             let directive = document.child(at: 0) as? BlockDirective
             XCTAssertNotNil(directive)
 
-            let (bundle, _) = try await testBundleAndContext(named: "SampleBundle")
+            let inputs = try await loadFromDisk(catalogName: "SampleBundle").inputs
 
             directive.map { directive in
                 var problems = [Problem]()
                 XCTAssertEqual(CallToAction.directiveName, directive.name)
-                let callToAction = CallToAction(from: directive, source: nil, for: bundle, problems: &problems)
+                let callToAction = CallToAction(from: directive, source: nil, for: inputs, problems: &problems)
                 XCTAssertNotNil(callToAction)
                 XCTAssert(problems.isEmpty)
             }
@@ -141,11 +141,11 @@ class CallToActionTests: XCTestCase {
             let document = Document(parsing: source, options: .parseBlockDirectives)
             let directive = try XCTUnwrap(document.child(at: 0) as? BlockDirective)
 
-            let (bundle, _) = try await testBundleAndContext(named: "SampleBundle")
+            let inputs = try await loadFromDisk(catalogName: "SampleBundle").inputs
 
             var problems = [Problem]()
             XCTAssertEqual(CallToAction.directiveName, directive.name)
-            let callToAction = try XCTUnwrap(CallToAction(from: directive, source: nil, for: bundle, problems: &problems))
+            let callToAction = try XCTUnwrap(CallToAction(from: directive, source: nil, for: inputs, problems: &problems))
             XCTAssert(problems.isEmpty)
             
             XCTAssertEqual(callToAction.buttonLabel(for: nil), expectedDefaultLabel)
diff --git a/Tests/SwiftDocCTests/Semantics/ChapterTests.swift b/Tests/SwiftDocCTests/Semantics/ChapterTests.swift
index ddff9733fb..5c24ca5885 100644
--- a/Tests/SwiftDocCTests/Semantics/ChapterTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/ChapterTests.swift
@@ -19,9 +19,9 @@ class ChapterTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let chapter = Chapter(from: directive, source: nil, for: bundle, problems: &problems)
+        let chapter = Chapter(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(chapter)
         XCTAssertEqual(3, problems.count)
         XCTAssertEqual("org.swift.docc.HasArgument.name", problems[0].diagnostic.identifier)
@@ -42,9 +42,9 @@ class ChapterTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let chapter = Chapter(from: directive, source: nil, for: bundle, problems: &problems)
+        let chapter = Chapter(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertEqual(1, problems.count)
         problems.first.map { problem in
             XCTAssertEqual("org.swift.docc.HasExactlyOne<\(Chapter.self), \(ImageMedia.self)>.DuplicateChildren", problem.diagnostic.identifier)
@@ -71,9 +71,9 @@ class ChapterTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let chapter = Chapter(from: directive, source: nil, for: bundle, problems: &problems)
+        let chapter = Chapter(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertTrue(problems.isEmpty)
         XCTAssertNotNil(chapter)
         chapter.map { chapter in
@@ -83,7 +83,7 @@ class ChapterTests: XCTestCase {
     }
     
     func testDuplicateTutorialReferences() async throws {
-        let (_, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await loadFromDisk(catalogName: "LegacyBundle_DoNotUseInNewTests")
         
         /*
          The test bundle contains the duplicate tutorial references in TestOverview:
diff --git a/Tests/SwiftDocCTests/Semantics/ChoiceTests.swift b/Tests/SwiftDocCTests/Semantics/ChoiceTests.swift
index 7be45b6176..66347bcfdf 100644
--- a/Tests/SwiftDocCTests/Semantics/ChoiceTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/ChoiceTests.swift
@@ -20,12 +20,12 @@ class ChoiceTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(Choice.directiveName, directive.name)
-            let choice = Choice(from: directive, source: nil, for: bundle, problems: &problems)
+            let choice = Choice(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNil(choice)
             let diagnosticIdentifiers = Set(problems.map { $0.diagnostic.identifier })
             XCTAssertEqual(2, problems.count)
@@ -47,12 +47,12 @@ class ChoiceTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(Choice.directiveName, directive.name)
-            let choice = Choice(from: directive, source: nil, for: bundle, problems: &problems)
+            let choice = Choice(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(choice)
             let diagnosticIdentifiers = Set(problems.map { $0.diagnostic.identifier })
             XCTAssertEqual(1, problems.count)
@@ -70,12 +70,12 @@ class ChoiceTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(Choice.directiveName, directive.name)
-            let choice = Choice(from: directive, source: nil, for: bundle, problems: &problems)
+            let choice = Choice(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNil(choice)
             XCTAssertEqual(1, problems.count)
             problems.first.map { problem in
@@ -96,12 +96,12 @@ class ChoiceTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(Choice.directiveName, directive.name)
-            let choice = Choice(from: directive, source: nil, for: bundle, problems: &problems)
+            let choice = Choice(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNil(choice)
             XCTAssertEqual(1, problems.count)
             problems.first.map { problem in
@@ -122,12 +122,12 @@ class ChoiceTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(Choice.directiveName, directive.name)
-            let choice = Choice(from: directive, source: nil, for: bundle, problems: &problems)
+            let choice = Choice(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNil(choice)
             XCTAssertEqual(1, problems.count)
             problems.first.map { problem in
@@ -152,12 +152,12 @@ class ChoiceTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(Choice.directiveName, directive.name)
-            let choice = Choice(from: directive, source: nil, for: bundle, problems: &problems)
+            let choice = Choice(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(choice)
             XCTAssertTrue(problems.isEmpty)
             choice.map { choice in
@@ -188,12 +188,12 @@ Choice @1:1-6:2 isCorrect: true
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(Choice.directiveName, directive.name)
-            let choice = Choice(from: directive, source: nil, for: bundle, problems: &problems)
+            let choice = Choice(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(choice)
             XCTAssertTrue(problems.isEmpty)
             choice.map { choice in
@@ -222,15 +222,15 @@ Choice @1:1-9:2 isCorrect: true
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await loadBundle(catalog: Folder(name: "unit-test.docc", content: [
+        let inputs = try await load(catalog: Folder(name: "unit-test.docc", content: [
             InfoPlist(identifier: "org.swift.docc.example"),
             DataFile(name: "blah.png", data: Data()),
-        ]))
+        ])).inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(Choice.directiveName, directive.name)
-            let choice = Choice(from: directive, source: nil, for: bundle, problems: &problems)
+            let choice = Choice(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(choice)
             XCTAssertTrue(problems.isEmpty)
             choice.map { choice in
diff --git a/Tests/SwiftDocCTests/Semantics/CodeTests.swift b/Tests/SwiftDocCTests/Semantics/CodeTests.swift
index 136d1796ba..6c16cbb507 100644
--- a/Tests/SwiftDocCTests/Semantics/CodeTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/CodeTests.swift
@@ -19,9 +19,9 @@ class CodeTests: XCTestCase {
         let source = "@Code"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let code = Code(from: directive, source: nil, for: bundle, problems: &problems)
+        let code = Code(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(code)
         XCTAssertEqual(1, problems.count)
         XCTAssertEqual("org.swift.docc.HasArgument.file", problems.first?.diagnostic.identifier)
diff --git a/Tests/SwiftDocCTests/Semantics/ContentAndMediaTests.swift b/Tests/SwiftDocCTests/Semantics/ContentAndMediaTests.swift
index 8ba8c47a86..47f5df0001 100644
--- a/Tests/SwiftDocCTests/Semantics/ContentAndMediaTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/ContentAndMediaTests.swift
@@ -19,9 +19,9 @@ class ContentAndMediaTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let contentAndMedia = ContentAndMedia(from: directive, source: nil, for: bundle, problems: &problems)
+        let contentAndMedia = ContentAndMedia(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(contentAndMedia)
         XCTAssertEqual(0, problems.count)
     }
@@ -37,9 +37,9 @@ class ContentAndMediaTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let contentAndMedia = ContentAndMedia(from: directive, source: nil, for: bundle, problems: &problems)
+        let contentAndMedia = ContentAndMedia(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(contentAndMedia)
         XCTAssertTrue(problems.isEmpty)
         contentAndMedia.map { contentAndMedia in
@@ -58,9 +58,9 @@ class ContentAndMediaTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let contentAndMedia = ContentAndMedia(from: directive, source: nil, for: bundle, problems: &problems)
+        let contentAndMedia = ContentAndMedia(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(contentAndMedia)
         XCTAssertTrue(problems.isEmpty)
         contentAndMedia.map { contentAndMedia in
@@ -81,9 +81,9 @@ class ContentAndMediaTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let contentAndMedia = ContentAndMedia(from: directive, source: nil, for: bundle, problems: &problems)
+        let contentAndMedia = ContentAndMedia(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(contentAndMedia)
         XCTAssertTrue(problems.isEmpty)
         contentAndMedia.map { contentAndMedia in
@@ -102,9 +102,9 @@ class ContentAndMediaTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let contentAndMedia = ContentAndMedia(from: directive, source: nil, for: bundle, problems: &problems)
+        let contentAndMedia = ContentAndMedia(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(contentAndMedia)
         XCTAssertEqual(problems.count, 3)
         XCTAssertEqual(
diff --git a/Tests/SwiftDocCTests/Semantics/DisplayNameTests.swift b/Tests/SwiftDocCTests/Semantics/DisplayNameTests.swift
index 3f927018cd..e4e94e2f1a 100644
--- a/Tests/SwiftDocCTests/Semantics/DisplayNameTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/DisplayNameTests.swift
@@ -19,9 +19,9 @@ class DisplayNameTests: XCTestCase {
         let source = "@DisplayName"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let displayName = DisplayName(from: directive, source: nil, for: bundle, problems: &problems)
+        let displayName = DisplayName(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(displayName)
         XCTAssertFalse(problems.containsErrors)
         XCTAssertEqual(1, problems.count)
@@ -32,9 +32,9 @@ class DisplayNameTests: XCTestCase {
         let source = "@DisplayName(\"Custom Symbol Name\")"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let displayName = DisplayName(from: directive, source: nil, for: bundle, problems: &problems)
+        let displayName = DisplayName(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(displayName)
         XCTAssertTrue(problems.isEmpty)
         XCTAssertEqual(displayName?.style, .conceptual)
@@ -44,9 +44,9 @@ class DisplayNameTests: XCTestCase {
         let source = "@DisplayName(\"Custom Symbol Name\", style: conceptual)"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let displayName = DisplayName(from: directive, source: nil, for: bundle, problems: &problems)
+        let displayName = DisplayName(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(displayName)
         XCTAssertTrue(problems.isEmpty)
         XCTAssertEqual(displayName?.style, .conceptual)
@@ -56,9 +56,9 @@ class DisplayNameTests: XCTestCase {
         let source = "@DisplayName(\"Custom Symbol Name\", style: symbol)"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let displayName = DisplayName(from: directive, source: nil, for: bundle, problems: &problems)
+        let displayName = DisplayName(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(displayName)
         XCTAssertTrue(problems.isEmpty)
         XCTAssertEqual(displayName?.style, .symbol)
@@ -68,9 +68,9 @@ class DisplayNameTests: XCTestCase {
         let source = "@DisplayName(\"Custom Symbol Name\", style: somethingUnknown)"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let displayName = DisplayName(from: directive, source: nil, for: bundle, problems: &problems)
+        let displayName = DisplayName(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(displayName)
         XCTAssertFalse(problems.containsErrors)
         XCTAssertEqual(1, problems.count)
@@ -81,9 +81,9 @@ class DisplayNameTests: XCTestCase {
         let source = "@DisplayName(\"Custom Symbol Name\", argument: value)"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let displayName = DisplayName(from: directive, source: nil, for: bundle, problems: &problems)
+        let displayName = DisplayName(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(displayName, "Even if there are warnings we can create a displayName value")
         XCTAssertFalse(problems.containsErrors)
         XCTAssertEqual(1, problems.count)
@@ -98,9 +98,9 @@ class DisplayNameTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let displayName = DisplayName(from: directive, source: nil, for: bundle, problems: &problems)
+        let displayName = DisplayName(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(displayName, "Even if there are warnings we can create a DisplayName value")
         XCTAssertFalse(problems.containsErrors)
         XCTAssertEqual(2, problems.count)
@@ -116,9 +116,9 @@ class DisplayNameTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let displayName = DisplayName(from: directive, source: nil, for: bundle, problems: &problems)
+        let displayName = DisplayName(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(displayName, "Even if there are warnings we can create a DisplayName value")
         XCTAssertFalse(problems.containsErrors)
         XCTAssertEqual(1, problems.count)
diff --git a/Tests/SwiftDocCTests/Semantics/DocumentationExtensionTests.swift b/Tests/SwiftDocCTests/Semantics/DocumentationExtensionTests.swift
index 6c6d5a5d9c..b6b2e15f81 100644
--- a/Tests/SwiftDocCTests/Semantics/DocumentationExtensionTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/DocumentationExtensionTests.swift
@@ -19,9 +19,9 @@ class DocumentationExtensionTests: XCTestCase {
         let source = "@DocumentationExtension"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let options = DocumentationExtension(from: directive, source: nil, for: bundle, problems: &problems)
+        let options = DocumentationExtension(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(options)
         XCTAssertFalse(problems.containsErrors)
         XCTAssertEqual(1, problems.count)
@@ -32,9 +32,9 @@ class DocumentationExtensionTests: XCTestCase {
         let source = "@DocumentationExtension(mergeBehavior: append)"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let options = DocumentationExtension(from: directive, source: nil, for: bundle, problems: &problems)
+        let options = DocumentationExtension(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(options)
         XCTAssertEqual(problems.count, 1)
         XCTAssertEqual("org.swift.docc.DocumentationExtension.NoConfiguration", problems.first?.diagnostic.identifier)
@@ -45,9 +45,9 @@ class DocumentationExtensionTests: XCTestCase {
         let source = "@DocumentationExtension(mergeBehavior: override)"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let options = DocumentationExtension(from: directive, source: nil, for: bundle, problems: &problems)
+        let options = DocumentationExtension(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(options)
         XCTAssertTrue(problems.isEmpty)
         XCTAssertEqual(options?.behavior, .override)
@@ -57,9 +57,9 @@ class DocumentationExtensionTests: XCTestCase {
         let source = "@DocumentationExtension(mergeBehavior: somethingUnknown )"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let options = DocumentationExtension(from: directive, source: nil, for: bundle, problems: &problems)
+        let options = DocumentationExtension(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(options)
         XCTAssertFalse(problems.containsErrors)
         XCTAssertEqual(1, problems.count)
@@ -70,9 +70,9 @@ class DocumentationExtensionTests: XCTestCase {
         let source = "@DocumentationExtension(mergeBehavior: override, argument: value)"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let options = DocumentationExtension(from: directive, source: nil, for: bundle, problems: &problems)
+        let options = DocumentationExtension(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(options, "Even if there are warnings we can create an options value")
         XCTAssertFalse(problems.containsErrors)
         XCTAssertEqual(1, problems.count)
@@ -87,9 +87,9 @@ class DocumentationExtensionTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let options = DocumentationExtension(from: directive, source: nil, for: bundle, problems: &problems)
+        let options = DocumentationExtension(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(options, "Even if there are warnings we can create a DocumentationExtension value")
         XCTAssertFalse(problems.containsErrors)
         XCTAssertEqual(2, problems.count)
@@ -105,9 +105,9 @@ class DocumentationExtensionTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let options = DocumentationExtension(from: directive, source: nil, for: bundle, problems: &problems)
+        let options = DocumentationExtension(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(options, "Even if there are warnings we can create a DocumentationExtension value")
         XCTAssertFalse(problems.containsErrors)
         XCTAssertEqual(1, problems.count)
@@ -121,9 +121,9 @@ class DocumentationExtensionTests: XCTestCase {
         
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let options = DocumentationExtension(from: directive, source: nil, for: bundle, problems: &problems)
+        let options = DocumentationExtension(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(options)
         XCTAssertFalse(problems.containsErrors)
         XCTAssertEqual(2, problems.count)
diff --git a/Tests/SwiftDocCTests/Semantics/DoxygenTests.swift b/Tests/SwiftDocCTests/Semantics/DoxygenTests.swift
index bd62af73f1..b6000aeda4 100644
--- a/Tests/SwiftDocCTests/Semantics/DoxygenTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/DoxygenTests.swift
@@ -88,8 +88,8 @@ class DoxygenTests: XCTestCase {
                 )),
             ])
 
-        let (bundle, context) = try await loadBundle(catalog: catalog)
-        let reference = ResolvedTopicReference(bundleID: bundle.id, path: "/documentation/ModuleName/SomeClass", sourceLanguage: .swift)
+        let context = try await load(catalog: catalog)
+        let reference = ResolvedTopicReference(bundleID: context.inputs.id, path: "/documentation/ModuleName/SomeClass", sourceLanguage: .swift)
 
         // Verify the expected content in the in-memory model
         let node = try context.entity(with: reference)
@@ -103,7 +103,7 @@ class DoxygenTests: XCTestCase {
         ])
 
         // Verify the expected content in the render model
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         let renderNode = try XCTUnwrap(translator.visit(node.semantic) as? RenderNode)
 
         XCTAssertEqual(renderNode.abstract, [.text("This is an abstract.")])
diff --git a/Tests/SwiftDocCTests/Semantics/General Purpose Analyses/HasAtLeastOneTests.swift b/Tests/SwiftDocCTests/Semantics/General Purpose Analyses/HasAtLeastOneTests.swift
index 7e73ab2cc2..bf26d46589 100644
--- a/Tests/SwiftDocCTests/Semantics/General Purpose Analyses/HasAtLeastOneTests.swift	
+++ b/Tests/SwiftDocCTests/Semantics/General Purpose Analyses/HasAtLeastOneTests.swift	
@@ -17,7 +17,7 @@ final class TestParent: Semantic, DirectiveConvertible {
     static let introducedVersion = "1.2.3"
     let originalMarkup: BlockDirective
     let testChildren: [TestChild]
-    init?(from directive: BlockDirective, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) {
+    init?(from directive: BlockDirective, source: URL?, for inputs: DocumentationContext.Inputs, problems: inout [Problem]) {
         precondition(TestParent.canConvertDirective(directive))
         self.originalMarkup = directive
         self.testChildren = directive.children.compactMap { child -> TestChild? in
@@ -25,7 +25,7 @@ final class TestParent: Semantic, DirectiveConvertible {
                 childDirective.name == TestChild.directiveName else {
                     return nil
             }
-            return TestChild(from: directive, source: nil, for: bundle, problems: &problems)
+            return TestChild(from: directive, source: nil, for: inputs, problems: &problems)
         }
     }
     
@@ -38,7 +38,7 @@ final class TestChild: Semantic, DirectiveConvertible {
     static let directiveName = "Child"
     static let introducedVersion = "1.2.3"
     let originalMarkup: BlockDirective
-    init?(from directive: BlockDirective, source: URL?, for bundle: DocumentationBundle, problems: inout [Problem]) {
+    init?(from directive: BlockDirective, source: URL?, for _: DocumentationContext.Inputs, problems: inout [Problem]) {
         precondition(TestChild.canConvertDirective(directive))
         self.originalMarkup = directive
     }
@@ -55,12 +55,12 @@ class HasAtLeastOneTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         do {
             var problems = [Problem]()
             directive.map { directive in
-                let (matches, remainder) = Semantic.Analyses.HasAtLeastOne<TestParent, TestChild>(severityIfNotFound: .error).analyze(directive, children: directive.children, source: nil, for: bundle, problems: &problems)
+                let (matches, remainder) = Semantic.Analyses.HasAtLeastOne<TestParent, TestChild>(severityIfNotFound: .error).analyze(directive, children: directive.children, source: nil, for: inputs, problems: &problems)
                 XCTAssertTrue(matches.isEmpty)
                 XCTAssertTrue(remainder.elements.isEmpty)
             }
@@ -75,7 +75,7 @@ class HasAtLeastOneTests: XCTestCase {
         do {
             var problems = [Problem]()
             directive.map { directive in
-                let (matches, remainder) = Semantic.Analyses.HasAtLeastOne<TestParent, TestChild>(severityIfNotFound: nil).analyze(directive, children: directive.children, source: nil, for: bundle, problems: &problems)
+                let (matches, remainder) = Semantic.Analyses.HasAtLeastOne<TestParent, TestChild>(severityIfNotFound: nil).analyze(directive, children: directive.children, source: nil, for: inputs, problems: &problems)
                 XCTAssertTrue(matches.isEmpty)
                 XCTAssertTrue(remainder.elements.isEmpty)
             }
@@ -94,10 +94,10 @@ class HasAtLeastOneTests: XCTestCase {
         var problems = [Problem]()
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
-            let (matches, remainder) = Semantic.Analyses.HasAtLeastOne<TestParent, TestChild>(severityIfNotFound: .error).analyze(directive, children: directive.children, source: nil, for: bundle, problems: &problems)
+            let (matches, remainder) = Semantic.Analyses.HasAtLeastOne<TestParent, TestChild>(severityIfNotFound: .error).analyze(directive, children: directive.children, source: nil, for: inputs, problems: &problems)
             XCTAssertEqual(1, matches.count)
             XCTAssertTrue(remainder.elements.isEmpty)
         }
@@ -117,10 +117,10 @@ class HasAtLeastOneTests: XCTestCase {
         var problems = [Problem]()
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
-            let (matches, remainder) = Semantic.Analyses.HasAtLeastOne<TestParent, TestChild>(severityIfNotFound: .error).analyze(directive, children: directive.children, source: nil, for: bundle, problems: &problems)
+            let (matches, remainder) = Semantic.Analyses.HasAtLeastOne<TestParent, TestChild>(severityIfNotFound: .error).analyze(directive, children: directive.children, source: nil, for: inputs, problems: &problems)
             XCTAssertEqual(3, matches.count)
             XCTAssertTrue(remainder.elements.isEmpty)
         }
@@ -138,10 +138,10 @@ class HasAtLeastOneTests: XCTestCase {
         var problems = [Problem]()
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
-            let (matches, remainder) = Semantic.Analyses.HasAtLeastOne<TestParent, TestChild>(severityIfNotFound: .error).analyze(directive, children: directive.children, source: nil, for: bundle, problems: &problems)
+            let (matches, remainder) = Semantic.Analyses.HasAtLeastOne<TestParent, TestChild>(severityIfNotFound: .error).analyze(directive, children: directive.children, source: nil, for: inputs, problems: &problems)
             XCTAssertEqual(1, matches.count)
             XCTAssertTrue(remainder.elements.isEmpty)
         }
diff --git a/Tests/SwiftDocCTests/Semantics/General Purpose Analyses/HasAtMostOneTests.swift b/Tests/SwiftDocCTests/Semantics/General Purpose Analyses/HasAtMostOneTests.swift
index 6a90fb619a..9fd0d1d010 100644
--- a/Tests/SwiftDocCTests/Semantics/General Purpose Analyses/HasAtMostOneTests.swift	
+++ b/Tests/SwiftDocCTests/Semantics/General Purpose Analyses/HasAtMostOneTests.swift	
@@ -19,11 +19,11 @@ class HasAtMostOneTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
-            let (match, remainder) = Semantic.Analyses.HasAtMostOne<TestParent, TestChild>().analyze(directive, children: directive.children, source: nil, for: bundle, problems: &problems)
+            let (match, remainder) = Semantic.Analyses.HasAtMostOne<TestParent, TestChild>().analyze(directive, children: directive.children, source: nil, for: inputs, problems: &problems)
             XCTAssertNil(match)
             XCTAssertTrue(remainder.isEmpty)
             XCTAssertTrue(problems.isEmpty)
@@ -40,11 +40,11 @@ class HasAtMostOneTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
-            let (match, remainder) = Semantic.Analyses.HasAtMostOne<TestParent, TestChild>().analyze(directive, children: directive.children, source: nil, for: bundle, problems: &problems)
+            let (match, remainder) = Semantic.Analyses.HasAtMostOne<TestParent, TestChild>().analyze(directive, children: directive.children, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(match)
             XCTAssertTrue(remainder.isEmpty)
             XCTAssertTrue(problems.isEmpty)
@@ -63,11 +63,11 @@ class HasAtMostOneTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
-            let (match, remainder) = Semantic.Analyses.HasAtMostOne<TestParent, TestChild>().analyze(directive, children: directive.children, source: nil, for: bundle, problems: &problems)
+            let (match, remainder) = Semantic.Analyses.HasAtMostOne<TestParent, TestChild>().analyze(directive, children: directive.children, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(match)
             XCTAssertTrue(remainder.isEmpty)
             XCTAssertEqual(2, problems.count)
@@ -90,11 +90,11 @@ class HasAtMostOneTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
-            let (match, remainder) = Semantic.Analyses.HasAtMostOne<TestParent, TestChild>().analyze(directive, children: directive.children, source: nil, for: bundle, problems: &problems)
+            let (match, remainder) = Semantic.Analyses.HasAtMostOne<TestParent, TestChild>().analyze(directive, children: directive.children, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(match)
             XCTAssertTrue(remainder.isEmpty)
             XCTAssertTrue(problems.isEmpty)
diff --git a/Tests/SwiftDocCTests/Semantics/General Purpose Analyses/HasExactlyOneTests.swift b/Tests/SwiftDocCTests/Semantics/General Purpose Analyses/HasExactlyOneTests.swift
index b64e8c7f19..94091bf1f0 100644
--- a/Tests/SwiftDocCTests/Semantics/General Purpose Analyses/HasExactlyOneTests.swift	
+++ b/Tests/SwiftDocCTests/Semantics/General Purpose Analyses/HasExactlyOneTests.swift	
@@ -19,11 +19,11 @@ class HasExactlyOneTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
-            let (match, remainder) = Semantic.Analyses.HasExactlyOne<TestParent, TestChild>(severityIfNotFound: .error).analyze(directive, children: directive.children, source: nil, for: bundle, problems: &problems)
+            let (match, remainder) = Semantic.Analyses.HasExactlyOne<TestParent, TestChild>(severityIfNotFound: .error).analyze(directive, children: directive.children, source: nil, for: inputs, problems: &problems)
             XCTAssertNil(match)
             XCTAssertTrue(remainder.isEmpty)
             XCTAssertEqual(1, problems.count)
@@ -50,11 +50,11 @@ class HasExactlyOneTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
-            let (match, remainder) = Semantic.Analyses.HasExactlyOne<TestParent, TestChild>(severityIfNotFound: .error).analyze(directive, children: directive.children, source: nil, for: bundle, problems: &problems)
+            let (match, remainder) = Semantic.Analyses.HasExactlyOne<TestParent, TestChild>(severityIfNotFound: .error).analyze(directive, children: directive.children, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(match)
             XCTAssertTrue(remainder.isEmpty)
             XCTAssertTrue(problems.isEmpty)
@@ -73,11 +73,11 @@ class HasExactlyOneTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
-            let (match, remainder) = Semantic.Analyses.HasExactlyOne<TestParent, TestChild>(severityIfNotFound: .error).analyze(directive, children: directive.children, source: nil, for: bundle, problems: &problems)
+            let (match, remainder) = Semantic.Analyses.HasExactlyOne<TestParent, TestChild>(severityIfNotFound: .error).analyze(directive, children: directive.children, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(match)
             XCTAssertTrue(remainder.isEmpty)
             XCTAssertEqual(2, problems.count)
@@ -102,11 +102,11 @@ class HasExactlyOneTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
-            let (match, remainder) = Semantic.Analyses.HasExactlyOne<TestParent, TestChild>(severityIfNotFound: .error).analyze(directive, children: directive.children, source: nil, for: bundle, problems: &problems)
+            let (match, remainder) = Semantic.Analyses.HasExactlyOne<TestParent, TestChild>(severityIfNotFound: .error).analyze(directive, children: directive.children, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(match)
             XCTAssertTrue(remainder.isEmpty)
             XCTAssertTrue(problems.isEmpty)
diff --git a/Tests/SwiftDocCTests/Semantics/General Purpose Analyses/HasOnlySequentialHeadingsTests.swift b/Tests/SwiftDocCTests/Semantics/General Purpose Analyses/HasOnlySequentialHeadingsTests.swift
index 85b351d8be..eb3f22763e 100644
--- a/Tests/SwiftDocCTests/Semantics/General Purpose Analyses/HasOnlySequentialHeadingsTests.swift	
+++ b/Tests/SwiftDocCTests/Semantics/General Purpose Analyses/HasOnlySequentialHeadingsTests.swift	
@@ -27,10 +27,10 @@ some more *stuff*
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
 
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         var problems: [Problem] = []
-        Semantic.Analyses.HasOnlySequentialHeadings<TutorialArticle>(severityIfFound: .warning, startingFromLevel: 2).analyze(containerDirective, children: document.children, source: nil, for: bundle, problems: &problems)
+        Semantic.Analyses.HasOnlySequentialHeadings<TutorialArticle>(severityIfFound: .warning, startingFromLevel: 2).analyze(containerDirective, children: document.children, source: nil, for: inputs, problems: &problems)
         
         XCTAssertTrue(problems.isEmpty)
     }
@@ -50,10 +50,10 @@ some more *stuff*
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
 
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         var problems: [Problem] = []
-        Semantic.Analyses.HasOnlySequentialHeadings<TutorialArticle>(severityIfFound: .warning, startingFromLevel: 2).analyze(containerDirective, children: document.children, source: nil, for: bundle, problems: &problems)
+        Semantic.Analyses.HasOnlySequentialHeadings<TutorialArticle>(severityIfFound: .warning, startingFromLevel: 2).analyze(containerDirective, children: document.children, source: nil, for: inputs, problems: &problems)
         
         XCTAssertTrue(problems.isEmpty)
     }
@@ -65,10 +65,10 @@ some more *stuff*
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
 
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         var problems: [Problem] = []
-        Semantic.Analyses.HasOnlySequentialHeadings<TutorialArticle>(severityIfFound: .warning, startingFromLevel: 2).analyze(containerDirective, children: document.children, source: nil, for: bundle, problems: &problems)
+        Semantic.Analyses.HasOnlySequentialHeadings<TutorialArticle>(severityIfFound: .warning, startingFromLevel: 2).analyze(containerDirective, children: document.children, source: nil, for: inputs, problems: &problems)
         
         XCTAssertEqual(problems.map { $0.diagnostic.summary },
                        [
@@ -86,10 +86,10 @@ some more *stuff*
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
 
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         var problems: [Problem] = []
-        Semantic.Analyses.HasOnlySequentialHeadings<TutorialArticle>(severityIfFound: .warning, startingFromLevel: 2).analyze(containerDirective, children: document.children, source: nil, for: bundle, problems: &problems)
+        Semantic.Analyses.HasOnlySequentialHeadings<TutorialArticle>(severityIfFound: .warning, startingFromLevel: 2).analyze(containerDirective, children: document.children, source: nil, for: inputs, problems: &problems)
         
         XCTAssertEqual(problems.map { $0.diagnostic.summary },
                        [
diff --git a/Tests/SwiftDocCTests/Semantics/ImageMediaTests.swift b/Tests/SwiftDocCTests/Semantics/ImageMediaTests.swift
index a3606604dd..eae2f36241 100644
--- a/Tests/SwiftDocCTests/Semantics/ImageMediaTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/ImageMediaTests.swift
@@ -19,9 +19,9 @@ class ImageMediaTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let image = ImageMedia(from: directive, source: nil, for: bundle, problems: &problems)
+        let image = ImageMedia(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(image)
         XCTAssertEqual(1, problems.count)
         XCTAssertFalse(problems.containsErrors)
@@ -38,9 +38,9 @@ class ImageMediaTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let image = ImageMedia(from: directive, source: nil, for: bundle, problems: &problems)
+        let image = ImageMedia(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(image)
         XCTAssertTrue(problems.isEmpty)
         image.map { image in
@@ -57,9 +57,9 @@ class ImageMediaTests: XCTestCase {
             """
             let document = Document(parsing: source, options: .parseBlockDirectives)
             let directive = document.child(at: 0)! as! BlockDirective
-            let (bundle, _) = try await testBundleAndContext()
+            let inputs = try await makeEmptyContext().inputs
             var problems = [Problem]()
-            let image = ImageMedia(from: directive, source: nil, for: bundle, problems: &problems)
+            let image = ImageMedia(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(image)
             XCTAssertTrue(problems.isEmpty)
             image.map { image in
@@ -75,9 +75,9 @@ class ImageMediaTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let image = ImageMedia(from: directive, source: nil, for: bundle, problems: &problems)
+        let image = ImageMedia(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(image)
         XCTAssertEqual(3, problems.count)
         XCTAssertFalse(problems.containsErrors)
@@ -96,45 +96,39 @@ class ImageMediaTests: XCTestCase {
     
     func testRenderImageDirectiveInReferenceMarkup() async throws {
         do {
-            let (renderedContent, problems, image) = try await parseDirective(ImageMedia.self, in: "BookLikeContent") {
+            let (renderedContent, problems, image) = try await parseDirective(ImageMedia.self, withAvailableAssetNames: ["figure1.jpg"]) {
                 """
                 @Image(source: "figure1")
                 """
             }
             
             XCTAssertNotNil(image)
-            
             XCTAssertEqual(problems, [])
-            
-            XCTAssertEqual(
-                renderedContent,
-                [
-                    RenderBlockContent.paragraph(RenderBlockContent.Paragraph(
-                        inlineContent: [.image(
-                            identifier: RenderReferenceIdentifier("figure1"),
-                            metadata: nil
-                        )]
-                    ))
-                ]
-            )
+            XCTAssertEqual(renderedContent, [
+                RenderBlockContent.paragraph(RenderBlockContent.Paragraph(
+                    inlineContent: [.image(
+                        identifier: RenderReferenceIdentifier("figure1"),
+                        metadata: nil
+                    )]
+                ))
+            ])
         }
         
         do {
-            let (renderedContent, problems, image) = try await parseDirective(ImageMedia.self, in: "BookLikeContent") {
+            let (renderedContent, problems, image) = try await parseDirective(ImageMedia.self, withAvailableAssetNames: []) {
                 """
                 @Image(source: "unknown-image")
                 """
             }
             
             XCTAssertNotNil(image)
-            
             XCTAssertEqual(problems, ["1: warning – org.swift.docc.unresolvedResource.Image"])
             XCTAssertEqual(renderedContent, [])
         }
     }
     
     func testRenderImageDirectiveWithCaption() async throws {
-        let (renderedContent, problems, image) = try await parseDirective(ImageMedia.self, in: "BookLikeContent") {
+        let (renderedContent, problems, image) = try await parseDirective(ImageMedia.self, withAvailableAssetNames: ["figure1.jpg"]) {
             """
             @Image(source: "figure1") {
                 This is my caption.
@@ -143,76 +137,61 @@ class ImageMediaTests: XCTestCase {
         }
         
         XCTAssertNotNil(image)
-        
         XCTAssertEqual(problems, [])
-        
-        XCTAssertEqual(
-            renderedContent,
-            [
-                RenderBlockContent.paragraph(RenderBlockContent.Paragraph(
-                    inlineContent: [.image(
-                        identifier: RenderReferenceIdentifier("figure1"),
-                        metadata: RenderContentMetadata(abstract: [.text("This is my caption.")])
-                    )]
-                ))
-            ]
-        )
+        XCTAssertEqual(renderedContent, [
+            RenderBlockContent.paragraph(RenderBlockContent.Paragraph(
+                inlineContent: [.image(
+                    identifier: RenderReferenceIdentifier("figure1"),
+                    metadata: RenderContentMetadata(abstract: [.text("This is my caption.")])
+                )]
+            ))
+        ])
     }
     
     func testImageDirectiveDiagnosesDeviceFrameByDefault() async throws {
-        let (renderedContent, problems, image) = try await parseDirective(ImageMedia.self, in: "BookLikeContent") {
+        let (renderedContent, problems, image) = try await parseDirective(ImageMedia.self, withAvailableAssetNames: ["figure1.jpg"]) {
             """
             @Image(source: "figure1", deviceFrame: phone)
             """
         }
         
         XCTAssertNotNil(image)
-        
         XCTAssertEqual(problems, ["1: warning – org.swift.docc.UnknownArgument"])
-        
-        XCTAssertEqual(
-            renderedContent,
-            [
-                RenderBlockContent.paragraph(RenderBlockContent.Paragraph(
-                    inlineContent: [.image(
-                        identifier: RenderReferenceIdentifier("figure1"),
-                        metadata: nil
-                    )]
-                ))
-            ]
-        )
+        XCTAssertEqual(renderedContent, [
+            RenderBlockContent.paragraph(RenderBlockContent.Paragraph(
+                inlineContent: [.image(
+                    identifier: RenderReferenceIdentifier("figure1"),
+                    metadata: nil
+                )]
+            ))
+        ])
     }
     
     func testRenderImageDirectiveWithDeviceFrame() async throws {
         enableFeatureFlag(\.isExperimentalDeviceFrameSupportEnabled)
         
-        let (renderedContent, problems, image) = try await parseDirective(ImageMedia.self, in: "BookLikeContent") {
+        let (renderedContent, problems, image) = try await parseDirective(ImageMedia.self, withAvailableAssetNames: ["figure1.jpg"]) {
             """
             @Image(source: "figure1", deviceFrame: phone)
             """
         }
         
         XCTAssertNotNil(image)
-        
         XCTAssertEqual(problems, [])
-        
-        XCTAssertEqual(
-            renderedContent,
-            [
-                RenderBlockContent.paragraph(RenderBlockContent.Paragraph(
-                    inlineContent: [.image(
-                        identifier: RenderReferenceIdentifier("figure1"),
-                        metadata: RenderContentMetadata(deviceFrame: "phone")
-                    )]
-                ))
-            ]
-        )
+        XCTAssertEqual(renderedContent, [
+            RenderBlockContent.paragraph(RenderBlockContent.Paragraph(
+                inlineContent: [.image(
+                    identifier: RenderReferenceIdentifier("figure1"),
+                    metadata: RenderContentMetadata(deviceFrame: "phone")
+                )]
+            ))
+        ])
     }
     
     func testRenderImageDirectiveWithDeviceFrameAndCaption() async throws {
         enableFeatureFlag(\.isExperimentalDeviceFrameSupportEnabled)
         
-        let (renderedContent, problems, image) = try await parseDirective(ImageMedia.self, in: "BookLikeContent") {
+        let (renderedContent, problems, image) = try await parseDirective(ImageMedia.self, withAvailableAssetNames: ["figure1.jpg"]) {
             """
             @Image(source: "figure1", deviceFrame: laptop) {
                 This is my caption.
@@ -221,43 +200,35 @@ class ImageMediaTests: XCTestCase {
         }
         
         XCTAssertNotNil(image)
-        
         XCTAssertEqual(problems, [])
-        
-        XCTAssertEqual(
-            renderedContent,
-            [
-                RenderBlockContent.paragraph(RenderBlockContent.Paragraph(
-                    inlineContent: [.image(
-                        identifier: RenderReferenceIdentifier("figure1"),
-                        metadata: RenderContentMetadata(abstract: [.text("This is my caption.")], deviceFrame: "laptop")
-                    )]
-                ))
-            ]
-        )
+        XCTAssertEqual(renderedContent, [
+            RenderBlockContent.paragraph(RenderBlockContent.Paragraph(
+                inlineContent: [.image(
+                    identifier: RenderReferenceIdentifier("figure1"),
+                    metadata: RenderContentMetadata(abstract: [.text("This is my caption.")], deviceFrame: "laptop")
+                )]
+            ))
+        ])
     }
     
     func testImageDirectiveDoesNotResolveVideoReference() async throws {
         // First check that the Video exists
-        let (_, videoProblems, _) = try await parseDirective(VideoMedia.self, in: "LegacyBundle_DoNotUseInNewTests") {
+        let (_, videoProblems, _) = try await parseDirective(VideoMedia.self, withAvailableAssetNames: ["introvideo.mp4"]) {
             """
             @Video(source: "introvideo")
             """
         }
-        
         XCTAssertEqual(videoProblems, [])
         
         // Then check that it doesn't resolve as an image
-        let (renderedContent, imageProblems, image) = try await parseDirective(ImageMedia.self, in: "LegacyBundle_DoNotUseInNewTests") {
+        let (renderedContent, imageProblems, image) = try await parseDirective(ImageMedia.self, withAvailableAssetNames: ["introvideo.mp4"]) {
             """
             @Image(source: "introvideo")
             """
         }
-        
         XCTAssertNotNil(image)
-        
         XCTAssertEqual(imageProblems, ["1: warning – org.swift.docc.unresolvedResource.Image"])
-        
         XCTAssertEqual(renderedContent, [])
     }
 }
+
diff --git a/Tests/SwiftDocCTests/Semantics/IntroTests.swift b/Tests/SwiftDocCTests/Semantics/IntroTests.swift
index 6b38105a28..4370aa6732 100644
--- a/Tests/SwiftDocCTests/Semantics/IntroTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/IntroTests.swift
@@ -17,9 +17,9 @@ class IntroTests: XCTestCase {
         let source = "@Intro"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let intro = Intro(from: directive, source: nil, for: bundle, problems: &problems)
+        let intro = Intro(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(intro)
         XCTAssertEqual(1, problems.count)
         XCTAssertFalse(problems.containsErrors)
@@ -42,9 +42,9 @@ class IntroTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let intro = Intro(from: directive, source: nil, for: bundle, problems: &problems)
+        let intro = Intro(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(intro)
         XCTAssertTrue(problems.isEmpty)
         intro.map { intro in
@@ -68,9 +68,9 @@ class IntroTests: XCTestCase {
         
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let intro = Intro(from: directive, source: nil, for: bundle, problems: &problems)
+        let intro = Intro(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(intro)
         XCTAssertEqual(2, problems.count)
         XCTAssertFalse(problems.containsErrors)
diff --git a/Tests/SwiftDocCTests/Semantics/JustificationTests.swift b/Tests/SwiftDocCTests/Semantics/JustificationTests.swift
index 247169b9f9..56cc4300b3 100644
--- a/Tests/SwiftDocCTests/Semantics/JustificationTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/JustificationTests.swift
@@ -19,12 +19,12 @@ class JustificationTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(directive.name, Justification.directiveName)
-            let justification = Justification(from: directive, source: nil, for: bundle, problems: &problems)
+            let justification = Justification(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(justification)
             XCTAssertNil(justification?.reaction)
             XCTAssertTrue(problems.isEmpty)
@@ -44,12 +44,12 @@ class JustificationTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(directive.name, Justification.directiveName)
-            let justification = Justification(from: directive, source: nil, for: bundle, problems: &problems)
+            let justification = Justification(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertTrue(problems.isEmpty)
             XCTAssertNotNil(justification)
             XCTAssertEqual(justification?.reaction, "Correct!")
diff --git a/Tests/SwiftDocCTests/Semantics/MarkupReferenceResolverTests.swift b/Tests/SwiftDocCTests/Semantics/MarkupReferenceResolverTests.swift
index b996285011..16334fc06a 100644
--- a/Tests/SwiftDocCTests/Semantics/MarkupReferenceResolverTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/MarkupReferenceResolverTests.swift
@@ -11,10 +11,15 @@
 import XCTest
 @testable import SwiftDocC
 import Markdown
+import SwiftDocCTestUtilities
 
 class MarkupReferenceResolverTests: XCTestCase {
     func testArbitraryReferenceInComment() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let catalog = Folder(name: "unit-test.docc", content: [
+            JSONFile(name: "ModuleName.symbols.json", content: makeSymbolGraph(moduleName: "ModuleName"))
+        ])
+        
+        let context = try await load(catalog: catalog)
         let source = """
         @Comment {
             ``hello`` and ``world`` are 2 arbitrary symbol links.
@@ -23,13 +28,13 @@ class MarkupReferenceResolverTests: XCTestCase {
         }
         """
         let document = Document(parsing: source, options: [.parseBlockDirectives, .parseSymbolLinks])
-        var resolver = MarkupReferenceResolver(context: context, bundle: bundle, rootReference: context.rootModules[0])
+        var resolver = MarkupReferenceResolver(context: context, rootReference: context.rootModules[0])
         _ = resolver.visit(document)
         XCTAssertEqual(0, resolver.problems.count)
     }
 
     func testDuplicatedDiagnosticForExtensionFile() async throws {
-        let (_, context) = try await testBundleAndContext(named: "ExtensionArticleBundle")
+        let context = try await loadFromDisk(catalogName: "ExtensionArticleBundle")
         // Before #733, symbols with documentation extension files emitted duplicated problems:
         // - one with a source location in the in-source documentation comment
         // - one with a source location in the documentation extension file.
diff --git a/Tests/SwiftDocCTests/Semantics/MetadataAvailabilityTests.swift b/Tests/SwiftDocCTests/Semantics/MetadataAvailabilityTests.swift
index 52292a079e..885e348f8a 100644
--- a/Tests/SwiftDocCTests/Semantics/MetadataAvailabilityTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/MetadataAvailabilityTests.swift
@@ -158,12 +158,12 @@ class MetadataAvailabilityTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
 
-        let (bundle, _) = try await testBundleAndContext(named: "AvailabilityBundle")
+        let inputs = try await loadFromDisk(catalogName: "AvailabilityBundle").inputs
 
         try directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(Directive.directiveName, directive.name)
-            let converted = Directive(from: directive, source: nil, for: bundle, problems: &problems)
+            let converted = Directive(from: directive, source: nil, for: inputs, problems: &problems)
             try assert(converted, problems)
         }
     }
diff --git a/Tests/SwiftDocCTests/Semantics/MetadataTests.swift b/Tests/SwiftDocCTests/Semantics/MetadataTests.swift
index 8f7f713a82..a34d6a72a4 100644
--- a/Tests/SwiftDocCTests/Semantics/MetadataTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/MetadataTests.swift
@@ -19,9 +19,9 @@ class MetadataTests: XCTestCase {
         let source = "@Metadata"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let metadata = Metadata(from: directive, source: nil, for: bundle, problems: &problems)
+        let metadata = Metadata(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(metadata, "Even if a Metadata directive is empty we can create it")
         XCTAssertEqual(1, problems.count)
         XCTAssertEqual("org.swift.docc.Metadata.NoConfiguration", problems.first?.diagnostic.identifier)
@@ -33,9 +33,9 @@ class MetadataTests: XCTestCase {
         let source = "@Metadata(argument: value)"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let metadata = Metadata(from: directive, source: nil, for: bundle, problems: &problems)
+        let metadata = Metadata(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(metadata, "Even if there are warnings we can create a metadata value")
         XCTAssertEqual(2, problems.count)
         XCTAssertEqual("org.swift.docc.UnknownArgument", problems.first?.diagnostic.identifier)
@@ -50,9 +50,9 @@ class MetadataTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let metadata = Metadata(from: directive, source: nil, for: bundle, problems: &problems)
+        let metadata = Metadata(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(metadata, "Even if there are warnings we can create a Metadata value")
         XCTAssertEqual(3, problems.count)
         XCTAssertEqual("org.swift.docc.HasOnlyKnownDirectives", problems.first?.diagnostic.identifier)
@@ -69,9 +69,9 @@ class MetadataTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let metadata = Metadata(from: directive, source: nil, for: bundle, problems: &problems)
+        let metadata = Metadata(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(metadata, "Even if there are warnings we can create a Metadata value")
         XCTAssertEqual(2, problems.count)
         XCTAssertEqual("org.swift.docc.Metadata.UnexpectedContent", problems.first?.diagnostic.identifier)
@@ -88,9 +88,9 @@ class MetadataTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let metadata = Metadata(from: directive, source: nil, for: bundle, problems: &problems)
+        let metadata = Metadata(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(metadata)
         XCTAssertEqual(0, problems.count)
         XCTAssertEqual(metadata?.documentationOptions?.behavior, .override)
@@ -105,9 +105,9 @@ class MetadataTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let metadata = Metadata(from: directive, source: nil, for: bundle, problems: &problems)
+        let metadata = Metadata(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(metadata)
         XCTAssertEqual(2, problems.count)
         XCTAssertEqual(problems.map(\.diagnostic.identifier).sorted(), [
@@ -125,9 +125,9 @@ class MetadataTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let metadata = Metadata(from: directive, source: nil, for: bundle, problems: &problems)
+        let metadata = Metadata(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(metadata)
         XCTAssert(problems.isEmpty, "There shouldn't be any problems. Got:\n\(problems.map { $0.diagnostic.summary })")
         
@@ -142,9 +142,9 @@ class MetadataTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let metadata = Metadata(from: directive, source: nil, for: bundle, problems: &problems)
+        let metadata = Metadata(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(metadata)
         XCTAssert(problems.isEmpty, "There shouldn't be any problems. Got:\n\(problems.map { $0.diagnostic.summary })")
         
@@ -160,9 +160,9 @@ class MetadataTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let metadata = Metadata(from: directive, source: nil, for: bundle, problems: &problems)
+        let metadata = Metadata(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(metadata)
         XCTAssertEqual(metadata?.customMetadata.count, 2)
         XCTAssertEqual(problems.count, 0)
@@ -176,9 +176,9 @@ class MetadataTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let metadata = Metadata(from: directive, source: nil, for: bundle, problems: &problems)
+        let metadata = Metadata(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(metadata)
         XCTAssertEqual(0, problems.count)
         XCTAssertEqual(metadata?.redirects?.first?.oldPath.relativePath, "some/other/path")
@@ -197,13 +197,13 @@ class MetadataTests: XCTestCase {
         The abstract of this article
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = Article(from: document, source: nil, for: bundle, problems: &problems)
+        let article = Article(from: document, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(article, "An Article value can be created with a Metadata child.")
         XCTAssert(problems.isEmpty, "There shouldn't be any problems. Got:\n\(problems.map { $0.diagnostic.summary })")
         
-        var analyzer = SemanticAnalyzer(source: nil, bundle: bundle)
+        var analyzer = SemanticAnalyzer(source: nil, inputs: inputs)
         _ = analyzer.visit(document)
         XCTAssert(analyzer.problems.isEmpty, "Expected no problems. Got:\n \(DiagnosticConsoleWriter.formattedDescription(for: analyzer.problems))")
     }
@@ -219,15 +219,15 @@ class MetadataTests: XCTestCase {
         The abstract of this documentation extension
         """
         let document = Document(parsing: source, options:  [.parseBlockDirectives, .parseSymbolLinks])
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = Article(from: document, source: nil, for: bundle, problems: &problems)
+        let article = Article(from: document, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(article, "An Article value can be created with a Metadata child with a DisplayName child.")
         XCTAssertNotNil(article?.metadata?.displayName, "The Article has the parsed DisplayName metadata.")
         
         XCTAssert(problems.isEmpty, "There shouldn't be any problems. Got:\n\(problems.map { $0.diagnostic.summary })")
         
-        var analyzer = SemanticAnalyzer(source: nil, bundle: bundle)
+        var analyzer = SemanticAnalyzer(source: nil, inputs: inputs)
         _ = analyzer.visit(document)
         XCTAssert(analyzer.problems.isEmpty, "Expected no problems. Got:\n \(DiagnosticConsoleWriter.formattedDescription(for: analyzer.problems))")
     }
@@ -243,9 +243,9 @@ class MetadataTests: XCTestCase {
         The abstract of this documentation extension
         """
         let document = Document(parsing: source, options: [.parseBlockDirectives, .parseSymbolLinks])
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = Article(from: document, source: nil, for: bundle, problems: &problems)
+        let article = Article(from: document, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(article, "An Article value can be created with a Metadata child with a DisplayName child.")
         XCTAssertNotNil(article?.metadata, "The Article has the parsed Metadata")
         XCTAssertNil(article?.metadata?.displayName, "The Article doesn't have the DisplayName")
@@ -279,16 +279,16 @@ class MetadataTests: XCTestCase {
         The abstract of this documentation extension
         """
         let document = Document(parsing: source, options:  [.parseBlockDirectives, .parseSymbolLinks])
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = Article(from: document, source: nil, for: bundle, problems: &problems)
+        let article = Article(from: document, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(article, "An Article value can be created with a Metadata child with a TitleHeading child.")
         XCTAssertNotNil(article?.metadata?.titleHeading, "The Article has the parsed TitleHeading metadata.")
         XCTAssertEqual(article?.metadata?.titleHeading?.heading, "Custom Heading")
         
         XCTAssert(problems.isEmpty, "There shouldn't be any problems. Got:\n\(problems.map { $0.diagnostic.summary })")
         
-        var analyzer = SemanticAnalyzer(source: nil, bundle: bundle)
+        var analyzer = SemanticAnalyzer(source: nil, inputs: inputs)
         _ = analyzer.visit(document)
         XCTAssert(analyzer.problems.isEmpty, "Expected no problems. Got:\n \(DiagnosticConsoleWriter.formattedDescription(for: analyzer.problems))")
     }
@@ -307,9 +307,9 @@ class MetadataTests: XCTestCase {
         The abstract of this documentation extension
         """
         let document = Document(parsing: source, options: [.parseBlockDirectives, .parseSymbolLinks])
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = Article(from: document, source: nil, for: bundle, problems: &problems)
+        let article = Article(from: document, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(article, "An Article value can be created with a Metadata child with a DisplayName child.")
         XCTAssertNotNil(article?.metadata, "The Article has the parsed Metadata")
         XCTAssertNil(article?.metadata?.displayName, "The Article doesn't have the DisplayName")
@@ -418,10 +418,9 @@ class MetadataTests: XCTestCase {
         line: UInt = #line
     ) async throws -> (problems: [String], metadata: Metadata) {
         let document = Document(parsing: source, options: [.parseBlockDirectives, .parseSymbolLinks])
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
-        
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = Article(from: document, source: nil, for: bundle, problems: &problems)
+        let article = Article(from: document, source: nil, for: inputs, problems: &problems)
         
         let problemIDs = problems.map { problem -> String in
             let line = problem.diagnostic.range?.lowerBound.line.description ?? "unknown-line"
diff --git a/Tests/SwiftDocCTests/Semantics/MultipleChoiceTests.swift b/Tests/SwiftDocCTests/Semantics/MultipleChoiceTests.swift
index 87ac419248..2fa392c956 100644
--- a/Tests/SwiftDocCTests/Semantics/MultipleChoiceTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/MultipleChoiceTests.swift
@@ -11,6 +11,7 @@
 import XCTest
 @testable import SwiftDocC
 import Markdown
+import SwiftDocCTestUtilities
 
 class MultipleChoiceTests: XCTestCase {
     func testInvalidEmpty() async throws {
@@ -19,12 +20,12 @@ class MultipleChoiceTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(MultipleChoice.directiveName, directive.name)
-            let multipleChoice = MultipleChoice(from: directive, source: nil, for: bundle, problems: &problems)
+            let multipleChoice = MultipleChoice(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNil(multipleChoice)
             XCTAssertEqual(3, problems.count)
             let diagnosticIdentifiers = Set(problems.map { $0.diagnostic.identifier })
@@ -53,12 +54,12 @@ class MultipleChoiceTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         
         try directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(MultipleChoice.directiveName, directive.name)
-            let multipleChoice = MultipleChoice(from: directive, source: nil, for: bundle, problems: &problems)
+            let multipleChoice = MultipleChoice(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(multipleChoice)
             XCTAssertEqual(1, problems.count)
             let problem = try XCTUnwrap(
@@ -101,12 +102,15 @@ class MultipleChoiceTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await load(catalog: Folder(name: "Something.docc", content: [
+            DataFile(name: "blah.png", data: Data()),
+            InfoPlist(identifier: "org.swift.docc.example")
+        ]))
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(MultipleChoice.directiveName, directive.name)
-            let multipleChoice = MultipleChoice(from: directive, source: nil, for: bundle, problems: &problems)
+            let multipleChoice = MultipleChoice(from: directive, source: nil, for: context.inputs, problems: &problems)
             XCTAssertNotNil(multipleChoice)
             XCTAssertFalse(problems.isEmpty)
             problems.first.map {
@@ -158,12 +162,12 @@ MultipleChoice @1:1-24:2 title: 'SwiftDocC.MarkupContainer'
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(MultipleChoice.directiveName, directive.name)
-            let multipleChoice = MultipleChoice(from: directive, source: nil, for: bundle, problems: &problems)
+            let multipleChoice = MultipleChoice(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(multipleChoice)
             XCTAssertTrue(problems.isEmpty)
             
@@ -214,12 +218,12 @@ MultipleChoice @1:1-18:2 title: 'SwiftDocC.MarkupContainer'
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(MultipleChoice.directiveName, directive.name)
-            let multipleChoice = MultipleChoice(from: directive, source: nil, for: bundle, problems: &problems)
+            let multipleChoice = MultipleChoice(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(multipleChoice)
             XCTAssertTrue(problems.isEmpty)
             
@@ -274,12 +278,12 @@ MultipleChoice @1:1-22:2 title: 'SwiftDocC.MarkupContainer'
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = try XCTUnwrap(document.child(at: 0) as? BlockDirective)
         
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         
         var problems = [Problem]()
         XCTAssertEqual(MultipleChoice.directiveName, directive.name)
         
-        let multipleChoice = MultipleChoice(from: directive, source: nil, for: bundle, problems: &problems)
+        let multipleChoice = MultipleChoice(from: directive, source: nil, for: inputs, problems: &problems)
         
         XCTAssertNotNil(multipleChoice)
         XCTAssertEqual(1, problems.count)
diff --git a/Tests/SwiftDocCTests/Semantics/RedirectedTests.swift b/Tests/SwiftDocCTests/Semantics/RedirectedTests.swift
index ccf72c18fe..c593515b1c 100644
--- a/Tests/SwiftDocCTests/Semantics/RedirectedTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/RedirectedTests.swift
@@ -19,9 +19,9 @@ class RedirectedTests: XCTestCase {
         let source = "@Redirected"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let redirected = Redirect(from: directive, source: nil, for: bundle, problems: &problems)
+        let redirected = Redirect(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(redirected)
         XCTAssertEqual(1, problems.count)
         XCTAssertFalse(problems.containsErrors)
@@ -33,9 +33,9 @@ class RedirectedTests: XCTestCase {
         let source = "@Redirected(from: \(oldPath))"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let redirected = Redirect(from: directive, source: nil, for: bundle, problems: &problems)
+        let redirected = Redirect(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(redirected)
         XCTAssertTrue(problems.isEmpty)
         XCTAssertEqual(redirected?.oldPath.path, oldPath)
@@ -46,9 +46,9 @@ class RedirectedTests: XCTestCase {
         let source = "@Redirected(from: \(oldPath), argument: value)"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let redirected = Redirect(from: directive, source: nil, for: bundle, problems: &problems)
+        let redirected = Redirect(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(redirected, "Even if there are warnings we can create a Redirected value")
         XCTAssertFalse(problems.containsErrors)
         XCTAssertEqual(1, problems.count)
@@ -64,9 +64,9 @@ class RedirectedTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let redirected = Redirect(from: directive, source: nil, for: bundle, problems: &problems)
+        let redirected = Redirect(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(redirected, "Even if there are warnings we can create a Redirected value")
         XCTAssertEqual(2, problems.count)
         XCTAssertFalse(problems.containsErrors)
@@ -83,9 +83,9 @@ class RedirectedTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let redirected = Redirect(from: directive, source: nil, for: bundle, problems: &problems)
+        let redirected = Redirect(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(redirected, "Even if there are warnings we can create a Redirected value")
         XCTAssertFalse(problems.containsErrors)
         XCTAssertEqual(1, problems.count)
@@ -107,13 +107,13 @@ class RedirectedTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let tutorialTableOfContents = TutorialTableOfContents(from: directive, source: nil, for: bundle, problems: &problems)
+        let tutorialTableOfContents = TutorialTableOfContents(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(tutorialTableOfContents, "A tutorial table-of-contents value can be created with a Redirected child.")
         XCTAssert(problems.isEmpty, "There shouldn't be any problems. Got:\n\(problems.map { $0.diagnostic.summary })")
         
-        var analyzer = SemanticAnalyzer(source: nil, bundle: bundle)
+        var analyzer = SemanticAnalyzer(source: nil, inputs: inputs)
         _ = analyzer.visit(document)
         XCTAssert(analyzer.problems.isEmpty, "Expected no problems. Got \(DiagnosticConsoleWriter.formattedDescription(for:  analyzer.problems))")
     }
@@ -139,9 +139,9 @@ class RedirectedTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let volume = Volume(from: directive, source: nil, for: bundle, problems: &problems)
+        let volume = Volume(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(volume, "A Volume value can be created with a Redirected child.")
         XCTAssert(problems.isEmpty, "There shouldn't be any problems. Got:\n\(problems.map { $0.diagnostic.summary })")
     }
@@ -204,13 +204,13 @@ class RedirectedTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let tutorial = Tutorial(from: directive, source: nil, for: bundle, problems: &problems)
+        let tutorial = Tutorial(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(tutorial, "A Tutorial value can be created with a Redirected child.")
         XCTAssert(problems.isEmpty, "There shouldn't be any problems. Got:\n\(problems.map { $0.diagnostic.summary })")
         
-        var analyzer = SemanticAnalyzer(source: nil, bundle: bundle)
+        var analyzer = SemanticAnalyzer(source: nil, inputs: inputs)
         _ = analyzer.visit(document)
         XCTAssert(analyzer.problems.isEmpty, "Expected no problems. Got \(DiagnosticConsoleWriter.formattedDescription(for:  analyzer.problems))")
     }
@@ -232,13 +232,13 @@ class RedirectedTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = TutorialArticle(from: directive, source: nil, for: bundle, problems: &problems)
+        let article = TutorialArticle(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(article, "A TutorialArticle value can be created with a Redirected child.")
         XCTAssert(problems.isEmpty, "There shouldn't be any problems. Got:\n\(problems.map { $0.diagnostic.summary })")
         
-        var analyzer = SemanticAnalyzer(source: nil, bundle: bundle)
+        var analyzer = SemanticAnalyzer(source: nil, inputs: inputs)
         _ = analyzer.visit(document)
         XCTAssert(analyzer.problems.isEmpty, "Expected no problems. Got \(DiagnosticConsoleWriter.formattedDescription(for:  analyzer.problems))")
     }
@@ -281,9 +281,9 @@ class RedirectedTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = Resources(from: directive, source: nil, for: bundle, problems: &problems)
+        let article = Resources(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(article, "A Resources value can be created with a Redirected child.")
         XCTAssert(problems.isEmpty, "There shouldn't be any problems. Got:\n\(problems.map { $0.diagnostic.summary })")
     }
@@ -302,13 +302,13 @@ class RedirectedTests: XCTestCase {
         ![full width image](referenced-article-image.png)
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = Article(from: document, source: nil, for: bundle, problems: &problems)
+        let article = Article(from: document, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(article, "An Article value can be created with a Redirected child.")
         XCTAssert(problems.isEmpty, "There shouldn't be any problems. Got:\n\(problems.map { $0.diagnostic.summary })")
 
-        var analyzer = SemanticAnalyzer(source: nil, bundle: bundle)
+        var analyzer = SemanticAnalyzer(source: nil, inputs: inputs)
         _ = analyzer.visit(document)
         XCTAssert(analyzer.problems.isEmpty, "Expected no problems. Got \(DiagnosticConsoleWriter.formattedDescription(for:  analyzer.problems))")
 
@@ -337,13 +337,13 @@ class RedirectedTests: XCTestCase {
         ![full width image](referenced-article-image.png)
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = Article(from: document, source: nil, for: bundle, problems: &problems)
+        let article = Article(from: document, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(article, "An Article value can be created with a Redirected child.")
         XCTAssert(problems.isEmpty, "There shouldn't be any problems. Got:\n\(problems.map { $0.diagnostic.summary })")
 
-        var analyzer = SemanticAnalyzer(source: nil, bundle: bundle)
+        var analyzer = SemanticAnalyzer(source: nil, inputs: inputs)
         _ = analyzer.visit(document)
         XCTAssert(analyzer.problems.isEmpty, "Expected no problems. Got \(DiagnosticConsoleWriter.formattedDescription(for:  analyzer.problems))")
 
@@ -374,13 +374,13 @@ class RedirectedTests: XCTestCase {
         ![full width image](referenced-article-image.png)
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let article = Article(from: document, source: nil, for: bundle, problems: &problems)
+        let article = Article(from: document, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(article, "An Article value can be created with a Redirected child.")
         XCTAssert(problems.isEmpty, "There shouldn't be any problems. Got:\n\(problems.map { $0.diagnostic.summary })")
                 
-        var analyzer = SemanticAnalyzer(source: nil, bundle: bundle)
+        var analyzer = SemanticAnalyzer(source: nil, inputs: inputs)
         _ = analyzer.visit(document)
         XCTAssert(analyzer.problems.isEmpty, "Expected no problems. Got \(DiagnosticConsoleWriter.formattedDescription(for:  analyzer.problems))")
 
@@ -398,9 +398,9 @@ class RedirectedTests: XCTestCase {
         let source = "@Redirected(fromURL: /old/path)"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let redirected = Redirect(from: directive, source: nil, for: bundle, problems: &problems)
+        let redirected = Redirect(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(redirected)
         XCTAssertEqual(2, problems.count)
         XCTAssertFalse(problems.containsErrors)
diff --git a/Tests/SwiftDocCTests/Semantics/Reference/LinksTests.swift b/Tests/SwiftDocCTests/Semantics/Reference/LinksTests.swift
index 8cc0d75e80..3a26a0b1f5 100644
--- a/Tests/SwiftDocCTests/Semantics/Reference/LinksTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/Reference/LinksTests.swift
@@ -17,7 +17,7 @@ import Markdown
 class LinksTests: XCTestCase {
     func testMissingBasicRequirements() async throws {
         do {
-            let (renderedContent, problems, links) = try await parseDirective(Links.self, in: "BookLikeContent") {
+            let (renderedContent, problems, links) = try await parseDirective(Links.self) {
                 """
                 @Links(visualStyle: compactGrid)
                 """
@@ -57,7 +57,7 @@ class LinksTests: XCTestCase {
     
     func testInvalidBodyContent() async throws {
         do {
-            let (renderedContent, problems, links) = try await parseDirective(Links.self, in: "BookLikeContent") {
+            let (renderedContent, problems, links) = try await parseDirective(Links.self) {
                 """
                 @Links(visualStyle: compactGrid) {
                     This is a paragraph of text in 'Links' directive.
diff --git a/Tests/SwiftDocCTests/Semantics/ResourcesTests.swift b/Tests/SwiftDocCTests/Semantics/ResourcesTests.swift
index e80b876609..b5a4186470 100644
--- a/Tests/SwiftDocCTests/Semantics/ResourcesTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/ResourcesTests.swift
@@ -17,9 +17,9 @@ class ResourcesTests: XCTestCase {
         let source = "@\(Resources.directiveName)"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let resources = Resources(from: directive, source: nil, for: bundle, problems: &problems)
+        let resources = Resources(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(resources)
         XCTAssertEqual(1, problems.count)
       
@@ -67,9 +67,9 @@ class ResourcesTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let resources = Resources(from: directive, source: nil, for: bundle, problems: &problems)
+        let resources = Resources(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(resources)
         XCTAssertTrue(problems.isEmpty, "Unexpected problems: \(problems)")
         
@@ -120,9 +120,9 @@ Resources @1:1-29:2
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let resources = Resources(from: directive, source: nil, for: bundle, problems: &problems)
+        let resources = Resources(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(resources)
         XCTAssertFalse(problems.containsErrors)
         
diff --git a/Tests/SwiftDocCTests/Semantics/SectionTests.swift b/Tests/SwiftDocCTests/Semantics/SectionTests.swift
index fbbd367833..f6df3cc2e7 100644
--- a/Tests/SwiftDocCTests/Semantics/SectionTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/SectionTests.swift
@@ -19,9 +19,9 @@ class TutorialSectionTests: XCTestCase {
         let source = "@Section"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let section = TutorialSection(from: directive, source: nil, for: bundle, problems: &problems)
+        let section = TutorialSection(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(section)
         XCTAssertEqual(2, problems.count)
         XCTAssertEqual(
diff --git a/Tests/SwiftDocCTests/Semantics/SnippetTests.swift b/Tests/SwiftDocCTests/Semantics/SnippetTests.swift
index 25e4bde699..1e8b9ec21c 100644
--- a/Tests/SwiftDocCTests/Semantics/SnippetTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/SnippetTests.swift
@@ -16,21 +16,21 @@ import Markdown
 
 class SnippetTests: XCTestCase {
     func testNoPath() async throws {
-        let (bundle, _) = try await testBundleAndContext(named: "Snippets")
+        let inputs = try await loadFromDisk(catalogName: "Snippets").inputs
         let source = """
         @Snippet()
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0) as! BlockDirective
         var problems = [Problem]()
-        XCTAssertNil(Snippet(from: directive, source: nil, for: bundle, problems: &problems))
+        XCTAssertNil(Snippet(from: directive, source: nil, for: inputs, problems: &problems))
         XCTAssertEqual(1, problems.count)
         XCTAssertEqual(.warning, problems[0].diagnostic.severity)
         XCTAssertEqual("org.swift.docc.HasArgument.path", problems[0].diagnostic.identifier)
     }
 
     func testHasInnerContent() async throws {
-        let (bundle, _) = try await testBundleAndContext(named: "Snippets")
+        let inputs = try await loadFromDisk(catalogName: "Snippets").inputs
         let source = """
         @Snippet(path: "path/to/snippet") {
             This content shouldn't be here.
@@ -39,33 +39,33 @@ class SnippetTests: XCTestCase {
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0) as! BlockDirective
         var problems = [Problem]()
-        XCTAssertNotNil(Snippet(from: directive, source: nil, for: bundle, problems: &problems))
+        XCTAssertNotNil(Snippet(from: directive, source: nil, for: inputs, problems: &problems))
         XCTAssertEqual(1, problems.count)
         XCTAssertEqual(.warning, problems[0].diagnostic.severity)
         XCTAssertEqual("org.swift.docc.Snippet.NoInnerContentAllowed", problems[0].diagnostic.identifier)
     }
 
     func testLinkResolves() async throws {
-        let (bundle, _) = try await testBundleAndContext(named: "Snippets")
+        let inputs = try await loadFromDisk(catalogName: "Snippets").inputs
         let source = """
         @Snippet(path: "Test/Snippets/MySnippet")
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0) as! BlockDirective
         var problems = [Problem]()
-        let snippet = try XCTUnwrap(Snippet(from: directive, source: nil, for: bundle, problems: &problems))
+        let snippet = try XCTUnwrap(Snippet(from: directive, source: nil, for: inputs, problems: &problems))
         XCTAssertEqual("Test/Snippets/MySnippet", snippet.path)
         XCTAssertNotNil(snippet)
         XCTAssertTrue(problems.isEmpty)
     }
     
     func testUnresolvedSnippetPathDiagnostic() async throws {
-        let (bundle, context) = try await testBundleAndContext(named: "Snippets")
+        let context = try await loadFromDisk(catalogName: "Snippets")
         let source = """
         @Snippet(path: "Test/Snippets/DoesntExist")
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
-        var resolver = MarkupReferenceResolver(context: context, bundle: bundle, rootReference: context.rootModules[0])
+        var resolver = MarkupReferenceResolver(context: context, rootReference: context.rootModules[0])
         _ = resolver.visit(document)
         XCTAssertEqual(1, resolver.problems.count)
         resolver.problems.first.map {
@@ -74,14 +74,14 @@ class SnippetTests: XCTestCase {
     }
     
     func testSliceResolves() async throws {
-        let (bundle, _) = try await testBundleAndContext(named: "Snippets")
+        let inputs = try await loadFromDisk(catalogName: "Snippets").inputs
         let source = """
         @Snippet(path: "Test/Snippets/MySnippet", slice: "foo")
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0) as! BlockDirective
         var problems = [Problem]()
-        let snippet = try XCTUnwrap(Snippet(from: directive, source: nil, for: bundle, problems: &problems))
+        let snippet = try XCTUnwrap(Snippet(from: directive, source: nil, for: inputs, problems: &problems))
         XCTAssertEqual("Test/Snippets/MySnippet", snippet.path)
         XCTAssertEqual("foo", snippet.slice)
         XCTAssertNotNil(snippet)
diff --git a/Tests/SwiftDocCTests/Semantics/StackTests.swift b/Tests/SwiftDocCTests/Semantics/StackTests.swift
index 0e432bc69d..575224ad92 100644
--- a/Tests/SwiftDocCTests/Semantics/StackTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/StackTests.swift
@@ -11,6 +11,7 @@
 import XCTest
 @testable import SwiftDocC
 import Markdown
+import SwiftDocCTestUtilities
 
 class StackTests: XCTestCase {
     func testEmpty() async throws {
@@ -19,12 +20,12 @@ class StackTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(Stack.directiveName, directive.name)
-            let stack = Stack(from: directive, source: nil, for: bundle, problems: &problems)
+            let stack = Stack(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(stack)
             XCTAssertEqual(1, problems.count)
             XCTAssertEqual(
@@ -48,12 +49,12 @@ class StackTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(Stack.directiveName, directive.name)
-            let stack = Stack(from: directive, source: nil, for: bundle, problems: &problems)
+            let stack = Stack(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(stack)
             XCTAssertEqual(0, problems.count)
         }
@@ -78,12 +79,14 @@ class StackTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await load(catalog: Folder(name: "Something.docc", content: [
+            DataFile(name: "code4.png", data: Data())
+        ]))
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(Stack.directiveName, directive.name)
-            let stack = Stack(from: directive, source: nil, for: bundle, problems: &problems)
+            let stack = Stack(from: directive, source: nil, for: context.inputs, problems: &problems)
             XCTAssertNotNil(stack)
             XCTAssertEqual(1, problems.count)
             XCTAssertEqual(
diff --git a/Tests/SwiftDocCTests/Semantics/StepTests.swift b/Tests/SwiftDocCTests/Semantics/StepTests.swift
index d4a4029105..6774051221 100644
--- a/Tests/SwiftDocCTests/Semantics/StepTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/StepTests.swift
@@ -11,6 +11,7 @@
 import XCTest
 @testable import SwiftDocC
 import Markdown
+import SwiftDocCTestUtilities
 
 class StepTests: XCTestCase {
     func testEmpty() async throws {
@@ -19,9 +20,9 @@ class StepTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let step = Step(from: directive, source: nil, for: bundle, problems: &problems)
+        let step = Step(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertEqual([
             "org.swift.docc.HasContent",
         ], problems.map { $0.diagnostic.identifier })
@@ -46,9 +47,11 @@ class StepTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await load(catalog: Folder(name: "Something.docc", content: [
+            DataFile(name: "test.png", data: Data())
+        ]))
         var problems = [Problem]()
-        let step = Step(from: directive, source: nil, for: bundle, problems: &problems)
+        let step = Step(from: directive, source: nil, for: context.inputs, problems: &problems)
         XCTAssertTrue(problems.isEmpty)
         XCTAssertNotNil(step)
         
@@ -97,16 +100,16 @@ Step @1:1-9:2
 
    > Important: This is not extraneous.
 
-   This is an extranous paragraph.
+   This is an extraneous paragraph.
 
    > Note: More than one aside is technically allowed per design.
 }
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let step = Step(from: directive, source: nil, for: bundle, problems: &problems)
+        let step = Step(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertEqual(2, problems.count)
         
         XCTAssertEqual([
diff --git a/Tests/SwiftDocCTests/Semantics/SymbolTests.swift b/Tests/SwiftDocCTests/Semantics/SymbolTests.swift
index c0157c6a26..1aa9e329f8 100644
--- a/Tests/SwiftDocCTests/Semantics/SymbolTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/SymbolTests.swift
@@ -502,16 +502,14 @@ class SymbolTests: XCTestCase {
     }
     
     func testNoWarningWhenDocCommentContainsDoxygen() async throws {
-        let tempURL = try createTemporaryDirectory()
-        
-        let bundleURL = try Folder(name: "Inheritance.docc", content: [
+        let catalog = Folder(name: "Inheritance.docc", content: [
             InfoPlist(displayName: "Inheritance", identifier: "com.test.inheritance"),
             CopyOfFile(original: Bundle.module.url(
                 forResource: "Inheritance.symbols", withExtension: "json",
                 subdirectory: "Test Resources")!),
-        ]).write(inside: tempURL)
+        ])
         
-        let (_, _, context) = try await loadBundle(from: bundleURL)
+        let context = try await load(catalog: catalog)
         let problems = context.diagnosticEngine.problems
         XCTAssertEqual(problems.count, 0)
     }
@@ -522,7 +520,7 @@ class SymbolTests: XCTestCase {
             withExtension: "symbols.json",
             subdirectory: "Test Resources"
         )!
-        let (_, _, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { url in
             try? FileManager.default.copyItem(at: deckKitSymbolGraph, to: url.appendingPathComponent("DeckKit.symbols.json"))
         }
         let symbol = try XCTUnwrap(context.documentationCache["c:objc(cs)PlayingCard(cm)newWithRank:ofSuit:"]?.semantic as? Symbol)
@@ -540,7 +538,7 @@ class SymbolTests: XCTestCase {
     }
 
     func testUnresolvedReferenceWarningsInDocumentationExtension() async throws {
-        let (url, _, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { url in
+        let (url, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { url in
             let myKitDocumentationExtensionComment = """
             # ``MyKit/MyClass``
 
@@ -950,7 +948,7 @@ class SymbolTests: XCTestCase {
         - <doc://com.test.external/ExternalPage>
         """
         
-        let (_, _, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { url in
             var graph = try JSONDecoder().decode(SymbolGraph.self, from: Data(contentsOf: url.appendingPathComponent("mykit-iOS.symbols.json")))
             let myFunctionUSR = "s:5MyKit0A5ClassC10myFunctionyyF"
 
@@ -1107,7 +1105,7 @@ class SymbolTests: XCTestCase {
 
     func testAddingConstraintsToSymbol() async throws {
         let myFunctionUSR = "s:5MyKit0A5ClassC10myFunctionyyF"
-        let (_, _, context) = try await testBundleAndContext(copying: "LegacyBundle_DoNotUseInNewTests") { url in
+        let (_, context) = try await loadFromDisk(copyingCatalogNamed: "LegacyBundle_DoNotUseInNewTests") { url in
             var graph = try JSONDecoder().decode(SymbolGraph.self, from: Data(contentsOf: url.appendingPathComponent("mykit-iOS.symbols.json")))
             
             let newDocComment = self.makeLineList(
@@ -1612,7 +1610,7 @@ class SymbolTests: XCTestCase {
         }
         
         let diagnosticEngine = DiagnosticEngine(filterLevel: diagnosticEngineFilterLevel)
-        let (_, context) = try await loadBundle(catalog: Folder(name: "unit-test.docc", content: catalogContent), diagnosticEngine: diagnosticEngine)
+        let context = try await load(catalog: Folder(name: "unit-test.docc", content: catalogContent), diagnosticEngine: diagnosticEngine)
         
         let node = try XCTUnwrap(context.documentationCache[methodUSR], file: file, line: line)
         
diff --git a/Tests/SwiftDocCTests/Semantics/TechnologyTests.swift b/Tests/SwiftDocCTests/Semantics/TechnologyTests.swift
index e3507fc4b6..ccc358067c 100644
--- a/Tests/SwiftDocCTests/Semantics/TechnologyTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/TechnologyTests.swift
@@ -19,9 +19,9 @@ class TechnologyTests: XCTestCase {
         let source = "@Tutorials"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let technology = TutorialTableOfContents(from: directive, source: nil, for: bundle, problems: &problems)
+        let technology = TutorialTableOfContents(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(technology)
         XCTAssertEqual(
             problems.map { $0.diagnostic.identifier },
diff --git a/Tests/SwiftDocCTests/Semantics/TileTests.swift b/Tests/SwiftDocCTests/Semantics/TileTests.swift
index 8fb8b7b148..91aebbe18c 100644
--- a/Tests/SwiftDocCTests/Semantics/TileTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/TileTests.swift
@@ -26,9 +26,9 @@ class TileTests: XCTestCase {
                 let source = "@\(directiveName)"
                 let document = Document(parsing: source, options: .parseBlockDirectives)
                 let directive = document.child(at: 0)! as! BlockDirective
-                let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+                let inputs = try await makeEmptyContext().inputs
                 var problems = [Problem]()
-                let tile = Tile(from: directive, source: nil, for: bundle, problems: &problems)
+                let tile = Tile(from: directive, source: nil, for: inputs, problems: &problems)
                 XCTAssertNotNil(tile)
                 XCTAssertEqual(2, problems.count)
                 XCTAssertEqual([
@@ -49,9 +49,9 @@ class TileTests: XCTestCase {
 """
                 let document = Document(parsing: source, options: .parseBlockDirectives)
                 let directive = document.child(at: 0)! as! BlockDirective
-                let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+                let inputs = try await makeEmptyContext().inputs
                 var problems = [Problem]()
-                let tile = Tile(from: directive, source: nil, for: bundle, problems: &problems)
+                let tile = Tile(from: directive, source: nil, for: inputs, problems: &problems)
                 XCTAssertNotNil(tile)
                 XCTAssertTrue(problems.isEmpty)
                 tile.map { tile in
@@ -75,9 +75,9 @@ class TileTests: XCTestCase {
                 let source = "@\(directiveName)"
                 let document = Document(parsing: source, options: .parseBlockDirectives)
                 let directive = document.child(at: 0)! as! BlockDirective
-                let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+                let inputs = try await makeEmptyContext().inputs
                 var problems = [Problem]()
-                let tile = Tile(from: directive, source: nil, for: bundle, problems: &problems)
+                let tile = Tile(from: directive, source: nil, for: inputs, problems: &problems)
                 XCTAssertNotNil(tile)
                 XCTAssertEqual(1, problems.count)
                 XCTAssertEqual([
@@ -97,9 +97,9 @@ class TileTests: XCTestCase {
 """
                 let document = Document(parsing: source, options: .parseBlockDirectives)
                 let directive = document.child(at: 0)! as! BlockDirective
-                let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+                let inputs = try await makeEmptyContext().inputs
                 var problems = [Problem]()
-                let tile = Tile(from: directive, source: nil, for: bundle, problems: &problems)
+                let tile = Tile(from: directive, source: nil, for: inputs, problems: &problems)
                 XCTAssertNotNil(tile)
                 XCTAssertTrue(problems.isEmpty)
                 tile.map { tile in
@@ -120,9 +120,9 @@ class TileTests: XCTestCase {
     """
             let document = Document(parsing: source, options: .parseBlockDirectives)
             let directive = document.child(at: 0)! as! BlockDirective
-            let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+            let inputs = try await makeEmptyContext().inputs
             var problems = [Problem]()
-            let tile = Tile(from: directive, source: nil, for: bundle, problems: &problems)
+            let tile = Tile(from: directive, source: nil, for: inputs, problems: &problems)
             // Destination is set.
             XCTAssertEqual(destination, tile?.destination)
         }
@@ -136,9 +136,9 @@ class TileTests: XCTestCase {
     """
             let document = Document(parsing: source, options: .parseBlockDirectives)
             let directive = document.child(at: 0)! as! BlockDirective
-            let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+            let inputs = try await makeEmptyContext().inputs
             var problems = [Problem]()
-            let tile = Tile(from: directive, source: nil, for: bundle, problems: &problems)
+            let tile = Tile(from: directive, source: nil, for: inputs, problems: &problems)
             // Destination is nil.
             XCTAssertNotNil(tile)
             XCTAssertEqual(nil, tile?.destination)
@@ -149,9 +149,9 @@ class TileTests: XCTestCase {
         let source = "@UnknownTile"
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let tile = Tile(from: directive, source: nil, for: bundle, problems: &problems)
+        let tile = Tile(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(tile)
         XCTAssertEqual(1, problems.count)
         XCTAssertEqual(problems.first?.diagnostic.identifier, "org.swift.docc.Resources.UnknownTile")
diff --git a/Tests/SwiftDocCTests/Semantics/TutorialArticleTests.swift b/Tests/SwiftDocCTests/Semantics/TutorialArticleTests.swift
index 17635d3408..ba356e2f62 100644
--- a/Tests/SwiftDocCTests/Semantics/TutorialArticleTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/TutorialArticleTests.swift
@@ -11,6 +11,7 @@
 import XCTest
 @testable import SwiftDocC
 import Markdown
+import SwiftDocCTestUtilities
 
 class TutorialArticleTests: XCTestCase {
     func testEmpty() async throws {
@@ -19,12 +20,12 @@ class TutorialArticleTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(TutorialArticle.directiveName, directive.name)
-            let article = TutorialArticle(from: directive, source: nil, for: bundle, problems: &problems)
+            let article = TutorialArticle(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(article)
             XCTAssertEqual(2, problems.count)
             XCTAssertEqual([
@@ -56,12 +57,12 @@ class TutorialArticleTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(TutorialArticle.directiveName, directive.name)
-            let article = TutorialArticle(from: directive, source: nil, for: bundle, problems: &problems)
+            let article = TutorialArticle(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(article)
             XCTAssertEqual(2, problems.count)
             article.map { article in
@@ -106,12 +107,12 @@ TutorialArticle @1:1-13:2
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(TutorialArticle.directiveName, directive.name)
-            let article = TutorialArticle(from: directive, source: nil, for: bundle, problems: &problems)
+            let article = TutorialArticle(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(article)
             XCTAssertEqual(4, problems.count)
             article.map { article in
@@ -155,12 +156,15 @@ TutorialArticle @1:1-23:2
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await load(catalog: Folder(name: "Something.docc", content: [
+            InfoPlist(identifier: "org.swift.docc.example"),
+            DataFile(name: "myimage.png", data: Data())
+        ]))
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(TutorialArticle.directiveName, directive.name)
-            let article = TutorialArticle(from: directive, source: nil, for: bundle, problems: &problems)
+            let article = TutorialArticle(from: directive, source: nil, for: context.inputs, problems: &problems)
             XCTAssertNotNil(article)
             XCTAssertEqual(0, problems.count)
             article.map { article in
@@ -265,12 +269,18 @@ TutorialArticle @1:1-23:2 title: 'Basic Augmented Reality App' time: '20'
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await load(catalog: Folder(name: "Something.docc", content: [
+            InfoPlist(identifier: "org.swift.docc.example"),
+            DataFile(name: "customize-text-view.png", data: Data()),
+            DataFile(name: "this-is-leading.png", data: Data()),
+            DataFile(name: "this-is-trailing.png", data: Data()),
+            DataFile(name: "this-is-still-trailing.png", data: Data())
+        ]))
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(TutorialArticle.directiveName, directive.name)
-            let article = TutorialArticle(from: directive, source: nil, for: bundle, problems: &problems)
+            let article = TutorialArticle(from: directive, source: nil, for: context.inputs, problems: &problems)
             XCTAssertNotNil(article)
             XCTAssertEqual(3, problems.count)
             let arbitraryMarkupProblem = problems.first(where: { $0.diagnostic.identifier == "org.swift.docc.Stack.UnexpectedContent" })
@@ -361,12 +371,15 @@ TutorialArticle @1:1-81:2
             let directive = document.child(at: 0) as? BlockDirective
             XCTAssertNotNil(directive)
             
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+            let context = try await load(catalog: Folder(name: "Something.docc", content: [
+                InfoPlist(identifier: "org.swift.docc.example"),
+                DataFile(name: "myimage.png", data: Data())
+            ]))
             
             directive.map { directive in
                 var problems = [Problem]()
                 XCTAssertEqual(TutorialArticle.directiveName, directive.name)
-                let article = TutorialArticle(from: directive, source: nil, for: bundle, problems: &problems)
+                let article = TutorialArticle(from: directive, source: nil, for: context.inputs, problems: &problems)
                 XCTAssertNotNil(article)
                 XCTAssertEqual(0, problems.count)
                 article.map { article in
@@ -398,7 +411,7 @@ TutorialArticle @1:1-42:2 title: 'Basic Augmented Reality App' time: '20'
         let reference = ResolvedTopicReference(bundleID: "org.swift.docc.TopicGraphTests", path: "/\(title)", sourceLanguage: .swift)
         let node = TopicGraph.Node(reference: reference, kind: .tutorialTableOfContents, source: .file(url: URL(fileURLWithPath: "/path/to/\(title)")), title: title)
 
-        let (_, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await makeEmptyContext()
         context.topicGraph.addNode(node)
 
         let engine = DiagnosticEngine()
@@ -417,7 +430,7 @@ TutorialArticle @1:1-42:2 title: 'Basic Augmented Reality App' time: '20'
         let reference = ResolvedTopicReference(bundleID: "org.swift.docc.TopicGraphTests", path: "/\(title)", sourceLanguage: .swift)
         let node = TopicGraph.Node(reference: reference, kind: .tutorialTableOfContents, source: .external, title: title)
 
-        let (_, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await makeEmptyContext()
         context.topicGraph.addNode(node)
 
         let engine = DiagnosticEngine()
@@ -437,7 +450,7 @@ TutorialArticle @1:1-42:2 title: 'Basic Augmented Reality App' time: '20'
         let range = SourceLocation(line: 1, column: 1, source: url)..<SourceLocation(line: 1, column: 1, source: url)
         let node = TopicGraph.Node(reference: reference, kind: .tutorialTableOfContents, source: .range(range, url: url) , title: title)
 
-        let (_, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await makeEmptyContext()
         context.topicGraph.addNode(node)
 
         let engine = DiagnosticEngine()
@@ -459,7 +472,7 @@ TutorialArticle @1:1-42:2 title: 'Basic Augmented Reality App' time: '20'
             return TopicGraph.Node(reference: reference, kind: kind, source: .range(range, url: url) , title: title)
         }
 
-        let (_, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await makeEmptyContext()
 
         let tutorialArticleNode = node(withTitle: "tutorial-article", ofKind: .tutorialArticle)
 
diff --git a/Tests/SwiftDocCTests/Semantics/TutorialReferenceTests.swift b/Tests/SwiftDocCTests/Semantics/TutorialReferenceTests.swift
index d7f35bb485..dac1e8855d 100644
--- a/Tests/SwiftDocCTests/Semantics/TutorialReferenceTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/TutorialReferenceTests.swift
@@ -19,9 +19,9 @@ class TutorialReferenceTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let tutorialReference = TutorialReference(from: directive, source: nil, for: bundle, problems: &problems)
+        let tutorialReference = TutorialReference(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(tutorialReference)
         XCTAssertEqual(1, problems.count)
         problems.first.map { problem in
@@ -37,9 +37,9 @@ class TutorialReferenceTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let tutorialReference = TutorialReference(from: directive, source: nil, for: bundle, problems: &problems)
+        let tutorialReference = TutorialReference(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(tutorialReference)
         tutorialReference.map { tutorialReference in
             guard case let .unresolved(unresolved) = tutorialReference.topic else {
@@ -57,9 +57,9 @@ class TutorialReferenceTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let tutorialReference = TutorialReference(from: directive, source: nil, for: bundle, problems: &problems)
+        let tutorialReference = TutorialReference(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(tutorialReference)
         XCTAssertEqual(problems.count, 1)
         let problem = try XCTUnwrap(problems.first)
diff --git a/Tests/SwiftDocCTests/Semantics/TutorialTests.swift b/Tests/SwiftDocCTests/Semantics/TutorialTests.swift
index 816b99cd21..1b9140030d 100644
--- a/Tests/SwiftDocCTests/Semantics/TutorialTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/TutorialTests.swift
@@ -11,6 +11,7 @@
 import XCTest
 @testable import SwiftDocC
 import Markdown
+import SwiftDocCTestUtilities
 
 class TutorialTests: XCTestCase {
     func testEmpty() async throws {
@@ -19,12 +20,12 @@ class TutorialTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(Tutorial.directiveName, directive.name)
-            let tutorial = Tutorial(from: directive, source: nil, for: bundle, problems: &problems)
+            let tutorial = Tutorial(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNil(tutorial)
             XCTAssertEqual(
                 [
@@ -195,12 +196,24 @@ class TutorialTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await load(catalog: Folder(name: "Something.docc", content: [
+            InfoPlist(identifier: "org.swift.docc.example"),
+            
+            DataFile(name: "app.mov", data: Data()),
+            DataFile(name: "app2.mov", data: Data()),
+            DataFile(name: "figure1.png", data: Data()),
+            DataFile(name: "myimage.png", data: Data()),
+            DataFile(name: "poster.png", data: Data()),
+            DataFile(name: "screenshot.png", data: Data()),
+            DataFile(name: "xcode.png", data: Data()),
+            DataFile(name: "xcode1.png", data: Data()),
+            DataFile(name: "test.mp4", data: Data()),
+        ]))
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(Tutorial.directiveName, directive.name)
-            let tutorial = Tutorial(from: directive, source: nil, for: bundle, problems: &problems)
+            let tutorial = Tutorial(from: directive, source: nil, for: context.inputs, problems: &problems)
             XCTAssertNotNil(tutorial)
             XCTAssertTrue(problems.isEmpty)
             tutorial.map { tutorial in
@@ -354,12 +367,18 @@ Tutorial @1:1-150:2 projectFiles: nil
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await load(catalog: Folder(name: "Something.docc", content: [
+            InfoPlist(identifier: "org.swift.docc.example"),
+            
+            DataFile(name: "myimage.png", data: Data()),
+            DataFile(name: "poster.png", data: Data()),
+            DataFile(name: "test.mp4", data: Data()),
+        ]))
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(Tutorial.directiveName, directive.name)
-            let tutorial = Tutorial(from: directive, source: nil, for: bundle, problems: &problems)
+            let tutorial = Tutorial(from: directive, source: nil, for: context.inputs, problems: &problems)
             XCTAssertNotNil(tutorial)
             XCTAssertEqual(1, tutorial?.sections.count)
             XCTAssertEqual([
@@ -373,7 +392,7 @@ Tutorial @1:1-150:2 projectFiles: nil
         let reference = ResolvedTopicReference(bundleID: "org.swift.docc.TopicGraphTests", path: "/\(title)", sourceLanguage: .swift)
         let node = TopicGraph.Node(reference: reference, kind: .tutorialTableOfContents, source: .file(url: URL(fileURLWithPath: "/path/to/\(title)")), title: title)
 
-        let (_, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await makeEmptyContext()
         context.topicGraph.addNode(node)
 
         let engine = DiagnosticEngine()
@@ -392,7 +411,7 @@ Tutorial @1:1-150:2 projectFiles: nil
         let reference = ResolvedTopicReference(bundleID: "org.swift.docc.TopicGraphTests", path: "/\(title)", sourceLanguage: .swift)
         let node = TopicGraph.Node(reference: reference, kind: .tutorialTableOfContents, source: .external, title: title)
 
-        let (_, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await makeEmptyContext()
         context.topicGraph.addNode(node)
 
         let engine = DiagnosticEngine()
@@ -412,7 +431,7 @@ Tutorial @1:1-150:2 projectFiles: nil
         let range = SourceLocation(line: 1, column: 1, source: url)..<SourceLocation(line: 1, column: 1, source: url)
         let node = TopicGraph.Node(reference: reference, kind: .tutorialTableOfContents, source: .range(range, url: url) , title: title)
 
-        let (_, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await makeEmptyContext()
         context.topicGraph.addNode(node)
 
         let engine = DiagnosticEngine()
@@ -434,7 +453,7 @@ Tutorial @1:1-150:2 projectFiles: nil
             return TopicGraph.Node(reference: reference, kind: kind, source: .range(range, url: url) , title: title)
         }
 
-        let (_, context) = try await testBundleAndContext(named: "LegacyBundle_DoNotUseInNewTests")
+        let context = try await makeEmptyContext()
 
         let tutorialNode = node(withTitle: "tutorial-article", ofKind: .tutorial)
 
diff --git a/Tests/SwiftDocCTests/Semantics/VideoMediaTests.swift b/Tests/SwiftDocCTests/Semantics/VideoMediaTests.swift
index 010fb3125a..8ff423833e 100644
--- a/Tests/SwiftDocCTests/Semantics/VideoMediaTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/VideoMediaTests.swift
@@ -20,9 +20,9 @@ class VideoMediaTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let video = VideoMedia(from: directive, source: nil, for: bundle, problems: &problems)
+        let video = VideoMedia(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(video)
         XCTAssertEqual(1, problems.count)
         XCTAssertFalse(problems.containsErrors)
@@ -39,9 +39,9 @@ class VideoMediaTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let video = VideoMedia(from: directive, source: nil, for: bundle, problems: &problems)
+        let video = VideoMedia(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(video)
         XCTAssertTrue(problems.isEmpty)
         video.map { video in
@@ -58,9 +58,9 @@ class VideoMediaTests: XCTestCase {
             """
             let document = Document(parsing: source, options: .parseBlockDirectives)
             let directive = document.child(at: 0)! as! BlockDirective
-            let (bundle, _) = try await testBundleAndContext()
+            let inputs = try await makeEmptyContext().inputs
             var problems = [Problem]()
-            let video = VideoMedia(from: directive, source: nil, for: bundle, problems: &problems)
+            let video = VideoMedia(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(video)
             XCTAssertTrue(problems.isEmpty)
             video.map { video in
@@ -77,9 +77,9 @@ class VideoMediaTests: XCTestCase {
         
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let video = VideoMedia(from: directive, source: nil, for: bundle, problems: &problems)
+        let video = VideoMedia(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(video)
         XCTAssertEqual(3, problems.count)
         XCTAssertFalse(problems.containsErrors)
@@ -326,19 +326,19 @@ class VideoMediaTests: XCTestCase {
         """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, context) = try await loadBundle(
+        let context = try await load(
             catalog: Folder(name: "unit-test.docc", content: [
                 DataFile(name: "introvideo.mov", data: Data())
             ])
         )
         var problems = [Problem]()
-        let video = VideoMedia(from: directive, source: nil, for: bundle, problems: &problems)
+        let video = VideoMedia(from: directive, source: nil, for: context.inputs, problems: &problems)
         let reference = ResolvedTopicReference(
-            bundleID: bundle.id,
-            path: "",
+            bundleID: context.inputs.id,
+            path: "/",
             sourceLanguage: .swift
         )
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: reference)
+        var translator = RenderNodeTranslator(context: context, identifier: reference)
         let videoMediaReference = translator.visitVideoMedia(video!) as! RenderReferenceIdentifier
         let videoMedia = translator.videoReferences[videoMediaReference.identifier]
         // Check that the video references in the node translator contains the alt text.
diff --git a/Tests/SwiftDocCTests/Semantics/VolumeTests.swift b/Tests/SwiftDocCTests/Semantics/VolumeTests.swift
index 827ab38f7d..f4c1a3f626 100644
--- a/Tests/SwiftDocCTests/Semantics/VolumeTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/VolumeTests.swift
@@ -20,9 +20,9 @@ class VolumeTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let volume = Volume(from: directive, source: nil, for: bundle, problems: &problems)
+        let volume = Volume(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNil(volume)
         XCTAssertEqual(4, problems.count)
         XCTAssertEqual([
@@ -51,9 +51,9 @@ class VolumeTests: XCTestCase {
 """
         let document = Document(parsing: source, options: .parseBlockDirectives)
         let directive = document.child(at: 0)! as! BlockDirective
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         var problems = [Problem]()
-        let volume = Volume(from: directive, source: nil, for: bundle, problems: &problems)
+        let volume = Volume(from: directive, source: nil, for: inputs, problems: &problems)
         XCTAssertNotNil(volume)
         XCTAssertTrue(problems.isEmpty)
         volume.map { volume in
@@ -97,9 +97,9 @@ class VolumeTests: XCTestCase {
             """)
         ])
         
-        let (bundle, context) = try await loadBundle(catalog: catalog)
+        let context = try await load(catalog: catalog)
         let node = try context.entity(
-            with: ResolvedTopicReference(bundleID: bundle.id, path: "/tutorials/TestOverview", sourceLanguage: .swift)
+            with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/tutorials/TestOverview", sourceLanguage: .swift)
         )
 
         let tutorial = try XCTUnwrap(node.semantic as? TutorialTableOfContents)
diff --git a/Tests/SwiftDocCTests/Semantics/XcodeRequirementTests.swift b/Tests/SwiftDocCTests/Semantics/XcodeRequirementTests.swift
index f477495bf8..e4cf12cc3f 100644
--- a/Tests/SwiftDocCTests/Semantics/XcodeRequirementTests.swift
+++ b/Tests/SwiftDocCTests/Semantics/XcodeRequirementTests.swift
@@ -19,12 +19,12 @@ class XcodeRequirementTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(XcodeRequirement.directiveName, directive.name)
-            let requirement = XcodeRequirement(from: directive, source: nil, for: bundle, problems: &problems)
+            let requirement = XcodeRequirement(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNil(requirement)
             XCTAssertEqual(2, problems.count)
             XCTAssertEqual(
@@ -48,12 +48,12 @@ class XcodeRequirementTests: XCTestCase {
         let directive = document.child(at: 0) as? BlockDirective
         XCTAssertNotNil(directive)
         
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         directive.map { directive in
             var problems = [Problem]()
             XCTAssertEqual(XcodeRequirement.directiveName, directive.name)
-            let requirement = XcodeRequirement(from: directive, source: nil, for: bundle, problems: &problems)
+            let requirement = XcodeRequirement(from: directive, source: nil, for: inputs, problems: &problems)
             XCTAssertNotNil(requirement)
             XCTAssertTrue(problems.isEmpty)
             requirement.map { requirement in
diff --git a/Tests/SwiftDocCTests/TestRenderNodeOutputConsumer.swift b/Tests/SwiftDocCTests/TestRenderNodeOutputConsumer.swift
index 67c0f5e3a7..bd5c737fc0 100644
--- a/Tests/SwiftDocCTests/TestRenderNodeOutputConsumer.swift
+++ b/Tests/SwiftDocCTests/TestRenderNodeOutputConsumer.swift
@@ -21,7 +21,7 @@ class TestRenderNodeOutputConsumer: ConvertOutputConsumer, ExternalNodeConsumer
         }
     }
     
-    func consume(assetsInBundle bundle: DocumentationBundle) throws { }
+    func consume(assetsInInputs inputs: DocumentationContext.Inputs) throws { }
     func consume(linkableElementSummaries: [LinkDestinationSummary]) throws { }
     func consume(indexingRecords: [IndexingRecord]) throws { }
     func consume(assets: [RenderReferenceType: [any RenderReference]]) throws { }
@@ -85,19 +85,18 @@ extension TestRenderNodeOutputConsumer {
 
 extension XCTestCase {
     func renderNodeConsumer(
-        for bundleName: String,
+        for catalogName: String,
         sourceRepository: SourceRepository? = nil,
         configureBundle: ((URL) throws -> Void)? = nil
     ) async throws -> TestRenderNodeOutputConsumer {
-        let (_, bundle, context) = try await testBundleAndContext(
-            copying: bundleName,
+        let (_, context) = try await loadFromDisk(
+            copyingCatalogNamed: catalogName,
             configureBundle: configureBundle
         )
         
         let outputConsumer = TestRenderNodeOutputConsumer()
         
         _ = try ConvertActionConverter.convert(
-            bundle: bundle,
             context: context,
             outputConsumer: outputConsumer,
             sourceRepository: sourceRepository,
diff --git a/Tests/SwiftDocCTests/Utility/ListItemExtractorTests.swift b/Tests/SwiftDocCTests/Utility/ListItemExtractorTests.swift
index 59fe23e12b..085e5dc833 100644
--- a/Tests/SwiftDocCTests/Utility/ListItemExtractorTests.swift
+++ b/Tests/SwiftDocCTests/Utility/ListItemExtractorTests.swift
@@ -273,7 +273,7 @@ class ListItemExtractorTests: XCTestCase {
     ) async throws {
         // Build documentation for a module page with one tagged item with a lot of different
         
-        let (bundle, context) = try await loadBundle(
+        let context = try await load(
             catalog: Folder(name: "Something.docc", content: [
                 JSONFile(name: "ModuleName.symbols.json", content: makeSymbolGraph(moduleName: "ModuleName")),
                 TextFile(name: "Extension.md", utf8Content: """
@@ -303,7 +303,7 @@ class ListItemExtractorTests: XCTestCase {
             ])
         )
         
-        try _assertExtractsRichContentFor(tagName: tagName, findModelContent: findModelContent, renderVerification: renderVerification, isAside: isAside, bundle: bundle, context: context, expectedLogText: """
+        try _assertExtractsRichContentFor(tagName: tagName, findModelContent: findModelContent, renderVerification: renderVerification, isAside: isAside, context: context, expectedLogText: """
         \u{001B}[1;33mwarning: 'FirstNotFoundSymbol' doesn't exist at '/ModuleName'\u{001B}[0;0m
          --> /Something.docc/Extension.md:5:\(49+tagName.count)-5:\(68+tagName.count)
         3 | Some description of this module.
@@ -339,7 +339,7 @@ class ListItemExtractorTests: XCTestCase {
     ) async throws {
         // Build documentation for a module page with one tagged item with a lot of different
         
-        let (bundle, context) = try await loadBundle(
+        let context = try await load(
             catalog: Folder(name: "Something.docc", content: [
                 JSONFile(name: "ModuleName.symbols.json", content: makeSymbolGraph(moduleName: "ModuleName")),
                 TextFile(name: "Extension.md", utf8Content: """
@@ -370,7 +370,7 @@ class ListItemExtractorTests: XCTestCase {
             ])
         )
         
-        try _assertExtractsRichContentFor(tagName: tagName, findModelContent: findModelContent, renderVerification: renderVerification, isAside: false, bundle: bundle, context: context, expectedLogText: """
+        try _assertExtractsRichContentFor(tagName: tagName, findModelContent: findModelContent, renderVerification: renderVerification, isAside: false, context: context, expectedLogText: """
         \u{001B}[1;33mwarning: 'FirstNotFoundSymbol' doesn't exist at '/ModuleName'\u{001B}[0;0m
          --> /Something.docc/Extension.md:6:60-6:79
         4 |
@@ -401,7 +401,6 @@ class ListItemExtractorTests: XCTestCase {
         findModelContent: (Symbol) -> [any Markup]?,
         renderVerification: RenderVerification,
         isAside: Bool,
-        bundle: DocumentationBundle,
         context: DocumentationContext,
         expectedLogText: String,
         file: StaticString = #filePath,
@@ -457,7 +456,7 @@ class ListItemExtractorTests: XCTestCase {
             return
         }
         
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let converter = DocumentationNodeConverter(context: context)
         let renderNode = converter.convert(node)
         
         let renderContent = try XCTUnwrap(findRenderContent(renderNode), "Didn't find any rendered content", file: file, line: line)
diff --git a/Tests/SwiftDocCTests/Utility/XCTestCase+MentionedIn.swift b/Tests/SwiftDocCTests/Utility/XCTestCase+MentionedIn.swift
index a7306396b9..a43ed542bf 100644
--- a/Tests/SwiftDocCTests/Utility/XCTestCase+MentionedIn.swift
+++ b/Tests/SwiftDocCTests/Utility/XCTestCase+MentionedIn.swift
@@ -15,7 +15,7 @@ import SymbolKit
 
 extension XCTestCase {
     /// Creates a test bundle for testing "Mentioned In" features.
-    func createMentionedInTestBundle() async throws -> (DocumentationBundle, DocumentationContext) {
+    func createMentionedInTestBundle() async throws -> DocumentationContext {
         let catalog = Folder(name: "MentionedIn.docc", content: [
             JSONFile(name: "MentionedIn.symbols.json", content: makeSymbolGraph(
                 moduleName: "MentionedIn",
@@ -72,7 +72,6 @@ extension XCTestCase {
                  """),
         ])
 
-        let (bundle, context) = try await loadBundle(catalog: catalog)
-        return (bundle, context)
+        return try await load(catalog: catalog)
     }
 }
diff --git a/Tests/SwiftDocCTests/XCTestCase+LoadingTestData.swift b/Tests/SwiftDocCTests/XCTestCase+LoadingTestData.swift
index 754a05314c..863330f97f 100644
--- a/Tests/SwiftDocCTests/XCTestCase+LoadingTestData.swift
+++ b/Tests/SwiftDocCTests/XCTestCase+LoadingTestData.swift
@@ -16,26 +16,25 @@ import SwiftDocCTestUtilities
 
 extension XCTestCase {
     
-    /// Loads a documentation bundle from the given source URL and creates a documentation context.
-    func loadBundle(
-        from catalogURL: URL,
-        externalResolvers: [DocumentationBundle.Identifier: any ExternalDocumentationSource] = [:],
+    /// Loads a collection of documentation input files from the given source URL on disk and creates a documentation context.
+    func loadFromDisk(
+        catalogURL: URL,
+        externalResolvers: [DocumentationContext.Inputs.Identifier: any ExternalDocumentationSource] = [:],
         externalSymbolResolver: (any GlobalExternalSymbolResolver)? = nil,
         fallbackResolver: (any ConvertServiceFallbackResolver)? = nil,
         diagnosticEngine: DiagnosticEngine = .init(filterLevel: .hint),
         configuration: DocumentationContext.Configuration = .init()
-    ) async throws -> (URL, DocumentationBundle, DocumentationContext) {
+    ) async throws -> DocumentationContext {
         var configuration = configuration
         configuration.externalDocumentationConfiguration.sources = externalResolvers
         configuration.externalDocumentationConfiguration.globalSymbolResolver = externalSymbolResolver
         configuration.convertServiceConfiguration.fallbackResolver = fallbackResolver
         configuration.externalMetadata.diagnosticLevel = diagnosticEngine.filterLevel
         
-        let (bundle, dataProvider) = try DocumentationContext.InputsProvider()
+        let (inputs, dataProvider) = try DocumentationContext.InputsProvider()
             .inputsAndDataProvider(startingPoint: catalogURL, options: .init())
 
-        let context = try await DocumentationContext(bundle: bundle, dataProvider: dataProvider, diagnosticEngine: diagnosticEngine, configuration: configuration)
-        return (catalogURL, bundle, context)
+        return try await DocumentationContext(inputs: inputs, dataProvider: dataProvider, diagnosticEngine: diagnosticEngine, configuration: configuration)
     }
     
     /// Loads a documentation catalog from an in-memory test file system.
@@ -46,19 +45,18 @@ extension XCTestCase {
     ///   - diagnosticEngine: The diagnostic engine for the created context.
     ///   - configuration: Configuration for the created context.
     /// - Returns: The loaded documentation bundle and context for the given catalog input.
-    func loadBundle(
+    func load(
         catalog: Folder,
         otherFileSystemDirectories: [Folder] = [],
         diagnosticEngine: DiagnosticEngine = .init(),
         configuration: DocumentationContext.Configuration = .init()
-    ) async throws -> (DocumentationBundle, DocumentationContext) {
+    ) async throws -> DocumentationContext {
         let fileSystem = try TestFileSystem(folders: [catalog] + otherFileSystemDirectories)
         
-        let (bundle, dataProvider) = try DocumentationContext.InputsProvider(fileManager: fileSystem)
+        let (inputs, dataProvider) = try DocumentationContext.InputsProvider(fileManager: fileSystem)
             .inputsAndDataProvider(startingPoint: URL(fileURLWithPath: "/\(catalog.name)"), options: .init())
 
-        let context = try await DocumentationContext(bundle: bundle, dataProvider: dataProvider, diagnosticEngine: diagnosticEngine, configuration: configuration)
-        return (bundle, context)
+        return try await DocumentationContext(inputs: inputs, dataProvider: dataProvider, diagnosticEngine: diagnosticEngine, configuration: configuration)
     }
     
     func testCatalogURL(named name: String, file: StaticString = #filePath, line: UInt = #line) throws -> URL {
@@ -68,81 +66,75 @@ extension XCTestCase {
         )
     }
     
-    func testBundleAndContext(
-        copying name: String,
+    func loadFromDisk(
+        copyingCatalogNamed catalogName: String,
         excludingPaths excludedPaths: [String] = [],
-        externalResolvers: [DocumentationBundle.Identifier : any ExternalDocumentationSource] = [:],
+        externalResolvers: [DocumentationContext.Inputs.Identifier : any ExternalDocumentationSource] = [:],
         externalSymbolResolver: (any GlobalExternalSymbolResolver)? = nil,
         fallbackResolver: (any ConvertServiceFallbackResolver)? = nil,
         diagnosticEngine: DiagnosticEngine = .init(filterLevel: .hint),
         configuration: DocumentationContext.Configuration = .init(),
         configureBundle: ((URL) throws -> Void)? = nil
-    ) async throws -> (URL, DocumentationBundle, DocumentationContext) {
-        let sourceURL = try testCatalogURL(named: name)
+    ) async throws -> (URL, DocumentationContext) {
+        let sourceURL = try testCatalogURL(named: catalogName)
         
         let sourceExists = FileManager.default.fileExists(atPath: sourceURL.path)
-        let bundleURL = sourceExists
-            ? try createTemporaryDirectory().appendingPathComponent("\(name).docc")
-            : try createTemporaryDirectory(named: "\(name).docc")
+        let copiedURL = sourceExists
+            ? try createTemporaryDirectory().appendingPathComponent("\(catalogName).docc")
+            : try createTemporaryDirectory(named: "\(catalogName).docc")
         
         if sourceExists {
-            try FileManager.default.copyItem(at: sourceURL, to: bundleURL)
+            try FileManager.default.copyItem(at: sourceURL, to: copiedURL)
         }
         
         for path in excludedPaths {
-            try FileManager.default.removeItem(at: bundleURL.appendingPathComponent(path))
+            try FileManager.default.removeItem(at: copiedURL.appendingPathComponent(path))
         }
         
         // Do any additional setup to the custom bundle - adding, modifying files, etc
-        try configureBundle?(bundleURL)
+        try configureBundle?(copiedURL)
         
-        return try await loadBundle(
-            from: bundleURL,
+        let context = try await loadFromDisk(
+            catalogURL: copiedURL,
             externalResolvers: externalResolvers,
             externalSymbolResolver: externalSymbolResolver,
             fallbackResolver: fallbackResolver,
             diagnosticEngine: diagnosticEngine,
             configuration: configuration
         )
+        return (copiedURL, context)
     }
     
-    func testBundleAndContext(
-        named name: String,
-        externalResolvers: [DocumentationBundle.Identifier: any ExternalDocumentationSource] = [:],
+    func loadFromDisk(
+        catalogName: String,
+        externalResolvers: [DocumentationContext.Inputs.Identifier: any ExternalDocumentationSource] = [:],
         fallbackResolver: (any ConvertServiceFallbackResolver)? = nil,
         configuration: DocumentationContext.Configuration = .init()
-    ) async throws -> (URL, DocumentationBundle, DocumentationContext) {
-        let catalogURL = try testCatalogURL(named: name)
-        return try await loadBundle(from: catalogURL, externalResolvers: externalResolvers, fallbackResolver: fallbackResolver, configuration: configuration)
+    ) async throws -> (URL, DocumentationContext) {
+        let catalogURL = try testCatalogURL(named: catalogName)
+        let context = try await loadFromDisk(catalogURL: catalogURL, externalResolvers: externalResolvers, fallbackResolver: fallbackResolver, configuration: configuration)
+        return (catalogURL, context)
     }
     
-    func testBundleAndContext(named name: String, externalResolvers: [DocumentationBundle.Identifier: any ExternalDocumentationSource] = [:]) async throws -> (DocumentationBundle, DocumentationContext) {
-        let (_, bundle, context) = try await testBundleAndContext(named: name, externalResolvers: externalResolvers)
-        return (bundle, context)
+    func loadFromDisk(catalogName: String, externalResolvers: [DocumentationContext.Inputs.Identifier: any ExternalDocumentationSource] = [:]) async throws -> DocumentationContext {
+        let (_, context) = try await loadFromDisk(catalogName: catalogName, externalResolvers: externalResolvers)
+        return context
     }
     
-    func renderNode(atPath path: String, fromTestBundleNamed testBundleName: String) async throws -> RenderNode {
-        let (bundle, context) = try await testBundleAndContext(named: testBundleName)
-        let node = try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: path, sourceLanguage: .swift))
-        var translator = RenderNodeTranslator(context: context, bundle: bundle, identifier: node.reference)
+    func renderNode(atPath path: String, fromOnDiskCatalogNamed catalogName: String) async throws -> RenderNode {
+        let context = try await loadFromDisk(catalogName: catalogName)
+        let node = try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: path, sourceLanguage: .swift))
+        var translator = RenderNodeTranslator(context: context, identifier: node.reference)
         return try XCTUnwrap(translator.visit(node.semantic) as? RenderNode)
     }
     
-    func testBundle(named name: String) async throws -> DocumentationBundle {
-        let (bundle, _) = try await testBundleAndContext(named: name)
-        return bundle
+    func testInputs(named name: String) async throws -> DocumentationContext.Inputs {
+        return try await loadFromDisk(catalogName: name).inputs
     }
     
-    func testBundleFromRootURL(named name: String) throws -> DocumentationBundle {
-        let rootURL = try testCatalogURL(named: name)
-        let inputProvider = DocumentationContext.InputsProvider()
-        let catalogURL = try XCTUnwrap(inputProvider.findCatalog(startingPoint: rootURL))
-        return try inputProvider.makeInputs(contentOf: catalogURL, options: .init())
-    }
-    
-    func testBundleAndContext() async throws -> (bundle: DocumentationBundle, context: DocumentationContext) {
-        let bundle = DocumentationBundle(
-            info: DocumentationBundle.Info(
+    func makeEmptyContext() async throws -> DocumentationContext {
+        let inputs = DocumentationContext.Inputs(
+            info: DocumentationContext.Inputs.Info(
                 displayName: "Test",
                 id: "com.example.test"
             ),
@@ -152,8 +144,7 @@ extension XCTestCase {
             miscResourceURLs: []
         )
         
-        let context = try await DocumentationContext(bundle: bundle, dataProvider: TestFileSystem(folders: []))
-        return (bundle, context)
+        return try await DocumentationContext(inputs: inputs, dataProvider: TestFileSystem(folders: []))
     }
     
     func parseDirective<Directive: DirectiveConvertible>(
@@ -162,7 +153,7 @@ extension XCTestCase {
         file: StaticString = #filePath,
         line: UInt = #line
     ) async throws -> (problemIdentifiers: [String], directive: Directive?) {
-        let (bundle, _) = try await testBundleAndContext()
+        let inputs = try await makeEmptyContext().inputs
         
         let source = URL(fileURLWithPath: "/path/to/test-source-\(ProcessInfo.processInfo.globallyUniqueString)")
         let document = Document(parsing: content(), source: source, options: .parseBlockDirectives)
@@ -173,7 +164,7 @@ extension XCTestCase {
         let directive = directive.init(
             from: blockDirectiveContainer,
             source: source,
-            for: bundle,
+            for: inputs,
             problems: &problems
         )
         
@@ -199,8 +190,8 @@ extension XCTestCase {
         directive: Directive?,
         collectedReferences: [String : any RenderReference]
     ) {
-        let (bundle, context) = try await loadBundle(catalog: catalog)
-        return try parseDirective(directive, bundle: bundle, context: context, content: content, file: file, line: line)
+        let context = try await load(catalog: catalog)
+        return try parseDirective(directive, context: context, content: content, file: file, line: line)
     }
     
     func parseDirective<Directive: RenderableDirectiveConvertible>(
@@ -233,20 +224,31 @@ extension XCTestCase {
         directive: Directive?,
         collectedReferences: [String : any RenderReference]
     ) {
-        let bundle: DocumentationBundle
-        let context: DocumentationContext
-        
-        if let bundleName {
-            (bundle, context) = try await testBundleAndContext(named: bundleName)
+        let context = if let bundleName {
+            try await loadFromDisk(catalogName: bundleName)
         } else {
-            (bundle, context) = try await testBundleAndContext()
+            try await makeEmptyContext()
         }
-        return try parseDirective(directive, bundle: bundle, context: context, content: content, file: file, line: line)
+        return try parseDirective(directive, context: context, content: content, file: file, line: line)
+    }
+    
+    func parseDirective<Directive: RenderableDirectiveConvertible>(
+        _ directive: Directive.Type,
+        withAvailableAssetNames assetNames: [String],
+        content: () -> String,
+        file: StaticString = #filePath,
+        line: UInt = #line
+    ) async throws -> (renderBlockContent: [RenderBlockContent], problemIdentifiers: [String], directive: Directive?) {
+        let context = try await load(catalog: Folder(name: "Something.docc", content: assetNames.map {
+            DataFile(name: $0, data: Data())
+        }))
+        
+        let (renderedContent, problems, directive, _) = try parseDirective(directive, context: context, content: content)
+        return (renderedContent, problems, directive)
     }
     
     private func parseDirective<Directive: RenderableDirectiveConvertible>(
         _ directive: Directive.Type,
-        bundle: DocumentationBundle,
         context: DocumentationContext,
         content: () -> String,
         file: StaticString = #filePath,
@@ -264,15 +266,11 @@ extension XCTestCase {
         
         let blockDirectiveContainer = try XCTUnwrap(document.child(at: 0) as? BlockDirective, file: file, line: line)
         
-        var analyzer = SemanticAnalyzer(source: source, bundle: bundle)
+        var analyzer = SemanticAnalyzer(source: source, inputs: context.inputs)
         let result = analyzer.visit(blockDirectiveContainer)
         context.diagnosticEngine.emit(analyzer.problems)
         
-        var referenceResolver = MarkupReferenceResolver(
-            context: context,
-            bundle: bundle,
-            rootReference: bundle.rootReference
-        )
+        var referenceResolver = MarkupReferenceResolver(context: context, rootReference: context.inputs.rootReference)
         
         _ = referenceResolver.visit(blockDirectiveContainer)
         context.diagnosticEngine.emit(referenceResolver.problems)
@@ -304,9 +302,8 @@ extension XCTestCase {
         
         var contentCompiler = RenderContentCompiler(
             context: context,
-            bundle: bundle,
             identifier: ResolvedTopicReference(
-                bundleID: bundle.id,
+                bundleID: context.inputs.id,
                 path: "/test-path-123",
                 sourceLanguage: .swift
             )
diff --git a/Tests/SwiftDocCUtilitiesTests/ConvertActionIndexerTests.swift b/Tests/SwiftDocCUtilitiesTests/ConvertActionIndexerTests.swift
index 39fa7a46d8..49a72c3243 100644
--- a/Tests/SwiftDocCUtilitiesTests/ConvertActionIndexerTests.swift
+++ b/Tests/SwiftDocCUtilitiesTests/ConvertActionIndexerTests.swift
@@ -17,19 +17,19 @@ class ConvertActionIndexerTests: XCTestCase {
     
     // Tests the standalone indexer
     func testConvertActionIndexer() async throws {
-        let (bundle, dataProvider) = try DocumentationContext.InputsProvider()
+        let (inputs, dataProvider) = try DocumentationContext.InputsProvider()
             .inputsAndDataProvider(startingPoint: testCatalogURL(named: "LegacyBundle_DoNotUseInNewTests"), options: .init())
         
-        let context = try await DocumentationContext(bundle: bundle, dataProvider: dataProvider)
-        let converter = DocumentationNodeConverter(bundle: bundle, context: context)
+        let context = try await DocumentationContext(inputs: inputs, dataProvider: dataProvider)
+        let converter = DocumentationNodeConverter(context: context)
         
         // Add /documentation/MyKit to the index, verify the tree dump
         do {
-            let reference = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/MyKit", sourceLanguage: .swift)
+            let reference = ResolvedTopicReference(bundleID: inputs.id, path: "/documentation/MyKit", sourceLanguage: .swift)
             let renderNode = try converter.convert(context.entity(with: reference))
 
             let tempIndexURL = try createTemporaryDirectory(named: "index")
-            let indexer = try ConvertAction.Indexer(outputURL: tempIndexURL, bundleID: bundle.id)
+            let indexer = try ConvertAction.Indexer(outputURL: tempIndexURL, bundleID: inputs.id)
             indexer.index(renderNode)
             XCTAssertTrue(indexer.finalize(emitJSON: false, emitLMDB: false).isEmpty)
             let treeDump = try XCTUnwrap(indexer.dumpTree())
@@ -47,14 +47,14 @@ class ConvertActionIndexerTests: XCTestCase {
         // Add two nodes /documentation/MyKit and /documentation/Test-Bundle/Default-Code-Listing-Syntax to the index
         // and verify the tree.
         do {
-            let reference1 = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/MyKit", sourceLanguage: .swift)
+            let reference1 = ResolvedTopicReference(bundleID: inputs.id, path: "/documentation/MyKit", sourceLanguage: .swift)
             let renderNode1 = try converter.convert(context.entity(with: reference1))
 
-            let reference2 = ResolvedTopicReference(bundleID: "org.swift.docc.example", path: "/documentation/Test-Bundle/Default-Code-Listing-Syntax", sourceLanguage: .swift)
+            let reference2 = ResolvedTopicReference(bundleID: inputs.id, path: "/documentation/Test-Bundle/Default-Code-Listing-Syntax", sourceLanguage: .swift)
             let renderNode2 = try converter.convert(context.entity(with: reference2))
 
             let tempIndexURL = try createTemporaryDirectory(named: "index")
-            let indexer = try ConvertAction.Indexer(outputURL: tempIndexURL, bundleID: bundle.id)
+            let indexer = try ConvertAction.Indexer(outputURL: tempIndexURL, bundleID: inputs.id)
             indexer.index(renderNode1)
             indexer.index(renderNode2)
             XCTAssertTrue(indexer.finalize(emitJSON: false, emitLMDB: false).isEmpty)
diff --git a/Tests/SwiftDocCUtilitiesTests/ConvertActionTests.swift b/Tests/SwiftDocCUtilitiesTests/ConvertActionTests.swift
index 85fc99fa13..cd390ca572 100644
--- a/Tests/SwiftDocCUtilitiesTests/ConvertActionTests.swift
+++ b/Tests/SwiftDocCUtilitiesTests/ConvertActionTests.swift
@@ -267,7 +267,7 @@ class ConvertActionTests: XCTestCase {
             currentPlatforms: nil,
             fileManager: testDataProvider,
             temporaryDirectory: testDataProvider.uniqueTemporaryDirectory(),
-            bundleDiscoveryOptions: BundleDiscoveryOptions(
+            bundleDiscoveryOptions: CatalogDiscoveryOptions(
                 infoPlistFallbacks: infoPlistFallbacks,
                 additionalSymbolGraphFiles: [URL(fileURLWithPath: "/Not-a-doc-bundle/MyKit.symbols.json")]
             )
@@ -2892,13 +2892,13 @@ class ConvertActionTests: XCTestCase {
             currentPlatforms: nil,
             fileManager: testDataProvider,
             temporaryDirectory: testDataProvider.uniqueTemporaryDirectory(),
-            bundleDiscoveryOptions: BundleDiscoveryOptions(
+            bundleDiscoveryOptions: CatalogDiscoveryOptions(
                 additionalSymbolGraphFiles: [URL(fileURLWithPath: "/Not-a-doc-bundle/MyKit.symbols.json")]
             )
         )
         let (_, context) = try await action.perform(logHandle: .none)
 
-        let bundle = try XCTUnwrap(context.bundle, "Should have registered the generated test bundle.")
+        let bundle = try XCTUnwrap(context.inputs, "Should have registered the generated test bundle.")
         XCTAssertEqual(bundle.displayName, "MyKit")
         XCTAssertEqual(bundle.id, "MyKit")
     }
@@ -2933,7 +2933,7 @@ class ConvertActionTests: XCTestCase {
                 currentPlatforms: nil,
                 fileManager: fileSystem,
                 temporaryDirectory: fileSystem.uniqueTemporaryDirectory(),
-                bundleDiscoveryOptions: BundleDiscoveryOptions(
+                bundleDiscoveryOptions: CatalogDiscoveryOptions(
                     infoPlistFallbacks: ["CFBundleIdentifier": "com.example.test"],
                     additionalSymbolGraphFiles: [
                         URL(fileURLWithPath: "/Not-a-doc-bundle/MyKit.symbols.json"),
@@ -2969,16 +2969,16 @@ class ConvertActionTests: XCTestCase {
             emitDigest: false,
             currentPlatforms: nil,
             temporaryDirectory: createTemporaryDirectory(),
-            bundleDiscoveryOptions: BundleDiscoveryOptions(
+            bundleDiscoveryOptions: CatalogDiscoveryOptions(
                 infoPlistFallbacks: infoPlistFallbacks,
                 additionalSymbolGraphFiles: []
             )
         )
         let (_, context) = try await action.perform(logHandle: .none)
 
-        let bundle = try XCTUnwrap(context.bundle, "Should have registered the generated test bundle.")
-        XCTAssertEqual(bundle.displayName, "Something")
-        XCTAssertEqual(bundle.id, "com.example.test")
+        let inputs = try XCTUnwrap(context.inputs, "Should have registered the generated test bundle.")
+        XCTAssertEqual(inputs.displayName, "Something")
+        XCTAssertEqual(inputs.id, "com.example.test")
     }
 
     private func uniformlyPrintDiagnosticMessages(_ problems: [Problem]) -> String {
diff --git a/Tests/SwiftDocCUtilitiesTests/MergeActionTests.swift b/Tests/SwiftDocCUtilitiesTests/MergeActionTests.swift
index 0853d154e4..b158877df3 100644
--- a/Tests/SwiftDocCUtilitiesTests/MergeActionTests.swift
+++ b/Tests/SwiftDocCUtilitiesTests/MergeActionTests.swift
@@ -876,13 +876,13 @@ class MergeActionTests: XCTestCase {
             try fileSystem.createDirectory(at: catalogDir, withIntermediateDirectories: true)
             try fileSystem.addFolder(catalog, basePath: catalogDir.deletingLastPathComponent())
             
-            let (bundle, dataProvider) = try DocumentationContext.InputsProvider(fileManager: fileSystem)
+            let (inputs, dataProvider) = try DocumentationContext.InputsProvider(fileManager: fileSystem)
                 .inputsAndDataProvider(startingPoint: catalogDir, options: .init())
-            XCTAssertEqual(bundle.miscResourceURLs.map(\.lastPathComponent), [
+            XCTAssertEqual(inputs.miscResourceURLs.map(\.lastPathComponent), [
                 "\(name.lowercased())-card.png",
             ])
             
-            let context = try await DocumentationContext(bundle: bundle, dataProvider: dataProvider, configuration: .init())
+            let context = try await DocumentationContext(inputs: inputs, dataProvider: dataProvider, configuration: .init())
 
             XCTAssert(
                 context.problems.filter { $0.diagnostic.identifier != "org.swift.docc.SummaryContainsLink" }.isEmpty,
@@ -893,11 +893,11 @@ class MergeActionTests: XCTestCase {
             let outputPath = baseOutputDir.appendingPathComponent("\(name).doccarchive", isDirectory: true)
             
             let realTempURL = try createTemporaryDirectory() // The navigator builder only support real file systems
-            let indexer = try ConvertAction.Indexer(outputURL: realTempURL, bundleID: bundle.id)
+            let indexer = try ConvertAction.Indexer(outputURL: realTempURL, bundleID: inputs.id)
             
-            let outputConsumer = ConvertFileWritingConsumer(targetFolder: outputPath, bundleRootFolder: catalogDir, fileManager: fileSystem, context: context, indexer: indexer, transformForStaticHostingIndexHTML: nil, bundleID: bundle.id)
+            let outputConsumer = ConvertFileWritingConsumer(targetFolder: outputPath, bundleRootFolder: catalogDir, fileManager: fileSystem, context: context, indexer: indexer, transformForStaticHostingIndexHTML: nil, bundleID: inputs.id)
             
-            let convertProblems = try ConvertActionConverter.convert(bundle: bundle, context: context, outputConsumer: outputConsumer, sourceRepository: nil, emitDigest: false, documentationCoverageOptions: .noCoverage)
+            let convertProblems = try ConvertActionConverter.convert(context: context, outputConsumer: outputConsumer, sourceRepository: nil, emitDigest: false, documentationCoverageOptions: .noCoverage)
             XCTAssert(convertProblems.isEmpty, "Unexpected problems: \(context.problems.map(\.diagnostic.summary).joined(separator: "\n"))", file: file, line: line)
             
             let navigatorProblems = indexer.finalize(emitJSON: true, emitLMDB: false)
@@ -1262,7 +1262,7 @@ class MergeActionTests: XCTestCase {
                 JSONFile(name: "index.json", content: RenderIndex(interfaceLanguages: [:], includedArchiveIdentifiers: [identifier]))
             ]),
             
-            JSONFile(name: "metadata.json", content: BuildMetadata(bundleDisplayName: name, bundleID: DocumentationBundle.Identifier(rawValue: identifier)))
+            JSONFile(name: "metadata.json", content: BuildMetadata(bundleDisplayName: name, bundleID: DocumentationContext.Inputs.Identifier(rawValue: identifier)))
         ]
         
         return Folder(name: "\(name).doccarchive", content: content)
diff --git a/Tests/SwiftDocCUtilitiesTests/SemanticAnalyzerTests.swift b/Tests/SwiftDocCUtilitiesTests/SemanticAnalyzerTests.swift
index 034b935152..ffbf22464d 100644
--- a/Tests/SwiftDocCUtilitiesTests/SemanticAnalyzerTests.swift
+++ b/Tests/SwiftDocCUtilitiesTests/SemanticAnalyzerTests.swift
@@ -55,9 +55,9 @@ class SemanticAnalyzerTests: XCTestCase {
     ])
     
     func testDoNotCrashOnInvalidContent() async throws {
-        let (bundle, context) = try await loadBundle(catalog: catalogHierarchy)
+        let context = try await load(catalog: catalogHierarchy)
         
-        XCTAssertThrowsError(try context.entity(with: ResolvedTopicReference(bundleID: bundle.id, path: "/Oops", sourceLanguage: .swift)))
+        XCTAssertThrowsError(try context.entity(with: ResolvedTopicReference(bundleID: context.inputs.id, path: "/Oops", sourceLanguage: .swift)))
     }
     
     func testWarningsAboutDirectiveSupport() async throws {
@@ -73,7 +73,7 @@ class SemanticAnalyzerTests: XCTestCase {
                 """),
                 InfoPlist(displayName: "TestBundle", identifier: "com.test.example"),
             ])
-            let (_, context) = try await loadBundle(catalog: catalogHierarchy)
+            let context = try await load(catalog: catalogHierarchy)
             
             return (
                 context.problems.filter({ $0.diagnostic.identifier == "org.swift.docc.unsupportedTopLevelChild" }),
@@ -110,10 +110,10 @@ class SemanticAnalyzerTests: XCTestCase {
     }
     
     func testDoesNotWarnOnEmptyTutorials() async throws {
-        let (bundle, _) = try await loadBundle(catalog: catalogHierarchy)
+        let inputs = try await load(catalog: catalogHierarchy).inputs
         
         let document = Document(parsing: "", options: .parseBlockDirectives)
-        var analyzer = SemanticAnalyzer(source: URL(string: "/empty.tutorial"), bundle: bundle)
+        var analyzer = SemanticAnalyzer(source: URL(string: "/empty.tutorial"), inputs: inputs)
         let semantic = analyzer.visitDocument(document)
         XCTAssertNil(semantic)
         XCTAssert(analyzer.problems.isEmpty)
diff --git a/Tests/SwiftDocCUtilitiesTests/XCTestCase+LoadingData.swift b/Tests/SwiftDocCUtilitiesTests/XCTestCase+LoadingData.swift
index cc50e4ca1f..e592f174cb 100644
--- a/Tests/SwiftDocCUtilitiesTests/XCTestCase+LoadingData.swift
+++ b/Tests/SwiftDocCUtilitiesTests/XCTestCase+LoadingData.swift
@@ -20,19 +20,18 @@ extension XCTestCase {
     ///   - catalog: The directory structure of the documentation catalog
     ///   - otherFileSystemDirectories: Any other directories in the test file system.
     ///   - configuration: Configuration for the created context.
-    /// - Returns: The loaded documentation bundle and context for the given catalog input.
-    func loadBundle(
+    /// - Returns: The loaded documentation context for the provided catalog.
+    func load(
         catalog: Folder,
         otherFileSystemDirectories: [Folder] = [],
         configuration: DocumentationContext.Configuration = .init()
-    ) async throws -> (DocumentationBundle, DocumentationContext) {
+    ) async throws -> DocumentationContext {
         let fileSystem = try TestFileSystem(folders: [catalog] + otherFileSystemDirectories)
         
-        let (bundle, dataProvider) = try DocumentationContext.InputsProvider(fileManager: fileSystem)
+        let (inputs, dataProvider) = try DocumentationContext.InputsProvider(fileManager: fileSystem)
             .inputsAndDataProvider(startingPoint: URL(fileURLWithPath: "/\(catalog.name)"), options: .init())
 
-        let context = try await DocumentationContext(bundle: bundle, dataProvider: dataProvider, configuration: configuration)
-        return (bundle, context)
+        return try await DocumentationContext(inputs: inputs, dataProvider: dataProvider, configuration: configuration)
     }
     
     func testCatalogURL(named name: String, file: StaticString = #filePath, line: UInt = #line) throws -> URL {