pray-cli 1.15.0 → 1.17.0

data/lib/pray/dependency_graph.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Pray
+  module DependencyGraph
+    module_function
+
+    def find_dependency_cycle(edges)
+      visiting = {}
+      visited = {}
+      stack = []
+      edges.keys.sort.each do |name|
+        next if visited[name]
+
+        cycle = depth_first_search(name, edges, visiting, visited, stack)
+        return cycle if cycle
+      end
+      nil
+    end
+
+    def depth_first_search(name, edges, visiting, visited, stack)
+      return nil if visited[name]
+      if visiting[name]
+        start = stack.index(name)
+        return nil unless start
+
+        return stack[start..] + [name]
+      end
+
+      visiting[name] = true
+      stack << name
+      Array(edges[name]).each do |dependency|
+        next unless edges.key?(dependency)
+
+        cycle = depth_first_search(dependency, edges, visiting, visited, stack)
+        return cycle if cycle
+      end
+      stack.pop
+      visiting.delete(name)
+      visited[name] = true
+      nil
+    end
+  end
+end

data/lib/pray/destination.rb

@@ -16,8 +16,7 @@ module Pray
 
     def local_path_form?(value)
       value.start_with?(".", "/") ||
-        value.end_with?(".md", ".txt", ".markdown") ||
-        !value.include?("/")
+        value.end_with?(".md", ".txt", ".markdown")
     end
 
     def destination_target_name(mode, path)
@@ -106,6 +105,7 @@ module Pray
       if existing.position == "after" && local.position != "after"
         existing.position = local.position
       end
+      existing.file ||= local.file
     end
 
     def bind_package_entry(target, package_name)
@@ -154,5 +154,35 @@ module Pray
       else false
       end
     end
+
+    def local_compose_embed?(manifest, local)
+      return false if local.file
+
+      manifest.targets.none? do |target|
+        target.mode == "tree" &&
+          target.entries.any? { |entry| entry.kind == "local" && entry.path == local.path }
+      end
+    end
+
+    def try_apply_local_pray(manifest, path, file_dest, other_package_signal, destination_index)
+      return false unless local_path_form?(path)
+
+      if file_dest
+        return false if other_package_signal
+        raise Error.parse("manifest", "a local file cannot use file:")
+      end
+      return false if other_package_signal
+      unless destination_index
+        raise Error.parse("manifest", "local pray paths are only valid inside compose")
+      end
+      mode = manifest.targets[destination_index].mode
+      unless mode == "compose"
+        raise Error.parse("manifest", "local pray paths are only valid inside compose")
+      end
+      local = ManifestLocal.new(path: path, bound: true)
+      bind_local_entry(manifest.targets[destination_index], local.path)
+      upsert_local(manifest, local)
+      true
+    end
   end
 end

data/lib/pray/distribution.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Pray
+  DISTRIBUTION_CONFIG_SPEC = "pray-distribution-config-1"
+  TORRENT_PROTOCOL = "torrent"
+  DISTRIBUTION_CONFIG_FIELDS = %w[spec protocols bootstrap_trackers enable_dht].freeze
+
+  RegistryDistributionSettings = Struct.new(
+    :spec, :protocols, :bootstrap_trackers, :enable_dht,
+    keyword_init: true
+  ) do
+    def initialize(spec: DISTRIBUTION_CONFIG_SPEC, protocols: [], bootstrap_trackers: [], enable_dht: false)
+      super
+    end
+
+    def allows_torrent?
+      Array(protocols).include?(TORRENT_PROTOCOL)
+    end
+  end
+
+  module Distribution
+    module_function
+
+    def default_settings
+      RegistryDistributionSettings.new
+    end
+
+    def parse_settings(text)
+      data = JSON.parse(text)
+      unless data.is_a?(Hash)
+        raise Error.parse("distribution config", "expected an object")
+      end
+
+      data.each_key do |key|
+        next if DISTRIBUTION_CONFIG_FIELDS.include?(key)
+
+        raise Error.parse("distribution config", "unsupported field: #{key}")
+      end
+      settings = RegistryDistributionSettings.new(
+        spec: data.fetch("spec", DISTRIBUTION_CONFIG_SPEC),
+        protocols: Array(data["protocols"]),
+        bootstrap_trackers: Array(data["bootstrap_trackers"]),
+        enable_dht: data["enable_dht"] == true
+      )
+      validate_settings!(settings)
+      settings
+    rescue JSON::ParserError => error
+      raise Error.parse("distribution config", error.message)
+    end
+
+    def read_settings(root)
+      path = File.join(root, "v1", "distribution.json")
+      return default_settings unless File.file?(path)
+
+      parse_settings(File.read(path))
+    end
+
+    def write_settings(root, settings = default_settings)
+      validate_settings!(settings)
+      path = File.join(root, "v1", "distribution.json")
+      FileUtils.mkdir_p(File.dirname(path))
+      payload = {"spec" => settings.spec, "protocols" => Array(settings.protocols)}
+      File.write(path, JSON.pretty_generate(payload))
+    end
+
+    def validate_settings!(settings)
+      unless settings.spec == DISTRIBUTION_CONFIG_SPEC
+        raise Error.parse("distribution config", "unsupported distribution config spec: #{settings.spec}")
+      end
+      Array(settings.protocols).each do |name|
+        next if name == TORRENT_PROTOCOL
+
+        raise Error.parse("distribution config", "unsupported protocol: #{name}")
+      end
+      if settings.enable_dht
+        raise Error.parse("distribution config", "DHT announce is not implemented")
+      end
+      return if Array(settings.bootstrap_trackers).empty? || settings.allows_torrent?
+
+      raise Error.parse("distribution config", "bootstrap_trackers requires protocols to include torrent")
+    end
+
+    def fetch_settings(source_url)
+      parse_settings(Registry.http_get(Registry.join_url(source_url, "v1/distribution.json")))
+    rescue Error => error
+      return default_settings if error.message.match?(/:\s*404\b/)
+
+      raise
+    end
+  end
+end

data/lib/pray/format_serialize.rb

@@ -42,10 +42,7 @@ module Pray
           path = target.skills.first || ""
           lines << %(tree "#{path}" do)
           target.entries.each do |entry|
-            next unless entry.kind == "package"
-
-            package = find_package(manifest, entry.name)
-            lines << "  #{ManifestMethods.format_package_declaration(package)}" if package
+            lines << "  #{format_destination_entry(entry, manifest)}"
           end
           lines << "end"
         end

data/lib/pray/git_sources.rb

@@ -16,8 +16,8 @@ module Pray
         next unless source.kind == "git"
 
         clone_url = source.url.delete_prefix("git+")
-        if local_filesystem_source?(clone_url) && !local_git_repo_path(clone_url)
-          source_root = local_git_source_root(clone_url)
+        if local_filesystem_source?(clone_url) && !local_git_repo_path(project_root, clone_url)
+          source_root = local_git_source_root(project_root, clone_url)
           if source_root
             checkouts[source.name] = GitSourceCheckout.new(
               cache_directory: source_root,
@@ -76,12 +76,8 @@ module Pray
       File.directory?(File.join(path, "v1", "packages"))
     end
 
-    def local_git_source_root(clone_url)
-      path = if clone_url.start_with?("file://")
-        clone_url.delete_prefix("file://")
-      else
-        clone_url
-      end
+    def local_git_source_root(project_root, clone_url)
+      path = clone_url_filesystem_path(project_root, clone_url)
       return nil unless File.exist?(path)
 
       discover_distribution_root(path)
@@ -136,12 +132,17 @@ module Pray
       clone_url.start_with?("file://") || Pathname.new(clone_url).absolute?
     end
 
-    def local_git_repo_path(clone_url)
-      path = clone_url.delete_prefix("file://")
+    def local_git_repo_path(project_root, clone_url)
+      path = clone_url_filesystem_path(project_root, clone_url)
       git_directory = File.join(path, ".git")
       File.directory?(git_directory) ? path : nil
     end
 
+    def clone_url_filesystem_path(project_root, clone_url)
+      path = clone_url.delete_prefix("file://")
+      Pathname.new(path).absolute? ? path : File.expand_path(path, project_root)
+    end
+
     def global_cache_root
       return ENV["PRAY_CACHE"] if ENV["PRAY_CACHE"]
       return File.join(ENV["PRAY_HOME"], "cache") if ENV["PRAY_HOME"]

data/lib/pray/local_prayer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Pray
+  DEFAULT_LOCAL_PRAYER_NAME = "project"
+  DEFAULT_PATH_SOURCE_NAME = "local"
+  DEFAULT_PATH_SOURCE_DIRECTORY = "prayers"
+
+  module LocalPrayer
+    module_function
+
+    def validate_name!(name)
+      trimmed = name.to_s.strip
+      raise Error.usage("prayer name is missing") if trimmed.empty?
+      if trimmed.include?("/") || trimmed.include?("\\") || trimmed == "." || trimmed == ".."
+        raise Error.usage("prayer name must be a single folder name")
+      end
+      if reserved_distribution_layout_name?(trimmed)
+        raise Error.usage("#{trimmed} is reserved for the distribution layout")
+      end
+
+      trimmed
+    end
+
+    def path_source_package_directory(source_name, package_name)
+      prefix = "#{source_name}/"
+      rest = package_name.delete_prefix(prefix)
+      if rest != package_name && !rest.empty? && !rest.include?("/") && !rest.include?("\\")
+        return rest
+      end
+
+      package_name.to_s.tr("/", "-").tr("\\", "-")
+    end
+
+    def reserved_distribution_layout_name?(name)
+      name.match?(/\Av[0-9]+\z/)
+    end
+  end
+end

data/lib/pray/lockfile.rb

@@ -5,6 +5,8 @@ require "perfect_toml"
 require_relative "lockfile_serialize"
 
 module Pray
+  LOCAL_EMBED_PACKAGE = "local"
+
   LockSource = Struct.new(:name, :kind, :url, :revision, :host_key_fingerprint)
   LockedPackage = Struct.new(
     :name, :version, :source, :path, :tree_hash, :artifact_hash, :artifact,
@@ -20,7 +22,11 @@ module Pray
   ManagedSpanRecord = Struct.new(
     :id, :target, :open_line, :close_line, :ideal_checksum, :package, :export,
     :source_checksum, :silenced
-  )
+  ) do
+    def local_embed?
+      package == LOCAL_EMBED_PACKAGE
+    end
+  end
   ProvisionedFileRecord = Struct.new(:path, :content_hash, :package, :export)
 
   Lockfile = Struct.new(
@@ -179,7 +185,7 @@ module Pray
         package: packages.map do |package|
           LockedPackage.new(
             name: package.declaration.name,
-            version: package.spec.version,
+            version: package.spec.recorded_version,
             source: package.declaration.source,
             path: relative_lockfile_path(project_root, package.root),
             tree_hash: package.tree_hash,

data/lib/pray/manifest.rb

@@ -46,8 +46,8 @@ module Pray
     end
   end
 
-  ManifestLocal = Struct.new(:path, :position, :optional, :bound) do
-    def initialize(path:, position: "after", optional: false, bound: false)
+  ManifestLocal = Struct.new(:path, :position, :optional, :bound, :file) do
+    def initialize(path:, position: "after", optional: false, bound: false, file: nil)
       super
     end
   end
@@ -135,7 +135,10 @@ module Pray
         PathSafety.validate_project_relative_path!(package.path) if package.path
         PathSafety.validate_destination_path!(package.file) if package.file
       end
-      manifest.local.each { |local| PathSafety.validate_project_relative_path!(local.path) }
+      manifest.local.each do |local|
+        PathSafety.validate_project_relative_path!(local.path)
+        PathSafety.validate_destination_path!(local.file) if local.file
+      end
     end
   end
 

data/lib/pray/manifest_json.rb

@@ -87,6 +87,7 @@ module Pray
         "optional" => entry.optional
       }
       fields["bound"] = true if entry.bound
+      fields["file"] = entry.file if entry.file
       fields
     end
 

data/lib/pray/manifest_parser_blocks.rb

@@ -116,7 +116,7 @@ module Pray
         while (statement = next_statement)
           if statement == "end"
             unless saw_package
-              raise Error.parse("manifest", "file block requires a pray package declaration")
+              raise Error.parse("manifest", "file block requires a pray package")
             end
             return
           end
@@ -132,7 +132,15 @@ module Pray
           return true
         end
         if (match = statement.match(/\A(?:pray|use|include|package) (.+)\z/))
-          bind_file_package(manifest, match[1], file_path)
+          rest = match[1]
+          values, keywords = parse_call(rest)
+          if values.length == 1 && keywords.empty?
+            first = string_from_value(values.first)
+            if Destination.local_path_form?(first)
+              raise Error.parse("manifest", "file: requires a package")
+            end
+          end
+          bind_file_package(manifest, rest, file_path)
           return true
         end
         raise Error.parse("manifest", "unsupported statement inside file block: #{statement}")
@@ -161,19 +169,11 @@ module Pray
       end
 
       def apply_local_pray_path(manifest, first, keywords, values, destination_index)
-        return false if package_signal?(values, keywords)
-        return false unless Destination.local_path_form?(first)
-
-        in_compose = destination_index &&
-          manifest.targets[destination_index]&.mode == "compose"
-        unless in_compose
-          raise Error.parse("manifest", "local pray paths are only valid inside compose blocks")
-        end
-
-        local = ManifestLocal.new(path: first, position: "after", optional: false, bound: true)
-        Destination.bind_local_entry(manifest.targets[destination_index], local.path)
-        Destination.upsert_local(manifest, local)
-        true
+        file_dest = keywords["file"]&.as_string
+        other_package_signal = values.length > 1 ||
+          %w[source export exports optional path git tag rev tarball oci targets features]
+            .any? { |key| keywords.key?(key) }
+        Destination.try_apply_local_pray(manifest, first, file_dest, other_package_signal, destination_index)
       end
 
       def package_signal?(values, keywords)

data/lib/pray/materialize.rb

@@ -54,9 +54,15 @@ module Pray
           raise
         end
       end
+      previous_lockfile = project.previous_lockfile
+      unless locked || frozen
+        if Upstream.apply_path_upstream_refreshes(project, previous_lockfile, nil, options)
+          project = Resolve.resolve_project_in_context(manifest_path, project_root, options)
+          previous_lockfile = project.previous_lockfile
+        end
+      end
       rendered = Render.render_project(project)
       lockfile_path = default_lockfile_path(project.project_root)
-      previous_lockfile = project.previous_lockfile
       next_lockfile = LockfileIO.build_lockfile(
         project.manifest_hash,
         project.environment,
@@ -133,6 +139,7 @@ module Pray
   def resolve_project(...) = Resolve.resolve_project(...)
   def render_project(...) = Render.render_project(...)
   def inspect_project(...) = Verify.inspect_project(...)
+  def inspect_locked_destinations(...) = Verify.inspect_locked_destinations(...)
   def verify_project(...) = Verify.verify_project(...)
   def drift_project(...) = Verify.drift_project(...)
 end

data/lib/pray/package_spec.rb

@@ -12,12 +12,12 @@ module Pray
   PackageUpstream = Struct.new(:name, :constraint, keyword_init: true)
 
   PackageSpec = Struct.new(
-    :name, :version, :summary, :description, :authors, :license, :homepage,
+    :name, :version, :summary, :description, :authors, :maintainers, :license, :homepage,
     :source_code_uri, :changelog_uri, :prayfile_version, :files, :exports,
     :skills, :templates, :adapters, :targets, :dependencies, :metadata, :upstream
   ) do
     def initialize(
-      name: "", version: "", summary: nil, description: nil, authors: [], license: nil,
+      name: "", version: "", summary: nil, description: nil, authors: [], maintainers: [], license: nil,
       homepage: nil, source_code_uri: nil, changelog_uri: nil, prayfile_version: nil,
       files: [], exports: {}, skills: {}, templates: {}, adapters: {}, targets: [],
       dependencies: [], metadata: {}, upstream: nil
@@ -47,8 +47,9 @@ module Pray
     def canonicalized
       dup.tap do |copy|
         copy.files = files.sort
-        copy.authors = authors.sort
-        copy.targets = targets.sort
+        copy.authors = Array(authors).sort
+        copy.maintainers = Array(maintainers).sort
+        copy.targets = Array(targets).sort
         copy.dependencies = dependencies.sort_by { |dependency| [dependency.name, dependency.constraint, dependency.optional] }
       end
     end
@@ -227,18 +228,29 @@ module Pray
         end
       end
 
+      STRING_ASSIGNMENTS = {
+        "name" => :name=,
+        "version" => :version=,
+        "summary" => :summary=,
+        "description" => :description=,
+        "license" => :license=,
+        "homepage" => :homepage=,
+        "source_code_uri" => :source_code_uri=,
+        "changelog_uri" => :changelog_uri=,
+        "prayfile_version" => :prayfile_version=,
+        "pray_version" => :prayfile_version=
+      }.freeze
+
       def apply_assignment(spec, field, value)
+        setter = STRING_ASSIGNMENTS[field]
+        if setter
+          spec.public_send(setter, string_from_literal(value))
+          return
+        end
+
         case field
-        when "name" then spec.name = string_from_literal(value)
-        when "version" then spec.version = string_from_literal(value)
-        when "summary" then spec.summary = string_from_literal(value)
-        when "description" then spec.description = string_from_literal(value)
         when "authors" then spec.authors = array_of_strings(value)
-        when "license" then spec.license = string_from_literal(value)
-        when "homepage" then spec.homepage = string_from_literal(value)
-        when "source_code_uri" then spec.source_code_uri = string_from_literal(value)
-        when "changelog_uri" then spec.changelog_uri = string_from_literal(value)
-        when "prayfile_version" then spec.prayfile_version = string_from_literal(value)
+        when "maintainers" then spec.maintainers = array_of_strings(value)
         when "files" then spec.files = array_of_strings(value)
         when "targets" then spec.targets = array_of_strings(value)
         when "exports" then spec.exports = parse_exports(value)

data/lib/pray/package_spec_render.rb

@@ -4,9 +4,9 @@ module Pray
   module PackageSpecRender
     module_function
 
-    def fork_spec_after_refresh(local, new_upstream, local_prayspec_file, clean_replica, merged_content_paths)
+    def fork_spec_after_refresh(local, new_upstream, clean_replica, merged_content_paths)
       spec = local.dup
-      spec.files = [local_prayspec_file, *merged_content_paths]
+      spec.files = merged_content_paths.dup
       if clean_replica
         spec.exports = new_upstream.exports.dup
         spec.templates = new_upstream.templates.dup
@@ -32,10 +32,11 @@ module Pray
 
     def push_identity_fields(lines, spec)
       push_assignment(lines, "name", spec.name)
-      push_assignment(lines, "version", spec.version)
+      push_assignment(lines, "version", spec.version) unless spec.version.to_s.empty?
       push_optional(lines, "summary", spec.summary)
       push_optional(lines, "description", spec.description)
       push_array(lines, "authors", spec.authors) unless spec.authors.nil? || spec.authors.empty?
+      push_array(lines, "maintainers", spec.maintainers) unless spec.maintainers.nil? || spec.maintainers.empty?
       push_optional(lines, "license", spec.license)
       push_optional(lines, "homepage", spec.homepage)
       push_optional(lines, "source_code_uri", spec.source_code_uri)

data/lib/pray/package_spec_version.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pray
+  class PackageSpec
+    LOCAL_VERSION = "local"
+
+    def has_release_version?
+      !version.to_s.empty? && version != LOCAL_VERSION
+    end
+
+    def recorded_version
+      has_release_version? ? version : LOCAL_VERSION
+    end
+
+    def require_release_version!
+      return if has_release_version?
+
+      raise Error.manifest("package #{name} needs a version before it can be packaged")
+    end
+
+    def satisfy_constraint!(constraint)
+      unless has_release_version?
+        normalized = Constraint.normalize_version_constraint(constraint)
+        return if normalized.empty? || normalized == "*"
+
+        raise Error.resolution("package #{name} has no version; add spec.version or omit the constraint")
+      end
+      return if Constraint.version_satisfies(version, constraint)
+
+      raise Error.resolution("package #{name} version #{version} does not satisfy constraint #{constraint}")
+    end
+  end
+end

data/lib/pray/plan.rb

@@ -13,7 +13,8 @@ module Pray
     def build_materialization_preview(project, rendered, lockfile, _lockfile_path, previous_lockfile)
       destinations = RenderDest.validate_destinations!(project, previous_lockfile)
       MaterializationPreview.new(
-        package_lines: package_summary_lines(previous_lockfile, lockfile, project),
+        package_lines: ApplyReport.local_summary_lines(previous_lockfile, project) +
+          package_summary_lines(previous_lockfile, lockfile, project),
         lockfile: lockfile_change_status(previous_lockfile, lockfile),
         targets: rendered.map { |target| target_change(project, target) },
         provisioned: destinations.map { |file, status| [file.path, status.to_s] },

data/lib/pray/publish.rb

@@ -17,14 +17,16 @@ module Pray
     def publish_to_root(project, root, signer: "local", signer_fingerprint: nil)
       root = File.expand_path(root)
       index = load_registry_index(root)
+      distribution = Distribution.read_settings(root)
       package_names = index.packages.to_set
 
       project.packages.each do |package|
+        package.spec.require_release_version!
         artifact_path = registry_artifact_path(package.declaration.name, package.spec.version)
         metadata_path = registry_metadata_path(root, package.declaration.name)
         metadata = load_registry_package_metadata(metadata_path, package.declaration.name)
         existing = metadata.versions.find { |entry| entry.version == package.spec.version }
-        stored_artifact = stored_package_artifact(root, artifact_path, package, existing)
+        stored_artifact = stored_package_artifact(root, artifact_path, package, existing, distribution)
         if stored_artifact && stored_publish_matches?(
           stored_artifact, package, signer, signer_fingerprint, existing
         )
@@ -35,6 +37,14 @@ module Pray
 
         archive_bytes = Archive.build_package_archive_bytes(package)
         write_output_bytes(File.join(root, artifact_path), archive_bytes)
+        TorrentManifest.write(
+          root,
+          name: package.declaration.name,
+          version: package.spec.version,
+          artifact_path: artifact_path,
+          archive_bytes: archive_bytes,
+          settings: distribution
+        )
         version_entry = published_registry_package_version(
           package,
           signer,
@@ -54,10 +64,24 @@ module Pray
     end
 
     def publish_to_server(project, server_url, signer: "local", signer_fingerprint: nil)
+      distribution = Distribution.fetch_settings(server_url)
       project.packages.each do |package|
         archive_bytes = Archive.build_package_archive_bytes(package)
         artifact_path = registry_artifact_path(package.declaration.name, package.spec.version)
         Registry.http_put(join_url(server_url, artifact_path), "application/octet-stream", archive_bytes)
+        if distribution.allows_torrent?
+          Registry.http_put(
+            join_url(server_url, TorrentManifest.path_for(artifact_path)),
+            "application/json",
+            TorrentManifest.bytes(
+              name: package.declaration.name,
+              version: package.spec.version,
+              artifact_path: artifact_path,
+              archive_bytes: archive_bytes,
+              trackers: distribution.bootstrap_trackers
+            )
+          )
+        end
 
         metadata = RegistryPackageMetadata.new(
           name: package.declaration.name,
@@ -95,7 +119,7 @@ module Pray
       )
     end
 
-    def stored_package_artifact(root, artifact_path, package, existing)
+    def stored_package_artifact(root, artifact_path, package, existing, distribution)
       return unless existing&.artifact == artifact_path && existing.tree_hash == package.tree_hash
 
       stored_path = File.join(root, artifact_path)
@@ -104,6 +128,7 @@ module Pray
       artifact_bytes = File.binread(stored_path)
       return unless existing.artifact_hash == Hashing.sha256_prefixed(artifact_bytes)
       return unless stored_prayspec_matches?(artifact_bytes, package.root)
+      return unless TorrentManifest.descriptor_present?(root, artifact_path, distribution)
 
       artifact_bytes
     end

data/lib/pray/registry.rb

@@ -8,6 +8,7 @@ require "pathname"
 require "time"
 require_relative "path_safety"
 require_relative "http_body"
+require_relative "registry_paths"
 
 module Pray
   RegistryPackageVersion = Struct.new(
@@ -40,6 +41,17 @@ module Pray
     module_function
 
     def resolve_registry_package_root(project_root, source_url, declaration, preferred_version: nil, offline: false)
+      if local_source?(source_url)
+        return resolve_local_registry_package_root(
+          project_root,
+          source_url,
+          RegistryPaths.local_registry_root(project_root, source_url),
+          declaration,
+          preferred_version: preferred_version,
+          offline: offline
+        )
+      end
+
       metadata = fetch_package_metadata(source_url, declaration.name)
       registry_latest_version = registry_latest_version_label(metadata)
       selected = select_package_version(metadata, declaration.constraint, preferred_version)