crosspack 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd9fa9d325c41f9b9b56fcbaf6fca186f28fcfff888002ba7f2f896e9f93fd38
-  data.tar.gz: c9281e44840c2f238ae49feacebb269f822f3ea15fb38681ac47f41804221bf2
+  metadata.gz: 5848f2a2de5e0c3a6d88dbb5160b90699f8e6b0075af0598a703d76a3a67a6fe
+  data.tar.gz: c653c7473c232c97d22e13656e7def070da7c478ad18ddbc44e8f9d596faa115
 SHA512:
-  metadata.gz: c13e601a7402da31931e3d2a8b93a7e9120369a5a157327992ed8aea827b756684f5e320e8880d4e3d1168e18d4e886ed3e6e0465d749d5c308feb628de9afa2
-  data.tar.gz: 924c9c9a07cdbfd2661f20e07eb0137566a8935f96d7b420275ecc27c3d513e59e885cf6f3a4f2345552f8540b4466213caf9c6f87f41f6c4c03335fe558a463
+  metadata.gz: 52df014c507a0746bc1573c9642ddda9cfa4cbaebbbdc763cda877bd6507ebf2119ce716b0ab4e69eb1abd8408025d5e0b5aa7e7928464f1e811784ffc0ccd24
+  data.tar.gz: 548c13c22c057b1d737673421cb3b9ce71c9dc5cb192cf5e0e0f9a7962f9251ddc1011e85516503c7fad110b9c1bb05ec91ae45605382bf8dd3fc6f0b9a3c29a

data/CHANGELOG.md

@@ -5,6 +5,91 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.8.0] - 2026-09-27
+
+### Added
+- Make-style build goals: a matrix entry may declare `goals:` and its `id`
+  doubles as a goal name, so a per-binary entry works with no extra syntax.
+  `crosspack build` compiles only the `default` goal's entries,
+  `crosspack build all` every host-buildable entry, `crosspack build
+  <goal>` one goal or binary (`crosspack build helloworld` rebuilds nothing
+  else). `crosspack run [goal]` builds just that goal before launching, and
+  launches the executable named by a binary goal instead of the first one;
+  `crosspack build <package-target>` (e.g. `debian-12`) still works when
+  the name is not a goal or entry id. `crosspack matrix` and
+  `crosspack validate` list each entry's goals.
+
+[0.8.0]: https://github.com/OrelSokolov/crosspack/releases/tag/v0.8.0
+
+## [0.7.3] - 2026-09-26
+
+### Fixed
+- The manifest icon keeps its real extension everywhere: an SVG now installs
+  to `share/icons/hicolor/scalable/apps/<name>.svg` (it was forced to
+  `share/pixmaps/<name>.png`, where desktops never found it); PNG/XPM keep
+  going to pixmaps.
+- `.desktop` `Categories` values are terminated with `;` per the spec — a
+  manifest value like `Utility;Audio` produced an invalid entry GNOME could
+  refuse to show.
+- macOS `Info.plist` escapes XML entities (`&`/`<` in the summary no longer
+  corrupt the plist), `CFBundleExecutable` is the first `package.executables`
+  entry (not the package name) and the bundle icon from `icon:` is copied to
+  `Contents/Resources` and referenced via `CFBundleIconFile`.
+- RPM `%description` carries the full package description, not just the
+  summary line.
+- PKGBUILD quotes the `license` value (a license with spaces broke the
+  generated bash).
+- deb omits an empty `Depends:` field instead of writing an invalid one.
+- WiX `Source` paths are XML-escaped (`&` in a path no longer breaks the
+  generated `.wxs`).
+
+### Added
+- The PKGBUILD now installs the `.desktop` file and the icon — desktop
+  integration was deb/rpm-only. Crosspack also builds the source tarball
+  (`<name>-<version>.tar.gz`) next to the PKGBUILD with the exact file names
+  and layout the install lines expect, so `makepkg` works out of the box —
+  and the PKGBUILD carries its real sha256 instead of `SKIP`.
+- deb/rpm packages with a `.desktop` file or a themed icon refresh the
+  application database and the hicolor icon cache (`postinst`/`postrm`,
+  `%post`/`%postun`); the tools are guarded, minimal systems without them
+  are fine.
+- Windows MSI gets an Add/Remove Programs icon (`ARPPRODUCTICON`): the
+  manifest `icon:` when it is an `.ico`, else a sibling `.ico` with the same
+  basename (`appicon.png` -> `appicon.ico`) when the build produces one.
+- `package.min_macos` sets the .app bundle's `LSMinimumSystemVersion`
+  (default stays 11.0).
+
+### Fixed
+- `.desktop` `Exec` is now an absolute path — the launcher symlink from
+  `links:` (e.g. `/usr/local/bin/h2voice`) or the executable inside
+  `lib_dir`; a bare name only resolved when `prefix/bin` happened to be in
+  PATH.
+
+[0.7.3]: https://github.com/OrelSokolov/crosspack/releases/tag/v0.7.3
+
+## [0.7.2] - 2026-09-26
+
+### Fixed
+- Windows MSI no longer fails to install with error 1324: the payload
+  directory is now `INSTALLFOLDER` (WiX v4+ treats any other Id as "author
+  did not define it" and injects a phantom `[Manufacturer] [ProductName]`
+  directory). The deb-style `Name <email>` maintainer is sanitized to the
+  name half before it reaches the MSI Manufacturer property.
+- calver versions (e.g. `2026.09.26`) map to a valid MSI ProductVersion
+  (`26.9.26`) in the `Package@Version` attribute too, not just the file
+  name — a major >= 256 tripped WIX1148.
+
+### Added
+- The Windows MSI now has a standard install wizard (`ui:WixUI
+  WixUI_InstallDir` with the license dialog): crosspack generates the
+  license `.rtf` and builds with `-ext WixToolset.UI.wixext`, installing the
+  UI extension itself when missing (`WixToolset.UI.wixext/6.0.1` on WiX 6).
+- Start Menu and Desktop shortcuts for the first `package.executables`
+  entry; the display name comes from `package.desktop.name` (falling back
+  to the package name). Previously the winget target ignored `desktop:`.
+
+[0.7.2]: https://github.com/OrelSokolov/crosspack/releases/tag/v0.7.2
+
 ## [0.7.0] - 2026-09-13
 
 ### Added

data/README.md

@@ -1,20 +1,29 @@
+<p align="center">
+  <img src="logo.png" width="220" alt="crosspack" />
+</p>
+
 # crosspack
 
+> Painless packaging for any platform.
+
 Cross-platform build **and** pack toolchain for Wails-style desktop apps,
 shipped as one gem, one command, one config file and a staged pipeline:
 
 ```
 crosspack deps <target>     # verify/install the build host's dependencies
-crosspack build <target>    # compile the target's matrix entry into builds/
+crosspack build [<goal>]    # compile a build goal's matrix entries into builds/
 crosspack pack <target>     # package builds/<target> as a native package
 ```
 
-Every stage is keyed by the same target vocabulary — `debian-12`,
-`ubuntu-24.04`, `fedora-41`, `arch`, `macos`, `windows-11.0` — and gated by
-the previous one: `build` refuses to start before the deps stage passes, and
-`pack` refuses to run before `build` filled `builds/<target>/`. The build
-stage also stamps the version into the tree, so `pack` normally needs no
-`--version`:
+The build stage is keyed by **goals** (make-style targets): `crosspack build`
+runs only the `default` goal, `crosspack build all` every goal and
+`crosspack build <goal>` one named goal — unrelated binaries are never
+rebuilt together. The deps and pack stages are keyed by the target
+vocabulary — `debian-12`, `ubuntu-24.04`, `fedora-41`, `arch`, `macos`,
+`windows-11.0` — and gated by the previous one: `build` refuses to start
+before the deps stage passes, and `pack` refuses to run before `build`
+filled `builds/<target>/`. The build stage also stamps the version into the
+tree, so `pack` normally needs no `--version`:
 
 ```
 crosspack deps ubuntu-24.04
@@ -31,6 +40,50 @@ token):
 crosspack deps && crosspack build && crosspack pack
 ```
 
+## Build goals
+
+Build goals are make-style targets — usually one binary each. A matrix entry
+is one goal's recipe; the entry `id` doubles as the goal name, so a
+per-binary entry needs no extra syntax. `goals:` regroups entries when one
+goal should cover several (an entry without `goals:` belongs to the implicit
+`default` goal; one entry may serve several goals):
+
+```yaml
+build:
+  matrix:
+    - id: helloworld        # goal name = entry id
+      build: linux/amd64
+      steps: [go build -o build/bin/helloworld ./cmd/helloworld]
+      artifacts: { from: build/bin, include: [helloworld], to: [ubuntu-24.04] }
+    - id: main
+      build: linux/amd64
+      goals: [default, app] # what `crosspack build` runs; also buildable as `app`
+      steps: [wails build -platform linux/amd64]
+      artifacts: { from: build/bin, to: [ubuntu-24.04, debian-12] }
+    - id: tools
+      build: linux/amd64
+      goals: [tools]
+      steps: [cargo build --release -p helper]
+```
+
+```
+crosspack build            # the default goal only (same as: build default)
+crosspack build helloworld # one binary — nothing else rebuilds
+crosspack build tools      # one named goal
+crosspack build all        # every host-buildable entry (--all works too)
+crosspack run helloworld   # build just that binary, then launch it
+crosspack run              # build the default goal, launch the first executable
+```
+
+`crosspack run <binary>` launches the executable named by the goal (it must
+be listed in `package.executables`); group goals and the default goal launch
+the first one. Goal names use letters/digits/`+._-`; `all` is reserved. A
+positional that is not a declared goal or entry id still works as a package
+target (`crosspack build debian-12` — the single entry distributing to it,
+with fanout limited to that target), so old invocations keep working.
+`crosspack matrix` lists each entry's goals and what the default goal would
+run on this host.
+
 ## crosspack.yml — one file, three sections + two host hooks
 
 The top level carries the shared facts — `name` (required once) and the
@@ -65,6 +118,7 @@ build:
 
   matrix:
     - build: linux/amd64   # os/arch this entry builds on (arch may be "any")
+      goals: [default]     # build goals this entry belongs to (default: [default])
       env:                 # extra env for the steps of this entry
         CGO_ENABLED: "1"
       steps:               # shell commands, run from the project root
@@ -199,11 +253,12 @@ config.
 ```
 # staged pipeline
 crosspack deps <target> [--check]        # verify/install build deps (--check: report only)
-crosspack build <target>|--all [--no-deps] [--version X]
+crosspack build [<goal>|all] [--no-deps] [--version X]
+                                         # goal: default (implicit), a declared goal, or all
 crosspack pack <target> [--version X]    # version defaults to the build stamp
 
-# host-only: this machine, no target argument
-crosspack run [-- --dev]                 # build for this host, then launch the main binary
+# host-only: this machine, no package-target argument
+crosspack run [<goal>] [-- --dev]        # build the goal (default: default), then launch the main binary
 crosspack install                        # launch this host's package with its installer
 
 # inspection
@@ -229,10 +284,11 @@ crosspacks/arch/x86_64/PKGBUILD
 ### Host-only commands: run and install
 
 `run` and `install` apply to the current host only — the build target *is*
-the run target, so they take no target argument. `crosspack run` runs the
-build stage for this host (same as `crosspack build <host target>`), then
-launches the first `package.executables` binary straight from `builds/` —
-the binary, not the package. Everything after `--` goes to the app:
+the run target, so they take no package-target argument. `crosspack run
+[goal]` runs the build stage for the given goal (default: `default` — same
+as `crosspack build <goal>`), then launches the first `package.executables`
+binary straight from `builds/` — the binary, not the package; only that
+goal's entries are rebuilt. Everything after `--` goes to the app:
 
 ```
 crosspack run -- --dev
@@ -258,7 +314,8 @@ executed directly, except a macOS `.app` bundle which is `open`ed.
 require 'crosspack'   # pulls in Crossbuild too
 
 Crossbuild.build('crosspack.yml', root: Dir.pwd)            # all host entries
-Crossbuild.build('crosspack.yml', target: 'ubuntu-24.04')   # the stages' build, library-level
+Crossbuild.build('crosspack.yml', goal: 'default')          # one build goal
+Crossbuild.build('crosspack.yml', target: 'ubuntu-24.04')   # legacy target selection
 
 Crosspack.pack(
   config: 'crosspack.yml',

data/exe/crosspack

@@ -46,9 +46,9 @@ parser = OptionParser.new do |opts|
   opts.banner = "crosspack #{Crosspack::VERSION} — staged pipeline: deps → build → pack\n" \
                 "Usage: crosspack <command> [options]\n" \
                 "Stages:   deps [<target>] [--check]      verify/install build deps (default: this host)\n" \
-                "          build [<target>]|--all          compile into builds/ (default: this host)\n" \
+                "          build [<goal>|all] [--no-deps] compile into builds/ (default goal: default)\n" \
                 "          pack [<target>] [--version X]   package builds/<target> (default: this host; version from the build stamp)\n" \
-                "Host:     run [-- <app args>]            build for this host, then launch the main binary\n" \
+                "Host:     run [<goal>] [-- <app args>]   build the goal (default: default), then launch the main binary\n" \
                 "          install                         launch this host's package with its installer\n" \
                 'Commands: validate, resolve, matrix, version, targets'
 
@@ -60,7 +60,7 @@ parser = OptionParser.new do |opts|
   opts.on('--output-base DIR', 'output directory (build stage: the manifest output, default builds; pack: default ./crosspacks)') { |v| options[:output_base] = v }
   opts.on('--check', 'with `deps`: only report presence, never install (exit 1 if missing)') { options[:check_only] = true }
   opts.on('--no-deps', 'with `build`: skip the deps stage') { options[:no_deps] = true }
-  opts.on('--all', 'with `build`: every host-buildable matrix entry (default target selection off)') { options[:all] = true }
+  opts.on('--all', 'with `build`: every host-buildable matrix entry (same as: build all)') { options[:all] = true }
   opts.on('-h', '--help', 'show help') do
     puts opts
     exit
@@ -75,8 +75,8 @@ end
 command = ARGV.shift
 abort_with 'No command given. See: crosspack --help' if command.nil?
 
-# Positional argument: a target for the stage commands (deps/build/pack,
-# resolve), a crosspack.yml path for validate.
+# Positional argument: a build goal for build/run, a package target for
+# deps/pack/resolve, a crosspack.yml path for validate.
 positional = ARGV.shift if ARGV.first && !ARGV.first.start_with?('-')
 
 options[:file] = positional if command == 'validate' && positional
@@ -108,7 +108,7 @@ rescue Crossbuild::Error => e
   abort_with e.message
 end
 
-# Stage commands (deps/build/pack) run for the current host when no target
+# Stage commands (deps/pack) run for the current host when no target
 # is given: macos, windows-11.0 or the distro from /etc/os-release.
 def host_target!(command)
   raw = Crosspack::Target.host_string
@@ -192,17 +192,31 @@ when 'deps'
 when 'build'
   build_manifest = config.build_manifest
   abort_with 'the build: section is invalid — run: crosspack validate' unless build_manifest.valid?
-  if options[:all]
-    target = nil
-  else
-    target = positional || host_target!('build')
+  # Positional: a build goal — empty/`default` (the implicit default goal),
+  # `all` (every host-buildable entry), a declared goal name or an entry id
+  # (make-style binary goal: crosspack build helloworld). Anything else
+  # falls back to the legacy package target (crosspack build debian-12).
+  arg = positional.to_s
+  goal = 'default'
+  target = nil
+  if options[:all] || arg == 'all'
+    goal = 'all'
+  elsif !arg.empty? && arg != 'default'
+    known_goal = build_manifest.declared_goals.include?(arg) || build_manifest.find_entry(arg)
+    goal = known_goal ? arg : nil
+    target = arg if goal.nil?
   end
   begin
     result = Crossbuild::Builder.new(build_manifest, root: options[:root],
                                       output_base: options[:output_base], version: options[:version],
-                                      deps: !options[:no_deps]).run(target: target)
+                                      deps: !options[:no_deps]).run(goal: goal, target: target)
   rescue Crossbuild::Error, Crosspack::InvalidManifestError => e
-    abort_with e.message
+    message = e.message
+    if target
+      selectors = (build_manifest.declared_goals | build_manifest.entries.map(&:id)).sort
+      message += "\nNot a package target either — buildable selectors: #{selectors.join(', ')} (plus 'all')"
+    end
+    abort_with message
   end
   puts Crosspack::Colors.green("\n📦 #{result.entries.size} entr#{result.entries.size == 1 ? 'y' : 'ies'} built, version #{result.version}")
   puts 'Pack with: crosspack pack <target>'
@@ -224,19 +238,23 @@ when 'pack'
   end
   puts Crosspack::Colors.green("📦 #{path}")
 when 'run', 'install'
-  # Host-only commands: no target argument; anything after `--` goes to the
-  # launched process (crosspack run -- --dev).
-  if positional
-    abort_with "crosspack #{command} works only for the current host — no target argument " \
-               "(other targets make no sense here)"
-  end
+  # Host-only commands: everything after `--` goes to the launched process
+  # (crosspack run -- --dev). `run` optionally takes a build goal; `install`
+  # never builds, so it takes no arguments.
   args = ARGV.dup
   args.shift if args.first == '--'
+  goal = 'default'
+  if command == 'run'
+    goal = positional if positional && !positional.empty?
+  elsif positional
+    abort_with "crosspack install launches this host's package — no arguments " \
+               '(crosspack run [goal] is the one that builds)'
+  end
   begin
     status =
       if command == 'run'
         Crosspack::Launcher.run(
-          config, root: options[:root], args: args,
+          config, root: options[:root], args: args, goal: goal,
           output_base: options[:output_base], version: options[:version], deps: !options[:no_deps]
         )
       else

data/lib/crossbuild/build_manifest.rb

@@ -24,18 +24,22 @@ module Crossbuild
     ARTIFACT_MODES = %w[symlink copy].freeze
     VERSION_SCHEMES = %w[calver git-tag].freeze
     TOP_LEVEL_KEYS = %w[name version output deps matrix].freeze
-    ENTRY_KEYS = %w[id build env steps artifacts].freeze
+    ENTRY_KEYS = %w[id goals build env steps artifacts].freeze
+    DEFAULT_GOAL = 'default'
+    ALL_GOAL = 'all'
     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
 
-    # One matrix entry: where it builds, what it runs, where artifacts go.
+    # One matrix entry: where it builds, what it runs, where artifacts go,
+    # which build goals it belongs to.
     class Entry
-      attr_reader :id, :os, :arch, :env, :steps, :artifacts, :index
+      attr_reader :id, :goals, :os, :arch, :env, :steps, :artifacts, :index
 
-      def initialize(id:, os:, arch:, env:, steps:, artifacts:, index:)
+      def initialize(id:, goals:, os:, arch:, env:, steps:, artifacts:, index:)
         @id = id
+        @goals = goals
         @os = os.to_sym
         @arch = arch
         @env = env
@@ -116,7 +120,8 @@ module Crossbuild
       lines = []
       if valid?
         noun = @entries.size == 1 ? 'entry' : 'entries'
-        lines << "#{path}: the build: section is valid (#{@entries.size} #{noun}: #{@entries.map(&:id).join(', ')})."
+        lines << "#{path}: the build: section is valid (#{@entries.size} #{noun}: #{@entries.map(&:id).join(', ')}; " \
+                 "goals: #{declared_goals.join(', ')})."
       else
         lines << "#{path}: the build: section is invalid (#{@errors.size} errors):"
         @errors.each { |e| lines << "  ✗ #{e}" }
@@ -134,6 +139,16 @@ module Crossbuild
       @entries.find { |e| e.id == id }
     end
 
+    # Every goal name used by the entries, sorted; an entry without `goals:`
+    # belongs to the implicit `default` goal.
+    def declared_goals
+      @entries.flat_map(&:goals).uniq.sort
+    end
+
+    def entries_for_goal(goal)
+      @entries.select { |e| e.goals.include?(goal) }
+    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).
@@ -314,6 +329,7 @@ module Crossbuild
       steps = validate_steps(entry['steps'], path)
       env = validate_env(entry['env'], path)
       artifacts = validate_artifacts(entry['artifacts'], path, arch)
+      goals = validate_goals(entry['goals'], path)
       id = entry['id'].nil? ? "#{os}/#{Platform.display_arch(arch == :any ? :x86_64 : arch)}" : entry['id'].to_s
       if entry['id'] && id.empty?
         @errors << Issue.new("#{path}.id", 'must be a non-empty string')
@@ -324,10 +340,31 @@ module Crossbuild
         return
       end
       @warnings << Issue.new(path, 'entry has no steps — existing artifacts only will be distributed') if entry['steps'].nil? && artifacts
-      @entries << Entry.new(id: id, os: os, arch: arch, env: env, steps: steps,
+      @entries << Entry.new(id: id, goals: goals, os: os, arch: arch, env: env, steps: steps,
                             artifacts: artifacts, index: index)
     end
 
+    # goals: names the make-style build goals this entry belongs to
+    # (crosspack build <goal>); missing -> the implicit `default` goal.
+    def validate_goals(goals, path)
+      return [DEFAULT_GOAL] if goals.nil?
+
+      unless goals.is_a?(Array) && !goals.empty? && goals.all? { |g| g.is_a?(String) && !g.strip.empty? }
+        @errors << Issue.new("#{path}.goals", "must be a non-empty list of goal names, e.g. [#{DEFAULT_GOAL}, tools]")
+        return []
+      end
+      goals.each do |goal|
+        if goal == ALL_GOAL
+          @errors << Issue.new("#{path}.goals", "#{goal.inspect} is reserved — `crosspack build all` builds every goal")
+        elsif goal !~ NAME_RE
+          @errors << Issue.new("#{path}.goals", "invalid goal name #{goal.inspect} (letters, digits, \"+\", \"_\", \"-\", \".\")")
+        end
+      end
+      @errors << Issue.new("#{path}.goals", "duplicate goal names: #{goals.tally.select { |_, n| n > 1 }.keys.join(', ')}") if goals.uniq.size != goals.size
+
+      goals.uniq
+    end
+
     def parse_build(build, path)
       if build.nil?
         @errors << Issue.new("#{path}.build", 'is required: the platform this entry builds on, e.g. linux/amd64')

data/lib/crossbuild/builder.rb

@@ -19,17 +19,19 @@ module Crossbuild
       @host_arch = host_arch
     end
 
-    # 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).
+    # entry_id: nil — otherwise the exact entry id (which must exist, but may
+    # target another host — the user asked for it explicitly).
     # 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)
+    # goal: nil/'all' — every entry buildable on this host; otherwise the
+    # entries declaring that build goal (entries without `goals:` belong to
+    # the implicit `default` goal).
+    def run(entry_id: nil, target: nil, goal: nil)
       manifest.validate!
       ensure_deps
       version = @version_override || VersionScheme.new(manifest.version).compute(root: @root)
-      entries = target ? entries_for_target(target) : select_entries(entry_id)
+      entries = target ? entries_for_target(target) : select_entries(entry_id, goal)
 
       entries.each do |entry|
         puts "\n==> #{manifest.name} [#{entry.id}] version #{version}"
@@ -60,18 +62,52 @@ module Crossbuild
       [entry]
     end
 
-    def select_entries(entry_id)
+    def select_entries(entry_id, goal)
       if entry_id
         entry = manifest.find_entry(entry_id)
         raise Error, "unknown matrix entry #{entry_id.inspect}; available: #{manifest.entries.map(&:id).join(', ')}" unless entry
 
         [entry]
+      elsif goal.nil? || goal == BuildManifest::ALL_GOAL
+        buildable_on_host
       else
-        buildable = manifest.buildable_entries(@host_os, @host_arch)
-        raise Error, "nothing to build on #{@host_os}/#{Platform.display_arch(@host_arch)} " \
-                     "(matrix entries: #{manifest.entries.map(&:id).join(', ')})" if buildable.empty?
+        entries_for_goal(goal)
+      end
+    end
+
+    def buildable_on_host
+      buildable = manifest.buildable_entries(@host_os, @host_arch)
+      raise Error, "nothing to build on #{@host_os}/#{Platform.display_arch(@host_arch)} " \
+                   "(matrix entries: #{manifest.entries.map(&:id).join(', ')})" if buildable.empty?
+
+      buildable
+    end
+
+    # A goal name may also be an entry id — `crosspack build helloworld`
+    # builds just the entry named helloworld (a make-style binary goal).
+    def entries_for_goal(goal)
+      if manifest.declared_goals.include?(goal)
+        buildable = manifest.entries_for_goal(goal).select { |e| e.buildable_on?(@host_os, @host_arch) }
+        if buildable.empty?
+          others = manifest.entries_for_goal(goal).map { |e| "#{e.id} (#{e.platform})" }
+          raise Error, "nothing to build on #{@host_os}/#{Platform.display_arch(@host_arch)} for goal #{goal.inspect} " \
+                       "(goal entries: #{others.join(', ')})"
+        end
 
         buildable
+      elsif (entry = manifest.find_entry(goal))
+        host = "#{@host_os}/#{Platform.display_arch(@host_arch)}"
+        unless entry.buildable_on?(@host_os, @host_arch)
+          raise Error,
+                "the entry for goal #{goal.inspect} (#{entry.id}) builds on #{entry.platform}, " \
+                "this host is #{host} — cross-compilation is not supported"
+        end
+
+        [entry]
+      else
+        available = (manifest.declared_goals | manifest.entries.map(&:id)).sort
+        raise Error, "unknown goal #{goal.inspect}; available: #{available.join(', ')} " \
+                     "(or '#{BuildManifest::ALL_GOAL}' for every entry)"
       end
     end
 

data/lib/crossbuild/matrix.rb

@@ -22,6 +22,10 @@ module Crossbuild
                else
                  "\n#{buildable.size} of #{@manifest.entries.size} entries build here: #{buildable.map(&:id).join(', ')}"
                end
+      default_here = buildable.select { |e| e.goals.include?('default') }
+      unless default_here.empty?
+        lines << "`crosspack build` (default goal) would run: #{default_here.map(&:id).join(', ')}"
+      end
       lines << render_deps
       lines.join("\n")
     end
@@ -42,6 +46,7 @@ module Crossbuild
                else
                  "#{entry.steps.size} step#{'s' unless entry.steps.size == 1}"
                end
+      parts << "goals: #{entry.goals.join(', ')}" unless entry.goals == ['default']
       parts << artifact_note(entry) if entry.artifacts
       parts.join('  ')
     end

data/lib/crossbuild.rb

@@ -18,11 +18,12 @@ require_relative 'crossbuild/builder'
 
 module Crossbuild
   # 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,
+  # host-buildable matrix entry and returns Builder::Result. goal: builds
+  # only the entries declaring that build goal ('all' or nil — every entry);
+  # 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, goal: 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
@@ -30,6 +31,6 @@ module Crossbuild
         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)
+                host_os: host_os, host_arch: host_arch).run(entry_id: entry_id, target: target, goal: goal)
   end
 end