         packageIdentity: PackageIdentity,
         toolsVersion: ToolsVersion,
         delegateQueue: DispatchQueue,
-        result: inout EvaluationResult
+        completion: @escaping (Result<EvaluationResult, Error>) -> Void
     ) throws {
+        var evaluationResult = EvaluationResult()
+
         delegateQueue.async {
             self.delegate?.willParse(manifest: manifestPath)
         }

                    delegateQueue: queue,
                    fileSystem: fileSystem,
                    observabilityScope: observabilityScope
                )

                // Convert legacy system packages to the current target‐based model.
                var products = parsedManifest.products
                var targets = parsedManifest.targets
                if products.isEmpty, targets.isEmpty,
                    fileSystem.isFile(path.parentDirectory.appending(component: moduleMapFilename)) {
                        products.append(ProductDescription(
                        name: parsedManifest.name,
                        type: .library(.automatic),
                        targets: [parsedManifest.name])
                    )
                    targets.append(try TargetDescription(
                        name: parsedManifest.name,
                        path: "",
                        type: .system,
                        pkgConfig: parsedManifest.pkgConfig,
                        providers: parsedManifest.providers
                    ))
                }

                let manifest = Manifest(
                    displayName: parsedManifest.name,
                    path: path,
                    packageKind: packageKind,
                    packageLocation: packageLocation,
                    defaultLocalization: parsedManifest.defaultLocalization,
                    platforms: parsedManifest.platforms,
                    version: version,
                    revision: revision,
                    toolsVersion: toolsVersion,
                    pkgConfig: parsedManifest.pkgConfig,
                    providers: parsedManifest.providers,
                    cLanguageStandard: parsedManifest.cLanguageStandard,
                    cxxLanguageStandard: parsedManifest.cxxLanguageStandard,
                    swiftLanguageVersions: parsedManifest.swiftLanguageVersions,
                    dependencies: parsedManifest.dependencies,
                    products: products,
                    targets: targets
                )

                try self.validate(manifest, toolsVersion: toolsVersion, observabilityScope: observabilityScope)

                if observabilityScope.errorsReported {
                    throw Diagnostics.fatalError
                }

                queue.async {
                    completion(.success(manifest))
                }
            } catch {
                queue.async {

                    throw PackageModel.Package.Error.noManifest(at: path, version: version?.description)
                }

                self.parseAndCacheManifest(
                    at: path,
                    packageIdentity: packageIdentity,
                    packageKind: packageKind,
