audition 0.2.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76a1b0c57c7a373182f7b9f88f765fa8e0167a492e28d028998335bc246c10d9
-  data.tar.gz: 2c5ecb49ed0a63ebd7a58cb3db9e8b5e8f9893953198d1c3e9f0cc5ca74cfb3a
+  metadata.gz: 28a9914f63873fd6bc4ec2e86154aa69e4e3dbfb08c3d9ee6218fc521e31836b
+  data.tar.gz: e1033a810ea825b21980fb3cb406bfd7bda1bf69e970e82c988fb0d149c0d172
 SHA512:
-  metadata.gz: 633d141cdc23a3e2e24df8b983b9112ffa9a759194669c4f9a6f62f0bf07219b507bd72cea8235de3c7193ab934c60ca8c98ee2095eabe21fad2e80f682ea8e2
-  data.tar.gz: bfd863839b4d5fbea291d22282487de79d261fd55bba5662d82d285e013827290257ca61d5b637000581453ec8f3a0510b1571bf6492d1b9f6f9e7de9f3af225
+  metadata.gz: 07b6250748bf1d3e854157b6ac81f8a2574259f77d2e28746d241e880763cb446410b27736740c29f803e4936fed3d5ff0f6ca1b95d73cc6cb664896630c17fe
+  data.tar.gz: ab564046d55d28d6e94af9e045991574322e14074e4121e788c6b59f8ce3628f4499351d5f9cac7e670564bc9ea7472b3615056d9b91beaeb64dc3e131babc04

data/README.md

@@ -11,6 +11,10 @@ graph. Some of the checks and fixes were trained on how Rails
 core itself is being ractorized; see the
 [pattern study](docs/rails_core_best_practices.md).
 
+<div align="center">
+  <img src="https://raw.githubusercontent.com/yaroslav/audition/refs/heads/main/assets/images/audition.png" width="512" height="512" alt="gem audition" title="gem audition">
+</div>
+
 [![GitHub Release](https://img.shields.io/github/v/release/yaroslav/audition)](https://github.com/yaroslav/audition/releases)
 [![Docs](https://img.shields.io/badge/yard-docs-blue.svg)](https://rubydoc.info/gems/audition)
 
@@ -24,8 +28,10 @@ core itself is being ractorized; see the
   (which rule of the Ractor model it violates) and a `fix`
   (what to write instead).
 - **`--fix` like RuboCop, in two tiers.** Safe corrections:
-  `.freeze` on string constants, `Ractor.make_shareable(...)` for
-  mutable and shallow-frozen containers and Proc constants, and
+  `.freeze` on string constants, sentinels, and containers whose
+  elements are all shareable, `Ractor.make_shareable(...)` for
+  the remaining mutable and shallow-frozen containers and for
+  Proc constants, and
   boot-time hoisting of method-body requires. `--fix-unsafe` adds
   semantics-affecting rewrites: magic-comment insertion,
   freeze-on-memoize for class-level memoization (both `@x ||=`
@@ -41,13 +47,15 @@ core itself is being ractorized; see the
   state, so `globalid` is not blamed for ActiveSupport's state.
 - **Dogfooding.** The scanner for Ractor compatibility is built
   using Ractors: static analysis fans out across CPU cores on
-  Ractor workers, and audition passes its own audit.
+  Ractor workers, and audition passes its own audit. It runs on
+  itself on every commit (a lefthook pre-commit over the staged
+  files) and on every push (a full self-audit in CI).
 - **Trained on Rails core.** Several checks and fix suggestions
   come straight from studying the Rails ractorization effort
-  (about 75 substantive commits): `Hash.new` default procs,
-  in-place mutation of registry constants, closure-carrying
-  `define_method`, copy-on-write rewrites. The findings are
-  documented in
+  (some two hundred commits and pull requests): `Hash.new`
+  default procs, in-place mutation of registry constants,
+  closure-carrying `define_method`, copy-on-write rewrites. The
+  findings are documented in
   [docs/rails_core_best_practices.md](docs/rails_core_best_practices.md).
 - **Terminal-native output.** Colors, glyphs, and OSC 8 hyperlinks;
   `path:line` is clickable in supporting terminals. JSON output for
@@ -112,6 +120,7 @@ proxying) and its verified semantics.
 - [Installation](#installation)
 - [Usage](#usage)
 - [Adopting incrementally](#adopting-incrementally)
+- [CI and git hooks](#ci-and-git-hooks)
 - [What it catches](#what-it-catches)
 - [Agent skill](#agent-skill)
 - [Extending](#extending)
@@ -140,6 +149,7 @@ audition path/to/gem-checkout # a gem working copy (*.gemspec)
 audition path/to/rack-app     # a config.ru directory
 audition path/to/rails-root   # a Rails application
 audition lib                  # any directory, static-only
+audition a.rb b.rb c.rb       # several files at once, statically
 audition Gemfile.lock         # sweep every gem in the bundle
 audition path/to/app --deps   # same, from the app root
 ```
@@ -154,16 +164,19 @@ Useful flags:
 | `--fix-unsafe` | also apply semantics-affecting corrections |
 | `--dry-run` | with a fix flag: preview edits, change nothing |
 | `--format json` | machine-readable report for CI |
-| `--format github` | GitHub Actions annotations on PR diffs |
+| `--format github` | GitHub Actions annotations + job summary |
 | `--compare old.json` | delta vs a previous report: fixed/introduced |
 | `--static-only` / `--dynamic-only` | pick one probe layer |
 | `--fail-on warning` | stricter CI gate (default: error) |
+| `--exit-zero` | report findings but never fail the build |
 | `--capabilities` | table of what this Ruby allows in Ractors |
 | `--timeout 60` | dynamic probe budget in seconds |
 | `--plain` | no colors or hyperlinks (also via NO_COLOR, pipes) |
 
 Exit codes: `0` clean, `1` findings at or above the `--fail-on`
 threshold (or a failed dynamic probe), `2` usage error.
+`--exit-zero` (alias for `--fail-on never`) always exits `0`
+unless the invocation itself is broken.
 
 ## Adopting incrementally
 
@@ -202,6 +215,71 @@ checks:
     - at-exit
 ```
 
+## CI and git hooks
+
+**GitHub Actions.** `--format github` turns findings into
+workflow-command annotations that land right on the PR diff, and
+appends a verdict-plus-counts markdown table to the job summary
+page. A blocking gate:
+
+```yaml
+- uses: ruby/setup-ruby@v1
+  with:
+    ruby-version: "4.0"
+- run: gem install audition
+- run: audition --format github .
+```
+
+To surface findings without failing the build while you adopt
+(the flag other linters call `--exit-zero` too, so it keeps its
+name here):
+
+```yaml
+- run: audition --format github --exit-zero .
+```
+
+`--fail-on never` is the long form, and works from
+`.audition.yml` as well; GitHub's own `continue-on-error: true`
+on the step is the workflow-level equivalent.
+
+**Git hooks.** Passing several `.rb` files audits exactly those
+files statically, which is the shape hook managers hand over.
+With [lefthook](https://github.com/evilmartians/lefthook):
+
+```yaml
+pre-commit:
+  commands:
+    audition:
+      glob: "*.rb"
+      run: audition --static-only --plain {staged_files}
+```
+
+With [pre-commit](https://pre-commit.com):
+
+```yaml
+- repo: local
+  hooks:
+    - id: audition
+      name: audition
+      language: system
+      entry: audition --static-only --plain
+      types: [ruby]
+```
+
+Config, pragmas, and the baseline resolve against the working
+directory, so a hook run from the repository root honors the
+same `.audition.yml` as a full audit.
+
+**This repository eats its own dog food.** Every commit runs
+`audition --static-only` over the staged files through lefthook
+(next to standardrb), and every push and pull request gets a
+full self-audit in CI with annotations and a job summary,
+non-blocking via `--exit-zero`
+([audit.yml](.github/workflows/audit.yml)). Current state: own
+code audits `ready`; the full dynamic probe reports the terminal
+dev-dependencies as `blocked`, which is exactly the distinction
+the verdict system exists to make.
+
 ## What it catches
 
 Static, with file:line precision:
@@ -235,6 +313,15 @@ Static, with file:line precision:
   `class_attribute` migration Rails itself made) and
   `class_attribute` without copy-on-write writes,
   `include Singleton`, `fork`, `ObjectSpace._id2ref`, ENV mutation.
+- **Native extensions that never declare Ractor safety**: a byte
+  scan of every compiled `.bundle`/`.so` for the
+  `rb_ext_ractor_safe` import, which also covers precompiled
+  platform gems that ship no sources; an unbuilt checkout is
+  scanned at the source level (`ext/**`, C, Rust, or Zig) instead.
+  A silent extension raises `Ractor::UnsafeError` on every call
+  from a non-main Ractor, so it rates a warning; a declared one
+  gets an info note, because the declaration is the maintainer's
+  assertion, not a proof.
 
 Dynamic, on the live object graph:
 
@@ -244,6 +331,11 @@ Dynamic, on the live object graph:
   `Ractor.shareable?`, and inspects every class and module for
   class-level ivars and class variables, with
   `const_source_location` attribution.
+- Records every compiled extension the load pulled in,
+  dependencies included, and byte-scans each for the
+  `rb_ext_ractor_safe` import; silent ones are reported against
+  the dependency that ships them. Ruby's own extensions are left
+  to Ruby.
 - Boots `config.ru` and serves one GET / entirely inside a Ractor,
   the per-worker model of Ractor web servers; then hammers it from
   4 Ractors x 25 requests to surface failures that only appear
@@ -305,7 +397,7 @@ Audition::Static::Checks.register(NoSleep)
 bundle install
 bundle exec rake spec       # RSpec suite
 bundle exec rake standard   # standardrb lint
-lefthook install            # pre-commit lint hook
+lefthook install            # pre-commit standardrb + audition
 bundle exec exe/audition --capabilities
 ```
 

data/lib/audition/bundle_sweep.rb

@@ -115,7 +115,8 @@ module Audition
         ruby_files: spec.require_paths.flat_map do |rp|
           ruby_files_under(File.join(root, rp))
         end,
-        entry: {mode: :require, feature: spec.name, root: root}
+        entry: {mode: :require, feature: spec.name, root: root},
+        compiled_files: Target.compiled_for(spec)
       )
     end
 
@@ -142,16 +143,23 @@ module Audition
       files = target.ruby_files.reject do |file|
         config.excluded?(file.delete_prefix("#{target.root}/"))
       end
+      compiled = target.compiled_files.reject do |file|
+        config.excluded?(file.delete_prefix("#{target.root}/"))
+      end
       per_file = Static::Analyzer.new
         .analyze_paths(files, workers: 1)
-      per_file + Static::GraphAudit.new.analyze_paths(files)
+      per_file + Static::GraphAudit.new.analyze_paths(files) +
+        Static::NativeExtensions.new.analyze(target,
+          compiled_files: compiled)
     end
 
     def dynamic_results(target)
       return [] if @static_only || target.entry.nil?
 
       prober = Dynamic::Prober.new(timeout: @timeout)
-      [prober.probe(target.entry)]
+      [prober.probe(
+        target.entry.merge(compiled_files: target.compiled_files)
+      )]
     end
   end
 end

data/lib/audition/cli.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
+require "json"
 require "optparse"
 require "table_tennis"
 
 module Audition
   class CLI
-    USAGE = "usage: audition [options] TARGET " \
+    USAGE = "usage: audition [options] TARGET [FILE...] " \
             "(a .rb script, directory, config.ru dir, Rails root, " \
-            "gem dir, or installed gem name)"
+            "gem dir, installed gem name, or several .rb files)"
 
     # Entry point used by `exe/audition`.
     #
@@ -31,13 +32,20 @@ module Audition
 
       return print_capabilities(options) if options[:capabilities]
 
-      target_arg = options[:args].first
-      unless target_arg
+      args = options[:args]
+      if args.empty?
         @stderr.puts(USAGE)
         return 2
       end
 
-      target = Target.detect(target_arg)
+      # A single argument keeps full detection (including the
+      # dynamic probe); several arguments are the git-hook shape,
+      # a plain list of staged .rb files audited statically.
+      target = if args.size == 1
+        Target.detect(args.first)
+      else
+        Target.for_files(args)
+      end
       target = deps_target(target) if options[:deps]
       if target.type == :bundle
         sweep(target, options)
@@ -89,11 +97,18 @@ module Audition
           "with --fix: show planned edits, change nothing") do
           options[:dry_run] = true
         end
-        o.on("--fail-on LEVEL", %w[error warning info],
-          "exit 1 threshold (default: error)") do |v|
+        o.on("--fail-on LEVEL", %w[error warning info never],
+          "exit 1 threshold (default: error); never always " \
+          "exits 0") do |v|
           options[:fail_on] = v.to_sym
           options[:explicit] << :fail_on
         end
+        o.on("--exit-zero",
+          "report findings but exit 0 (same as " \
+          "--fail-on never)") do
+          options[:fail_on] = :never
+          options[:explicit] << :fail_on
+        end
         o.on("--write-baseline",
           "record current findings as the baseline") do
           options[:write_baseline] = true
@@ -150,7 +165,9 @@ module Audition
 
       results = []
       if target.entry && !options[:static_only]
-        results << prober(options).probe(target.entry)
+        results << prober(options).probe(
+          target.entry.merge(compiled_files: target.compiled_files)
+        )
       end
 
       all = findings +
@@ -262,8 +279,13 @@ module Audition
       files = target.ruby_files.reject do |file|
         config.excluded?(file.delete_prefix("#{target.root}/"))
       end
+      compiled = target.compiled_files.reject do |file|
+        config.excluded?(file.delete_prefix("#{target.root}/"))
+      end
       per_file = Static::Analyzer.new.analyze_paths(files)
-      per_file + Static::GraphAudit.new.analyze_paths(files)
+      per_file + Static::GraphAudit.new.analyze_paths(files) +
+        Static::NativeExtensions.new.analyze(target,
+          compiled_files: compiled)
     end
 
     # Fix chatter goes to stderr: stdout carries the report, which
@@ -312,12 +334,33 @@ module Audition
 
     def emit(report, options)
       case options[:format]
-      when :json then @stdout.puts(report.to_json)
-      when :github then @stdout.puts(report.to_github)
-      else @stdout.puts(report.to_text(style: style(options)))
+      when :json
+        @stdout.puts(Report::Json.new(report).render)
+      when :github
+        github = Report::Github.new(report)
+        @stdout.puts(github.render)
+        append_step_summary(github.summary)
+      else
+        @stdout.puts(
+          Report::Text.new(report, style(options)).render
+        )
       end
     end
 
+    # GitHub Actions exposes the job summary as an appendable
+    # file; outside Actions the variable is absent and this is a
+    # no-op. A broken path must not fail the audit itself.
+    def append_step_summary(markdown)
+      path = ENV["GITHUB_STEP_SUMMARY"]
+      return if path.nil? || path.empty?
+
+      File.open(path, "a") { |f| f.puts(markdown) }
+    rescue SystemCallError => e
+      @stderr.puts(
+        "audition: cannot write step summary: #{e.message}"
+      )
+    end
+
     def style(options, io: @stdout)
       if options[:plain]
         Report::Style.new(color: false, hyperlinks: false)
@@ -327,6 +370,8 @@ module Audition
     end
 
     def exit_code(report, options)
+      return 0 if options[:fail_on] == :never
+
       threshold = SEVERITIES.fetch(options[:fail_on])
       failed =
         report.findings.any? do |f|
@@ -359,11 +404,13 @@ module Audition
       )
       rows = sweeper.rows(progress: sweep_progress)
 
-      if options[:format] == :json
-        emit_sweep_json(rows)
-      else
-        emit_sweep_table(rows, options)
+      case options[:format]
+      when :json then emit_sweep_json(rows)
+      when :github then emit_sweep_github(rows)
+      else emit_sweep_table(rows, options)
       end
+      return 0 if options[:fail_on] == :never
+
       threshold = SEVERITIES.fetch(options[:fail_on])
       (rows.any? { |r| row_failed?(r, threshold) }) ? 1 : 0
     end
@@ -421,6 +468,53 @@ module Audition
       )
     end
 
+    # Sweep rows carry no file or line, so the annotations land on
+    # the run summary rather than a diff; the markdown table goes
+    # to the job summary page when Actions provides one.
+    def emit_sweep_github(rows)
+      ready = rows.count { |r| r.verdict == :ready }
+      rows.each do |row|
+        level = sweep_annotation_level(row)
+        next unless level
+
+        @stdout.puts(
+          "::#{level} title=audition::gem #{row.name} " \
+          "#{row.version}: #{row.errors} errors, " \
+          "#{row.dep_errors} dependency errors, " \
+          "#{row.warnings} warnings " \
+          "(#{VERDICT_CELLS.fetch(row.verdict)})"
+        )
+      end
+      @stdout.puts("#{ready} of #{rows.size} gems ractor-ready")
+      append_step_summary(sweep_summary_markdown(rows, ready))
+    end
+
+    def sweep_annotation_level(row)
+      if row.verdict == :not_ready ||
+          (row.errors + row.dep_errors).positive?
+        "error"
+      elsif row.warnings.positive?
+        "warning"
+      end
+    end
+
+    def sweep_summary_markdown(rows, ready)
+      lines = [
+        "## audition bundle sweep", "",
+        "| gem | version | verdict | errors | dep errors " \
+        "| warnings | fixable |",
+        "| --- | --- | --- | --- | --- | --- | --- |"
+      ]
+      rows.each do |r|
+        lines << "| #{r.name} | #{r.version} | " \
+          "#{VERDICT_CELLS.fetch(r.verdict)} | #{r.errors} | " \
+          "#{r.dep_errors} | #{r.warnings} | #{r.fixable} |"
+      end
+      lines << ""
+      lines << "#{ready} of #{rows.size} gems ractor-ready"
+      lines.join("\n")
+    end
+
     def emit_sweep_json(rows)
       @stdout.puts(JSON.pretty_generate(
         "audition" => VERSION,

data/lib/audition/config.rb

@@ -23,7 +23,7 @@ module Audition
        disabled_checks: []}
     )
 
-    FAIL_ON_LEVELS = %w[error warning info].freeze
+    FAIL_ON_LEVELS = %w[error warning info never].freeze
 
     attr_reader :fail_on, :timeout, :exclude, :disabled_checks
 
@@ -59,8 +59,8 @@ module Audition
         FAIL_ON_LEVELS.include?(fail_on.to_s)
 
       raise Error,
-        "#{path}: fail_on must be one of error, warning, or " \
-        "info (got #{fail_on.inspect})"
+        "#{path}: fail_on must be one of error, warning, " \
+        "info, or never (got #{fail_on.inspect})"
     end
     private_class_method :validate!
 

data/lib/audition/dynamic/harness.rb

@@ -12,10 +12,23 @@ Warning[:experimental] = false
 Thread.report_on_exception = false
 
 require "json"
+require "rbconfig"
 
 module AuditionHarness
   MAX_CONSTS = 5000
 
+  # Directories under the target root that are not the target's
+  # own surface. Bundler's deployment mode (and bundler-cache in
+  # GitHub Actions) vendors every gem into <root>/vendor/bundle,
+  # and attributing those constants to the target would flip its
+  # verdict from blocked to not_ready. Must mirror
+  # Audition::Target::EXCLUDED_DIRS (this file is a standalone
+  # subprocess script and cannot require the gem); a spec keeps
+  # the two lists in sync.
+  EXCLUDED_DIRS = %w[
+    vendor node_modules tmp log coverage pkg .git .bundle
+  ].freeze
+
   # Fixtures for capability probes.
   CAP_CONST = [1, 2] # audition:disable mutable-constants
 
@@ -125,18 +138,45 @@ module AuditionHarness
       $LOAD_PATH.unshift(lp) # audition:disable global-variables
     end
     before = Object.constants
-    feature = payload.fetch("feature")
-    begin
-      require feature # audition:disable runtime-require
-    rescue LoadError
-      # Dashed gem names conventionally ship slashed entry files
-      # (rspec-mocks provides rspec/mocks).
-      slashed = feature.tr("-", "/")
-      raise if slashed == feature
+    features = $LOADED_FEATURES.dup # audition:disable global-variables
+    require_target(payload.fetch("feature"), payload["root"])
+    scan(Object.constants - before, root: payload["root"]).merge(
+      "native_extensions" => native_extensions(
+        features, payload["root"], payload["known_compiled"]
+      )
+    )
+  end
 
-      require slashed # audition:disable runtime-require
+  # Gem names and entry files diverge in two conventional ways:
+  # dashed names ship slashed files (rspec-mocks provides
+  # rspec/mocks), and squashed names ship snake_case files
+  # (activesupport provides active_support). The second has no
+  # rule to invert, so when the target ships exactly one top-level
+  # file under lib/, that file is the entry, required by absolute
+  # path. An absolute require keeps the path as given, and scan
+  # compares constant origins against the realpathed root, so the
+  # candidate is built from the realpath too (a symlinked tmpdir,
+  # macOS /var, otherwise turns own findings into dependency ones).
+  # The error reported is the last one seen: a candidate that loads
+  # but fails inside says more than "cannot load such file".
+  def require_target(feature, root)
+    require feature # audition:disable runtime-require
+  rescue LoadError => error
+    entry_candidates(feature, root).each do |candidate|
+      return require candidate # audition:disable runtime-require
+    rescue LoadError => e
+      error = e
     end
-    scan(Object.constants - before, root: payload["root"])
+    raise error
+  end
+
+  def entry_candidates(feature, root)
+    candidates = []
+    slashed = feature.tr("-", "/")
+    candidates << slashed if slashed != feature
+    files = root ? Dir[File.join(realpath(root), "lib", "*.rb")] : []
+    candidates << files.first.delete_suffix(".rb") if files.size == 1
+    candidates
   end
 
   # Breadth-first walk of every constant the require introduced:
@@ -148,13 +188,7 @@ module AuditionHarness
     # Loaded features are realpathed by require; the target root
     # must be too, or symlinked paths (macOS /var vs /private/var)
     # break the own-vs-dependency comparison.
-    if root
-      root = begin
-        File.realpath(root)
-      rescue
-        root
-      end
-    end
+    root = realpath(root)
     unshareable = []
     class_state = []
     class_vars = []
@@ -218,10 +252,64 @@ module AuditionHarness
     end
     # The separator matters: /x/app must not claim /x/app-helpers.
     own = root.nil? || path.nil? || path == root ||
-      path.start_with?(root + File::SEPARATOR)
+      (path.start_with?(root + File::SEPARATOR) &&
+        !excluded?(path, root))
     {"path" => path, "line" => line, "own" => own}
   end
 
+  # Matches the static scanner's exclusion rule: any excluded or
+  # dot-prefixed component in the root-relative path means the
+  # file is not the target's own code.
+  def excluded?(path, root)
+    relative = path.delete_prefix(root + File::SEPARATOR)
+    relative.split(File::SEPARATOR).any? do |part|
+      EXCLUDED_DIRS.include?(part) || part.start_with?(".")
+    end
+  end
+
+  NATIVE = /\.(bundle|so)\z/
+  DECLARATION = "rb_ext_ractor_safe"
+
+  # Compiled extensions the require pulled in, with the one fact
+  # that decides their Ractor behavior: whether the file imports
+  # rb_ext_ractor_safe. Ruby's own extensions (archdir) are flagged
+  # so the prober can leave them to Ruby, and files the static check
+  # already covers are flagged as known.
+  def native_extensions(before, root, known)
+    root = realpath(root)
+    known = Array(known).map { |path| realpath(path) }
+    archdir = RbConfig::CONFIG["archdir"] + File::SEPARATOR
+    loaded = $LOADED_FEATURES - before # audition:disable global-variables
+    loaded.grep(NATIVE).map do |path|
+      {"path" => path,
+       "declares" => declares?(path),
+       "ruby" => path.start_with?(archdir),
+       "known" => known.include?(path),
+       "own" => known.include?(path) || own_path?(path, root)}
+    end
+  end
+
+  def declares?(path)
+    File.binread(path).include?(DECLARATION)
+  rescue SystemCallError
+    false
+  end
+
+  def own_path?(path, root)
+    return false unless root
+
+    path == root ||
+      (path.start_with?(root + File::SEPARATOR) && !excluded?(path, root))
+  end
+
+  def realpath(path)
+    return path if path.nil?
+
+    File.realpath(path)
+  rescue SystemCallError
+    path
+  end
+
   def inspect_module(full, mod, origin, class_state, class_vars)
     ivars = mod.instance_variables
     if ivars.any?
@@ -360,6 +448,7 @@ module AuditionHarness
   def rails(payload)
     environment = payload.fetch("environment")
     before = Object.constants
+    features = $LOADED_FEATURES.dup # audition:disable global-variables
     started = Time.now
     require environment # audition:disable runtime-require
     begin
@@ -369,8 +458,12 @@ module AuditionHarness
     end
     boot = {"ok" => true,
             "seconds" => (Time.now - started).round(1)}
-    scan(Object.constants - before, root: payload["root"])
-      .merge("boot" => boot)
+    scan(Object.constants - before, root: payload["root"]).merge(
+      "boot" => boot,
+      "native_extensions" => native_extensions(
+        features, payload["root"], payload["known_compiled"]
+      )
+    )
   rescue Exception => e
     {"boot" => {"ok" => false, "error" => describe_error(e)}}
   end