crosspack 0.2.1 → 0.5.0

data/lib/crossbuild/build_manifest.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
-require 'yaml'
-
 module Crossbuild
-  # A single schema problem: full path into build.yaml + human explanation.
+  # A single schema problem: full path into the build: section + human
+  # explanation.
   class Issue
     attr_reader :path, :message
 
@@ -17,16 +16,17 @@ module Crossbuild
     end
   end
 
-  class InvalidManifestError < StandardError; end
+  class InvalidManifestError < Crosspack::InvalidManifestError; end
 
   class BuildManifest
     OS_LIST = %w[linux darwin windows].freeze
     ARCH_LIST = %w[amd64 x86_64 arm64 aarch64 any].freeze
     ARTIFACT_MODES = %w[symlink copy].freeze
     VERSION_SCHEMES = %w[calver git-tag].freeze
-    TOP_LEVEL_KEYS = %w[name version output matrix].freeze
+    TOP_LEVEL_KEYS = %w[name version output deps matrix].freeze
     ENTRY_KEYS = %w[id build env steps artifacts].freeze
     ARTIFACTS_KEYS = %w[from include to mode].freeze
+    DEP_KEYS = %w[hosts].freeze
     BUILD_RE = /\A(linux|darwin|windows)\/(#{ARCH_LIST.join('|')})\z/.freeze
     NAME_RE = /\A[a-z0-9][a-z0-9+._-]*\z/i.freeze
 
@@ -54,6 +54,22 @@ module Crossbuild
       end
     end
 
+    # A build dependency from the top-level deps: section. `hosts` maps a
+    # host selector (distro id from os-release, ID_LIKE token, os name or
+    # "*") to a rule with per-system commands:
+    #   verify:  presence probe (default: PATH lookup of the name)
+    #   install: how to install it (a verify-only rule may omit this)
+    class Dependency
+      RULE_KEYS = %w[verify install].freeze
+
+      attr_reader :name, :hosts
+
+      def initialize(name, hosts)
+        @name = name
+        @hosts = hosts
+      end
+    end
+
     # Where artifacts come from and which builds/ directories they fan out to.
     class Artifacts
       attr_reader :from, :include, :to, :mode
@@ -66,22 +82,7 @@ module Crossbuild
       end
     end
 
-    attr_reader :path, :name, :version, :output, :entries, :errors, :warnings
-
-    def self.load(path)
-      unless File.file?(path)
-        raise InvalidManifestError,
-              "Build manifest not found: #{path}\n" \
-              'Create build.yaml next to the Rakefile (see crossbuild/README.md).'
-      end
-      begin
-        raw = YAML.safe_load(File.read(path), permitted_classes: [], aliases: false)
-      rescue Psych::SyntaxError => e
-        raise InvalidManifestError,
-              "#{path}: YAML syntax error on line #{e.line}: #{e.problem}"
-      end
-      new(path, raw)
-    end
+    attr_reader :path, :name, :version, :output, :deps, :entries, :errors, :warnings
 
     def initialize(path, raw)
       @path = path
@@ -89,6 +90,7 @@ module Crossbuild
       @name = nil
       @version = nil
       @output = 'builds'
+      @deps = []
       @entries = []
       @errors = []
       @warnings = []
@@ -103,7 +105,7 @@ module Crossbuild
     def validate!
       return self if valid?
 
-      lines = ["#{path}: build.yaml schema is invalid (#{@errors.size} errors):"]
+      lines = ["#{path}: the build: section is invalid (#{@errors.size} errors):"]
       @errors.each { |e| lines << "  ✗ #{e}" }
       lines << 'Build aborted: fix the listed nodes and retry.'
       raise InvalidManifestError, lines.join("\n")
@@ -114,9 +116,9 @@ module Crossbuild
       lines = []
       if valid?
         noun = @entries.size == 1 ? 'entry' : 'entries'
-        lines << "#{path}: schema is valid (#{@entries.size} #{noun}: #{@entries.map(&:id).join(', ')})."
+        lines << "#{path}: the build: section is valid (#{@entries.size} #{noun}: #{@entries.map(&:id).join(', ')})."
       else
-        lines << "#{path}: build.yaml schema is invalid (#{@errors.size} errors):"
+        lines << "#{path}: the build: section is invalid (#{@errors.size} errors):"
         @errors.each { |e| lines << "  ✗ #{e}" }
       end
       @warnings.each { |w| lines << "  ⚠ #{w}" }
@@ -132,11 +134,33 @@ module Crossbuild
       @entries.find { |e| e.id == id }
     end
 
+    # The single matrix entry that distributes artifacts to the given target
+    # string (e.g. "ubuntu-24.04"). Raises Crossbuild::Error when no entry
+    # claims it or when several do (ambiguous).
+    def entry_for_target(raw)
+      matches = @entries.select { |e| e.artifacts&.to&.include?(raw) }
+      declared = @entries.filter_map { |e| e.artifacts&.to }.flatten.uniq
+      if matches.empty?
+        raise Error,
+              "no matrix entry distributes to target #{raw.inspect}; " \
+              "declared targets: #{declared.join(', ')}"
+      end
+      if matches.size > 1
+        raise Error,
+              "target #{raw.inspect} is distributed by several entries " \
+              "(#{matches.map(&:id).join(', ')}) — crosspack build <target> needs exactly one"
+      end
+
+      matches.first
+    end
+
     private
 
     def validate
       unless @raw.is_a?(Hash) && !@raw.empty?
-        @errors << Issue.new('(root)', 'file must be a non-empty mapping with at least a name and a matrix')
+        @errors << Issue.new('(root)',
+                             'the build: section of crosspack.yml is missing or empty — ' \
+                             'the deps and build stages need it (matrix, steps, artifacts)')
         return
       end
 
@@ -144,13 +168,14 @@ module Crossbuild
       validate_name
       validate_version
       validate_output
+      validate_deps
       validate_matrix
     end
 
     def validate_name
       @name = @raw['name'].to_s
       if @raw['name'].nil? || @name.empty?
-        @errors << Issue.new('name', 'is required: the application name, e.g. myapp')
+        @errors << Issue.new('name', 'is required at the top level of crosspack.yml, e.g. name: myapp')
       elsif @name !~ NAME_RE
         @errors << Issue.new('name', "invalid name #{@name.inspect} (letters, digits, \"+\", \"_\", \"-\", \".\")")
       end
@@ -159,7 +184,7 @@ module Crossbuild
     def validate_version
       spec = @raw['version']
       if spec.nil?
-        @warnings << Issue.new('version', 'not set — defaulting to calver (YYYY.MM.DD-<secs>)')
+        @warnings << Issue.new('version', 'not set at the top level of crosspack.yml — defaulting to calver (YYYY.MM.DD-<secs>)')
         @version = 'calver'
         return
       end
@@ -184,6 +209,76 @@ module Crossbuild
       end
     end
 
+    def validate_deps
+      deps = @raw['deps']
+      return if deps.nil?
+
+      unless deps.is_a?(Hash)
+        @errors << Issue.new(
+          'deps',
+          "must be a mapping of dependency name -> {check?, hosts}; expected:\n" \
+          "    deps:\n" \
+          "      imagemagick:\n" \
+          "        check: magick -version\n" \
+          "        hosts:\n" \
+          "          ubuntu: sudo apt-get install -y imagemagick"
+        )
+        return
+      end
+
+      deps.each { |name, body| validate_dep(name, body) }
+    end
+
+    def validate_dep(name, body)
+      path = "deps.#{name}"
+      if name !~ NAME_RE
+        @errors << Issue.new(path, "invalid dependency name #{name.inspect} (letters, digits, \"+\", \"_\", \"-\", \".\")")
+        return
+      end
+      unless body.is_a?(Hash)
+        @errors << Issue.new(path, 'must be a mapping with the key: hosts')
+        return
+      end
+      check_unknown_keys(path, body.keys, DEP_KEYS)
+
+      hosts = body['hosts']
+      unless hosts.is_a?(Hash) && !hosts.empty?
+        @errors << Issue.new(
+          "#{path}.hosts",
+          "must be a non-empty mapping of host selector -> {verify?, install?}; expected:\n" \
+          "    deps:\n" \
+          "      #{name}:\n" \
+          "        hosts:\n" \
+          "          ubuntu:\n" \
+          "            verify: dpkg -s #{name}\n" \
+          "            install: sudo apt-get install -y #{name}"
+        )
+        return
+      end
+      hosts.each { |selector, rule| validate_host_rule(name, selector, rule) }
+      return unless valid_dep?(name, body)
+
+      @deps << Dependency.new(name, hosts)
+    end
+
+    def validate_host_rule(name, selector, rule)
+      path = "deps.#{name}.hosts.#{selector}"
+      unless rule.is_a?(Hash) && !rule.empty?
+        @errors << Issue.new(path, "must be a mapping with verify and/or install commands, e.g. { install: sudo apt-get install -y #{name} }")
+        return
+      end
+      check_unknown_keys(path, rule.keys, Dependency::RULE_KEYS)
+      rule.each do |key, command|
+        unless command.is_a?(String) && !command.strip.empty?
+          @errors << Issue.new("#{path}.#{key}", 'must be a non-empty shell command')
+        end
+      end
+    end
+
+    def valid_dep?(name, body)
+      @errors.none? { |e| e.path.start_with?("deps.#{name}") }
+    end
+
     def validate_matrix
       matrix = @raw['matrix']
       unless matrix.is_a?(Array) && !matrix.empty?

data/lib/crossbuild/builder.rb

@@ -8,12 +8,13 @@ module Crossbuild
 
     attr_reader :manifest
 
-    def initialize(manifest, root: Dir.pwd, output_base: nil, version: nil,
+    def initialize(manifest, root: Dir.pwd, output_base: nil, version: nil, deps: true,
                    host_os: Platform.os, host_arch: Platform.arch)
       @manifest = manifest
       @root = root
       @output_base = output_base || manifest.output
       @version_override = version
+      @deps = deps
       @host_os = host_os
       @host_arch = host_arch
     end
@@ -21,20 +22,44 @@ module Crossbuild
     # entry_id: nil — every entry buildable on this host; otherwise the exact
     # entry id (which must exist, but may target another host — the user
     # asked for it explicitly).
-    def run(entry_id: nil)
+    # target: a raw target string (e.g. "ubuntu-24.04") — builds the single
+    # matrix entry distributing to it and fans artifacts out to that target
+    # only; the entry must be buildable on this host (no cross-compilation).
+    def run(entry_id: nil, target: nil)
       manifest.validate!
+      ensure_deps
       version = @version_override || VersionScheme.new(manifest.version).compute(root: @root)
-      entries = select_entries(entry_id)
+      entries = target ? entries_for_target(target) : select_entries(entry_id)
 
       entries.each do |entry|
         puts "\n==> #{manifest.name} [#{entry.id}] version #{version}"
-        run_entry(entry, version)
+        run_entry(entry, version, only: target)
       end
       Result.new(version: version, entries: entries)
     end
 
     private
 
+    # deps: false (--no-deps) skips the pre-build check/install pass.
+    def ensure_deps
+      return if !@deps || manifest.deps.empty?
+
+      puts '⧗ build deps'
+      DepInstaller.new(manifest, root: @root).ensure_all
+    end
+
+    def entries_for_target(raw)
+      entry = manifest.entry_for_target(raw)
+      host = "#{@host_os}/#{Platform.display_arch(@host_arch)}"
+      unless entry.buildable_on?(@host_os, @host_arch)
+        raise Error,
+              "the entry for #{raw.inspect} (#{entry.id}) builds on #{entry.platform}, " \
+              "this host is #{host} — cross-compilation is not supported"
+      end
+
+      [entry]
+    end
+
     def select_entries(entry_id)
       if entry_id
         entry = manifest.find_entry(entry_id)
@@ -50,7 +75,7 @@ module Crossbuild
       end
     end
 
-    def run_entry(entry, version)
+    def run_entry(entry, version, only: nil)
       arch = entry.arch == :any ? @host_arch : entry.arch
       vars = {
         name: manifest.name,
@@ -63,7 +88,8 @@ module Crossbuild
 
       Runner.new(root: @root, vars: vars, env: entry.env).run(entry.steps) unless entry.steps.empty?
 
-      dirs = Distributor.new(root: @root, output_base: @output_base).distribute(entry, host_arch: @host_arch)
+      dirs = Distributor.new(root: @root, output_base: @output_base)
+                       .distribute(entry, host_arch: @host_arch, version: version, only: only)
       return if dirs.empty?
 
       dirs.each { |d| puts "🌳 #{d.sub("#{@root}/", '')}" }

data/lib/crossbuild/dep_installer.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Crossbuild
+  # Verifies and installs the build dependencies declared in the deps:
+  # rules of the build: section of crosspack.yml. Host selectors (distro
+  # id, ID_LIKE tokens, os, "*" — see Platform.selectors) are matched
+  # against each dependency's hosts: rules; the first hit wins. Every rule
+  # carries its own commands:
+  # `verify` decides presence (exit 0 = installed; default: PATH lookup of
+  # the dependency name), `install` says how to install it on that host.
+  class DepInstaller
+    class DepError < Error; end
+
+    # Outcome of one dependency: resolved selector + install command, and
+    # whether the dependency is present after ensure_all/check_all ran.
+    Status = Struct.new(:dep, :selector, :command, :installed, keyword_init: true)
+
+    attr_reader :statuses
+
+    def initialize(manifest, root:, selectors: Platform.selectors, os: Platform.os)
+      @manifest = manifest
+      @root = root
+      @selectors = selectors
+      @os = os
+      @runner = Runner.new(root: root, vars: {
+        name: manifest.name,
+        version: manifest.version,
+        os: os.to_s,
+        arch: Platform.display_arch(Platform.arch),
+        platform: Platform.to_s,
+        id: Platform.to_s
+      })
+    end
+
+    # Verify every dependency; install the missing ones via their host rule
+    # and re-verify. Raises DepError when something stays missing.
+    def ensure_all
+      @statuses = @manifest.deps.map { |dep| ensure_dep(dep) }
+      @statuses
+    end
+
+    # Report-only pass for `crosspack deps <target> --check`: never installs.
+    def check_all
+      @statuses = @manifest.deps.map do |dep|
+        selector, rule = resolve(dep)
+        Status.new(dep: dep.name, selector: selector, command: display_command(rule),
+                   installed: present?(dep, rule))
+      end
+    end
+
+    # One line per dependency for the CLI doctor output.
+    def report
+      return '  (no deps declared)' if @manifest.deps.empty?
+
+      (@statuses || check_all).map do |s|
+        format('  %-20s %-8s %-8s %s',
+               s.dep, s.installed ? 'ok' : 'MISSING', s.selector, s.command)
+      end.join("\n")
+    end
+
+    private
+
+    def ensure_dep(dep)
+      selector, rule = resolve(dep)
+      if present?(dep, rule)
+        return Status.new(dep: dep.name, selector: selector,
+                          command: display_command(rule), installed: true)
+      end
+
+      install(dep, selector, rule)
+      unless present?(dep, rule)
+        detail = rule['verify'] ? "the verify `#{rule['verify']}` still fails" : "#{dep.name} is still not on PATH"
+        raise DepError,
+              "#{dep.name}: #{detail} after `#{rule['install']}`. " \
+              'Fix the install command or the verify probe.'
+      end
+      Status.new(dep: dep.name, selector: selector, command: display_command(rule), installed: true)
+    end
+
+    def resolve(dep)
+      @selectors.each do |selector|
+        return [selector, dep.hosts[selector]] if dep.hosts.key?(selector)
+      end
+      raise DepError,
+            "#{dep.name}: no rule for this host (selectors tried: #{@selectors.join(', ')}; " \
+            "described: #{dep.hosts.keys.join(', ')}) — add one of those or a \"*\" wildcard to deps.#{dep.name}.hosts"
+    end
+
+    def present?(dep, rule)
+      verify = rule['verify']
+      return on_path?(dep.name) if verify.nil?
+
+      system(@runner.interpolate(verify), chdir: @root, out: File::NULL, err: File::NULL)
+    end
+
+    def install(dep, selector, rule)
+      command = rule['install']
+      if command.nil?
+        raise DepError,
+              "#{dep.name}: verification failed on #{selector} and the rule has no install command — " \
+              "add deps.#{dep.name}.hosts.#{selector}.install"
+      end
+
+      command = @runner.interpolate(command)
+      puts "▶ #{command}   (#{dep.name} @ #{selector})"
+      return if system(command, chdir: @root)
+
+      status = $?.nil? ? 'unknown status' : "exit #{$?.exitstatus || $?.to_i}"
+      raise DepError, "#{dep.name}: install command failed (#{status}): #{command}"
+    end
+
+    def display_command(rule)
+      rule['install'] || "(verify only: #{rule['verify']})"
+    end
+
+    # Pure-Ruby PATH probe (portable: no `command -v` / `where` shell dance;
+    # `system` skips the shell for metacharacter-free strings, where shell
+    # builtins do not resolve). On Windows PATHEXT extensions are honored.
+    def on_path?(name)
+      exts = @os == :windows ? ENV['PATHEXT'].to_s.split(File::PATH_SEPARATOR) : ['']
+      ENV['PATH'].to_s.split(File::PATH_SEPARATOR).any? do |dir|
+        base = File.join(dir.strip.empty? ? '.' : dir, name)
+        exts.any? { |ext| File.executable?("#{base}#{ext}") }
+      end
+    end
+  end
+end

data/lib/crossbuild/distributor.rb

@@ -8,7 +8,12 @@ module Crossbuild
   # crosspacks/ tree crosspack writes, so crosspack can pack straight from it.
   # Items are symlinked by default (packers copy through symlinks); copy mode
   # is available for trees that get archived or shipped as-is.
+  #
+  # The build version is stamped into .crosspack-build in every target
+  # directory, so a later `crosspack pack <target>` needs no --version.
   class Distributor
+    STAMP_NAME = Crosspack::Builds::STAMP_NAME
+
     attr_reader :placed_dirs
 
     def initialize(root:, output_base:)
@@ -18,7 +23,9 @@ module Crossbuild
     end
 
     # Returns the list of builds/ directories that received artifacts.
-    def distribute(entry, host_arch:)
+    # only: distribute to just this raw target string (from artifacts.to)
+    # instead of all of them — used by `crosspack build <target>`.
+    def distribute(entry, host_arch:, version: nil, only: nil)
       spec = entry.artifacts
       return [] unless spec
 
@@ -30,11 +37,17 @@ module Crossbuild
       items = select_items(from_dir, spec.include)
       arch = entry.arch == :any ? host_arch : entry.arch
 
-      spec.to.each do |raw|
+      targets = only ? spec.to.select { |raw| raw == only } : spec.to
+      if targets.empty?
+        raise Error, "#{entry.id} does not distribute to #{only.inspect} (its targets: #{spec.to.join(', ')})"
+      end
+
+      targets.each do |raw|
         target = Crosspack::Target.parse(raw, arch: arch)
         dst_dir = target.output_dir(File.expand_path(@output_base, @root))
         FileUtils.mkdir_p(dst_dir)
         items.each { |item| place(item, File.join(dst_dir, File.basename(item)), spec.mode) }
+        File.write(File.join(dst_dir, STAMP_NAME), "#{version}\n") if version
         @placed_dirs << dst_dir
       end
       @placed_dirs.uniq

data/lib/crossbuild/matrix.rb

@@ -4,15 +4,17 @@ module Crossbuild
   # Human-readable build matrix: which entries exist, which can run on this
   # host, what they run and where their artifacts land.
   class Matrix
-    def initialize(manifest, host_os: Platform.os, host_arch: Platform.arch)
+    def initialize(manifest, host_os: Platform.os, host_arch: Platform.arch,
+                   selectors: Platform.selectors)
       @manifest = manifest
       @host_os = host_os
       @host_arch = host_arch
+      @selectors = selectors
     end
 
     def render
       host = "#{@host_os}/#{Platform.display_arch(@host_arch)}"
-      lines = ["build.yaml matrix — host: #{host}"]
+      lines = ["build matrix — host: #{host}"]
       @manifest.entries.each { |e| lines << render_entry(e) }
       buildable = @manifest.buildable_entries(@host_os, @host_arch)
       lines << if buildable.empty?
@@ -20,6 +22,7 @@ module Crossbuild
                else
                  "\n#{buildable.size} of #{@manifest.entries.size} entries build here: #{buildable.map(&:id).join(', ')}"
                end
+      lines << render_deps
       lines.join("\n")
     end
 
@@ -48,5 +51,29 @@ module Crossbuild
       to = entry.artifacts.to.join(', ')
       "#{from} -> #{to}"
     end
+
+    # How each deps: entry resolves on this host's selector list.
+    def render_deps
+      return '' if @manifest.deps.empty?
+
+      lines = ["\ndeps on this host (#{join_selectors}):"]
+      @manifest.deps.each do |dep|
+        selector = @selectors.find { |s| dep.hosts.key?(s) }
+        lines << if selector
+                   "  ⚙ #{dep.name.ljust(18)} #{selector} -> #{rule_note(dep.hosts[selector])}"
+                 else
+                   "  ✗ #{dep.name.ljust(18)} no rule for this host (described: #{dep.hosts.keys.join(', ')})"
+                 end
+      end
+      lines.join("\n")
+    end
+
+    def rule_note(rule)
+      rule['install'] || "(verify only: #{rule['verify']})"
+    end
+
+    def join_selectors
+      @selectors.join(' > ')
+    end
   end
 end

data/lib/crossbuild/platform.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Crossbuild
-  # Host platform detection, normalized to the os/arch vocabulary build.yaml
-  # uses: linux/amd64, darwin/arm64, windows/amd64.
+  # Host platform detection, normalized to the os/arch vocabulary the
+  # build: section uses: linux/amd64, darwin/arm64, windows/amd64.
   module Platform
     OS_BY_RUBY = {
       linux: /linux/,
@@ -36,5 +36,38 @@ module Crossbuild
     def self.display_arch(arch)
       arch == :x86_64 ? 'amd64' : arch.to_s
     end
+
+    # Distro id from /etc/os-release ("ubuntu", "fedora", ...), nil off Linux.
+    def self.distro
+      return nil unless os == :linux
+
+      facts = os_release
+      facts['ID']
+    end
+
+    # Ordered host selectors for the deps: rules of the build: section — distro id,
+    # then ID_LIKE tokens (Linux only), then the os, then "*" as the final
+    # wildcard. The first selector with a matching rule wins.
+    def self.selectors
+      sel = []
+      if os == :linux
+        facts = os_release
+        sel << facts['ID'] if facts['ID']
+        sel.concat(facts['ID_LIKE'].to_s.split)
+      end
+      sel << os.to_s << '*'
+    end
+
+    # Parses /etc/os-release into a Hash (ID, ID_LIKE, ...); {} when absent.
+    def self.os_release(path: '/etc/os-release')
+      File.read(path).each_line.with_object({}) do |line, facts|
+        key, value = line.split('=', 2)
+        next if value.nil?
+
+        facts[key.strip] = value.strip.delete_prefix('"').delete_suffix('"')
+      end
+    rescue Errno::ENOENT
+      {}
+    end
   end
 end

data/lib/crossbuild/runner.rb

@@ -4,7 +4,7 @@ module Crossbuild
   # Runs the shell steps of a matrix entry from the project root. Commands may
   # reference build facts via {{version}}, {{name}}, {{platform}}, {{os}},
   # {{arch}} and {{id}} placeholders — expanded by the gem itself so the same
-  # build.yaml works under POSIX shells and cmd.exe. The same facts are also
+  # config works under POSIX shells and cmd.exe. The same facts are also
   # exported as CROSSBUILD_* environment variables.
   class Runner
     class BuildError < Error; end

data/lib/crossbuild/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Crossbuild
-  VERSION = '0.1.0'
+  VERSION = '0.5.0'
 end

data/lib/crossbuild/version_scheme.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 module Crossbuild
-  # Computes the build version from the `version:` field of build.yaml.
+  # Computes the build version from the top-level `version:` of
+  # crosspack.yml.
   # Supported specs:
   #   calver    — YYYY.MM.DD-<seconds since local midnight>, e.g. 2026.08.31-33837
   #   git-tag   — latest `git describe --tags --abbrev=0`, fallback 0.0.0-dev
@@ -43,7 +44,7 @@ module Crossbuild
 
     def env_version(var)
       value = ENV[var].to_s.strip
-      raise Error, "version env var #{var} is not set (version: env:#{var} in build.yaml)" if value.empty?
+      raise Error, "version env var #{var} is not set (version: env:#{var} at the top level of crosspack.yml)" if value.empty?
 
       value
     end

data/lib/crossbuild.rb

@@ -11,17 +11,25 @@ require_relative 'crossbuild/platform'
 require_relative 'crossbuild/version_scheme'
 require_relative 'crossbuild/build_manifest'
 require_relative 'crossbuild/runner'
+require_relative 'crossbuild/dep_installer'
 require_relative 'crossbuild/distributor'
 require_relative 'crossbuild/matrix'
 require_relative 'crossbuild/builder'
 
 module Crossbuild
-  # Convenience wrapper: Crossbuild.build('build.yaml') runs every
-  # host-buildable matrix entry and returns Builder::Result.
-  def self.build(manifest, entry_id: nil, root: Dir.pwd, output_base: nil, version: nil,
-                 host_os: Platform.os, host_arch: Platform.arch)
-    m = manifest.is_a?(BuildManifest) ? manifest : BuildManifest.load(manifest)
-    Builder.new(m, root: root, output_base: output_base, version: version,
-                host_os: host_os, host_arch: host_arch).run(entry_id: entry_id)
+  # Convenience wrapper: Crossbuild.build('crosspack.yml') runs every
+  # host-buildable matrix entry and returns Builder::Result. target: builds
+  # the entry distributing to that target only; deps: false skips the
+  # pre-build dependency check/install pass. The manifest argument may be a
+  # Config, a path to crosspack.yml or a ready BuildManifest.
+  def self.build(manifest, entry_id: nil, target: nil, root: Dir.pwd, output_base: nil, version: nil,
+                 deps: true, host_os: Platform.os, host_arch: Platform.arch)
+    m = case manifest
+        when BuildManifest then manifest
+        when Crosspack::Config then manifest.build_manifest
+        else Crosspack::Config.coerce(manifest, root: root).build_manifest
+        end
+    Builder.new(m, root: root, output_base: output_base, version: version, deps: deps,
+                host_os: host_os, host_arch: host_arch).run(entry_id: entry_id, target: target)
   end
 end

data/lib/crosspack/builders/pkgbuild.rb

@@ -42,7 +42,7 @@ module Crosspack
 
         <<~PKGBUILD
           # Maintainer: #{maintainer}
-          # Generated by crosspack — edit deps.yaml, not this file.
+          # Generated by crosspack — edit the deps: section of crosspack.yml, not this file.
           pkgname=#{name}
           pkgver=#{version}
           pkgrel=#{release}