rubycc 1.0.0

data/data/verified_gems.json

@@ -0,0 +1,397 @@
+{
+  "json": {
+    "verifications": [
+      {
+        "versions": ["2.21.1"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-07-17",
+        "evidence": "Built with rubycc (parser.so + generator.so via rmake); gem's own test suite passed 606 tests / 100% (Step 54). B6 in-process rmake build re-confirmed (Step 61), hermetic distroless-headers gem install succeeded (Step 64)."
+      },
+      {
+        "versions": ["2.21.1"],
+        "environment": "musl x86_64 / ruby 4.0.6",
+        "verified_at": "2026-08-04",
+        "evidence": "RUBYCC=1 gem install json succeeded (parser.so + generator.so built through rmake); the gem's own test/unit suite passed 596 tests / 3,390 assertions / 0 failures / 0 errors (Step 191)."
+      },
+      {
+        "versions": ["2.21.1"],
+        "environment": "glibc aarch64 / ruby 4.0.6",
+        "verified_at": "2026-08-11",
+        "evidence": "RUBYCC=1 gem install json succeeded (parser.so + generator.so built through rmake); the gem's own test/unit suite passed 596 tests / 3,390 assertions / 0 failures / 0 errors (Step m4-aarch64-acceptance-2)."
+      }
+    ],
+    "notes": "The gem's SIMD probe (parser-use-simd/generator-use-simd) is naturally disabled when its conftests run through rubycc, so the scalar fallback path is what is built (Step 60). No JSON_DISABLE_SIMD flag needed via mkmf_shim."
+  },
+  "msgpack": {
+    "verifications": [
+      {
+        "versions": ["1.8.3"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-07-17",
+        "evidence": "Built with rubycc (12 translation units via rmake, jobs:4); gem's own RSpec suite passed 455 examples / 0 failures (Step 54). B6 in-process rmake build re-confirmed (Step 61), hermetic distroless-headers gem install succeeded (Step 64). Re-confirmed in H4 (Step 98) with no compiler changes: all MRI-applicable examples among the upstream 468 examples passed, with the 13 JRuby-only examples excluded as not applicable."
+      },
+      {
+        "versions": ["1.8.3"],
+        "environment": "glibc aarch64 / ruby 4.0.6",
+        "verified_at": "2026-08-11",
+        "evidence": "RUBYCC=1 gem install msgpack succeeded (msgpack.so built through rmake); the gem's own RSpec suite passed 455 examples / 0 failures (Step m4-aarch64-acceptance-2)."
+      }
+    ],
+    "notes": "No known issues on glibc x86_64. The run reported 1 pending (not failures)."
+  },
+  "bigdecimal": {
+    "verifications": [
+      {
+        "versions": ["4.1.2"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-01",
+        "evidence": "RUBYCC=1 gem install bigdecimal succeeded (lib/bigdecimal.so built through rmake); the gem's own test suite passed 265 tests / 8,267 assertions / 0 failures / 0 errors (Steps 93-97). Re-verified with tools/verify_gem_tests.rb (Step 162): the gem's own test/unit suite passed 265 tests / 8,267 assertions / 0 failures / 0 errors."
+      },
+      {
+        "versions": ["4.1.2"],
+        "environment": "glibc aarch64 / ruby 4.0.6",
+        "verified_at": "2026-08-11",
+        "evidence": "RUBYCC=1 gem install bigdecimal succeeded (bigdecimal.so built through rmake); the gem's own test/unit suite passed 265 tests / 8,269 assertions / 0 failures / 0 errors (Step m4-aarch64-acceptance-2)."
+      }
+    ],
+    "notes": "11 tests are omitted because BIGDECIMAL_USE_VP_TEST_METHODS is not set; this is an expected, normal omission and not a failure. What this build compiles changed in Step 161, so the earlier runs of this suite and this one are not the same build. Until then, extconf's have_header(\"ruby/atomic.h\") — which mkmf aliases to try_compile, so it really does compile the header — failed under rubycc because that header reaches the __atomic_* builtins, HAVE_RUBY_ATOMIC_H was therefore never defined, and the gem's own non-atomic fallback was compiled where the gcc build compiled the atomic path (measured in Step 160). Step 161 lowers those builtins, the probe now succeeds, and this build takes the same atomic path gcc does: lock xadd / lock cmpxchg appear 12 times in the built bigdecimal.so, where the Step 160 build had none. The suite does not distinguish the two, because RUBY_ATOMIC_SIZE_INC is only reached under BIGDECIMAL_DEBUG. The AArch64 record was taken for what this gem alone exercises there: its bits.h passes a 128-bit integer by value and shifts one by 64 (the debts Steps 94 and 95 closed), which under AAPCS64 means the even-register-pair rule and 16-byte stack alignment rather than the SysV eightbyte pair. Until this run those paths had only ever been checked by the suite's own differential cases, never by a real gem on that machine."
+  },
+  "redcarpet": {
+    "verifications": [
+      {
+        "versions": ["3.6.1"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-07-24",
+        "evidence": "RUBYCC=1 gem install redcarpet succeeded; the gem's own test/unit suite passed 136 tests / 206 assertions / 0 failures / 0 errors / 0 skips (Step 98)."
+      }
+    ],
+    "notes": "extconf.rb is a pure C-extension build with no configure-time probes."
+  },
+  "racc": {
+    "verifications": [
+      {
+        "versions": ["1.8.1"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-08",
+        "evidence": "RUBYCC=1 gem install racc built ext/racc/cparse (cparse.so); the gem's own test/unit suite passed 71 tests / 319 assertions / 0 failures / 0 errors (Step 99). Re-verified with tools/verify_gem_tests.rb (Step codex/gaps-debt-20260808-1): the gem's own test/unit suite passed 71 tests / 319 assertions / 0 failures / 0 errors."
+      }
+    ],
+    "notes": "This was not a fully hands-off gem install: the generated file lib/racc/parser-text.rb had to be manually supplied from the rmake build's generated output."
+  },
+  "date": {
+    "verifications": [
+      {
+        "versions": ["3.5.1"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-07-24",
+        "evidence": "RUBYCC=1 gem install date succeeded (lib/date_core.so built); the gem's own test/unit suite passed 143 tests / 162,593 assertions / 0 failures / 0 errors / 0 skips (Steps 99-104)."
+      }
+    ],
+    "notes": ""
+  },
+  "nkf": {
+    "verifications": [
+      {
+        "versions": ["0.3.0"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-07-30",
+        "evidence": "RUBYCC=1 gem install nkf succeeded (nkf.so built through rmake); the gem's own test/unit suite passed 8 tests / 46 assertions / 0 failures / 0 errors (Step 151)."
+      }
+    ],
+    "notes": "nkf ships bundled with the interpreter, so this run is against the .so injected from the rubycc build (the sanity check confirms it via $LOADED_FEATURES). Building it required the incomplete-array-type composition from C11 6.2.7p3 (Step 150): nkf-utf8/utf8tbl.c combines an `extern const unsigned short euc_to_utf8_1byte[];` forward declaration with a bounds-fixing initializer."
+  },
+  "stackprof": {
+    "verifications": [
+      {
+        "versions": ["0.2.28"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-07-31",
+        "evidence": "RUBYCC=1 gem install stackprof succeeded (stackprof.so built through rmake); the gem's own test/unit suite passed 31 tests / 184 assertions / 0 failures / 0 errors (Step 153)."
+      }
+    ],
+    "notes": "Building this required the __dso_handle synthesis from Step 152: stackprof calls pthread_atfork, which glibc's shared libc does not provide (it ships only in libc_nonshared.a), and the archive member that supplies it references __dso_handle. It also required the _POSIX_MONOTONIC_CLOCK definition from Step 149; without it stackprof falls into the upstream's dead #else branch, which has a syntax error. Step 156 closed the gap this entry originally recorded: the linker now synthesizes a .fini_array entry calling __cxa_finalize(__dso_handle), so the handlers this .so registers are dropped when it is dlclose'd (measured on the built stackprof.so)."
+  },
+  "strscan": {
+    "verifications": [
+      {
+        "versions": ["3.1.6"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-07-31",
+        "evidence": "RUBYCC=1 gem install strscan succeeded (strscan.so built through rmake); the gem's own test/unit suite passed 150 tests / 1,049 assertions / 0 failures / 0 errors (Step 157)."
+      }
+    ],
+    "notes": "strscan is a default gem shipped with the interpreter, so this run is against the .so injected from the rubycc build: the sanity check confirms through $LOADED_FEATURES that the injected copy, not the interpreter's own strscan.so, is what the suite loaded. Init_strscan calls rb_require(\"strscan/strscan\"), so the upstream tree's lib/strscan/strscan.rb (which defines StringScanner#scan_integer) must be on the load path as well; it ships in the tarball, so nothing had to be supplied by hand. No test was excluded and the build needed no extra flag."
+  },
+  "stringio": {
+    "verifications": [
+      {
+        "versions": ["3.2.0"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-07-31",
+        "evidence": "RUBYCC=1 gem install stringio succeeded (stringio.so built through rmake); the gem's own test/unit suite passed 103 tests / 626 assertions / 0 failures / 0 errors (Step 157)."
+      },
+      {
+        "versions": ["3.2.0"],
+        "environment": "musl x86_64 / ruby 4.0.6",
+        "verified_at": "2026-08-04",
+        "evidence": "RUBYCC=1 gem install stringio succeeded (stringio.so built through rmake); the gem's own test/unit suite passed 103 tests / 626 assertions / 0 failures / 0 errors (Step 191)."
+      },
+      {
+        "versions": ["3.2.0"],
+        "environment": "glibc aarch64 / ruby 4.0.6",
+        "verified_at": "2026-08-05",
+        "evidence": "RUBYCC=1 gem install stringio succeeded (stringio.so built through rmake); the gem's own test/unit suite passed 103 tests / 626 assertions / 0 failures / 0 errors (Step 208)."
+      }
+    ],
+    "notes": "stringio is a default gem shipped with the interpreter, so this run is against the .so injected from the rubycc build: the sanity check confirms through $LOADED_FEATURES that the injected copy, not the interpreter's own stringio.so (3.1.2 on this interpreter), is what the suite loaded. No test was excluded and the build needed no extra flag; test/ruby/ut_eof.rb is outside the test_*.rb glob because test_stringio.rb pulls it in with require_relative, exactly as the upstream Rakefile leaves it."
+  },
+  "etc": {
+    "verifications": [
+      {
+        "versions": ["1.4.6"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-01",
+        "evidence": "RUBYCC=1 gem install etc succeeded (etc.so built through rmake); the gem's own test/unit suite passed 18 tests / 449 assertions / 0 failures / 0 errors (Step 162)."
+      }
+    ],
+    "notes": "This entry needs three Step-158-to-161 changes at once: rmake's POSIX backslash removal (Step 158), the confstr/fpathconf/pathconf declarations added to the bundled unistd.h (Step 160), and the __atomic_* builtins (Step 161) that ruby.h reaches unconditionally. The bundled unistd.h defines only _CS_PATH and _PC_PIPE_BUF of the 46 _CS_*/_PC_* constants ext/etc/mkconstants.rb publishes, so ext/etc/constdefs.h comes out with 11 constants where the gcc build gets 179; test_etc.rb guards test_confstr and test_pathconf with 'if defined?', so the shortfall shows up as tests that are never defined rather than as failures. The run reported 2 omissions (not failures)."
+  },
+  "io-nonblock": {
+    "verifications": [
+      {
+        "versions": ["0.3.2"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-04",
+        "evidence": "RUBYCC=1 gem install io-nonblock succeeded (nonblock.so built through rmake); the gem's own test/unit suite passed 2 tests / 8 assertions / 0 failures / 0 errors (Step 164)."
+      }
+    ],
+    "notes": "io/nonblock ships with the interpreter, so this run is against the .so injected from the rubycc build; the sanity check confirms through $LOADED_FEATURES that the injected copy, not the interpreter's own, is what the suite loaded. Two tests is the whole of what upstream ships at this tag -- nothing was excluded. test/io/nonblock/test_flush.rb wraps its own require in a rescue LoadError and guards the entire class with `if IO.method_defined?(:nonblock)`, so a suite that loaded nothing at all would report zero failures rather than an error; the recipe requires io/nonblock outside that rescue so that state cannot be recorded as a pass. This build takes the same path gcc's does: all three extconf probes (rb_io_descriptor, O_NONBLOCK, F_GETFL) come out yes under rubycc exactly as under the host gcc control, so HAVE_RB_IO_DESCRIPTOR is defined and the io_descriptor_fallback branch is compiled out on both sides. Building it needed the Step 163 linker fix: before that the r-x load segment did not cover the tail of .plt, and requiring the .so segfaulted on the first call through rb_ext_ractor_safe@plt."
+  },
+  "io-wait": {
+    "verifications": [
+      {
+        "versions": ["0.4.0"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-04",
+        "evidence": "RUBYCC=1 gem install io-wait succeeded (wait.so built through rmake); the gem's own test/unit suite passed 26 tests / 41 assertions / 0 failures / 0 errors (Step 165)."
+      },
+      {
+        "versions": ["0.4.0"],
+        "environment": "musl x86_64 / ruby 4.0.6",
+        "verified_at": "2026-08-04",
+        "evidence": "RUBYCC=1 gem install io-wait succeeded (wait.so built through rmake); the gem's own test/unit suite passed 26 tests / 41 assertions / 0 failures / 0 errors (Step 183). Re-verified with tools/verify_gem_tests.rb (Step 191): the gem's own test/unit suite passed 26 tests / 41 assertions / 0 failures / 0 errors."
+      },
+      {
+        "versions": ["0.4.0"],
+        "environment": "glibc aarch64 / ruby 4.0.6",
+        "verified_at": "2026-08-05",
+        "evidence": "RUBYCC=1 gem install io-wait succeeded (wait.so built through rmake); the gem's own test/unit suite passed 26 tests / 41 assertions / 0 failures / 0 errors (Step 208)."
+      }
+    ],
+    "notes": "io/wait ships with the interpreter, so this run is against the .so injected from the rubycc build; the sanity check confirms through $LOADED_FEATURES that the injected copy, not the interpreter's own, is what the suite loaded. Its extconf.rb is three lines and runs no probes at all, so unlike bigdecimal or io-nonblock there is no configure-time branch rubycc and gcc could have taken differently: the same translation unit is what both compile. Measured against a host gcc control on the same upstream tree: 26 tests / 41 assertions / 0 failures / 0 errors / 1 omission on both sides, identical. The recipe passes upstream's own --ignore-name=/ungetc_in_text/ (its Rakefile's Rake::TestTask#options) rather than excluding the file, which holds tests that do run. The run reported 1 omission (not failures): test_tty_wait, because /dev/tty cannot be opened in a session with no controlling terminal (Errno::ENXIO) -- a property of the environment, and the gcc control omits it identically."
+  },
+  "erb": {
+    "verifications": [
+      {
+        "versions": ["6.0.1.1"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-04",
+        "evidence": "RUBYCC=1 gem install erb succeeded (escape.so built through rmake); the gem's own test/unit suite passed 48 tests / 143 assertions / 0 failures / 0 errors (Step 166)."
+      }
+    ],
+    "notes": "erb ships with the interpreter, so this run is against the .so injected from the rubycc build; the sanity check confirms through $LOADED_FEATURES that the injected copy, not the interpreter's own erb/escape.so, is what the suite loaded. Only ext/erb/escape is C -- everything else in the gem is Ruby, and lib/erb/util.rb wraps `require 'erb/escape'` in a rescue LoadError with a pure-Ruby ERB::Escape#html_escape over CGI.escapeHTML behind it. Measured how visible that fallback is: corrupting the injected escape.so leaves 47 of the 48 tests passing, and the single failure is upstream's own test_html_escape_extension, which asserts html_escape has no source_location. So this suite does detect its own fallback; what it cannot detect is the wrong copy, since the interpreter's escape.so satisfies that assertion just as well. The one extconf probe, have_func(\"rb_ext_ractor_safe\", \"ruby.h\"), comes out yes under rubycc exactly as under the host gcc control, so HAVE_RB_EXT_RACTOR_SAFE is defined and Init_escape calls rb_ext_ractor_safe(true) on both sides. No test was excluded and the build needed no extra flag."
+  },
+  "io-console": {
+    "verifications": [
+      {
+        "versions": ["0.8.2"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-04",
+        "evidence": "RUBYCC=1 gem install io-console succeeded (console.so built through rmake); the gem's own test/unit suite passed 28 tests / 109 assertions / 0 failures / 0 errors (Step 169)."
+      }
+    ],
+    "notes": "io/console ships with the interpreter, and the gem also carries a pure-Ruby FFI implementation under lib/ffi/ for JRuby; the sanity check confirms through $LOADED_FEATURES that neither is what the suite loaded, but the .so injected from the rubycc build. This gem took two rubycc changes to build at all. Step 167: the bundled termios.h did not declare cfmakeraw and the bundled unistd.h did not declare ttyname_r, which mkmf's have_func probes cannot notice because they declare the function themselves -- the error only appears compiling the body. Step 168: console.c reaches ruby/ractor.h, which forward-declares rb_ractor_shareable_p_continue from inside a static inline function's body, and rubycc rejected block-scope function declarations outright. All 13 extconf probes come out yes under rubycc exactly as under the host gcc control. 28 of the 37 `def test_` in the source actually run, and this is a property of the environment, not of rubycc: five (test_get_winsize_console, test_set_winsize_console, test_getch_timeout, test_pressed_valid, test_pressed_invalid) sit inside a class_eval guarded by `IO.console`, so with no controlling terminal they are never defined, and four names are defined twice across two class_eval blocks so the later definition wins. The tty tests that go through PTY.open (test_raw, test_noecho, test_getpass, test_intr, test_cursor_position and the rest) do run and pass. A host gcc control built from the same upstream tree runs the same 28 tests / 109 assertions / 0 failures / 0 errors / 0 omissions, identical."
+  },
+  "digest": {
+    "verifications": [
+      {
+        "versions": ["3.2.1"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-04",
+        "evidence": "RUBYCC=1 gem install digest succeeded (digest.so + bubblebabble.so + md5.so + rmd160.so + sha1.so + sha2.so built through rmake); the gem's own test/unit suite passed 98 tests / 215 assertions / 0 failures / 0 errors (Step 170)."
+      }
+    ],
+    "notes": "The first corpus gem with more than one extension: six extconf.rb under ext/digest, six .so, all six built by rubycc through rmake in one gem install with no flag and no change to the mkmf shim. digest ships with the interpreter, so the run is against the injected copies; the sanity check requires all six by name, because requiring only \"digest\" loads two of them and leaves the other four unproven (Digest's const_missing pulls the algorithm extensions in lazily), and the gate demands every injected .so appear in $LOADED_FEATURES. What this suite proves is unusually direct for a corpus gem: it checks digests of known inputs against known hex outputs, so a miscompiled round function would show up as a wrong value rather than as a crash. The three extconf probes (CommonCrypto/CommonDigest.h no, u_int8_t yes, sys/cdefs.h yes) come out identical under rubycc and the host gcc control -- CommonCrypto is macOS-only, so both sides compile the bundled algorithm sources rather than the platform ones. The upstream tree keeps digest/loader.rb and digest/sha2/loader.rb under ext/digest/lib (gem install copies them into lib/), so that directory has to be on the load path as the Rakefile puts it there."
+  },
+  "zlib": {
+    "verifications": [
+      {
+        "versions": ["3.2.3"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-04",
+        "evidence": "RUBYCC=1 gem install zlib succeeded (zlib.so built through rmake); the gem's own test/unit suite passed 97 tests / 540 assertions / 0 failures / 0 errors (Step 171)."
+      },
+      {
+        "versions": ["3.2.3"],
+        "environment": "glibc aarch64 / ruby 4.0.6",
+        "verified_at": "2026-08-11",
+        "evidence": "RUBYCC=1 gem install zlib succeeded (zlib.so built through rmake); the gem's own test/unit suite passed 97 tests / 538 assertions / 0 failures / 0 errors (Step m4-aarch64-acceptance-2)."
+      }
+    ],
+    "notes": "The first corpus gem that links a host system library, the case R10 names. extconf's have_library('z', 'deflateReset(NULL)', 'zlib.h') is a try_link, so its success means rubycc both found the host's /usr/include/zlib.h and linked -lz; had it failed, the build would not have stopped but switched to the bundled-zlib branch, so the choice was read out of the generated Makefile rather than assumed. All seven probes come out yes under rubycc exactly as under the host gcc control (deflateReset in -lz, crc32_combine, adler32_combine, z_crc_t, z_size_t, crc32_z, adler32_z), the Makefile carries -DHAVE_ZLIB_SIZE_T_FUNCS and no ZSRC, and the built zlib.so records libz.so.1 in DT_NEEDED exactly as the gcc-built one does. One difference from the gcc control's .so: gcc's also lists libm.so.6 in DT_NEEDED while rubycc's does not, because rubycc's linker records only libraries that actually supply a needed symbol and zlib.c references none from libm; every undefined symbol resolves and the suite passes either way. zlib ships with the interpreter, so the run is against the injected copy, which the sanity check confirms through $LOADED_FEATURES. The run reported 1 omission (not failures). The same three markers were measured again for the AArch64 record -- -DHAVE_ZLIB_SIZE_T_FUNCS in CPPFLAGS, -lz in LIBS, and libz.so.1 in the built .so's DT_NEEDED with deflate left undefined -- because a library search is per-architecture, and that is precisely the layer that was broken on AArch64 once (Step 208, where the resolver looked in x86-64's multiarch directory). The AArch64 omission is test_path_tmpfile, which the container's filesystem answers with EOPNOTSUPP."
+  },
+  "psych": {
+    "verifications": [
+      {
+        "versions": ["5.3.1"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-04",
+        "evidence": "RUBYCC=1 gem install psych succeeded (psych.so built through rmake); the gem's own test/unit suite passed 633 tests / 1,598 assertions / 0 failures / 0 errors (Step 172)."
+      }
+    ],
+    "notes": "The second corpus gem that links a host system library, and the first whose configure path rubycc's own pkg-config shim *changed*. extconf tries pkg_config('yaml-0.1') first and only falls back to find_header('yaml.h') + find_library('yaml', 'yaml_get_version') when that comes up empty. This host has no pkg-config at all, so the gcc control gets \"not found\" and takes the fallback branch, while under rubycc the transcript reads `checking for pkg-config for yaml-0.1... [\" \", \"\", \"-lyaml\"]` -- exe/rubycc-pkgconf answered, so the pkg_config branch ran instead. Both branches converge on the same LIBS = $(LIBRUBYARG_SHARED)  -lyaml -lm -lpthread  -lc and the suite passes, but the two sides did not configure through the same code path, which is recorded here rather than left implicit (Step 160's lesson: a matching pass count is not evidence that the same thing was built). The build also exposed a separate rmake gap, fixed in Step 173: the Makefile's `-cd libyaml && $(MAKE) clean` echoed as `cd libyaml &&  clean` because rmake did not predefine the MAKE macro that POSIX requires. It was harmless here -- the rule is `-`-prefixed so its failure is ignored, and this build uses the host libyaml rather than the bundled one -- but it would have silently no-opped the recursive-make rule that builds bundled libyaml. psych ships with the interpreter and MRI has no pure-Ruby parser to fall back to (ext/java is JRuby's SnakeYAML binding), so the sanity check's $LOADED_FEATURES test is what rules out the interpreter's own copy winning the require."
+  },
+  "syslog": {
+    "verifications": [
+      {
+        "versions": ["0.3.0"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-06",
+        "evidence": "RUBYCC=1 gem install syslog succeeded (syslog_ext.so built through rmake); the gem's own test/unit suite passed 32 tests / 234 assertions / 0 failures / 0 errors (Step 209)."
+      }
+    ],
+    "notes": "Ruby 3.4.5 glibc x86_64; upstream tests ran against rubycc-built extension."
+  },
+  "http_parser.rb": {
+    "verifications": [
+      {
+        "versions": ["0.8.1"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-06",
+        "evidence": "RUBYCC=1 gem install http_parser.rb succeeded (ruby_http_parser.so built through rmake); the gem's own RSpec suite passed 72 examples / 0 failures (Step 209)."
+      }
+    ],
+    "notes": "Ruby 3.4.5 glibc x86_64; upstream tests ran against rubycc-built extension."
+  },
+  "websocket-driver": {
+    "verifications": [
+      {
+        "versions": ["0.8.2"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-06",
+        "evidence": "RUBYCC=1 gem install websocket-driver succeeded (websocket_mask.so built through rmake); the gem's own RSpec suite passed 196 examples / 0 failures (Step 209)."
+      }
+    ],
+    "notes": "The upstream RSpec suite passed 196 examples against the injected websocket_mask.so. The run used the recipe's synthetic Gemfile to activate the runtime/test dependencies without resolving the repository's development-only bundle."
+  },
+  "bootsnap": {
+    "verifications": [
+      {
+        "versions": ["1.24.6"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-06",
+        "evidence": "RUBYCC=1 gem install bootsnap succeeded (bootsnap.so built through rmake); the gem's own test/unit suite passed 154 tests / 331 assertions / 0 failures / 0 errors (Step 210)."
+      }
+    ],
+    "notes": "The upstream test/unit suite passed 154 tests / 331 assertions against the injected bootsnap.so. The run used the recipe's synthetic Gemfile and pinned minitest 5.25.5, matching the suite's compatibility requirement."
+  },
+  "yajl-ruby": {
+    "verifications": [
+      {
+        "versions": ["1.4.3"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-06",
+        "evidence": "RUBYCC=1 gem install yajl-ruby succeeded (yajl.so built through rmake); the gem's own RSpec suite passed 416 examples / 0 failures (Step 211)."
+      }
+    ],
+    "notes": "The upstream RSpec suite passed 416 examples against the injected yajl.so; the extension was loaded from the rubycc build, not a fallback implementation."
+  },
+  "prism": {
+    "verifications": [
+      {
+        "versions": ["1.8.1"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-06",
+        "evidence": "RUBYCC=1 gem install prism succeeded (prism.so built through rmake); the gem's own test/unit suite passed 17,306 tests / 1,762,400 assertions / 0 failures / 0 errors (Step 212)."
+      }
+    ],
+    "notes": "The upstream test/unit suite passed 17,306 tests / 1,762,400 assertions against the injected prism.so. The run reported 3 omissions (not failures); the source archive was supplemented with the generated Ruby API files present in the gem package."
+  },
+  "fiddle": {
+    "verifications": [
+      {
+        "versions": ["1.1.8"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-06",
+        "evidence": "RUBYCC=1 gem install fiddle succeeded (fiddle.so built through rmake); the gem's own test/unit suite passed 227 tests / 615 assertions / 0 failures / 0 errors (Step 213)."
+      }
+    ],
+    "notes": "The upstream test/unit suite passed 227 tests / 615 assertions against the injected fiddle.so, with the system libffi ABI path enabled."
+  },
+  "nio4r": {
+    "verifications": [
+      {
+        "versions": ["2.7.5"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-07",
+        "evidence": "RUBYCC=1 gem install nio4r succeeded (nio4r_ext.so built through rmake); the gem's own RSpec suite passed 112 examples / 0 failures (Step atomic-type-4)."
+      }
+    ],
+    "notes": "PR #19 recorded nio4r as blocked by sandbox socket/PTY constraints; a re-measurement showed TCP, PTY and UNIX sockets all work here, and the suite passed with no rubycc change. The run reported 2 pendings (not failures)."
+  },
+  "google-protobuf": {
+    "verifications": [
+      {
+        "versions": ["4.35.1"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-08",
+        "evidence": "RUBYCC=1 gem install google-protobuf succeeded (protobuf_c.so built through rmake); the gem's own test/unit suite passed 328 tests / 555,716 assertions / 0 failures / 0 errors (Step atomic-type-14)."
+      }
+    ],
+    "notes": "Verification requires protoc: the upstream tarball ships no _pb.rb, so the recipe generates all 27 of them (12 well-known + 15 test protos) with the protoc matching the pinned tag. Measured with libprotoc 35.1 -- note the gemspec version 4.35.1 and the upstream tag v35.1 differ. The gemspec lists two extensions in one directory, so RubyGems overwrites gem_make.out with the second (non-compiling) one; the Makefile's CC=rubycc is what proves the build, and the .so carries no .comment section (a gcc-built .so on this host carries 'GCC: (Ubuntu 13.3.0-...)'). The run reported 2 omissions (not failures)."
+  },
+  "mysql2": {
+    "verifications": [
+      {
+        "versions": ["0.5.7"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-08",
+        "evidence": "RUBYCC=1 gem install mysql2 succeeded (mysql2.so built through rmake); the gem's own RSpec suite passed 340 examples / 0 failures (Step atomic-type-15)."
+      }
+    ],
+    "notes": "Verification needs a MariaDB server AND a small-socket-buffer network namespace: spec/mysql2/result_spec.rb:240 asserts that net_write_timeout aborts a stream the client reads too slowly, and that never fires on an ordinary loopback -- the 10,000-row / 2.4 MiB result fits entirely inside the host's tcp_wmem (4 MiB) and tcp_rmem (6 MiB), so the server never blocks writing. Measured: the same test raises 'Lost connection to server during query' at row 47,248 when the table is grown to 60,000 rows (14.6 MiB). It fails identically under gcc without this environment, and passes identically under gcc with it. The recipe therefore runs the suite inside the DB container's network namespace, whose buffers are pinned to 32 KiB both ways; see suite_exec in tools/verify_gem_tests.rb. The run also mounts a host libyaml-0.so.2 because the mariadb:11 image has none and Ruby's psych needs it. The run reported 6 pendings (not failures)."
+  },
+  "puma": {
+    "verifications": [
+      {
+        "versions": ["8.0.2"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-08",
+        "evidence": "RUBYCC=1 gem install puma succeeded (puma_http11.so built through rmake); the gem's own test/unit suite passed 840 tests / 2,490 assertions / 0 failures / 0 errors (Step corpus-ninety-2)."
+      }
+    ],
+    "notes": "The suite must run the way upstream runs it: under bundler with puma's own Gemfile, and with CI=1. Without bundler 12 of the 840 tests fail on their absence alone (TestWorkerGemIndependence calls Bundler.with_unbundled_env, TestPreserveBundlerEnv asserts BUNDLE_GEMFILE survives a phased restart, prune_bundler has nothing to prune, and TestRackUp cannot find the rackup binstub) -- identically under gcc. CI=1 is what test/helper.rb:118 checks before enabling minitest-retry: the TestIntegrationCluster fork/phased-restart cases are inherently timing-dependent (measured: two runs of the same gcc build gave 6 and 7 failures, and rubycc and gcc each failed a different single case), so upstream itself runs them with retries. PUMA_NO_RUBOCOP=1 keeps the lint-only half of the Gemfile out. The run reported 8 skips (not failures)."
+  },
+  "sqlite3": {
+    "verifications": [
+      {
+        "versions": ["2.9.5"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-11",
+        "evidence": "RUBYCC=1 gem install sqlite3 succeeded (sqlite3_native.so built through rmake); the gem's own test/unit suite passed 334 tests / 661 assertions / 0 failures / 0 errors (Step corpus-sqlite3-pg-1)."
+      }
+    ],
+    "notes": "Installed with --enable-system-libraries, the R10 profile test/corpus/gems.rb declares for this gem: the default path builds the bundled amalgamation through mini_portile2 and configure, which R10 excludes. The sanity expression asserts SQLite3::SQLITE_PACKAGED_LIBRARIES == false, so the record is evidence about the system-library build and no other. The run reported 5 skips (not failures); 3 of them are test/test_database_uri.rb's own `skip(\"system libraries may not allow URIs\") unless SQLite3::SQLITE_PACKAGED_LIBRARIES`, i.e. a consequence of that same profile rather than of rubycc."
+  },
+  "pg": {
+    "verifications": [
+      {
+        "versions": ["1.6.3"],
+        "environment": "glibc x86_64 / ruby 3.4.5",
+        "verified_at": "2026-08-11",
+        "evidence": "RUBYCC=1 gem install pg succeeded (pg_ext.so built through rmake); the gem's own RSpec suite passed 1,040 examples / 0 failures (Step corpus-sqlite3-pg-2)."
+      }
+    ],
+    "notes": "The suite starts its own PostgreSQL server from `pg_config --bindir`, so the host needs the server package and not only libpq; the socket directory it uses must also stay under the 107-byte sun_path limit, which a long work directory silently breaks (the server then refuses to start and no example runs at all). The run reported 4 pendings (not failures): two are upstream's own `skip` when port 5432 is already taken (spec/pg/connection_spec.rb:840), which is the case whenever a normal PostgreSQL install is running, and two apply to native binary gems only. A dozen specs assert on wall-clock durations read from Time.now, so a host that steps its clock fails them at random: measured here at 2/40 runs for rubycc and 3/40 for the gcc control, while the underlying connection took 2.003-2.010 s on both sides in all 80 measurements (Step corpus-sqlite3-pg-2). The recorded run was made with the clock stepping stopped."
+  }
+}

data/exe/rmake

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# rmake — rubycc's build-only make (M3 / ROADMAP §6 B6). RubyGems runs this as
+# `$(MAKE)` when the rubygems_plugin has set ENV["MAKE"] to it, so it must be
+# launchable directly by path. The repository lib/ is put on the load path here
+# (mirroring exe/rubycc) so the require resolves both from an installed gem and
+# from a source checkout, regardless of RUBYLIB.
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
+require "rubycc/rmake/rmake"
+
+# The executable is a thin launcher: all argument parsing, Makefile loading and
+# the always-on rubycc tool substitution live in Rubycc::Rmake::CLI, which
+# returns the process exit status.
+exit Rubycc::Rmake::CLI.run(ARGV)

data/exe/rubycc

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rubycc"
+
+# The executable is a thin launcher: all argument parsing and mode selection
+# lives in Rubycc::Driver, the gcc-compatible driver, which returns the process
+# exit status.
+exit Rubycc::Driver.run(ARGV)

data/exe/rubycc-ar

@@ -0,0 +1,114 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rubycc"
+
+PROG = "rubycc-ar"
+
+def fail_with(message)
+  warn "#{PROG}: error: #{message}"
+  exit 1
+end
+
+def usage_error(message)
+  warn "#{PROG}: error: #{message}"
+  warn "usage: #{PROG} {rcs|t|x}[cDsu] archive [member...]"
+  exit 1
+end
+
+# An archive's member name is meant to be a bare basename; the archive format
+# itself is untrusted input (a hand-crafted archive can name a member
+# anything), so a name carrying a path — an absolute path, a "/" separator, or
+# "." / ".." — is rejected outright rather than silently rewritten to
+# something safe, which would let a zip-slip-style write outside the current
+# directory succeed under a different name and erase the evidence of the
+# attempt.
+def safe_member_name?(name)
+  return false if name.empty? || name.start_with?("/") || name.include?("/")
+  return false if name == "." || name == ".."
+
+  true
+end
+
+if ARGV.include?("--version") || ARGV.include?("-v")
+  puts "#{PROG} #{Rubycc::VERSION}"
+  exit 0
+end
+
+args = ARGV.dup
+usage_error("no operation specified") if args.empty?
+
+# The first word is the combined flag string (e.g. "rcs", "t", "x"), with an
+# optional leading dash as `ar` also accepts ("-rcs"). Exactly one operation
+# letter selects the action; c/s/u/D and friends are modifiers that our writer
+# already honors implicitly (creation is always allowed, the index is always
+# refreshed, output is always deterministic), so they are accepted as no-ops.
+flags = args.shift.sub(/\A-/, "")
+
+operation =
+  if flags.include?("r") then :replace
+  elsif flags.include?("t") then :list
+  elsif flags.include?("x") then :extract
+  elsif flags.include?("s") then :index
+  end
+usage_error("unknown or missing operation in flags '#{flags}'") if operation.nil?
+
+archive = args.shift
+usage_error("no archive specified") if archive.nil?
+members = args
+
+Reader = Rubycc::ObjFile::ArReader
+Writer = Rubycc::ObjFile::ArWriter
+
+begin
+  case operation
+  when :replace
+    # Replace-or-append: start from the archive's current regular members (if it
+    # exists), then for each named file replace the same-named member in place or
+    # append a new one. The symbol index is regenerated by the writer.
+    order = []
+    data_by_name = {}
+    if File.exist?(archive)
+      Reader.read_file(archive).members.reject(&:special?).each do |m|
+        order << m.name
+        data_by_name[m.name] = m.data
+      end
+    end
+
+    members.each do |path|
+      name = File.basename(path)
+      order << name unless data_by_name.key?(name)
+      data_by_name[name] = File.binread(path)
+    end
+
+    writer = Writer.new
+    order.each { |name| writer.add_member(name, data_by_name[name]) }
+    writer.write(archive)
+
+  when :list
+    Reader.read_file(archive).members.reject(&:special?).each { |m| puts m.name }
+
+  when :extract
+    wanted = members.empty? ? nil : members.map { |p| File.basename(p) }
+    Reader.read_file(archive).members.reject(&:special?).each do |m|
+      next if wanted && !wanted.include?(m.name)
+
+      fail_with("refusing to extract member with unsafe name '#{m.name}'") unless safe_member_name?(m.name)
+
+      File.binwrite(m.name, m.data)
+    end
+
+  when :index
+    # `s` on its own (ranlib): rewrite the archive so its symbol index is fresh.
+    # Our writer always regenerates it, so a read-then-write suffices.
+    writer = Writer.new
+    Reader.read_file(archive).members.reject(&:special?).each { |m| writer.add_member(m.name, m.data) }
+    writer.write(archive)
+  end
+rescue Rubycc::ObjFile::ArFormatError => e
+  fail_with(e.message)
+rescue Errno::ENOENT => e
+  fail_with(e.message)
+end
+
+exit 0

data/exe/rubycc-doctor

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# rubycc-doctor — the adoption-check command (ROADMAP §6 "M3 完了後のツール").
+# The repository lib/ is put on the load path (mirroring exe/rubycc and exe/rmake)
+# so the require resolves both from an installed gem and from a source checkout.
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
+require "rubycc/doctor"
+
+# Thin launcher: all option parsing, the verified-database lookup and the
+# on-the-spot build orchestration live in Rubycc::Doctor::CLI, which returns the
+# process exit status.
+exit Rubycc::Doctor::CLI.run(ARGV)

data/exe/rubycc-pkgconf

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rubycc/pkgconf/pkgconf"
+
+# The executable is a thin launcher: all argument parsing, .pc resolution and
+# rendering lives in Rubycc::Pkgconf, which returns the process exit status.
+exit Rubycc::Pkgconf.run(ARGV)