crosspack 0.7.3 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da2fde445d69125a1c1ebd8120b06bb06d37400cb65d5bf95ee773c89223a235
-  data.tar.gz: cdcefb6dcc30071b80b640e319a13e11691cdbd7b8cb8a511f07173b53da6100
+  metadata.gz: 134cfe690edd007f3b616d068d71bacac0fe53f8cceed1cd98e355cfde631010
+  data.tar.gz: 9f29cd01d22b8ef7dd9984006f955beb6a80c5dbd6c773c4f1b12ef4d1aeb326
 SHA512:
-  metadata.gz: e05e92f827a5128d77a58c3d9655d4f5ffe0e4aaa39fd4bee1fde34e20a20ed320b6295d2f5fcffc92698afc3b3a9580a3397d1287b097c83ed6c56969ae6371
-  data.tar.gz: d8a2a11bfd9ea856eb1fc08322a2848be3f630003767981b5d9bf3b394127800d1bcd4f6eb165db79e64a38446653db159c256a71f27f551948335cb3bf27440
+  metadata.gz: cd549f921be34bc876d5fa261d8fffb426c3e9356eb3bc1c30afc70954c98856efafc22b7323b70eeff48d8eb379002b477e6cd69678c9d2c87c933c1d59246c
+  data.tar.gz: be9a6cbec90a2e3b42121c504ec6108e9b95d9bbcbd5ed64e72fa929ef793ae5fb7cc7ef9195ac993a73848e65d49cb10d61672ea78d68499eaa1d193d80ec32

data/CHANGELOG.md

@@ -5,6 +5,33 @@ 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.9.0] - 2026-10-25
+
+### Changed
+- Dependency resolution no longer aborts on an undescribed distro version
+  (e.g. `ubuntu-26.04`): when the deps: section has no rule for the exact
+  version and no `"*"` wildcard, crosspack now falls back to the rules of
+  the newest described version of that family and prints a warning.
+  Only a family with no rules at all remains a hard error.
+
+[0.9.0]: https://github.com/OrelSokolov/crosspack/releases/tag/v0.9.0
+
+## [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
@@ -29,8 +56,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 - The PKGBUILD now installs the `.desktop` file and the icon — desktop
-  integration was deb/rpm-only. The source tarball must carry the icon under
-  its own file name and the `.desktop` file as `<name>.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
 

data/README.md

@@ -11,16 +11,19 @@ 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
@@ -37,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
@@ -71,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
@@ -149,6 +197,8 @@ deps:
       fedora: { "*": [webkit2gtk4.1] }
       macos: system      # OS component
       windows: system    # preinstalled (WebView2)
+  # An undescribed version (ubuntu-26.04) falls back to the newest described
+  # version of the family with a warning; only a family with no rules errors.
 
 # host-only launch hooks (optional): same host selectors as build.deps
 run:                       # `crosspack run`: how to launch the built binary
@@ -205,11 +255,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
@@ -235,10 +286,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
@@ -264,7 +316,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

data/lib/crosspack/builders/app_dir.rb

@@ -14,7 +14,8 @@ module Crosspack
       #   CFBundleExecutable, falling back to the package name)
       # icon: path to the bundle icon, copied into Contents/Resources
       def self.build(name:, version:, summary:, files:, executables: [],
-                     display_name: nil, icon: nil, identifier: nil, output:)
+                     display_name: nil, icon: nil, identifier: nil,
+                     min_macos: '11.0', output:)
         app_dir = File.join(output, "#{name}.app")
         FileUtils.rm_rf(app_dir)
         macos_dir = File.join(app_dir, 'Contents', 'MacOS')
@@ -48,7 +49,8 @@ module Crosspack
                          name: name, version: version, summary: summary,
                          executable: executables.first || name,
                          display_name: display_name || name,
-                         icon_file: icon_file, identifier: identifier)
+                         icon_file: icon_file, identifier: identifier,
+                         min_macos: min_macos)
 
         File.write(File.join(output, 'BUILD-DMG.txt'), <<~TXT)
           DMG not built: hdiutil only exists on macOS.
@@ -59,7 +61,8 @@ module Crosspack
       end
 
       def self.write_info_plist(path, name:, version:, summary:, executable:,
-                                display_name:, icon_file: nil, identifier: nil)
+                                display_name:, icon_file: nil, identifier: nil,
+                                min_macos: '11.0')
         bundle_id = identifier || "org.crosspack.#{name}"
         # Without the extension .icns is assumed; other formats (png) must
         # be named in full.
@@ -86,7 +89,7 @@ module Crosspack
             <key>CFBundleInfoDictionaryVersion</key>
             <string>6.0</string>
             <key>LSMinimumSystemVersion</key>
-            <string>11.0</string>
+            <string>#{escape(min_macos)}</string>
             <key>NSPrincipalClass</key>
             <string>NSApplication</string>
             <key>NSSupportsAutomaticTermination</key>

data/lib/crosspack/builders/deb.rb

@@ -45,6 +45,7 @@ module Crosspack
         stage_files(pkg_root)
         stage_symlinks(pkg_root)
         write_control(File.join(pkg_root, 'DEBIAN'))
+        write_maintainer_scripts(File.join(pkg_root, 'DEBIAN'))
 
         FileUtils.mkdir_p(File.dirname(@output))
         FileUtils.rm_f(@output)
@@ -112,6 +113,38 @@ module Crosspack
         File.write(File.join(debian_dir, 'control'),
                    "#{(fields + ["Description: #{summary}"]).join("\n")}\n#{body.join("\n")}\n")
       end
+
+      # Desktop integration caches: refresh the application database and the
+      # hicolor icon cache after (un)install when the package carries a
+      # .desktop file or a themed icon. The tools are guarded — they are not
+      # dpkg dependencies, minimal systems may lack them.
+      def write_maintainer_scripts(debian_dir)
+        commands = desktop_cache_commands
+        return if commands.empty?
+
+        script = "#!/bin/sh\nset -e\n#{commands.join("\n")}\n"
+        %w[postinst postrm].each do |script_name|
+          path = File.join(debian_dir, script_name)
+          File.write(path, script)
+          FileUtils.chmod(0o755, path)
+        end
+      end
+
+      def desktop_cache_commands
+        commands = @files.values.select { |d| d.end_with?('.desktop') }
+                         .map { |d| File.dirname(d) }.uniq
+                         .map do |dir|
+                           "if command -v update-desktop-database >/dev/null 2>&1; then " \
+                           "update-desktop-database -q /#{dir} || true; fi"
+                         end
+        commands += @files.values.select { |d| d.include?('/share/icons/') }
+                          .map { |d| File.dirname(d) }.uniq
+                          .map do |dir|
+                            "if command -v gtk-update-icon-cache >/dev/null 2>&1; then " \
+                            "gtk-update-icon-cache -q -t -f /#{dir} || true; fi"
+                          end
+        commands
+      end
     end
   end
 end

data/lib/crosspack/builders/pkgbuild.rb

@@ -11,12 +11,13 @@ module Crosspack
     class Pkgbuild
       def self.generate(name:, version:, release:, pkgdesc:, depends:, arch:,
                         files:, symlinks: {}, executables: [], source:,
-                        maintainer:, url: '', license: 'Proprietary', output:)
+                        sha256: nil, maintainer:, url: '', license: 'Proprietary',
+                        output:)
         content = render(
           name: name, version: version, release: release, pkgdesc: pkgdesc,
           depends: Array(depends), arch: Array(arch), files: files,
           symlinks: symlinks, executables: executables, source: Array(source),
-          maintainer: maintainer, url: url, license: license
+          sha256: sha256, maintainer: maintainer, url: url, license: license
         )
         FileUtils.mkdir_p(File.dirname(output))
         File.write(output, content)
@@ -24,8 +25,8 @@ module Crosspack
       end
 
       def self.render(name:, version:, release:, pkgdesc:, depends:, arch:,
-                      files:, symlinks:, executables:, source:, maintainer:,
-                      url:, license:)
+                      files:, symlinks:, executables:, source:, sha256:,
+                      maintainer:, url:, license:)
         depends_line = depends.map { |d| "'#{d}'" }.join(' ')
         source_line = source.map { |s| "'#{s}'" }.join(' ')
         srcbase = "$srcdir/$pkgname-$pkgver"
@@ -52,7 +53,7 @@ module Crosspack
           license=('#{license}')
           depends=(#{depends_line})
           source=(#{source_line})
-          sha256sums=('SKIP')
+          sha256sums=('#{sha256 || 'SKIP'}')
 
           package() {
           #{(install_lines + link_lines).join("\n")}

data/lib/crosspack/builders/rpm.rb

@@ -29,6 +29,7 @@ module Crosspack
         description ||= summary
         requires_line = Array(requires).join(', ')
         entries = spec_entries(files: files, symlinks: symlinks)
+        scriptlets = desktop_cache_scriptlets(files)
 
         <<~SPEC
           Name: #{name}
@@ -48,12 +49,35 @@ module Crosspack
           %install
           # Files are staged into the buildroot by crosspack.
 
+          #{scriptlets}
           %files
           %defattr(-,root,root,-)
           #{entries.join("\n")}
         SPEC
       end
 
+      # %post/%postun: refresh the application database and the hicolor icon
+      # cache when the package carries a .desktop file or a themed icon; the
+      # tools are guarded (minimal systems may lack them).
+      def self.desktop_cache_scriptlets(files)
+        commands = files.values.select { |d| d.end_with?('.desktop') }
+                        .map { |d| File.dirname(d) }.uniq
+                        .map do |dir|
+                          "command -v update-desktop-database >/dev/null 2>&1 && " \
+                          "update-desktop-database -q /#{dir} || :"
+                        end
+        commands += files.values.select { |d| d.include?('/share/icons/') }
+                         .map { |d| File.dirname(d) }.uniq
+                         .map do |dir|
+                           "command -v gtk-update-icon-cache >/dev/null 2>&1 && " \
+                           "gtk-update-icon-cache -q -t -f /#{dir} || :"
+                         end
+        return '' if commands.empty?
+
+        body = commands.join("\n")
+          "%post\n#{body}\n\n%postun\n#{body}\n\n"
+      end
+
       # %files entries: %dir for every directory so we never claim ownership
       # of shared paths like /usr or /usr/local.
       def self.spec_entries(files:, symlinks:)

data/lib/crosspack/builders/wix.rb

@@ -64,9 +64,10 @@ module Crosspack
 
       # shortcuts: nil, or { name: "Display Name", target: "app.exe" } (the
       # payload file inside INSTALLFOLDER the shortcuts launch) — installs
-      # Start Menu and Desktop shortcuts.
+      # Start Menu and Desktop shortcuts. icon: local path to an .ico for
+      # the Add/Remove Programs entry (ARPPRODUCTICON), or nil.
       def self.generate_wxs(name:, version:, manufacturer:, summary:, files:,
-                            arch: 'x64', shortcuts: nil)
+                            arch: 'x64', shortcuts: nil, icon: nil)
         license_rtf_file = "#{name}-license.rtf"
         name = escape(name)
         manufacturer = escape(sanitize_manufacturer(manufacturer))
@@ -86,6 +87,7 @@ module Crosspack
         shortcut_xml = shortcuts ? shortcuts_fragment(shortcuts) : nil
         feature_refs = ["<ComponentGroupRef Id=\"Payload\" />"]
         feature_refs << '<ComponentGroupRef Id="Shortcuts" />' if shortcuts
+        arp_icon = icon ? arp_icon_fragment(icon) : nil
 
         <<~WXS
           <?xml version="1.0" encoding="UTF-8"?>
@@ -103,7 +105,7 @@ module Crosspack
 
               <Property Id="WixUILicenseRtf" Value="#{license_rtf_file}" />
               <ui:WixUI Id="WixUI_InstallDir" InstallDirectory="INSTALLFOLDER" />
-
+          #{arp_icon}
               <Feature Id="Main" Title="#{name}" Level="1">
           #{feature_refs.map { |r| "        #{r}" }.join("\n")}
               </Feature>
@@ -147,7 +149,7 @@ module Crosspack
       # the output and, when WiX is installed, builds a real MSI. Returns
       # the path of whatever was produced.
       def self.build(name:, version:, manufacturer:, summary:, files:, output:,
-                     arch: 'x64', shortcuts: nil, license: nil)
+                     arch: 'x64', shortcuts: nil, license: nil, icon: nil)
         arch = { 'x86_64' => 'x64', 'aarch64' => 'arm64' }.fetch(arch, arch)
         missing = files.reject { |src, _dst| File.file?(src) }
         unless missing.empty?
@@ -163,9 +165,11 @@ module Crosspack
         File.write(wxs_path, generate_wxs(name: name, version: version,
                                           manufacturer: manufacturer,
                                           summary: summary, files: files,
-                                          arch: arch, shortcuts: shortcuts))
+                                          arch: arch, shortcuts: shortcuts,
+                                          icon: icon))
         File.write(File.join(out_dir, "#{name}-license.rtf"),
                    license_rtf(license || summary))
+        FileUtils.cp(icon, File.join(out_dir, File.basename(icon))) if icon
 
         wix = wix_command
         unless wix
@@ -202,6 +206,14 @@ module Crosspack
         nil
       end
 
+      # The Add/Remove Programs entry shows this icon (ARP/Publisher uses
+      # the MSI Icons table, not the installed files).
+      def self.arp_icon_fragment(icon)
+        icon_file = File.basename(icon)
+        "    <Property Id=\"ARPPRODUCTICON\" Value=\"AppIcon\" />\n" \
+          "    <Icon Id=\"AppIcon\" SourceFile=\"#{escape(icon_file)}\" />"
+      end
+
       # The WixUI dialogs live in the UI extension, so it must be installed
       # before `wix build -ext WixToolset.UI.wixext` can resolve it. A no-op
       # when it is already present.

data/lib/crosspack/launcher.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 module Crosspack
-  # Host-only launch commands: `crosspack run` (build the host target, then
-  # launch the application's main binary) and `crosspack install` (launch the
-  # package packed for this host). Both resolve the current host target, so
-  # they take no target argument and are meaningless on any other system.
+  # Host-only launch commands: `crosspack run [goal]` (build the goal's
+  # host-buildable entries — default goal: `default` —, then launch the
+  # application's main binary) and `crosspack install` (launch the package
+  # packed for this host). Both resolve the current host target, so they
+  # take no package-target argument and are meaningless on any other system.
   #
   # Commands may be overridden per host in crosspack.yml (run:/install:
   # sections, selectors like the deps: rules of build:); placeholders:
@@ -15,11 +16,14 @@ module Crosspack
   class Launcher
     class Error < BuildError; end
 
-    # Builds the host target first (the same stage `crosspack build` runs),
-    # then launches the first package.executables binary from builds/.
+    # Builds the given goal's host-buildable entries first (the same stage
+    # `crosspack build <goal>` runs; default goal: `default`), then launches
+    # a package.executables binary from builds/ — the one named by the goal
+    # when it matches, otherwise the first.
     # Returns the launched process's exit code.
     def self.run(config, root: Dir.pwd, args: [], output_base: nil, version: nil,
-                 deps: true, host_string: nil, host_os: Crossbuild::Platform.os,
+                 deps: true, goal: Crossbuild::BuildManifest::DEFAULT_GOAL, host_string: nil,
+                 host_os: Crossbuild::Platform.os,
                  host_arch: Crossbuild::Platform.arch, selectors: Crossbuild::Platform.selectors)
       config = Config.coerce(config, root: root)
       target = host_target('run', host_string, host_arch)
@@ -30,9 +34,12 @@ module Crosspack
       Crossbuild::Builder.new(build_manifest, root: root, output_base: output_base,
                                             version: version, deps: deps,
                                             host_os: host_os, host_arch: host_arch)
-                         .run(target: target.to_s)
+                         .run(goal: goal)
 
-      exe = pkg.executables_for(target).first
+      # A binary goal (`crosspack run helloworld`) launches that executable;
+      # a group goal or the default goal launches the first one.
+      executables = pkg.executables_for(target)
+      exe = executables.include?(goal) ? goal : executables.first
       if exe.nil?
         raise Error,
               'run: the package: section does not name the binary to launch — ' \

data/lib/crosspack/package_manifest.rb

@@ -14,7 +14,7 @@ module Crosspack
   # no .so libraries and vice versa.
   class PackageManifest
     REQUIRED = %w[maintainer description sources prefix payload].freeze
-    OPTIONAL = %w[name summary license section lib_dir executables links desktop icon].freeze
+    OPTIONAL = %w[name summary license section lib_dir executables links desktop icon min_macos].freeze
 
     # Payload selectors may name an os in addition to a family: every distro
     # family packs a linux target, so "linux:" covers deb/rpm/PKGBUILD
@@ -142,6 +142,12 @@ module Crosspack
       @data['icon']
     end
 
+    # Minimum macOS version for the .app bundle (LSMinimumSystemVersion);
+    # defaults to 11.0 in the builder.
+    def min_macos
+      @data['min_macos']
+    end
+
     private
 
     def validate
@@ -172,6 +178,7 @@ module Crosspack
       validate_string('description', nil)
       validate_string('sources', nil)
       validate_string('prefix', /\A[a-z0-9][a-z0-9+._\/-]*\z/)
+      validate_string('min_macos', /\A\d+(\.\d+)*\z/)
       validate_payload
       validate_executables
       validate_links

data/lib/crosspack/packer.rb

@@ -2,6 +2,8 @@
 
 require 'fileutils'
 require 'tmpdir'
+require 'open3'
+require 'digest'
 
 module Crosspack
   # Single entry point: takes a Config (the package: and deps: sections of
@@ -129,7 +131,7 @@ module Crosspack
         Type=Application
         Name=#{d['name'] || @pkg.name}
         Comment=#{d['comment'] || @pkg.summary}
-        Exec=#{d['exec'] || @pkg.name}
+        Exec=#{d['exec'] || desktop_exec}
         Icon=#{@pkg.name}
         Terminal=false
         Categories=#{categories}
@@ -137,6 +139,19 @@ module Crosspack
       path
     end
 
+    # Absolute launcher path: a bare name only resolves when prefix/bin is
+    # in PATH (true for usr/local, not for custom prefixes). Prefer the
+    # bin/ symlink from links:, else the executable inside lib_dir.
+    def desktop_exec
+      link = @pkg.links.keys.find { |l| l.split('/').first == 'bin' }
+      return File.join('/', @pkg.prefix, link) if link
+
+      exe = @pkg.executables.first
+      return File.join('/', @pkg.prefix, @pkg.lib_dir, exe) if exe
+
+      @pkg.name
+    end
+
     def icon_source
       src = File.expand_path(@pkg.icon, @root)
       raise BuildError, "icon: file not found #{src}" unless File.file?(src)
@@ -206,12 +221,21 @@ module Crosspack
       # Same desktop integration as deb/rpm: the .desktop file and the icon
       # go to the same destinations; their sources are archive-relative
       # names (the icon under its own file name).
+      sources = @pkg.payload_for(@target).to_h { |n| [n, File.join(@pkg_data[:src_dir], n)] }
       files = @pkg.payload_for(@target).to_h { |n| [n, File.join(@pkg_data[:lib_dst], n)] }
       if @pkg.desktop
         files["#{@pkg.name}.desktop"] = File.join(@pkg.prefix, 'share', 'applications',
                                                   "#{@pkg.name}.desktop")
+        sources["#{@pkg.name}.desktop"] = desktop_entry_path
       end
-      files[File.basename(@pkg.icon)] = icon_destination if @pkg.icon
+      if @pkg.icon
+        files[File.basename(@pkg.icon)] = icon_destination
+        sources[File.basename(@pkg.icon)] = icon_source
+      end
+      sha256 = write_source_tarball(
+        File.join(File.dirname(output), "#{@pkg.name}-#{version}.tar.gz"),
+        "#{@pkg.name}-#{version}", sources
+      )
       Builders::Pkgbuild.generate(
         name: @pkg.name,
         version: version,
@@ -225,12 +249,37 @@ module Crosspack
         symlinks: @pkg_data[:symlinks],
         executables: @pkg_data[:executables],
         source: ["#{@pkg.name}-#{version}.tar.gz"],
+        sha256: sha256,
         license: @pkg.license,
         output: output
       )
       output
     end
 
+    # makepkg needs the source archive referenced by the PKGBUILD, and it
+    # must extract into <name>-<version>/ with the exact file names the
+    # install lines use. Crosspack builds it from the staged artifacts, so
+    # the PKGBUILD works out of the box (with a real sha256 instead of
+    # SKIP). Returns the hex digest.
+    def write_source_tarball(tarball, root, sources)
+      require 'tmpdir'
+      missing = sources.values.reject { |src| File.file?(src) }
+      unless missing.empty?
+        raise BuildError, "Source files for the PKGBUILD tarball not found:\n" \
+                          "#{missing.map { |s| "  ✗ #{s}" }.join("\n")}"
+      end
+
+      FileUtils.mkdir_p(File.dirname(tarball))
+      Dir.mktmpdir('crosspack-pkgbuild') do |stage|
+        root_dir = File.join(stage, root)
+        FileUtils.mkdir_p(root_dir)
+        sources.each_value { |src| FileUtils.cp(src, File.join(root_dir, File.basename(src))) }
+        out, status = Open3.capture2e('tar', '-czf', tarball, '-C', stage, root)
+        raise BuildError, "tar failed to build #{tarball}:\n#{out}" unless status.success?
+      end
+      Digest::SHA256.file(tarball).hexdigest
+    end
+
     def split_version
       parts = @version.split('-', 2)
       parts << '1' if parts.size == 1
@@ -252,11 +301,27 @@ module Crosspack
         license: @pkg.license,
         files: files,
         shortcuts: windows_shortcuts,
+        icon: windows_arp_icon,
         arch: @target.package_arch(:winget),
         output: output
       )
     end
 
+    # The ARP icon must be an .ico (the MSI Icons table does not take a
+    # png). The manifest icon is used when it is one; otherwise a sibling
+    # .ico with the same basename (appicon.png -> appicon.ico) is picked up
+    # when the build produces it. A png-only project gets no ARP icon — the
+    # exe icon still shows in Start Menu shortcuts.
+    def windows_arp_icon
+      return nil unless @pkg.icon
+
+      src = File.expand_path(@pkg.icon, @root)
+      return src if File.file?(src) && File.extname(src).casecmp('.ico').zero?
+
+      sibling = File.join(File.dirname(src), "#{File.basename(src, '.*')}.ico")
+      File.file?(sibling) ? sibling : nil
+    end
+
     # Shortcut facts for the MSI: the display name from desktop: (falling
     # back to the package name) and the first executable as the target.
     def windows_shortcuts
@@ -281,6 +346,7 @@ module Crosspack
         files: files,
         executables: @pkg.executables_for(@target),
         icon: @pkg.icon && File.expand_path(@pkg.icon, @root),
+        min_macos: @pkg.min_macos,
         output: output_dir
       )
     end

data/lib/crosspack/resolver.rb

@@ -81,11 +81,28 @@ module Crosspack
       fallback = rule['*']
       return fallback unless fallback.nil?
 
-      versions = rule.keys.map { |v| v == '*' ? '"*" (any)' : v.inspect }.join(', ')
-      raise ResolveError,
-            "#{name}: no rules for #{family} #{target.version.inspect} and no \"*\" key. " \
-            "Versions described in the file: #{versions}. Add targets.#{family}.\"#{target.version}\" " \
-            'or a "*" wildcard rule'
+      newest = newest_version_key(rule.keys)
+      if newest.nil?
+        versions = rule.keys.map { |v| v == '*' ? '"*" (any)' : v.inspect }.join(', ')
+        raise ResolveError,
+              "#{name}: no rules for #{family} #{target.version.inspect} and no \"*\" key. " \
+              "Versions described in the file: #{versions}. Add targets.#{family}.\"#{target.version}\" " \
+              'or a "*" wildcard rule'
+      end
+
+      warn Colors.yellow(
+        "#{name}: no recipe for #{family} #{target.version.inspect} — " \
+        "using the rules of the newest described version #{newest.inspect}. " \
+        "Add targets.#{family}.\"#{target.version}\" or a \"*\" wildcard to pin it explicitly"
+      )
+      rule[newest]
+    end
+
+    # The newest version key among the described ones ("24.10" beats "24.4",
+    # which beats "9"), comparing dot-separated numeric segments.
+    def newest_version_key(keys)
+      keys.reject { |k| k == '*' }
+          .max_by { |k| k.split('.').map(&:to_i) }
     end
   end
 end

data/lib/crosspack/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Crosspack
-  VERSION = '0.7.3'
+  VERSION = '0.9.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: crosspack
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.9.0
 platform: ruby
 authors:
 - Oleg Orlov
@@ -87,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Painless packaging for any platform
 test_files: []