crosspack 0.2.0 → 0.4.0

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,126 @@
+# frozen_string_literal: true
+
+module Crossbuild
+  # Verifies and installs the build dependencies declared in the deps:
+  # section of build.yaml. 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,10 +4,12 @@ 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
@@ -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

@@ -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: matrix of build.yaml — 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/version.rb

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

data/lib/crossbuild.rb

@@ -11,17 +11,20 @@ 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)
+  # 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.
+  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 = 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)
+    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/wix.rb

@@ -27,8 +27,17 @@ module Crosspack
         "#{hex[0, 8]}-#{hex[8, 4]}-#{hex[12, 4]}-#{hex[16, 4]}-#{hex[20, 12]}"
       end
 
+      # Escapes XML entities so manifest values (e.g. a maintainer with
+      # "Name <email>") never break the generated .wxs.
+      def self.escape(text)
+        text.to_s.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;').gsub('"', '&quot;')
+      end
+
       def self.generate_wxs(name:, version:, manufacturer:, summary:, files:,
                             arch: 'x64')
+        name = escape(name)
+        manufacturer = escape(manufacturer)
+        summary = escape(summary)
         directory = arch == 'arm64' ? 'ProgramFiles6432Folder' : 'ProgramFiles64Folder'
         components = files.values.each_with_index.map do |dst, i|
           src = files.key(dst).gsub('/', '\\')
@@ -97,7 +106,7 @@ module Crosspack
           return wxs_path
         end
 
-        out, status = Open3.capture2e(wix, 'build', "-arch #{arch}",
+        out, status = Open3.capture2e(wix, 'build', '-arch', arch.to_s,
                                       '-o', output, wxs_path)
         unless status.success?
           raise BuildError, "wix build failed to build #{output}:\n#{out}"
@@ -105,11 +114,12 @@ module Crosspack
         output
       end
 
+      # WiX v4+ is a .NET tool invoked as `wix` (dotnet tool install -g wix);
+      # plain `dotnet` cannot build an MSI, so it is not a fallback.
       def self.wix_command
-        %w[wix dotnet].each do |cmd|
-          _, _, status = Open3.capture3(cmd, '--version')
-          return cmd if status.success?
-        end
+        _, _, status = Open3.capture3('wix', '--version')
+        return 'wix' if status.success?
+
         nil
       rescue Errno::ENOENT
         nil

data/lib/crosspack/builds.rb

@@ -8,6 +8,10 @@ module Crosspack
   module Builds
     ARCH_DIR_RE = /\A(amd64|x86_64|x64|arm64|aarch64)\z/i.freeze
 
+    # Written by `crosspack build <target>` into every builds/<target>/
+    # directory; `crosspack pack <target>` reads it as the default version.
+    STAMP_NAME = '.crosspack-build'
+
     # Returns [Target] for every target directory found under root.
     def self.available(root)
       return [] unless File.directory?(root)
@@ -30,6 +34,14 @@ module Crosspack
       lines.join("\n")
     end
 
+    # The version stamped by `crosspack build <target>` into the target's
+    # builds/ directory, or nil when the directory has no stamp (packed by
+    # an older build or never built through the stage pipeline).
+    def self.version_for(target, root)
+      stamp = File.join(target.output_dir(root.to_s, target.format), STAMP_NAME)
+      File.exist?(stamp) ? File.read(stamp).strip : nil
+    end
+
     private
 
     def self.scan_family(dir, family)

data/lib/crosspack/manifest.rb

@@ -33,9 +33,15 @@ module Crosspack
 
   # Parses and validates deps.yaml. Root keys are canonical dependency
   # names; each maps to { targets: { family: { "version": [pkgs] } } } or a
-  # scalar verdict for a whole family.
+  # scalar verdict for a whole family. A reserved top-level `version:` key
+  # declares the schema version (see SCHEMA_VERSION).
   class Manifest
-    attr_reader :path, :deps, :errors, :warnings
+    # The deps.yaml schema version this crosspack understands. Files
+    # declaring a newer version are rejected at load time with an upgrade
+    # hint; older (or absent) versions are accepted.
+    SCHEMA_VERSION = 1
+
+    attr_reader :path, :deps, :schema_version, :errors, :warnings
 
     def self.load(path)
       unless File.file?(path)
@@ -54,10 +60,12 @@ module Crosspack
 
     def initialize(path, raw)
       @path = path
-      @deps = raw.is_a?(Hash) ? raw : {}
-      @raw = raw
+      @schema_version = raw.is_a?(Hash) ? raw['version'] : nil
       @errors = []
       @warnings = []
+      check_schema_version!
+      @deps = raw.is_a?(Hash) ? raw.reject { |key, _| key == 'version' } : {}
+      @raw = raw
       validate
     end
 
@@ -90,6 +98,26 @@ module Crosspack
 
     private
 
+    # A schema version newer than this crosspack supports is a hard, loud
+    # error at load time — every command (resolve, matrix, pack) reports it,
+    # not just validate. Malformed versions (not an integer >= 1) are
+    # ordinary schema errors.
+    def check_schema_version!
+      v = @schema_version
+      return if v.nil?
+
+      unless v.is_a?(Integer) && v >= 1
+        @errors << Issue.new('version', "schema version must be an integer >= 1, got #{v.inspect}")
+        return
+      end
+      return if v <= SCHEMA_VERSION
+
+      raise InvalidManifestError,
+            "#{@path}: deps.yaml declares schema version #{v}, " \
+            "but this crosspack (#{Crosspack::VERSION}) supports up to #{SCHEMA_VERSION}. " \
+            'Update the gem (gem update crosspack) or lower the declared version.'
+    end
+
     def validate
       unless @raw.is_a?(Hash) && !@raw.empty?
         @errors << Issue.new(
@@ -98,7 +126,7 @@ module Crosspack
         )
         return
       end
-      @raw.each { |name, body| validate_dep(name.to_s, body) }
+      @raw.each { |name, body| validate_dep(name.to_s, body) unless name == 'version' }
     end
 
     def validate_dep(name, body)

data/lib/crosspack/packer.rb

@@ -8,8 +8,10 @@ module Crosspack
   # package.yaml), resolves dependencies for the target (per deps.yaml) and
   # produces a native package under output_base/<family>/<version>/<arch>/.
   # The builder is chosen by the target format — deb, rpm or PKGBUILD.
+  # version: when omitted, the version stamped by `crosspack build <target>`
+  # (.crosspack-build in the target's builds/ directory) is used.
   class Packer
-    def self.pack(manifest:, deps:, target:, version:, root: Dir.pwd,
+    def self.pack(manifest:, deps:, target:, version: nil, root: Dir.pwd,
                   output_base: 'crosspacks')
       new(manifest: manifest, deps: deps, target: target, version: version,
           root: root, output_base: output_base).pack
@@ -19,15 +21,16 @@ module Crosspack
       @pkg_path = manifest
       @deps_path = deps
       @target = target
-      @version = version.to_s
+      @version = version && version.to_s
       @root = root
-      @output_base = output_base
+      @output_base = output_base || 'crosspacks'
     end
 
     def pack
       @pkg = PackageManifest.load(@pkg_path)
       @deps = Manifest.load(@deps_path)
       validate_both!
+      resolve_version!
       @pkg_data = build_layout
 
       case @target.format
@@ -49,6 +52,21 @@ module Crosspack
 
     private
 
+    # --version wins; otherwise the version recorded by the build stage.
+    def resolve_version!
+      return unless @version.nil? || @version.strip.empty?
+
+      stamped = Builds.version_for(@target, File.expand_path(@pkg.sources, @root))
+      if stamped.nil? || stamped.strip.empty?
+        raise BuildError,
+              "No version for target #{@target}: no --version given and no build stamp " \
+              "(#{Builds::STAMP_NAME}) in #{@pkg.sources}. " \
+              "Run: crosspack build #{@target} — or pass --version explicitly."
+      end
+
+      @version = stamped
+    end
+
     def validate_both!
       errors = []
       errors << @pkg.error_report unless @pkg.valid?
@@ -70,10 +88,10 @@ module Crosspack
         hint = available.empty? ? 'no built targets at all.' :
                "available builds: #{available.map { |t| "#{t} (#{t.output_dir(@pkg.sources, t.format)})" }.join(', ')}."
         raise BuildError,
-              "No compiled artifacts for target #{@target}: expected them in #{src_dir}.\n" \
+              "Build stage not done for target #{@target}: expected compiled artifacts in #{src_dir}.\n" \
               "The builds tree (#{@pkg.sources}) mirrors the output tree: builds/<family>/<version>/<arch>/. " \
               "Currently #{hint}\n" \
-              'Build the application for this target first, then pack.'
+              "Run: crosspack build #{@target}"
       end
 
       lib_dst = File.join(@pkg.prefix, @pkg.lib_dir)

data/lib/crosspack/version.rb

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

metadata

@@ -1,35 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: crosspack
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Oleg Orlov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-08 00:00:00.000000000 Z
+date: 2026-09-13 00:00:00.000000000 Z
 dependencies: []
-description: 'Two cooperating commands: crossbuild runs the build steps of a project
-  from a build.yaml matrix and fans the produced artifacts out into the per-target
-  builds/ tree; crosspack turns that tree into native packages, driven by a cross-distro
-  deps.yaml. Both share the same target vocabulary so the trees never drift apart.'
+description: 'One command, one target vocabulary: crosspack deps <target> verifies
+  and installs the build host dependencies, crosspack build <target> runs the build.yaml
+  matrix entry and fans artifacts into builds/, crosspack pack <target> turns that
+  tree into a native package. Stages are gated — no packing before building — and
+  keyed by the same target strings throughout.'
 email:
 - orelcokolov@gmail.com
 executables:
 - crosspack
-- crossbuild
 extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - LICENSE
 - README.md
-- exe/crossbuild
 - exe/crosspack
 - lib/crossbuild.rb
 - lib/crossbuild/build_manifest.rb
 - lib/crossbuild/builder.rb
+- lib/crossbuild/dep_installer.rb
 - lib/crossbuild/distributor.rb
 - lib/crossbuild/matrix.rb
 - lib/crossbuild/platform.rb
@@ -74,5 +74,5 @@ requirements: []
 rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: Cross-platform build orchestrator and native package builder (deb/rpm/PKGBUILD/winget/cask)
+summary: 'Staged cross-platform pipeline: deps → build → pack native packages (deb/rpm/PKGBUILD/winget/cask)'
 test_files: []