microsandbox-rb 0.17.0 → 0.17.2

data/lib/microsandbox/sandbox.rb

@@ -42,13 +42,13 @@ module Microsandbox
     # @return [Time, nil]
     def created_at
       ms = @native.created_at_ms
-      ms && Time.at(ms / 1000.0)
+      Microsandbox.time_from_ms(ms)
     end
 
     # @return [Time, nil]
     def updated_at
       ms = @native.updated_at_ms
-      ms && Time.at(ms / 1000.0)
+      Microsandbox.time_from_ms(ms)
     end
 
     # Gracefully stop the sandbox (SIGTERM→SIGKILL escalation, 10s default).
@@ -263,7 +263,7 @@ module Microsandbox
 
     # @return [Time] when the stopped state was observed
     def observed_at
-      Time.at(@observed_at_ms / 1000.0)
+      Microsandbox.time_from_ms(@observed_at_ms)
     end
 
     def inspect
@@ -495,7 +495,11 @@ module Microsandbox
       # @return [Sandbox, Object] the sandbox, or the block's return value
       def create(name, **kwargs, &block)
         opts = build_create_opts(**kwargs)
-        sandbox = new(Native::Sandbox.create(name.to_s, opts))
+        Microsandbox.ensure_runtime!
+        # Everything Ruby-level happens BEFORE `acquire`: its interrupt mask must
+        # cover only the native call plus the wrap, never caller-supplied code.
+        sandbox_name = name.to_s
+        sandbox = acquire { Native::Sandbox.create(sandbox_name, opts) }
         return sandbox unless block_given?
 
         begin
@@ -551,7 +555,9 @@ module Microsandbox
       # @return [Sandbox, Object] the live sandbox, or the block's return value
       def connect_or_create(name, **kwargs, &block)
         opts = build_create_opts(**kwargs)
-        sandbox = new(Native::Sandbox.connect_or_create(name.to_s, opts))
+        Microsandbox.ensure_runtime!
+        sandbox_name = name.to_s # outside the interrupt mask, like in {create}
+        sandbox = acquire { Native::Sandbox.connect_or_create(sandbox_name, opts) }
         return sandbox unless block_given?
 
         begin
@@ -582,11 +588,74 @@ module Microsandbox
             "for progress, then call #sandbox and stop it when done"
         end
         opts = build_create_opts(**kwargs)
+        Microsandbox.ensure_runtime!
         PullSession.new(Native::Sandbox.create_with_progress(name.to_s, opts))
       end
 
       # @api private
-      # Shared keyword-option builder for {create}/{create_with_progress}.
+      # Wrap the native sandbox the block acquires, and stop it again if an
+      # interrupt cuts in before the caller has it.
+      #
+      # A native call cannot be interrupted while it runs, so a `Thread#raise`
+      # (what `Timeout.timeout` uses) or a `Thread#kill` that arrives during the
+      # block is delivered after it — at the next interrupt checkpoint, which is
+      # still in here, before the caller ever sees the object. Left alone the
+      # sandbox would be garbage and only GC would stop it, "eventually"; for
+      # `Timeout.timeout { Sandbox.create(...) }` that is not good enough. So:
+      #
+      # - the acquisition runs under `Thread.handle_interrupt(Object => :never)`,
+      #   which holds a queued exception (or kill) back until the wrapper is
+      #   assigned. The mask covers only the uninterruptible native call plus
+      #   the wrap, so it changes no observable timing; runtime provisioning
+      #   ({Microsandbox.ensure_runtime!}) and the block forms' `yield` stay
+      #   outside it, with normal interrupt handling. For the same reason the
+      #   block passed here must contain NOTHING but the native call: argument
+      #   conversion (`name.to_s`, option Hashes) is the caller's own code and
+      #   has to run before `acquire`, where it stays interruptible;
+      # - the `ensure` plus the `acquired` flag — not `rescue Exception; raise` —
+      #   is what also covers `Thread#kill`, which no `rescue` can catch.
+      #
+      # A SIGINT (Ctrl-C on the main thread) is the exception: it is not queued
+      # like those two and cannot be masked. One that lands during the native
+      # call is raised the moment the call returns — the VM checks interrupts
+      # as it pops the native method's frame, before any Ruby code here can
+      # hold the result — so no assignment order would catch it; the sandbox
+      # is then torn down when the unreferenced object is garbage-collected.
+      #
+      # Ownership: {connect_or_create} can hand back a sandbox that was already
+      # running for someone else, and {start} restarts a persisted one. The
+      # cleanup therefore applies EXACTLY the predicate the block form of
+      # {connect_or_create} uses — {Sandbox#owns_lifecycle?} — in all three
+      # callers, {create} included: a sandbox this call does not own is never
+      # stopped here. Its reference is just let go (GC closes the handle, the
+      # sandbox keeps running).
+      # @yieldreturn [Native::Sandbox]
+      # @return [Sandbox]
+      def acquire
+        sandbox = nil
+        acquired = false
+        begin
+          Thread.handle_interrupt(Object => :never) do
+            sandbox = new(yield)
+          end
+          acquired = true
+        ensure
+          if sandbox && !acquired && sandbox.owns_lifecycle?
+            begin
+              sandbox.stop
+            rescue Microsandbox::Error
+              # best-effort cleanup; the interrupt is what the caller must see
+            end
+          end
+        end
+        sandbox
+      end
+
+      # @api private
+      # Shared keyword-option builder for {create}/{connect_or_create}/
+      # {create_with_progress}. Pure validation and normalization: the callers
+      # provision the runtime ({Microsandbox.ensure_runtime!}) only after this
+      # returns, so a rejected option never triggers a runtime download.
       def build_create_opts(image: nil, cpus: nil, max_cpus: nil, memory: nil, max_memory: nil,
         env: nil, workdir: nil,
         shell: nil, user: nil, hostname: nil, labels: nil, scripts: nil,
@@ -610,7 +679,14 @@ module Microsandbox
         if root_disk && oci_upper_size
           raise ArgumentError, "pass either root_disk: or oci_upper_size:, not both"
         end
-        Microsandbox.ensure_runtime!
+        # The core refuses patches on a snapshot-booted sandbox, but only after
+        # it has claimed the sandbox name on disk. Refuse the pair before any
+        # side effect.
+        if from_snapshot && patches && !Array(patches).empty?
+          raise ArgumentError,
+            "patches: cannot be combined with from_snapshot: (a snapshot restores its own " \
+            "root disk; apply changes after boot with sandbox.fs instead)"
+        end
         # `fstype:` names the inner filesystem of a disk-image rootfs, so it only
         # applies when `image:` is a disk-image path (a local path ending in
         # .raw/.qcow2/.vmdk). Routing an OCI ref (e.g. "python") through the
@@ -692,7 +768,9 @@ module Microsandbox
       # @return [Sandbox]
       def start(name, detached: false)
         Microsandbox.ensure_runtime!
-        new(Native::Sandbox.start(name.to_s, {"detached" => detached}))
+        sandbox_name = name.to_s # outside the interrupt mask, like in {create}
+        opts = {"detached" => detached}
+        acquire { Native::Sandbox.start(sandbox_name, opts) }
       end
 
       # Fetch a controllable handle for a sandbox by name (running or not).
@@ -779,7 +857,16 @@ module Microsandbox
       end
 
       def stringify(hash)
-        hash.each_with_object({}) { |(k, v), acc| acc[k.to_s] = v.to_s }
+        # Anything that converts to pairs is fine (a Hash, ENV, an Array of
+        # pairs). For the rest, name the type, not the value: env values are
+        # often credentials.
+        pairs = begin
+          hash.to_h if hash.respond_to?(:to_h)
+        rescue TypeError
+          nil
+        end
+        raise ArgumentError, "expected a Hash of names to values (got #{hash.class})" unless pairs
+        pairs.each_with_object({}) { |(k, v), acc| acc[k.to_s] = v.to_s }
       end
 
       # Wrap a native page Hash ({"sandboxes" => [...], "next_cursor" => ...})
@@ -844,7 +931,21 @@ module Microsandbox
       # :inject_basic_auth / :inject_query / :inject_body, and :on_violation (see
       # {#normalize_violation}).
       def normalize_secrets(secrets)
-        Array(secrets).map { |spec| normalize_secret(spec) }
+        if secrets.is_a?(Hash)
+          # One spec given bare is fine. A Hash keyed by variable name is the
+          # shape {Sandbox#modify} takes, where `env:` also means something
+          # else (the HOST variable to read); it is not a create-time spec.
+          unless secrets.key?(:env) || secrets.key?("env")
+            raise ArgumentError,
+              "secrets: takes an Array of Hashes like { env:, value:, host: } at create time; " \
+              "the { \"NAME\" => { ... } } form belongs to #modify"
+          end
+          secrets = [secrets]
+        end
+        Array(secrets).map do |spec|
+          raise ArgumentError, "secret spec must be a Hash (got #{spec.class})" unless spec.is_a?(Hash)
+          normalize_secret(spec)
+        end
       end
 
       # @api private
@@ -1409,9 +1510,11 @@ module Microsandbox
       # plain Hash) into string-keyed Hashes for the native layer. Values are
       # passed through unchanged (mode stays Integer, content stays String).
       def normalize_patches(patches)
+        patches = [patches] if patches.is_a?(Hash) # a single patch, not a list of pairs
         Array(patches).map do |p|
           unless p.is_a?(Hash)
-            raise ArgumentError, "patch must be a Hash (use Microsandbox::Patch.*): #{p.inspect}"
+            # Name the type, not the value: a patch can carry file content.
+            raise ArgumentError, "patch must be a Hash (use Microsandbox::Patch.*), got #{p.class}"
           end
           p.each_with_object({}) { |(k, v), acc| acc[k.to_s] = v }
         end
@@ -1957,10 +2060,22 @@ module Microsandbox
 
     # The booted sandbox. Joins the create task (draining any remaining pull
     # progress first), so call it after iterating progress. The returned
-    # {Sandbox} is live — stop it when done. Memoized; callable once.
+    # {Sandbox} is live — stop it when done. Memoized: the native result can be
+    # taken only once, so a later call returns the same {Sandbox}, or re-raises
+    # the same error if the create failed.
+    #
+    # Interrupt-safe like {Sandbox.create}: if a `Timeout.timeout` (or another
+    # `Thread#raise`/`Thread#kill`) arrives while this is waiting, the sandbox
+    # the session produced is stopped before the exception propagates rather
+    # than left running with nothing referring to it. The result is consumed
+    # by then, so a later call raises instead of returning a sandbox.
     # @return [Sandbox]
     def sandbox
-      @sandbox ||= Sandbox.new(@native.result)
+      raise @failure if @failure
+      @sandbox ||= Sandbox.acquire { @native.result }
+    rescue Microsandbox::Error => e
+      @failure ||= e
+      raise
     end
   end
 end

data/lib/microsandbox/snapshot.rb

@@ -92,7 +92,7 @@ module Microsandbox
 
     # @return [Time, nil]
     def created_at
-      @created_at_ms && Time.at(@created_at_ms / 1000.0)
+      Microsandbox.time_from_ms(@created_at_ms)
     end
 
     # Re-open this snapshot's artifact (cheap metadata validation), returning a

data/lib/microsandbox/ssh.rb

@@ -173,11 +173,7 @@ module Microsandbox
       session = SftpClient.new(@native.sftp)
       return session unless block_given?
 
-      begin
-        yield session
-      ensure
-        session.close
-      end
+      Microsandbox.close_after(session) { yield session }
     end
 
     # Close the SSH client session. Idempotent. Sends the graceful protocol
@@ -245,11 +241,7 @@ module Microsandbox
       client = SshClient.new(@native.ssh_open_client(opts))
       return client unless block_given?
 
-      begin
-        yield client
-      ensure
-        client.close
-      end
+      Microsandbox.close_after(client) { yield client }
     end
 
     # Prepare a reusable SSH server endpoint for the sandbox.

data/lib/microsandbox/streams.rb

@@ -2,17 +2,20 @@
 
 module Microsandbox
   # A live stream of {LogEntry}s, returned by {Sandbox#log_stream}. Enumerable:
-  # iterate to consume entries as they are appended. With `follow: true` the
-  # iteration blocks for new entries until the sandbox stops; otherwise it ends
-  # once the historical log is drained.
+  # iterate to consume entries as they are appended. Without `follow:` the
+  # iteration ends once the historical log is drained. With `follow: true` it
+  # keeps waiting for new entries and does NOT end when the sandbox stops: the
+  # runtime follows the log file, not the sandbox, and there is no way to
+  # cancel the wait.
   #
   # @note **Single-pass, forward-only, single-consumer.** `each` drains a
   #   one-shot native channel, so it is *not* rewindable: a second `each` — or
   #   any `Enumerable` combinator after a partial drain (`to_a` twice, `count`
   #   then `each`, `first(n)` then `each`) — silently yields nothing. Iterate
   #   exactly once, from one thread. With `follow: true`, `each` blocks the
-  #   calling thread uninterruptibly until the sandbox stops (see DESIGN.md on
-  #   GVL release).
+  #   calling thread uninterruptibly and indefinitely (see DESIGN.md on GVL
+  #   release); a thread blocked there also keeps the process from exiting
+  #   normally, so follow from a process you are prepared to kill.
   #
   # @example
   #   sb.log_stream(follow: true).each { |entry| print entry.text }

data/lib/microsandbox/version.rb

@@ -8,7 +8,7 @@ module Microsandbox
   # Versioning section of the README for the full gem-to-runtime map. Must equal
   # the native ext's Cargo crate version (`Native.version`), enforced by
   # spec/unit/version_spec.rb.
-  VERSION = "0.17.0"
+  VERSION = "0.17.2"
 
   # The upstream microsandbox runtime release this gem build embeds — the `tag`
   # pinned on the `microsandbox`/`microsandbox-network` git deps in

data/lib/microsandbox/volume.rb

@@ -38,7 +38,7 @@ module Microsandbox
 
     # @return [Time, nil]
     def created_at
-      @created_at_ms && Time.at(@created_at_ms / 1000.0)
+      Microsandbox.time_from_ms(@created_at_ms)
     end
 
     # A host-side filesystem view over this volume (read/write its contents
@@ -55,8 +55,10 @@ module Microsandbox
 
   # A host-side filesystem view over a named volume, from {Volume.fs} or
   # {VolumeInfo#fs}. Reads and writes the volume's contents directly on the host,
-  # without booting a sandbox. All paths are relative to the volume root. Mirrors
-  # the `VolumeFs` of the official Python/Node SDKs.
+  # without booting a sandbox. All paths are relative to the volume root (a
+  # leading `/` is the volume root) and may not contain a `..` segment — every
+  # operation raises {FilesystemError} for one. Mirrors the `VolumeFs` of the
+  # official Python/Node SDKs.
   class VolumeFs
     def initialize(native)
       @native = native
@@ -65,13 +67,13 @@ module Microsandbox
     # Read a file as raw bytes (ASCII-8BIT).
     # @return [String]
     def read(path)
-      @native.read(path.to_s)
+      @native.read(contained(path))
     end
 
     # Read a file as a UTF-8 string.
     # @return [String]
     def read_text(path)
-      @native.read_text(path.to_s)
+      @native.read_text(contained(path))
     end
 
     # Write data to a file, creating parent directories as needed.
@@ -80,60 +82,75 @@ module Microsandbox
     # @return [nil]
     def write(path, data)
       bytes = Microsandbox.coerce_write_bytes(data)
-      @native.write(path.to_s, bytes)
+      @native.write(contained(path), bytes)
       nil
     end
 
     # List the entries of a directory.
     # @return [Array<FsEntry>]
     def list(path)
-      @native.list(path.to_s).map { |entry| FsEntry.new(entry) }
+      @native.list(contained(path)).map { |entry| FsEntry.new(entry) }
     end
 
     # Create a directory (and any missing parents).
     # @return [nil]
     def mkdir(path)
-      @native.mkdir(path.to_s)
+      @native.mkdir(contained(path))
       nil
     end
 
     # Remove a single file.
     # @return [nil]
     def remove_file(path)
-      @native.remove_file(path.to_s)
+      @native.remove_file(contained(path))
       nil
     end
 
     # Remove a directory recursively.
     # @return [nil]
     def remove_dir(path)
-      @native.remove_dir(path.to_s)
+      @native.remove_dir(contained(path))
       nil
     end
 
     # @return [Boolean] whether the path exists in the volume
     def exists?(path)
-      @native.exists(path.to_s)
+      @native.exists(contained(path))
     end
 
     # Copy a file within the volume.
     # @return [nil]
     def copy(src, dst)
-      @native.copy(src.to_s, dst.to_s)
+      @native.copy(contained(src), contained(dst))
       nil
     end
 
     # Rename/move a file or directory within the volume.
     # @return [nil]
     def rename(src, dst)
-      @native.rename(src.to_s, dst.to_s)
+      @native.rename(contained(src), contained(dst))
       nil
     end
 
     # Stat a path.
     # @return [FsMetadata]
     def stat(path)
-      FsMetadata.new(@native.stat(path.to_s))
+      FsMetadata.new(@native.stat(contained(path)))
+    end
+
+    private
+
+    # Volume paths are relative to the volume root and never need a `..`
+    # segment, so one is refused here with a clear message instead of being
+    # handed to the resolver. The native layer enforces the same rule; this
+    # check only exists so the error names the cause.
+    def contained(path)
+      s = path.to_s
+      if s.split("/").include?("..")
+        raise Microsandbox::FilesystemError,
+          "path traversal outside volume root (`..` segments are not allowed in volume paths)"
+      end
+      s
     end
   end
 

data/lib/microsandbox-rb.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Entry point named after the gem. `require "microsandbox"` resolves to
+# whichever installed gem ships that file first, and the separate
+# `microsandbox` gem on RubyGems ships one too; outside Bundler,
+# `require "microsandbox-rb"` always loads this gem.
+require_relative "microsandbox"

data/lib/microsandbox.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "monitor"
+
 require_relative "microsandbox/version"
 
 # Load the compiled native extension. Precompiled platform gems stage the
@@ -47,6 +49,13 @@ require_relative "microsandbox/sandbox"
 #     puts sb.exec("python", ["-c", "print('Hello, World!')"]).stdout
 #   end
 module Microsandbox
+  # Serializes runtime provisioning within this process: {install}, {setup} and
+  # the first-use check in {ensure_runtime!}. The installer replaces files in
+  # place, so two threads racing through a first `Sandbox.create` must not both
+  # run it. A Monitor (re-entrant) because ensure_runtime! calls install.
+  RUNTIME_SETUP_LOCK = Monitor.new
+  private_constant :RUNTIME_SETUP_LOCK
+
   class << self
     # @return [String] the gem version
     def version
@@ -74,7 +83,7 @@ module Microsandbox
     # gem supplies the runtime.
     # @return [nil]
     def install
-      Native.install
+      RUNTIME_SETUP_LOCK.synchronize { Native.install }
       nil
     end
 
@@ -93,7 +102,7 @@ module Microsandbox
       opts["version"] = version.to_s if version
       opts["force"] = true if force
       opts["skip_verify"] = true if skip_verify
-      Native.setup(opts)
+      RUNTIME_SETUP_LOCK.synchronize { Native.setup(opts) }
       nil
     end
 
@@ -130,34 +139,38 @@ module Microsandbox
     # @return [nil]
     def ensure_runtime!
       return if @runtime_ready
-      # A cloud backend has no local msb/libkrunfw runtime to provision: skip the
-      # presence check and the first-use download entirely. Resolving the kind
-      # uses the same lazy env/profile/config ladder every operation already
-      # consults, so this adds no work for local hosts (the common case).
-      return if default_backend_kind == :cloud
-      # The binaries gem won the resolver: its vendored msb (and the libkrunfw
-      # beside it) are exactly the version this gem was built for, so there is
-      # nothing to verify or download. (If `MSB_PATH` overrides it, the user owns
-      # the runtime and we fall through to the existing behaviour.)
-      if bundled_runtime_active?
-        @runtime_ready = true
-        return
-      end
-      # Opted out: the caller manages the runtime out of band, so don't fetch,
-      # verify, or repair it here. Memoize the decision (the env var is stable for
-      # the process); the operation resolves `msb` itself and surfaces any problem.
-      if auto_install_disabled?
-        @runtime_ready = true
-        return
-      end
+      RUNTIME_SETUP_LOCK.synchronize do
+        # Re-check under the lock: another thread may have finished meanwhile.
+        return if @runtime_ready
+        # A cloud backend has no local msb/libkrunfw runtime to provision: skip the
+        # presence check and the first-use download entirely. Resolving the kind
+        # uses the same lazy env/profile/config ladder every operation already
+        # consults, so this adds no work for local hosts (the common case).
+        return if default_backend_kind == :cloud
+        # The binaries gem won the resolver: its vendored msb (and the libkrunfw
+        # beside it) are exactly the version this gem was built for, so there is
+        # nothing to verify or download. (If `MSB_PATH` overrides it, the user owns
+        # the runtime and we fall through to the existing behaviour.)
+        if bundled_runtime_active?
+          @runtime_ready = true
+          return
+        end
+        # Opted out: the caller manages the runtime out of band, so don't fetch,
+        # verify, or repair it here. Memoize the decision (the env var is stable for
+        # the process); the operation resolves `msb` itself and surfaces any problem.
+        if auto_install_disabled?
+          @runtime_ready = true
+          return
+        end
 
-      unless installed?
-        warn "[microsandbox] runtime (msb + libkrunfw) not found; " \
-             "downloading to ~/.microsandbox (set MICROSANDBOX_NO_AUTO_INSTALL to skip, " \
-             "or install the microsandbox-rb-binaries gem to ship it with your bundle)..."
+        unless installed?
+          warn "[microsandbox] runtime (msb + libkrunfw) not found; " \
+               "downloading to ~/.microsandbox (set MICROSANDBOX_NO_AUTO_INSTALL to skip, " \
+               "or install the microsandbox-rb-binaries gem to ship it with your bundle)..."
+        end
+        install
+        @runtime_ready = true
       end
-      install
-      @runtime_ready = true
       nil
     end
 
@@ -176,7 +189,9 @@ module Microsandbox
     # setter is a no-op — use `MSB_PATH` to override a bundled runtime.
     # @param path [String]
     # @return [void]
+    # @raise [ArgumentError] for nil or an empty path (the slot cannot be cleared)
     def runtime_path=(path)
+      require_runtime_path!(:runtime_path=, path)
       if @bundled_msb_path && path.to_s != @bundled_msb_path
         warn "[microsandbox] runtime_path= ignored: the microsandbox-rb-binaries gem already " \
              "claimed the set-once SDK slot (#{@bundled_msb_path}); set MSB_PATH to override it"
@@ -190,7 +205,9 @@ module Microsandbox
     # Mirrors {runtime_path=} for libkrunfw.
     # @param path [String]
     # @return [void]
+    # @raise [ArgumentError] for nil or an empty path (the slot cannot be cleared)
     def libkrunfw_path=(path)
+      require_runtime_path!(:libkrunfw_path=, path)
       Native.set_runtime_libkrunfw_path(path.to_s)
     end
 
@@ -272,6 +289,36 @@ module Microsandbox
         raise TypeError, "data must be a String (got #{data.class})"
     end
 
+    # A Time for an epoch-milliseconds Integer from the native layer, or nil.
+    # Integer arithmetic on purpose: `Time.at(ms / 1000.0)` goes through a
+    # Float and lands one millisecond low for about half of all timestamps.
+    # @api private
+    # @param ms [Integer, nil]
+    # @return [Time, nil]
+    def time_from_ms(ms)
+      ms && Time.at(ms.div(1000), ms % 1000, :millisecond)
+    end
+
+    # Run the block, then close +resource+ — the shared tail of the block forms
+    # that own a resource whose close can fail (a write sink flushes on close).
+    # If the block raised, its exception is the one the caller needs: a failure
+    # from the close that follows is dropped instead of replacing it. If the
+    # block finished (or left via break/throw), a close failure propagates.
+    # @api private
+    def close_after(resource)
+      raised = false
+      yield
+    rescue Exception # standard:disable Lint/RescueException -- re-raised unchanged
+      raised = true
+      raise
+    ensure
+      begin
+        resource.close
+      rescue
+        raise unless raised
+      end
+    end
+
     private
 
     # Auto-provisioning is on by default; any non-empty, non-"0"/"false" value
@@ -358,12 +405,22 @@ module Microsandbox
     private_constant :TRUSTED_BINARIES_OWNERS
 
     # Name of the loaded gem whose files define Microsandbox::Binaries, or nil
-    # when it came from a bare load path.
+    # when it came from a bare load path. Gem roots can nest — a host project
+    # that is itself a gem, with its bundle installed under the project
+    # directory, is a prefix of every gem in that bundle — so the owner is the
+    # gem with the LONGEST matching root, not whichever one is listed first.
     def bundled_runtime_owner
       source = Binaries.method(:msb_path).source_location&.first
       return nil unless source
-      spec = Gem.loaded_specs.values.find { |s| source.start_with?(File.join(s.full_gem_path, "")) }
-      spec&.name
+      roots = Gem.loaded_specs.values.select { |s| source.start_with?(File.join(s.full_gem_path, "")) }
+      roots.max_by { |s| s.full_gem_path.length }&.name
+    end
+
+    # The runtime path slots are set-once in the core and have no "unset": nil
+    # or "" would be stored as an empty path for the rest of the process.
+    def require_runtime_path!(setter, path)
+      return unless path.nil? || path.to_s.empty?
+      raise ArgumentError, "#{setter} needs a non-empty path (the slot is set-once and cannot be cleared)"
     end
 
     # Whether the binaries gem's msb is what the resolver actually returns — i.e.