tebako-release 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da808fc0759260d4b29d60ffb1d51622cb07c3f8cf3125b4ea01025f1db4f927
-  data.tar.gz: 8d21389348ae2bb086aaf17f3901f386e62598be12bee027e653b76b361e8d1b
+  metadata.gz: 5382811aa28e5730bd9a513c18f61cd0619d6586ec0089de1822d8283313399f
+  data.tar.gz: da87f7c9358a2c1b69e38f0986b42ddbe73c29cd835814657e1f8ade793f402b
 SHA512:
-  metadata.gz: d73130a2cbd8d1de0df2bb1cf1d801bfe260db9b5569cc04e736eca3324d945576cf8ee9c13c22eb31000872e9229cfb5931c553a491e72188bf58d793206cba
-  data.tar.gz: c111f4d684714a0b03fbc92891b9e2f6640f8cc05369b77870e73bc04f34847367692c89cbaf06c48138fbf8d6172fe675c4124add72be2da7ba8c2bcd674915
+  metadata.gz: 451fa6d51c2392f4739c0236dd5d72dfce5788cd07dc9e240d72d61a59a47e265dbc0d009f3e7f1b7175d15c371096490b9ff852999b3aab1116e9eaf7732aa9
+  data.tar.gz: 5ba106db23aa707ec41abe0629d06e16a6dd7a61156495bff9dc6e3134f6cdcbab9724d19fc5996d746f864519c6cef91c543b6de16ebc14cb6762e64d026ff6

data/README.md

@@ -23,7 +23,12 @@ through a small adapter file and pin this gem — they never carry copies.
   in-bundle SHA256SUMS; fixed member order, mtime=0 — identical inputs
   yield identical bytes). A factory opts into the bundle-era publish shape
   through its adapter (`bundle_publish? → true`); the per-file shape stays
-  the default for pre-bundle lines.
+  the default for pre-bundle lines. Bundle-era lines whose consumers
+  include the lazy arm additionally opt into co-publish
+  (`per_file_alongside_bundle? → true`, spec 36 §3): the staged members
+  are served as standalone assets beside the bundle, the shard carries
+  the `per_file_assets` witness (runtime-manifest MINOR 2), the facet
+  signature declarations return, and the audit expects the union.
 - **`TebakoRelease::Blksum`** — the spec 39 §3 block-group digest sidecar
   (`<image>.blksum.json`: one sha256 per 4 MiB group of env-image bytes,
   the lazy mount's range-GET trust anchor). The uploader derives it

data/lib/tebako_release/adapter.rb

@@ -55,5 +55,18 @@ module TebakoRelease
     def bundle_publish?
       false
     end
+
+    # Spec 36 §3's co-publish: when true (and bundle_publish? holds), each
+    # leg ALSO serves the per-file assets — the exe under its historical
+    # spelling, the env image, the windows DLL — as standalone release
+    # assets beside the bundle, each with its .sha256 sidecar. The lazy
+    # arm (spec 39 §7) range-fetches the image's groups over HTTP, which
+    # is impossible inside the gzip stream; the shard gains the additive
+    # per_file_assets witness (runtime-manifest MINOR 2) that gates the
+    # loaders' lazy arm on bundle-declaring shards. Default off: a
+    # factory opts in when its consumers include the lazy arm.
+    def per_file_alongside_bundle?
+      false
+    end
   end
 end

data/lib/tebako_release/uploader.rb

@@ -29,6 +29,7 @@ require "octokit"
 require "digest"
 require "json"
 require "pathname"
+require "stringio"
 require "tmpdir"
 require "yaml"
 
@@ -437,7 +438,7 @@ module TebakoRelease
       nil
     end
 
-    def manifest_entry(package, image = nil, dll = nil, bundle: nil) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def manifest_entry(package, image = nil, dll = nil, bundle: nil) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
       runtime_version, platform = parse_package_filename(package.basename.to_s)
       contract = contract_sidecar(package)
       filename = package.basename.to_s
@@ -470,6 +471,11 @@ module TebakoRelease
         entry[:image] = image_entry(image, blksum) if image
         entry[:dll] = dll_entry(dll, runtime_version, platform) if dll
         entry[:bundle] = bundle_entry(bundle) if bundle
+        # Spec 36 §3's co-publish witness (runtime-manifest MINOR 2):
+        # true declares the per-file assets are served standalone beside
+        # the bundle — the lazy arm's gate on bundle-declaring shards
+        # (spec 39 §7). Never emitted on bundle-only lines.
+        entry[:per_file_assets] = true if bundle && copublish?
         declare_signatures(entry)
       end
     end
@@ -530,7 +536,13 @@ module TebakoRelease
       return unless signing_enabled?
 
       keyid = signing_keyid
-      return declare_bundle_signature(entry, keyid) if entry[:bundle]
+      declare_bundle_signature(entry, keyid) if entry[:bundle]
+      # Bundle-only lines serve no other payload asset — declaring the
+      # members' .ascs there would be an invalid signing state (spec 09
+      # §4). A co-published line (spec 36 §3, the shard's per_file_assets
+      # witness) serves the members standalone, so the every-served-name
+      # rule covers the exe/image/dll set again.
+      return if entry[:bundle] && !entry[:per_file_assets]
 
       entry[:signature] = { keyid: keyid, asc: "#{entry[:filename]}.asc" }
       %i[image dll].each do |facet|
@@ -539,10 +551,10 @@ module TebakoRelease
       end
     end
 
-    # Bundle-era (spec 36 §3): the only served payload is the bundle —
-    # three signatures per leg (bundle, its sidecar, the shard). The
-    # exe/image/dll member pins are NOT served assets; declaring their
-    # .asc would be an invalid signing state (spec 09 §4).
+    # Bundle-era (spec 36 §3): the bundle's own signature declaration.
+    # On bundle-only lines it is the ONLY payload signature — three
+    # signatures per leg (bundle, its sidecar, the shard); co-published
+    # lines add the per-file declarations on top (declare_signatures).
     def declare_bundle_signature(entry, keyid)
       entry[:bundle][:signature] = { keyid: keyid, asc: "#{entry[:bundle][:filename]}.asc" }
     end
@@ -832,11 +844,16 @@ module TebakoRelease
     # feeds the entry's bundle block and the idempotent skip), upload the
     # bundles as the legs' only payload assets, then the metadata (shard
     # with the bundle block + the bundle's sidecar). The member files
-    # themselves never become release assets — the bundle is the unit.
+    # themselves never become release assets — the bundle is the unit —
+    # UNLESS the factory co-publishes (spec 36 §3): then the members are
+    # standalone served names beside the bundle (the lazy arm
+    # range-fetches the image), still ahead of the shard that witnesses
+    # them (a witnessed shard without its assets is the invalid publish).
     def process_bundle_release(release, packages)
       bundles = build_bundles(packages)
       entries = build_manifest_entries(packages, bundles: bundles)
       bundles.each_value { |bundle| upload_package(release, bundle) }
+      packages.each { |package| upload_package(release, package) } if copublish?
       upload_blksum_sidecars(release, entries)
       entries.each { |entry| ensure_package_metadata(release, entry) }
       print_settled_summary
@@ -877,6 +894,14 @@ module TebakoRelease
       @config.adapter.bundle_publish?
     end
 
+    # Spec 36 §3's co-publish mode: a bundle-era line that ALSO serves
+    # the per-file assets as standalone release assets (the lazy arm's
+    # serving requirement — spec 39 §7). Factory-declared through the
+    # adapter, like the era.
+    def copublish?
+      bundle_publish? && @config.adapter.per_file_alongside_bundle?
+    end
+
     # AUDIT_ONLY (the coordinator's release job / a publish dry run):
     # strictly read-only — finds the release (never creates one), needs no
     # local packages, uploads nothing, touches no notes; the release's
@@ -932,7 +957,7 @@ module TebakoRelease
     # metadata describes what the release serves, never the fresh bytes
     # that did not land.
     def ensure_package_metadata(release, entry)
-      effective = effective_entry(entry)
+      effective = effective_entry(release, entry)
       ensure_metadata_asset(release, shard_name_for(effective), "#{JSON.pretty_generate(effective)}\n")
       metadata_assets(effective).each do |name, sha|
         ensure_metadata_asset(release, "#{name}#{SIDECAR_SUFFIX}", "#{sha}  #{name}\n")
@@ -943,20 +968,27 @@ module TebakoRelease
     # era: the exe, its .tfs image and its .dll facet. Bundle era (spec 36
     # §3): the bundle is the ONE served payload asset — the entry's
     # exe/image/dll fields are member pins, not served names, so they earn
-    # no sidecar. Both eras: the derived blksum sidecar (spec 39 §3) IS a
-    # served standalone asset, so it earns its own .sha256 sidecar like
+    # no sidecar — UNLESS the entry carries the co-publish witness, when
+    # the members ARE served standalone beside the bundle and earn theirs.
+    # Both eras: the derived blksum sidecar (spec 39 §3) IS a served
+    # standalone asset, so it earns its own .sha256 sidecar like
     # every served name.
     def metadata_assets(entry)
-      served = if entry[:bundle]
-                 { entry[:bundle][:filename] => entry[:bundle][:sha256] }
-               else
-                 { entry[:filename] => entry[:sha256] }
-                   .merge(facet_metadata(entry, :image))
-                   .merge(facet_metadata(entry, :dll))
-               end
+      served = bundle_metadata(entry)
+      served.merge!(per_file_metadata(entry)) unless entry[:bundle] && !entry[:per_file_assets]
       served.merge(blksum_metadata(entry))
     end
 
+    def bundle_metadata(entry)
+      entry[:bundle] ? { entry[:bundle][:filename] => entry[:bundle][:sha256] } : {}
+    end
+
+    def per_file_metadata(entry)
+      { entry[:filename] => entry[:sha256] }
+        .merge(facet_metadata(entry, :image))
+        .merge(facet_metadata(entry, :dll))
+    end
+
     def facet_metadata(entry, facet)
       block = entry[facet]
       block ? { block[:filename] => block[:sha256] } : {}
@@ -977,12 +1009,57 @@ module TebakoRelease
     # A settled package (any of its assets kept their previous bytes) speaks
     # with the previous entry's voice; a never-published settle has nothing
     # truthful to keep and never reaches here (upload_package re-raised).
-    def effective_entry(entry)
+    # The co-publish adoption exception (spec 36 §3): the previous bundle-era
+    # entry predates the witness, and this run repaired the standalone
+    # members out of the settled bundle — the entry keeps the previous pins
+    # (they pin exactly those bytes) and gains the witness, the served
+    # blksum pin, and the members' signature declarations, each only when
+    # the asset it names verifiably landed.
+    def effective_entry(release, entry)
       names = [entry[:filename], entry.dig(:image, :filename), entry.dig(:dll, :filename),
                entry.dig(:image, :blksum, :filename)].compact
       return entry unless names.any? { |name| settled?(name) }
 
-      previous_entry_for(entry[:filename]) || entry
+      previous = previous_entry_for(entry[:filename]) || entry
+      return previous unless entry[:per_file_assets] && !previous[:per_file_assets]
+      return previous unless copublish_members_landed?(release, previous)
+
+      witnessed_repair_entry(release, previous, entry)
+    end
+
+    # The witness gate: the standalone members the previous entry pins are
+    # all on the release (landed this run through the repair, or served all
+    # along). A witness without its assets is the invalid publish.
+    def copublish_members_landed?(release, entry)
+      names = [entry[:filename], entry.dig(:image, :filename), entry.dig(:dll, :filename)].compact
+      names.all? { |name| find_asset(release, name) }
+    end
+
+    # The adoption shard: the previous entry verbatim (its pins describe
+    # the served bytes exactly) plus the co-publish witness, the blksum pin
+    # read off the landed sidecar's listing digest (byte-truthful by
+    # construction — never the fresh build's derivation), and the members'
+    # signature declarations on signing-enabled lines (spec 09 §5's
+    # every-served-name rule; the in-leg sign pass fulfills them).
+    def witnessed_repair_entry(release, previous, fresh)
+      repaired = Marshal.load(Marshal.dump(previous))
+      repaired[:per_file_assets] = true
+      blksum_name = fresh.dig(:image, :blksum, :filename)
+      blksum_sha = blksum_name && listed_digest(release, blksum_name)
+      repaired[:image][:blksum] = { filename: blksum_name, sha256: blksum_sha } if blksum_sha && repaired[:image]
+      declare_repaired_member_signatures(repaired)
+      repaired
+    end
+
+    def declare_repaired_member_signatures(entry)
+      return unless signing_enabled?
+
+      keyid = signing_keyid
+      entry[:signature] = { keyid: keyid, asc: "#{entry[:filename]}.asc" }
+      %i[image dll].each do |facet|
+        block = entry[facet]
+        block[:signature] = { keyid: keyid, asc: "#{block[:filename]}.asc" } if block
+      end
     end
 
     # One metadata asset, converged: already-current bytes (the listing's
@@ -1183,7 +1260,7 @@ module TebakoRelease
 
       exe = [name, "#{name}.exe"].find { |candidate| present.include?(candidate) }
       landed, missing = expected_facets(name).partition { |facet| present.include?(facet) }
-      landed, missing = split_blksum_expectation(release, present, name, landed, missing)
+      landed, missing = split_blksum_expectation(served_shard(release, present, name), present, landed, missing)
       missing.unshift(name) unless exe
       return missing if exe.nil?
 
@@ -1194,12 +1271,17 @@ module TebakoRelease
     # asset; a landed bundle owes its sidecar and the package's shard
     # (plus an .asc of each on signing-enabled audits). The declared
     # blksum sidecar (spec 39 §3) is a standalone served asset in this
-    # era too — expected, with its own metadata, when the shard pins it.
+    # era too — expected, with its own metadata, when the shard pins it —
+    # and a shard carrying the co-publish witness (spec 36 §3's
+    # per_file_assets) owes the standalone per-file assets beside the
+    # bundle.
     def missing_bundle_assets(release, present, name, require_signatures: false)
       bundle = "#{name}#{Bundler::BUNDLE_SUFFIX}"
       return [bundle] unless present.include?(bundle)
 
-      landed, missing = split_blksum_expectation(release, present, name, [bundle], [])
+      shard = served_shard(release, present, name)
+      landed, missing = split_blksum_expectation(shard, present, [bundle], [])
+      landed, missing = split_copublish_expectation(shard, present, name, landed, missing)
       missing + missing_metadata(present, name, landed, require_signatures: require_signatures)
     end
 
@@ -1212,8 +1294,8 @@ module TebakoRelease
     # the shard's own gap is the gate's business). A DECLARED sidecar that
     # never landed reports its own name only — its sidecar/.asc cascade
     # rides the landed set, one error per gap.
-    def split_blksum_expectation(release, present, name, landed, missing)
-      declared = declared_blksum_name(release, present, name)
+    def split_blksum_expectation(shard, present, landed, missing)
+      declared = shard&.dig("image", "blksum", "filename")
       return [landed, missing] unless declared
 
       if present.include?(declared)
@@ -1223,17 +1305,35 @@ module TebakoRelease
       end
     end
 
-    # The sidecar name the package's shard declares (`image.blksum`),
-    # nil when undeclared, when the shard never landed, or when it cannot
-    # be read (loudly — the audit never guesses an expectation).
-    def declared_blksum_name(release, present, name)
+    # The shard-witnessed co-publish expectation (spec 36 §3): a shard
+    # carrying per_file_assets: true owes the standalone per-file assets —
+    # the exe (either spelling), the image, the windows DLL — beside the
+    # bundle; each landed member earns its metadata through the landed
+    # set. An unwitnessed shard expects nothing (bundle-only lines audit
+    # green), and a missing exe reports its own gap only, never a
+    # cascade (the one-error-per-gap rule).
+    def split_copublish_expectation(shard, present, name, landed, missing)
+      return [landed, missing] unless shard && shard["per_file_assets"] == true
+
+      exe = [name, "#{name}.exe"].find { |candidate| present.include?(candidate) }
+      facets_landed, facets_missing = expected_facets(name).partition { |facet| present.include?(facet) }
+      gaps = facets_missing
+      gaps = [name] + gaps unless exe
+      [landed + [exe, *facets_landed].compact, missing + gaps]
+    end
+
+    # The package's served shard as parsed JSON — the declarations' only
+    # authority (the additive keys gate the audit's expectations). nil
+    # when the shard never landed (its own gap is the gate's business) or
+    # cannot be read (loudly — the audit never guesses an expectation).
+    def served_shard(release, present, name)
       shard = "#{name}#{SHARD_SUFFIX}"
       return nil unless present.include?(shard)
 
-      download_asset_json(find_asset(release, shard)).dig("image", "blksum", "filename")
+      download_asset_json(find_asset(release, shard))
     rescue StandardError => e
-      puts "::warning::could not read #{shard} for the blksum expectation (#{e.class}: #{e.message}) — " \
-           "no blksum sidecar is expected of this package"
+      puts "::warning::could not read #{shard} for the additive expectations (#{e.class}: #{e.message}) — " \
+           "no additive assets are expected of this package"
       nil
     end
 
@@ -1497,10 +1597,16 @@ module TebakoRelease
       exit 1
     end
 
-    def upload_package(release, package) # rubocop:disable Metrics/MethodLength
+    def upload_package(release, package) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       filename = package.basename.to_s
       puts "Processing #{filename}..."
       if settled?(filename)
+        # A settled stem stands its facets down ONLY when they are on the
+        # release — a facet that never landed has nothing to keep, and on a
+        # co-publish line the byte-truthful source is the settled bundle
+        # itself (its members ARE the previous entry's pins).
+        return repair_settled_absent_asset(release, filename) if copublish? && !find_asset(release, filename)
+
         puts "#{filename} kept its previous bytes earlier in this publish run — " \
              "the settled asset is never re-attempted; the refresh lands on a republish onto a recreated release object"
         return nil
@@ -1535,6 +1641,155 @@ module TebakoRelease
       nil
     end
 
+    # The settled-stem co-publish repair (spec 36 §3 adoption on a
+    # bundle-era release): the stem settled (the byte-immutable keep — the
+    # build is not bit-reproducible), so the package speaks with the
+    # previous entry's voice — but the previous bundle-era publish never
+    # served the standalone members. The settled bundle on the release
+    # holds exactly the bytes the previous entry pins (that is what the
+    # bundle IS), so the members are served from it: extract, verify
+    # against the pin, upload. A member absent with nothing truthful to
+    # repair from (no previous entry, no pin, no bundle asset) is a named
+    # error — never a silent skip, never a lying upload.
+    def repair_settled_absent_asset(release, filename)
+      if Blksum.blksum_file?(Pathname.new(filename))
+        repair_settled_blksum(release, filename)
+      else
+        repair_settled_member(release, filename)
+      end
+    end
+
+    def repair_settled_member(release, filename)
+      entry = previous_entry_for_stem(filename)
+      bundle_asset = repair_bundle_asset(release, entry, filename)
+      member = verified_bundle_member(release, bundle_asset, entry, filename)
+      puts "Repairing #{filename} from the settled bundle #{bundle_asset.name} " \
+           "(the co-publish adoption serves the bundle's own members standalone — byte-identical with the pin)"
+      perform_upload(release, member, filename)
+      filename
+    end
+
+    # The settled bundle asset the previous entry pins this member over, or
+    # a named error: an absent member with nothing truthful to repair from
+    # (no previous entry, no pin, no bundle asset) is never silently
+    # skipped and never freshly uploaded over a settled voice.
+    def repair_bundle_asset(release, entry, filename)
+      pin = entry && member_pin_for(entry, filename)
+      bundle_asset = entry && find_asset(release, entry&.dig(:bundle, :filename))
+      return bundle_asset if pin && bundle_asset
+
+      raise Error, "#{filename} never landed on the release and its settled package has nothing truthful " \
+                   "to repair from (no previous entry pinning it over a served bundle) — " \
+                   "the refresh lands on a republish onto a recreated release object"
+    end
+
+    # The member's extraction, verified against the previous entry's pin —
+    # the bundle's contents and the shard must agree, or neither is served.
+    def verified_bundle_member(release, bundle_asset, entry, filename)
+      member = extracted_bundle_members(release, bundle_asset)[filename]
+      actual = member && Digest::SHA256.file(member).hexdigest
+      return member if member && actual == member_pin_for(entry, filename)
+
+      raise Error, "#{filename} extracted from the settled bundle #{bundle_asset.name} does not hash to the " \
+                   "package's published pin (#{actual || "not a member"}) — the bundle and the shard " \
+                   "disagree; refusing to serve either reading (byte-truthful, never a guess)"
+    end
+
+    # The derived blksum sidecar of a settled package derives from the
+    # SERVED image bytes — never the fresh build's (they did not land).
+    # The served bytes are the just-repaired extraction when this run
+    # landed the image, else the release's own image asset.
+    def repair_settled_blksum(release, filename)
+      image_name = filename.delete_suffix(Blksum::SIDECAR_SUFFIX)
+      image = served_image_path(release, image_name)
+      blksum = Blksum.for_image(image)
+      sidecar = Pathname.new(Dir.mktmpdir).join(filename).tap { |path| path.write(blksum.render) }
+      puts "Repairing #{filename} derived from the served image #{image_name} (spec 39 §3)"
+      perform_upload(release, sidecar, filename)
+      filename
+    end
+
+    def served_image_path(release, image_name)
+      extracted = repaired_image_extraction(release, image_name)
+      return extracted if extracted
+
+      asset = find_asset(release, image_name)
+      unless asset
+        raise Error, "the served image #{image_name} is not on the release — cannot derive its blksum sidecar"
+      end
+
+      bytes = with_transient_retries { @client.get(asset.browser_download_url) }.to_s
+      Pathname.new(Dir.mktmpdir).join(image_name).tap { |path| path.binwrite(bytes) }
+    end
+
+    # The image's extraction when this run repaired it (the just-landed
+    # bytes), nil when the image was never extracted here.
+    def repaired_image_extraction(release, image_name)
+      entry = previous_entry_for_stem(image_name)
+      bundle_asset = entry && find_asset(release, entry&.dig(:bundle, :filename))
+      bundle_asset && extracted_bundle_members(release, bundle_asset)[image_name]
+    end
+
+    # The previous manifest entry of the package stem an asset name belongs
+    # to (the exe, its facets, the derived sidecars, the bundle — one
+    # stem). previous_entry_covering's metadata-assets walk does not serve
+    # here: an UNWITNESSED bundle-era entry's metadata covers the bundle
+    # alone, while the repair needs the member pins it still carries.
+    def previous_entry_for_stem(filename)
+      stem = package_stem(filename)
+      previous_manifest_entries.find { |entry| package_stem(entry[:filename]) == stem }
+    end
+
+    # The previous entry's pin for one member name: the exe at the top
+    # level, the image/dll in their facet blocks. nil when the entry does
+    # not pin the name (nothing truthful to verify an extraction against).
+    def member_pin_for(entry, filename)
+      return entry[:sha256] if entry[:filename] == filename
+
+      %i[image dll].each do |facet|
+        block = entry[facet]
+        return block[:sha256] if block && block[:filename] == filename
+      end
+      nil
+    end
+
+    # The settled bundle's members, extracted once per bundle into a
+    # process-lifetime scratch dir (the exe/image/dll repairs of one stem
+    # share the one download). The bundle grammar is flat bare basenames
+    # (Bundler writes them so); anything else is refused, never extracted.
+    def extracted_bundle_members(release, bundle_asset)
+      @extracted_bundles ||= {}
+      @extracted_bundles[bundle_asset.name] ||= extract_bundle(release, bundle_asset)
+    end
+
+    def extract_bundle(_release, bundle_asset)
+      bytes = with_transient_retries { @client.get(bundle_asset.browser_download_url) }.to_s
+      dir = Pathname.new(Dir.mktmpdir("tebako-release-bundle-"))
+      Zlib::GzipReader.wrap(StringIO.new(bytes)) { |gzip| extract_tar_members(bundle_asset, gzip, dir) }
+    end
+
+    def extract_tar_members(bundle_asset, gzip, dir)
+      members = {}
+      Gem::Package::TarReader.new(gzip) do |tar|
+        tar.each do |tar_entry|
+          next unless tar_entry.file?
+
+          name = flat_member_name(bundle_asset, tar_entry.full_name)
+          members[name] = dir.join(name).tap { |path| path.binwrite(tar_entry.read) }
+        end
+      end
+      members
+    end
+
+    # The bundle grammar is flat bare basenames (Bundler writes them so);
+    # anything else is refused, never extracted.
+    def flat_member_name(bundle_asset, name)
+      return name if name == File.basename(name)
+
+      raise Error, "bundle #{bundle_asset.name} carries the non-flat member #{name} — " \
+                   "the spec 36 §2 grammar is bare basenames only; refusing to extract"
+    end
+
     # The settled ledger — the durable half of warn-and-keep-previous. The
     # publish step runs the uploader once per platform (sequential
     # processes, one workspace); an asset settled in one invocation (the

data/lib/tebako_release/version.rb

@@ -5,5 +5,5 @@
 # This file is a part of tamatebako
 
 module TebakoRelease
-  VERSION = "0.3.0"
+  VERSION = "0.4.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tebako-release
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Ribose Inc