bundler-spinel 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5a1d4be2ef6216a5cd1241e7ef27dd6ee5222f79f21e6924b8c52c0fe02f35b
-  data.tar.gz: 0a36f37f19a5333e42515a23ec80524ee99bd2d81322e573bb7b3376b4a231b9
+  metadata.gz: 8518bfe1ec1303fb7116e33738abb8246bb3c7072afca1b70057523f824b4a2c
+  data.tar.gz: 5d945e9ca4fa4409f5ff325a6eae9d917469e5c0e7ceb2ef69c8c356551c0fda
 SHA512:
-  metadata.gz: e9fd87e3769ca2246b536ef82c4e6c5c6a704021183008516ce7b41ebf10f0e310d03e297b06887c86cb9f97dc8ae388c6f45f01ce92f1a1a7af791763af0af9
-  data.tar.gz: '0894f3ed497a5b7c2e226d5ec5b86ce8b60872775d12c72090df8a6da3f8eead78a93b8ced7e994769e0359a48850be22526192683351a1b16dfe49714744013'
+  metadata.gz: ff071af5cde1af69f32f92b509092ec6d535173dfbbdbe84c02940b5118abb1f7cafacc610cc26a4c3e20263426e4a7422560ba166c766ff296d391be1758e34
+  data.tar.gz: e704f7c8a825a0cdb278c604a86bb38fd9363ac0fe8fe7406c88c52e9b77e1a76cd2675036d503b3e80fe488f27f3ff1820c7803428989f7ac1930bdaff9a412

data/CHANGELOG.md

@@ -4,6 +4,108 @@ All notable changes to `bundler-spinel` are documented here. The format
 follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the
 project aims to follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.0] — 2026-06-15
+
+### Fixed
+- **Probe: a require-only compile failure is the load-path limit, not
+  `analyze-failed` (spinel master b60fbd7 absorption).** Since matz/spinel's
+  #1383 fix, an unresolvable plain `require "gem/sub"` makes `spinel -c` exit
+  non-zero instead of warning and continuing. Because that idiom is
+  near-universal, the b60fbd7 corpus reprobe spuriously turned thousands of
+  previously-`clean` gems into `rejected:analyze-failed`. The probe now detects
+  a compile that failed *solely* on an unresolvable `require` (the
+  `CallNode \`require\`` form, with no real codegen error and no other
+  unsupported call) and classifies it `risky [load-path:require]` — the
+  documented no-load-path limitation a real Spinel project resolves by
+  vendoring. Real codegen errors still reject. +`test/probe_classify_test.rb`.
+- **Engine rev detection for worktrees + frozen copies.** `Engine#rev` fell
+  back to an opaque `bin:<hash>` (a) in a git *worktree*, where `.git` is a
+  file not a directory, and (b) for a frozen/detached engine copy with no
+  `.git`. Both now resolve to `git:<short-sha>`: worktree `.git` files are
+  honored (`File.exist?`, not `File.directory?`), and a `.spinel_rev` stamp
+  (a bare HEAD sha written at freeze time) is read first. Keeps the ledger
+  key — and the history/diff tooling that joins on it — consistent across the
+  build layouts a reprobe actually uses. `bin/reprobe-corpus.sh`'s frozen
+  engines now carry the stamp.
+- **cmake build-units on macOS (spinelgems#21).** The Vendorer now sets the
+  SDK libc++ include path (`CPLUS_INCLUDE_PATH` via `xcrun --show-sdk-path`)
+  for cmake build-unit invocations on Darwin — without it every C++ unit died
+  with `fatal error: 'array' file not found` (toy#27's Mac cold-start LIB
+  leg; fix verified on an M2). Caller-set `CPLUS_INCLUDE_PATH` is preserved
+  (SDK path appends); missing/failing `xcrun` degrades to the previous
+  behavior.
+
+### Added
+- **Opt-in build-units + variant build dirs (spinelgems#20).** An `optional`
+  entry may declare `"default": "disabled"`: a plain `vendor` skips its build
+  entirely (placeholder ← `disabled_cflags`) until the consumer enables it via
+  `--with-ext NAME` / `SPINEL_EXT_ENABLE` — what a CUDA unit needs to not
+  attempt nvcc configures on a CUDA-less box. Explicit disable beats enable;
+  unknown enable names warn loud. cmake units take `"build_dir"` (default
+  `"build"`, relative-only) so two entries can build one shared source dir
+  into variant trees (`build/` vs `build-cuda/`), and source dirs are copied
+  once per vendor run — a second entry sharing `dir` no longer wipes the first
+  unit's just-built artifacts. Unblocks toy merging its staged
+  `spinel-ext-gpu.json` into `spinel-ext.json` (toy#45 Phase 3 → publish).
+- **A gem's `sig/*.rbs` acts as the type root (spinelgems#13).** Spinel infers
+  param types from call sites (whole-program, closed-world), so an *uncalled*
+  public method widens to `int`/`poly` — the failure mode hand-written seed
+  blocks exist to patch. `--rbs` was verified to re-pin uncalled methods' param,
+  return, and ivar types, so the tooling now treats a shipped `sig/` tree as
+  authoritative: `spinel-compat verify` auto-passes `--rbs <gem>/sig` when the
+  gem ships signatures (`--rbs DIR` to override, `--no-rbs` to opt out), and
+  records an `rbs:sig` provenance tag in the verdict reasons. `vendor` copies
+  each gem's `sig/` alongside `lib/`, aggregates all of them under
+  `<into>/sig/<gem>/`, and advertises the single `--rbs <into>/sig` root in
+  `deps.rb` and the CLI output. A spinel-native gem (SpinelKit, the Tep
+  batteries) ships one standard Ruby artifact — no seed soup, no manifest keys.
+
+## [0.3.0] — 2026-06-08
+
+### Added
+- **`spinel-compat vendor` build-units (spinelgems#14).** `spinel-ext.json` now
+  supports a `build` entry — a declared native build (`tool: cmake | make`, with
+  `dir`, `args`, `targets`, `artifacts`, and `patches`) run **inside the
+  consumer's vendor tree**, with link flags expanded relative to it (`{dir}` and
+  cross-entry `{dir:NAME}`). This lets a heavy-native gem — toy's vendored ggml
+  CMake build plus its tinynn shims — vendor **self-contained and relocatable**,
+  the same end state tep's small per-`.c` shims already had. A
+  `SPINEL_EXT_<PLACEHOLDER>` override substitutes prebuilt flags and skips the
+  build. Declared `patches` apply with stack-level already-applied detection, so
+  a `path:`-sourced dev checkout (already patched) vendors cleanly. Proven
+  end-to-end: a consumer vendors toy, the archives build in-tree, a
+  Spinel-compiled program links and runs, with zero absolute paths and survival
+  across a project move. Strictly narrower than `extconf.rb` (no free-form
+  shell; declared artifacts) — the Spinel analogue of a gemspec `extensions:`.
+- **`spinel-compat vendor` handles transitive gem→gem dependencies
+  (spinelgems#19).** Vendoring a gem that depends on another vendored gem now
+  works: `deps.rb` is emitted in **topological order** (every gem's runtime
+  dependencies load before it, via a DFS over `spec.dependencies` with a stable
+  alphabetical tiebreak and a cycle guard) instead of the lockfile's alphabetical
+  order, and it prepends each vendored gem's `lib` to `$LOAD_PATH` so a
+  dependent's plain `require "<depgem>"` resolves under CRuby too. Spinel (no load
+  path) ignores both and relies on the topo-ordered `require_relative`s, so the
+  one `deps.rb` is correct under both runtimes — verified identical output on a
+  two-gem fixture. Unblocks `tep` → `spinel_kit` (the new stdlib-surface gem)
+  on the clean `gem "spinel_kit"` + vendor path.
+- **`spinel-compat why <gem>` (spinelgems#12).** A legible "why doesn't this gem
+  work (yet)?" report: a plain-English cause, a category (native C-ext / Spinel
+  limitation / fixable compiler bug / dependency-blocked / metaprogramming), the
+  concrete evidence (the CRuby-vs-Spinel diff, the unresolved calls, the missing
+  require, the hard construct), and — most usefully — whether the verdict is
+  **terminal** (needs an upstream port or compiler feature) or **fixable** (a
+  tracked compiler bug that can graduate). Reads the dominant-rev ledger entry
+  like the catalog; `--probe` / `--dir` explains a fresh live probe instead.
+
+### Changed
+- **`spinel-ext.json` wiring now warns on manifest drift.** A declared
+  placeholder that matches no vendored `.rb` emits a loud warning at vendor time
+  — replacing the per-gem "cflags canary" constants consumers maintained by hand.
+- **Catalog/site rendering** advanced across several engine-rev reprobes (signals
+  lead every verdict tier; the download floor is off by default; human
+  attestations earn a verified rung; a load-bearing-gems roadmap page). These
+  affect the rendered spinelgems.org catalog, not the plugin's gating behaviour.
+
 ## [0.2.1] — 2026-06-01
 
 ### Fixed

data/lib/bundler/spinel/cli.rb

@@ -21,6 +21,7 @@ module Bundler
         when "install-engine" then cmd_install_engine(argv)
         when "init"    then cmd_init(argv)
         when "probe"   then cmd_probe(argv)
+        when "why"     then cmd_why(argv)
         when "verify"  then cmd_verify(argv)
         when "vendor"  then cmd_vendor(argv)
         when "check"   then cmd_check(argv)
@@ -29,6 +30,7 @@ module Bundler
         when "build-site"  then cmd_build_site(argv)
         when "build-db"    then cmd_build_db(argv)
         when "build-history" then cmd_build_history(argv)
+        when "build-load-bearing" then cmd_build_load_bearing(argv)
         when "server"      then cmd_server(argv)
         when "ledger"  then cmd_ledger(argv)
         when "diff"    then cmd_diff(argv)
@@ -91,12 +93,64 @@ module Bundler
         v.rejected? ? 1 : 0
       end
 
+      # why NAME [VERSION] [--rev REV] [--probe] [--dir PATH]
+      # Legible "why doesn't this gem work (yet)?" report (spinelgems#12).
+      # Reads the recorded verdict (dominant rev, like the catalog) by default;
+      # --probe / --dir explains a fresh live probe instead.
+      def cmd_why(argv)
+        require_relative "why"
+        dir = (i = argv.index("--dir")) ? argv.delete_at(i + 1).tap { argv.delete_at(i) } : nil
+        rev = (k = argv.index("--rev")) ? argv.delete_at(k + 1).tap { argv.delete_at(k) } : nil
+        live = !!argv.delete("--probe") || !!dir
+        name = argv.shift or raise Error, "usage: spinel-compat why NAME [VERSION] [--rev REV] [--probe] [--dir PATH]"
+        version = argv.shift
+
+        if live
+          engine = Engine.new
+          src = dir ? File.expand_path(dir) : GemFetcher.new.fetch(name, version || latest_version(name))
+          v = Probe.new(engine, Ledger.new).probe(name, version || "path", src)
+          Why.new(out: @out).report(v, source: "live probe")
+        else
+          v = ledger_pick(name, version: version, rev: rev)
+          unless v
+            @out.puts "  no recorded verdict for #{name}#{version ? " #{version}" : ''}. " \
+                      "Run `spinel-compat why #{name} --probe` to evaluate it now."
+            return 1
+          end
+          Why.new(out: @out).report(v, source: "ledger #{v.rev}")
+        end
+        0
+      end
+
+      # The authoritative ledger entry for a gem: a specific --rev if asked,
+      # else the entry at the ledger's dominant rev (the rev most rows share —
+      # the same target the catalog renders), else the most recent seen.
+      def ledger_pick(name, version: nil, rev: nil)
+        entries = []
+        rev_counts = Hash.new(0)
+        Ledger.new.each do |v|
+          rev_counts[v.rev] += 1
+          next unless v.gem == name
+          next if version && v.version != version
+          entries << v
+        end
+        return nil if entries.empty?
+        return entries.select { |v| v.rev == rev }.last if rev
+
+        target = rev_counts.max_by { |_, c| c }&.first
+        entries.select { |v| v.rev == target }.last || entries.last
+      end
+
       def cmd_verify(argv)
         dir = (i = argv.index("--dir")) ? argv.delete_at(i + 1).tap { argv.delete_at(i) } : nil
         smoke = (j = argv.index("--smoke")) ? argv.delete_at(j + 1).tap { argv.delete_at(j) } : nil
         full = !!argv.delete("--full")
         tests = !!argv.delete("--tests")
-        name = argv.shift or raise Error, "usage: spinel-compat verify NAME [VERSION] [--dir PATH] [--smoke FILE | --tests] [--full]"
+        # --rbs DIR / --no-rbs: explicit type root / opt out. Default :auto —
+        # use the gem's own sig/*.rbs when shipped (spinelgems#13).
+        rbs = (k = argv.index("--rbs")) ? argv.delete_at(k + 1).tap { argv.delete_at(k) } : :auto
+        rbs = false if argv.delete("--no-rbs")
+        name = argv.shift or raise Error, "usage: spinel-compat verify NAME [VERSION] [--dir PATH] [--smoke FILE | --tests] [--full] [--rbs DIR | --no-rbs]"
         engine = Engine.new
         if dir
           version = argv.shift || "path"
@@ -114,7 +168,7 @@ module Bundler
           smoke = File.join(Dir.tmpdir, "__spinel_tests_#{name}.rb")
           File.write(smoke, runner)
         end
-        v = Verifier.new(engine, Ledger.new).verify(name, version, gem_dir, smoke: smoke && File.expand_path(smoke), full: full)
+        v = Verifier.new(engine, Ledger.new).verify(name, version, gem_dir, smoke: smoke && File.expand_path(smoke), full: full, rbs: rbs)
         print_verdict(v)
         File.delete(smoke) if tests && smoke && File.exist?(smoke)
         (v.verified? || v.loaded?) ? 0 : 1
@@ -136,13 +190,26 @@ module Bundler
           ext_disable << argv.delete_at(d + 1).to_s
           argv.delete_at(d)
         end
+        # --with-ext NAME : opt IN to a default-disabled entry, e.g. a CUDA
+        # build-unit (repeatable; also SPINEL_EXT_ENABLE). spinelgems#20.
+        ext_enable = []
+        while (w = argv.index("--with-ext"))
+          ext_enable << argv.delete_at(w + 1).to_s
+          argv.delete_at(w)
+        end
         lock = argv.shift || "Gemfile.lock"
         raise Error, "no #{lock}; run `bundle lock` first" unless File.exist?(lock)
 
-        res = Vendorer.new.vendor(lock, into: into, ext_overrides: ext_overrides, ext_disable: ext_disable)
+        res = Vendorer.new.vendor(lock, into: into, ext_overrides: ext_overrides,
+                                        ext_disable: ext_disable, ext_enable: ext_enable)
         ext = res[:extensions].to_i
         @out.puts "vendored #{res[:count]} gem(s)#{ext.positive? ? " (+#{ext} C ext)" : ''} -> #{res[:into]}"
         @out.puts "  require_relative \"#{res[:into]}/deps\" from your Spinel entrypoint"
+        sigs = res[:sig_gems] || []
+        unless sigs.empty?
+          @out.puts "  #{sigs.size} gem(s) ship sig/*.rbs type roots -> #{res[:into]}/sig"
+          @out.puts "  compile with: spinel ... --rbs #{res[:into]}/sig   (spinelgems#13)"
+        end
         0
       end
 
@@ -308,6 +375,13 @@ module Bundler
         0
       end
 
+      def cmd_build_load_bearing(argv)
+        out = (j = argv.index("--out")) ? argv[j + 1] : raise(Error, "build-load-bearing needs --out FILE")
+        f = LoadBearing.new.build_html(File.expand_path(out))
+        @out.puts "built load-bearing -> #{f}"
+        0
+      end
+
       # Serve the static site + (with --store) the Compact Index from one process
       # — what the deploy host runs. Port defaults to $PORT (Upsun) then 9292.
       def cmd_server(argv)
@@ -410,8 +484,11 @@ module Bundler
             spinel-compat install-engine [REV]    fetch+build the Spinel compiler -> ~/.cache/spinel
             spinel-compat init [DIR]              scaffold a Spinel+Tep project (Gemfile, app.rb, bin/build)
             spinel-compat probe NAME [VERSION]    probe one gem, record a verdict
+            spinel-compat why NAME [--probe]      legible "why doesn't this work (yet)?" report
             spinel-compat verify NAME [--smoke F]  differential CRuby-vs-Spinel run -> verified
-            spinel-compat vendor [LOCK] [--into D] place deps where Spinel finds them + deps.rb
+                                  [--rbs DIR | --no-rbs]  type root: gem's sig/*.rbs (auto when shipped)
+            spinel-compat vendor [LOCK] [--into D] place deps where Spinel finds them + deps.rb (+ sig/ roots)
+                                  [--with-ext NAME | --no-ext NAME]  opt in/out of optional C-ext units
             spinel-compat check [LOCK] [--strict] gate a Gemfile.lock (exit 1 if rejected)
             spinel-compat survey GEM... | --list F  wholesale review -> reason histogram
             spinel-compat serve --store DIR        curated source (only vetted gems)

data/lib/bundler/spinel/engine.rb

@@ -76,7 +76,17 @@ module Bundler
       private
 
       def compute_rev
-        if File.directory?(File.join(@dir, ".git"))
+        # A frozen/detached engine copy (bin/reprobe-corpus.sh's
+        # spinel-frozen-<rev>, or a build whose .git was stripped) can carry a
+        # `.spinel_rev` stamp — a bare HEAD sha written at freeze time — so it
+        # still keys to its real git rev instead of an opaque binary hash.
+        stamp = File.join(@dir, ".spinel_rev")
+        if File.file?(stamp) && !(s = File.read(stamp).strip[0, 12].to_s).empty?
+          return "git:#{s}"
+        end
+        # `.git` is a *file* in a git worktree (a gitdir pointer), not a dir —
+        # File.exist? covers both so worktree checkouts report git:, not bin:.
+        if File.exist?(File.join(@dir, ".git"))
           sha = capture("git", "-C", @dir, "rev-parse", "--short", "HEAD")
           if sha && !sha.empty?
             dirty = capture("git", "-C", @dir, "status", "--porcelain")

data/lib/bundler/spinel/history.rb

@@ -26,6 +26,89 @@ module Bundler
                 "(<code>e2e010c</code>); together with the new <code>instance_methods</code> const-fold " \
                 "(<a href=\"https://github.com/matz/spinel/issues/1073\">#1073</a>) and <code>transpose</code>/map " \
                 "specializations, the brass cluster and thousands more moved out of <code>rejected</code>." },
+        { rev: "95557f5", date: "2026-06-02", commit: "module/class-body side effects + lexical const refs (#1256), Regexp.last_match(n) (#1257), preserve Float-in-Hash (#1258), Struct typing, JSON.generate, alias, +14 more",
+          file: "survey-95557f5/compat.jsonl",
+          note: "<strong>The biggest single jump yet.</strong> 22 upstream commits — including fixes for three " \
+                "issues this harness filed (<a href=\"https://github.com/matz/spinel/issues/1256\">#1256</a> module-body, " \
+                "<a href=\"https://github.com/matz/spinel/issues/1257\">#1257</a> <code>Regexp.last_match</code>, " \
+                "<a href=\"https://github.com/matz/spinel/issues/1258\">#1258</a> Float-in-Hash) plus Struct typing, " \
+                "<code>alias</code>, <code>JSON.generate</code> for records and more — moved <strong>20,175</strong> gems " \
+                "out of <code>rejected</code>, among them <code>rspec</code>, <code>globalid</code>, " \
+                "<code>mini_portile2</code> and <code>coffee-rails</code>." },
+        { rev: "a782696", date: "2026-06-03", commit: "StringScanner unscan/check + Error, Time#to_s + puts-nil, Dir.exist? + alias_method dispatch, missing int-hash keys as nil, RBS extractor heterogeneous-union→poly, subclass-initialize poly unification (13 commits)",
+          file: "survey-a782696/compat.jsonl",
+          note: "<strong>A consolidation rev.</strong> The base verdict mix is essentially flat after the previous " \
+                "jump — 13 upstream commits of correctness fixes (<code>StringScanner</code>, <code>Time#to_s</code>, " \
+                "<code>Dir.exist?</code>/<code>alias_method</code>, and the RBS-extractor union→poly change) graduated a " \
+                "small set of gems — <code>google-adwords-api</code>, <code>libdatadog</code>, <code>random_user_agent</code>, " \
+                "<code>twitter_username_extractor</code> and the <code>redcar-*</code> cluster — while a couple regressed " \
+                "and were caught by the re-probe. The bigger story this rev was off the catalog: the harness found " \
+                "<code>spinel_analyze</code> consuming 100+ GB on a cluster of auto-generated API-SDK gems (a compiler " \
+                "memory blow-up, filed upstream)." },
+        { rev: "9c0a5f0", date: "2026-06-04", commit: "79 commits — incl. fixes for 6 harness-filed issues: stdlib-class-in-ivar (#1305), reopen-Object (#1306), lambda/proc branch-local (#1315), &blk+block_given? (#1316), inject(&:sym) (#1317), ignored-require constant (#1273)",
+          file: "survey-9c0a5f0/compat.jsonl",
+          note: "<strong>The harness loop paying off.</strong> matz landed fixes for <strong>six</strong> issues this " \
+                "harness filed the day before — all common idioms: <code>block_given?</code> with a named " \
+                "<code>&amp;blk</code> (<a href=\"https://github.com/matz/spinel/issues/1316\">#1316</a>), " \
+                "<code>inject(&amp;:+)</code> (<a href=\"https://github.com/matz/spinel/issues/1317\">#1317</a>), " \
+                "reopening <code>class Object</code> (<a href=\"https://github.com/matz/spinel/issues/1306\">#1306</a>), " \
+                "a stdlib class held in an instance variable " \
+                "(<a href=\"https://github.com/matz/spinel/issues/1305\">#1305</a>), and a branch-assigned local inside a " \
+                "lambda/proc (<a href=\"https://github.com/matz/spinel/issues/1315\">#1315</a>). <strong>3,487</strong> gems " \
+                "moved out of <code>rejected</code> (110.3k→106.8k). The one feature ruled out of scope — aliasing the " \
+                "regexp special globals (<a href=\"https://github.com/matz/spinel/issues/1307\">#1307</a>) — now fails with a " \
+                "clear diagnostic instead of bad C." },
+        { rev: "5c9790c", date: "2026-06-05", commit: "17 commits — fixes for 3 harness-filed typed-collection issues: Hash#fetch on int_int_hash (#1329), Array#join on poly_array (#1332), Class-in-collection→poly (#1337); plus regex line-anchoring/gsub-buffer + first-class string type",
+          file: "survey-5c9790c/compat.jsonl",
+          note: "<strong>Typed-collection coverage.</strong> matz fixed three issues this harness filed hours earlier — all " \
+                "the same shape: a method that exists on the generic path but was missing on a <em>specialized</em> " \
+                "collection. <code>Hash#fetch</code> on an int→int hash " \
+                "(<a href=\"https://github.com/matz/spinel/issues/1329\">#1329</a>), <code>Array#join</code> on a mixed " \
+                "<code>poly_array</code> (<a href=\"https://github.com/matz/spinel/issues/1332\">#1332</a>), and a " \
+                "<code>Class</code> value stored in a Hash/Array now typed as poly instead of int " \
+                "(<a href=\"https://github.com/matz/spinel/issues/1337\">#1337</a>, which had broken every options-hash " \
+                "carrying an exception class). The compile+scan base barely moves on fixes like these — they're " \
+                "full-surface/runtime, so the graduation shows in the behaviour-verified tier." },
+        { rev: "57af7f9", date: "2026-06-07", commit: "~40 commits — 9 harness-filed issues closed in one wave: the ecosystem-spine front doors (alias→attr_reader #1356, &:sym-after-positional parse #1359), unary operator mangling (#1357), sp_sym_intern link (#1355), plus typed-collection nil steps (#801/#1180) and #line / --emit-symbol-map diagnostics (the #1338 RFC direction)",
+          file: "survey-57af7f9/compat.jsonl",
+          note: "<strong>The spine-gems wave.</strong> Auditing why <code>bundler</code>/<code>rake</code>/" \
+                "<code>minitest</code>/<code>thor</code> reject found two shallow front doors — " \
+                "<code>alias</code> to an <code>attr_reader</code>-generated method " \
+                "(<a href=\"https://github.com/matz/spinel/issues/1356\">#1356</a>, rake + thor) and " \
+                "<code>&amp;:sym</code> after a positional argument mis-parsed as a hash literal " \
+                "(<a href=\"https://github.com/matz/spinel/issues/1359\">#1359</a>, bundler + minitest) — and matz closed " \
+                "both within a day, alongside 7 more harness filings. All four spine gems now compile past their old " \
+                "blockers into distinct second-tier issues " \
+                "(<a href=\"https://github.com/matz/spinel/issues/1368\">#1368</a> et al.). C compile errors now map back " \
+                "to Ruby source lines via <code>#line</code>, on by default — the " \
+                "<a href=\"https://github.com/matz/spinel/issues/1338\">#1338</a> RFC direction. The behaviour-verified " \
+                "tier reached 144 mechanical ★ this run." },
+        { rev: "cb23cc6", date: "2026-06-09", commit: "~23 commits — 12 harness-filed issues closed in one wave, incl. Mutex/Monitor#synchronize + Thread.new now running and carrying their block value (#1360), class-instance-vars in class methods (#1352), is_a?(IncludedModule)/ancestors (#1350), \\h/\\H regex (#1349), reopened-builtin optional defaults (#1348), bitwise/shift operator mangling (#1358/#1368), the captured-&block value/type family",
+          file: "survey-cb23cc6/compat.jsonl",
+          note: "<strong>Mutex/Thread come in from the cold.</strong> With matz/spinel#1360 landing " \
+                "(<code>Mutex#synchronize</code>/<code>Thread.new</code> now run single-threaded and carry their " \
+                "block's value), the static pre-filter no longer hard-rejects them — they're flagged " \
+                "<code>risky</code> (correct for defensive use, degenerate only for true concurrency). Re-probing " \
+                "the 8,833 gems that had been rejected on sight for <code>Mutex.new</code>/<code>Thread.new</code>, " \
+                "<strong>3,493 (39.5%) moved out of <code>rejected</code></strong> — they compile now; the static " \
+                "wall had been hiding it. The four spine gems (<code>bundler</code>/<code>rake</code>/" \
+                "<code>minitest</code>/<code>thor</code>) now reject for their <em>real</em> reason — the deep " \
+                "metaprogramming surface (<code>send</code>/<code>method_missing</code>/<code>cattr_accessor</code>) — " \
+                "not a misleading <code>hard:Mutex.new</code>. The differential re-audit also caught one regression in " \
+                "the wave: returning <code>self</code> from a reopened-builtin method " \
+                "(<a href=\"https://github.com/matz/spinel/issues/1386\">#1386</a>, <code>to-bool</code>), filed same day." },
+        { rev: "b60fbd7", date: "2026-06-15", commit: "636 commits — the largest wave yet. A type-inference + codegen rewrite (typed-array/poly ~222, inference/cast/box ~168, string ~124, block/yield ~101, module/singleton ~94) closing many harness-filed issues at once: reopened-builtin self (#1386), hash-block String type (#1382/#1394), circular require_relative (#1373), computed require (#1383), class-method yield (#1387), Scheduled-server boot + SIGTERM (#1369/#1384). New surfaces: value-type objects, --rbs/--emit-rbs/--emit-symbol-map.",
+          file: "survey-b60fbd7/compat.jsonl",
+          note: "<strong>The largest movement in the catalog's history.</strong> 636 upstream commits — a type-inference " \
+                "rewrite that resolved the entire <code>unresolved:&lt;method&gt;</code> reject family (~60k records → ~0): " \
+                "<strong>~49,000 gems moved out of <code>rejected</code></strong> (−46%), +22k to <code>clean</code>. The " \
+                "wave also changed unresolvable <code>require</code> to hard-fail the compile (post-#1383); because " \
+                "<code>require \"gem/version\"</code> is near-universal that spuriously rejected thousands, so the probe " \
+                "now classifies a require-only failure as the no-load-path limit (<code>risky [load-path:require]</code>, " \
+                "9,716 gems corrected). Cost side, caught by re-verifying every ★ at this rev: <strong>~34 of 175 " \
+                "behaviour-verified gems regressed</strong> (12 miscompiles incl. <code>after_commit_action</code>, 22 " \
+                "codegen incl. bare-<code>super</code>/<code>ForwardingSuperNode</code>) — the trust tier dropped 175→136. " \
+                "Fresh-verify overrode stickiness, so the ★ count is honest, not carried." },
       ].freeze
 
       ORDER = %w[clean risky rejected].freeze
@@ -133,7 +216,7 @@ module Bundler
           <title>#{h title}</title><link rel="stylesheet" href="/assets/style.css"></head>
           <body>
           <header><a class="brand" href="/">#{gem}SpinelGems</a>
-            <nav><a href="/">Home</a> <a href="/catalog">Catalog</a> <a href="/history.html">History</a>
+            <nav><a href="/">Home</a> <a href="/catalog">Catalog</a> <a href="/load-bearing.html">Load-bearing</a> <a href="/history.html">History</a>
               <a href="https://github.com/OriPekelman/spinelgems">GitHub</a></nav></header>
           <main>
           #{body}

data/lib/bundler/spinel/load_bearing.rb

@@ -0,0 +1,116 @@
+require "cgi"
+require_relative "site"
+
+module Bundler
+  module Spinel
+    # The "build-it-first" roadmap page: which gems, if made to compile, unblock
+    # the most of the ecosystem. Reads the committed
+    # harness/load-bearing/targets.tsv (transitive load-bearing + buildability
+    # impact, precomputed from the local dependency graph) and renders a clear,
+    # status-coloured table. Static, committed in site/ like the history page.
+    class LoadBearing
+      DATA = File.expand_path("../../../harness/load-bearing/targets.tsv", __dir__)
+      GLYPH = Site::GLYPH
+
+      # Buildability snapshot @ 95557f5 (from harness/load-bearing/buildability.rb).
+      BUILDABLE = 50_688
+      BLOCKED   = 29_139
+      REJECTED  = 110_256
+
+      def initialize(data = DATA) = (@data = data)
+
+      def build_html(out)
+        rows = File.exist?(@data) ? File.readlines(@data)[1..].map { |l| l.chomp.split("\t") } : []
+        compiler = rows.select { |r| r[7] == "compiler" }.sort_by { |r| -r[1].to_i }
+        File.write(out, page("Load-bearing gems — SpinelGems", body(compiler, rows)))
+        out
+      end
+
+      private
+
+      def body(compiler, all)
+        b = +""
+        b << "<h1>Load-bearing gems</h1>\n"
+        b << %(<p class="lede">A gem matters to the ecosystem by how many gems pull it in )
+        b << %(<em>transitively</em> — directly, or as a dependency of a dependency, turtles all )
+        b << %(the way down. If Spinel can't compile a load-bearing gem, nothing above it can ship )
+        b << %(either. This is the build-it-first roadmap.</p>\n)
+
+        b << %(<div class="stat-row">\n)
+        b << stat("buildable", BUILDABLE, "whole dependency tree compiles")
+        b << stat("blocked", BLOCKED, "compiles itself — but a dependency is rejected")
+        b << stat("rejected", REJECTED, "doesn't compile")
+        b << %(</div>\n)
+        b << %(<p class="note">~<strong>#{fmt(BLOCKED)}</strong> gems compile on their own but )
+        b << %(can't actually be used because something beneath them is rejected. Fixing a load-bearing )
+        b << %(blocker flows <em>up</em> the tree — its dependents become buildable too.</p>\n)
+
+        b << %(<h2>Build-it-first targets</h2>\n)
+        b << %(<p class="sub">Ranked by <strong>impact</strong> — how many blocked gems become )
+        b << %(buildable if this one alone is fixed. Filtered to <strong>compiler-fixable</strong> )
+        b << %(failures: the native (C-extension) and heavy-metaprogramming (Rails-shaped) clusters )
+        b << %(are deliberately set aside as not the first target here. Each row carries two ways to )
+        b << %(fix it — a focused Spinel issue, or, for a small library, a PR to the gem itself.</p>\n)
+
+        b << %(<table id="catalog"><thead><tr>)
+        b << %(<th class="num">impact</th><th>gem</th><th>status</th><th class="num">load-bearing</th>)
+        b << %(<th>failure</th><th class="num">lib size</th><th>fix</th></tr></thead><tbody>\n)
+        compiler.first(120).each do |r|
+          gem, sole, _reach, transit, _dl, verdict, ftype, _ach, files, loc = r
+          fi = files.to_i
+          strat = fi.positive? && fi <= 12 ? %(<span class="badge human">lib PR</span> small — #{fi} files) :
+                  %(<span class="badge rubric">Spinel issue</span>)
+          b << %(<tr>)
+          b << %(<td class="num"><strong>#{fmt sole}</strong></td>)
+          b << %(<td class="g">#{h gem}</td>)
+          b << %(<td class="v #{verdict}">#{GLYPH[verdict] || '?'} #{h verdict}</td>)
+          b << %(<td class="num">#{fmt transit}</td>)
+          b << %(<td><span class="badge rubric">#{h ftype}</span></td>)
+          b << %(<td class="num">#{fi.positive? ? "#{fi}f / #{loc}L" : "—"}</td>)
+          b << %(<td>#{strat}</td>)
+          b << %(</tr>\n)
+        end
+        b << "</tbody></table>\n"
+
+        nat = all.count { |r| r[7] == "native" }; mp = all.count { |r| r[7] == "metaprog" }
+        b << %(<p class="meta">Set aside as not-first-target: <strong>#{nat}</strong> native )
+        b << %(C-extension blockers (need FFI/ext vendoring) and <strong>#{mp}</strong> heavy-metaprogramming )
+        b << %(blockers (the Rails ecosystem). Method + data: )
+        b << %(<a href="https://github.com/OriPekelman/spinelgems/blob/main/docs/load-bearing-gems.md">docs/load-bearing-gems.md</a> · )
+        b << %(<a href="https://github.com/OriPekelman/spinelgems/blob/main/harness/load-bearing/">harness/load-bearing/</a>. )
+        b << %(Built locally from the gem cache's dependency graph; impact is per engine revision.</p>\n)
+        b
+      end
+
+      def stat(cls, n, label)
+        %(  <div class="stat #{cls}"><b>#{fmt n}</b><span>#{label}</span></div>\n)
+      end
+
+      def fmt(n)
+        n = n.to_i
+        n >= 1000 ? "#{(n / 1000.0).round(1)}k" : n.to_s
+      end
+
+      def h(s) = CGI.escapeHTML(s.to_s)
+
+      def page(title, body)
+        gem = %(<svg class="gem" viewBox="0 0 24 24" aria-hidden="true"><path d="M6 3h12l4 6-10 13L2 9z" fill="#7b2d8e"/><path d="M6 3 2 9l10 13z" fill="#5a1f6b" opacity=".55"/><path d="M18 3l4 6-10 13z" fill="#b14fc4"/><path d="M6 3h12l-6 6z" fill="#d98ee8"/></svg>)
+        <<~HTML
+          <!doctype html>
+          <html lang="en"><head><meta charset="utf-8">
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+          <title>#{h title}</title><link rel="stylesheet" href="/assets/style.css"></head>
+          <body>
+          <header><a class="brand" href="/">#{gem}SpinelGems</a>
+            <nav><a href="/">Home</a> <a href="/catalog">Catalog</a> <a href="/load-bearing.html">Load-bearing</a>
+              <a href="/history.html">History</a> <a href="https://github.com/OriPekelman/spinelgems">GitHub</a></nav></header>
+          <main>
+          #{body}
+          </main>
+          #{Site::FOOTER_HTML}
+          </body></html>
+        HTML
+      end
+    end
+  end
+end

data/lib/bundler/spinel/localizer.rb

@@ -65,17 +65,19 @@ module Bundler
         file.empty? ? "line #{v['line']}" : "#{file}:#{v['line']}"
       end
 
-      # Resolve bisect.sh. It lives in spinel-dev (separate from the compiler
-      # engine), so there's no fixed relation to the engine dir — probe a few
-      # conventional spots, newest-intent first: an explicit override, a sibling
-      # spinel-dev checkout next to the engine, the conventional ~/sites layout.
+      # Resolve bisect.sh. It lives in the spinel-dev tooling repo (separate from
+      # the compiler engine), so there's no fixed relation to the engine dir —
+      # probe a few conventional spots, newest-intent first: an explicit override,
+      # a sibling checkout next to the engine, the conventional ~/sites layout.
+      # The local checkout may be named spinel-tools (gx10) or spinel-dev (the
+      # GitHub repo name), so probe both.
       def bisect_script
         rel = "tools/value-bisect/bisect.sh"
-        candidates = [
-          ENV["SPINEL_BISECT"],
-          File.expand_path(File.join(@engine.dir, "..", "spinel-dev", rel)),
-          File.expand_path("~/sites/spinel-dev/#{rel}")
-        ]
+        candidates = [ENV["SPINEL_BISECT"]]
+        %w[spinel-tools spinel-dev].each do |repo|
+          candidates << File.expand_path(File.join(@engine.dir, "..", repo, rel))
+          candidates << File.expand_path("~/sites/#{repo}/#{rel}")
+        end
         candidates.find { |c| c && File.exist?(c) }
       end
     end