scint 0.7.0 → 0.7.1

data/lib/scint/fs.rb

@@ -21,28 +21,75 @@ module Scint
       @mkdir_mutex.synchronize { @mkdir_cache[path] = true }
     end
 
+    # Detect best file copy strategy once per process.
+    # Returns :reflink, :hardlink, or :copy.
+    @copy_strategy = nil
+    @copy_strategy_mutex = Thread::Mutex.new
+
+    def detect_copy_strategy(src_dir, dst_dir)
+      @copy_strategy_mutex.synchronize do
+        return @copy_strategy if @copy_strategy
+
+        @copy_strategy = _probe_copy_strategy(src_dir, dst_dir)
+      end
+    end
+
+    def _probe_copy_strategy(src_dir, dst_dir)
+      # Create a temp file in src to test against dst
+      probe_src = File.join(src_dir, ".scint_probe_#{$$}")
+      probe_dst = File.join(dst_dir, ".scint_probe_#{$$}")
+      begin
+        File.write(probe_src, "x")
+        mkdir_p(dst_dir)
+
+        if Platform.macos?
+          if system("cp", "-c", probe_src, probe_dst, [:out, :err] => File::NULL)
+            return :reflink
+          end
+          File.delete(probe_dst) if File.exist?(probe_dst)
+        elsif Platform.linux?
+          if system("cp", "--reflink=always", probe_src, probe_dst, [:out, :err] => File::NULL)
+            return :reflink
+          end
+          File.delete(probe_dst) if File.exist?(probe_dst)
+        end
+
+        begin
+          File.link(probe_src, probe_dst)
+          return :hardlink
+        rescue SystemCallError
+          File.delete(probe_dst) if File.exist?(probe_dst)
+        end
+
+        :copy
+      ensure
+        File.delete(probe_src) if File.exist?(probe_src)
+        File.delete(probe_dst) if File.exist?(probe_dst)
+      end
+    rescue StandardError
+      :copy
+    end
+
     # APFS clonefile (CoW copy). Falls back to hardlink, then regular copy.
     def clonefile(src, dst)
       src = src.to_s
       dst = dst.to_s
       mkdir_p(File.dirname(dst))
 
-      # Try APFS clonefile via cp -c (macOS)
-      if Platform.macos?
-        return if system("cp", "-c", src, dst, [:out, :err] => File::NULL)
-      end
-
-      # Try Linux reflink copy-on-write where supported (btrfs/xfs/etc).
-      if Platform.linux?
-        return if system("cp", "--reflink=always", src, dst, [:out, :err] => File::NULL)
-      end
-
-      # Fallback: hardlink
-      begin
-        File.link(src, dst)
-        return
-      rescue SystemCallError
-        # cross-device or unsupported
+      case detect_copy_strategy(File.dirname(src), File.dirname(dst))
+      when :reflink
+        if Platform.macos?
+          return if system("cp", "-c", src, dst, [:out, :err] => File::NULL)
+        elsif Platform.linux?
+          return if system("cp", "--reflink=always", src, dst, [:out, :err] => File::NULL)
+        end
+      when :hardlink
+        begin
+          File.link(src, dst)
+          return
+        rescue SystemCallError
+          # fall through to copy
+        end
       end
 
       # Final fallback: regular copy
@@ -58,21 +105,117 @@ module Scint
       raise Errno::ENOENT, src_dir unless Dir.exist?(src_dir)
       mkdir_p(dst_dir)
 
-      # Fast path on macOS/APFS: copy-on-write clone of full tree.
-      if Platform.macos?
-        src_contents = File.join(src_dir, ".")
-        return if system("cp", "-cR", src_contents, dst_dir, [:out, :err] => File::NULL)
-      end
+      strategy = detect_copy_strategy(src_dir, dst_dir)
 
-      # Fast path on Linux filesystems with reflink support.
-      if Platform.linux?
+      if strategy == :reflink
         src_contents = File.join(src_dir, ".")
-        return if system("cp", "--reflink=always", "-R", src_contents, dst_dir, [:out, :err] => File::NULL)
+        if Platform.macos?
+          return if system("cp", "-cR", src_contents, dst_dir, [:out, :err] => File::NULL)
+        elsif Platform.linux?
+          return if system("cp", "--reflink=always", "-R", src_contents, dst_dir, [:out, :err] => File::NULL)
+        end
       end
 
       hardlink_tree(src_dir, dst_dir)
     end
 
+    # Materialize a tree using a manifest to avoid directory scans.
+    # Manifest entries must be hashes with "path" and "type" keys.
+    # Uses the fastest available file copy strategy (reflink > hardlink > copy).
+    def materialize_from_manifest(src_dir, dst_dir, entries)
+      src_dir = src_dir.to_s
+      dst_dir = dst_dir.to_s
+      entries = Array(entries)
+      raise Errno::ENOENT, src_dir unless Dir.exist?(src_dir)
+      mkdir_p(dst_dir)
+
+      strategy = detect_copy_strategy(src_dir, dst_dir)
+
+      entries.each do |entry|
+        rel = entry["path"].to_s
+        next if rel.empty? || rel.start_with?("/") || rel.include?("..")
+
+        src_path = File.join(src_dir, rel)
+        dst_path = File.join(dst_dir, rel)
+
+        case entry["type"]
+        when "dir"
+          mkdir_p(dst_path)
+        when "symlink"
+          mkdir_p(File.dirname(dst_path))
+          next if File.exist?(dst_path) || File.symlink?(dst_path)
+
+          target = File.readlink(src_path)
+          begin
+            File.symlink(target, dst_path)
+          rescue Errno::EEXIST
+            next
+          end
+        else
+          mkdir_p(File.dirname(dst_path))
+          next if File.exist?(dst_path)
+
+          begin
+            _link_or_copy(src_path, dst_path, strategy)
+          rescue Errno::EEXIST
+            next
+          rescue SystemCallError
+            next if File.exist?(dst_path)
+            raise
+          end
+        end
+      end
+    end
+
+    # Fast file link/copy using a pre-detected strategy (no per-file probing).
+    def _link_or_copy(src, dst, strategy)
+      case strategy
+      when :reflink
+        if Platform.macos?
+          return if system("cp", "-c", src, dst, [:out, :err] => File::NULL)
+        elsif Platform.linux?
+          return if system("cp", "--reflink=always", src, dst, [:out, :err] => File::NULL)
+        end
+        # reflink failed for this file, try hardlink
+        begin
+          File.link(src, dst)
+          return
+        rescue SystemCallError; end
+        FileUtils.cp(src, dst)
+      when :hardlink
+        begin
+          File.link(src, dst)
+          return
+        rescue SystemCallError; end
+        FileUtils.cp(src, dst)
+      else
+        FileUtils.cp(src, dst)
+      end
+    end
+
+    LINKER_SCRIPT = File.expand_path("linker.sh", __dir__).freeze
+
+    # Bulk-link cached gem directories into dst_parent.
+    # Opens one helper process (linker.sh) and writes gem basenames to its
+    # stdin. The helper probes the fastest FS strategy once then applies it
+    # to every gem.
+    def bulk_link_gems(src_parent, dst_parent, gem_names)
+      src_parent = src_parent.to_s
+      dst_parent = dst_parent.to_s
+      gem_names = Array(gem_names)
+      return 0 if gem_names.empty?
+
+      mkdir_p(dst_parent)
+
+      IO.popen(["/bin/bash", LINKER_SCRIPT], "w") do |io|
+        io.puts src_parent
+        io.puts dst_parent
+        gem_names.each { |name| io.puts name }
+      end
+
+      gem_names.size
+    end
+
     # Clone many source directories into one destination parent directory.
     # This is significantly faster than one process per gem on large warm
     # installs because it batches cp invocations while preserving CoW/reflink.
@@ -86,6 +229,8 @@ module Scint
       return 0 if sources.empty?
 
       copied = 0
+      strategy = sources.first ? detect_copy_strategy(sources.first, dst_parent) : :copy
+
       sources.each_slice([chunk_size.to_i, 1].max) do |slice|
         pending = slice.reject do |src|
           Dir.exist?(File.join(dst_parent, File.basename(src)))
@@ -93,10 +238,12 @@ module Scint
         next if pending.empty?
 
         ok = false
-        if Platform.macos?
-          ok = system("cp", "-cR", *pending, dst_parent, [:out, :err] => File::NULL)
-        elsif Platform.linux?
-          ok = system("cp", "--reflink=always", "-R", *pending, dst_parent, [:out, :err] => File::NULL)
+        if strategy == :reflink
+          if Platform.macos?
+            ok = system("cp", "-cR", *pending, dst_parent, [:out, :err] => File::NULL)
+          elsif Platform.linux?
+            ok = system("cp", "--reflink=always", "-R", *pending, dst_parent, [:out, :err] => File::NULL)
+          end
         end
 
         unless ok

data/lib/scint/gem/package.rb

@@ -17,7 +17,9 @@ module Scint
           tar.each do |entry|
             if entry.full_name == "metadata.gz"
               gz = Zlib::GzipReader.new(StringIO.new(entry.read))
-              return ::Gem::Specification.from_yaml(gz.read)
+              yaml = gz.read
+              yaml.force_encoding("UTF-8") if yaml.encoding == Encoding::US_ASCII
+              return ::Gem::Specification.from_yaml(yaml)
             end
           end
         end
@@ -38,7 +40,9 @@ module Scint
             case entry.full_name
             when "metadata.gz"
               gz = Zlib::GzipReader.new(StringIO.new(entry.read))
-              gemspec = ::Gem::Specification.from_yaml(gz.read)
+              yaml = gz.read
+              yaml.force_encoding("UTF-8") if yaml.encoding == Encoding::US_ASCII
+              gemspec = ::Gem::Specification.from_yaml(yaml)
             when "data.tar.gz"
               # Write data.tar.gz to a temp file for extraction
               tmp = File.join(dest_dir, ".data.tar.gz.tmp")

data/lib/scint/gemfile/parser.rb

@@ -6,7 +6,7 @@ require_relative "../source/path"
 module Scint
   module Gemfile
     # Result of parsing a Gemfile.
-    ParseResult = Struct.new(:dependencies, :sources, :ruby_version, :platforms, keyword_init: true)
+    ParseResult = Struct.new(:dependencies, :sources, :ruby_version, :platforms, :optional_groups, keyword_init: true)
 
     # Evaluates a Gemfile using instance_eval, just like stock bundler.
     # Supports the full Gemfile DSL: source, gem, group, platforms, git_source,
@@ -20,14 +20,16 @@ module Scint
           sources: parser.parsed_sources.uniq,
           ruby_version: parser.parsed_ruby_version,
           platforms: parser.parsed_platforms,
+          optional_groups: parser.parsed_optional_groups,
         )
       end
 
       # Accessors that don't collide with DSL method names
-      def parsed_dependencies;  @dependencies;  end
-      def parsed_sources;       @sources;       end
-      def parsed_ruby_version;  @ruby_version;  end
-      def parsed_platforms;     @declared_platforms; end
+      def parsed_dependencies;    @dependencies;      end
+      def parsed_sources;         @sources;           end
+      def parsed_ruby_version;    @ruby_version;      end
+      def parsed_platforms;       @declared_platforms; end
+      def parsed_optional_groups; @optional_groups;   end
 
       def initialize(gemfile_path)
         @gemfile_path = File.expand_path(gemfile_path)
@@ -39,6 +41,7 @@ module Scint
         @current_source_options = {}
         @ruby_version = nil
         @declared_platforms = []
+        @optional_groups = []
 
         add_default_git_sources
       end
@@ -167,7 +170,11 @@ module Scint
 
       def group(*names, **opts, &blk)
         old_groups = @current_groups.dup
-        @current_groups.concat(names.map(&:to_sym))
+        group_syms = names.map(&:to_sym)
+        @current_groups.concat(group_syms)
+        if opts[:optional]
+          group_syms.each { |g| @optional_groups << g unless @optional_groups.include?(g) }
+        end
         yield
       ensure
         @current_groups = old_groups

data/lib/scint/installer/extension_builder.rb

@@ -11,24 +11,21 @@ module Scint
     module ExtensionBuilder
       module_function
 
+      BUILD_MARKER = ".scint.build_complete"
+
       # Build native extensions for a prepared gem.
       # prepared_gem: PreparedGem struct
       # bundle_path:  .bundle/ root
       # abi_key:      e.g. "ruby-3.3.0-arm64-darwin24" (defaults to Platform.abi_key)
       def build(prepared_gem, bundle_path, cache_layout, abi_key: Platform.abi_key, compile_slots: 1, output_tail: nil)
         spec = prepared_gem.spec
-        ruby_dir = Platform.ruby_install_dir(bundle_path)
         build_ruby_dir = cache_layout.install_ruby_dir
+        src_dir = prepared_gem.extracted_path
 
-        # Check global extension cache first
-        cached_ext = cache_layout.ext_path(spec, abi_key)
-        if Dir.exist?(cached_ext) && File.exist?(File.join(cached_ext, "gem.build_complete"))
-          link_extensions(cached_ext, ruby_dir, spec, abi_key)
-          return true
-        end
+        marker = build_marker_path(src_dir)
+        return true if File.exist?(marker)
 
-        # Build in a temp dir, then cache
-        src_dir = prepared_gem.extracted_path
+        # Build in a temp dir, then sync artifacts into the source tree.
         FS.with_tempdir("scint-ext") do |tmpdir|
           # Stage the full gem source tree in an isolated workspace.
           # Many extconf scripts use paths like ../../vendor relative to ext/,
@@ -53,34 +50,24 @@ module Scint
             compile_extension(ext_dir, ext_build_dir, install_dir, staged_src_dir, spec, build_ruby_dir, compile_slots, output_tail)
           end
 
-          # Write marker
-          File.write(File.join(install_dir, "gem.build_complete"), "")
-
-          # Cache globally
-          FS.mkdir_p(File.dirname(cached_ext))
-          FS.atomic_move(install_dir, cached_ext)
+          sync_extensions_into_gem(install_dir, src_dir)
         end
 
-        link_extensions(cached_ext, ruby_dir, spec, abi_key)
+        File.write(marker, "")
         true
       end
 
       # True when a completed global extension build exists for this spec + ABI.
       def cached_build_available?(spec, cache_layout, abi_key: Platform.abi_key)
-        cached_ext = cache_layout.ext_path(spec, abi_key)
-        Dir.exist?(cached_ext) && File.exist?(File.join(cached_ext, "gem.build_complete"))
+        cached_dir = cache_layout.cached_path(spec, abi_key)
+        File.exist?(build_marker_path(cached_dir))
       end
 
-      # Link already-compiled extensions from global cache into bundle_path.
-      # Returns true when cache was present and linked, false otherwise.
-      def link_cached_build(prepared_gem, bundle_path, cache_layout, abi_key: Platform.abi_key)
+      # Link already-compiled extensions from the cached gem tree.
+      # Returns true when cache marker is present, false otherwise.
+      def link_cached_build(prepared_gem, _bundle_path, cache_layout, abi_key: Platform.abi_key)
         spec = prepared_gem.spec
-        return false unless cached_build_available?(spec, cache_layout, abi_key: abi_key)
-
-        ruby_dir = Platform.ruby_install_dir(bundle_path)
-        cached_ext = cache_layout.ext_path(spec, abi_key)
-        link_extensions(cached_ext, ruby_dir, spec, abi_key)
-        true
+        cached_build_available?(spec, cache_layout, abi_key: abi_key)
       end
 
       # True when a gem has native extension sources that need compiling.
@@ -235,22 +222,29 @@ module Scint
                                     Platform.gem_arch, Platform.extension_api_version,
                                     spec_full_name(spec))
         FS.clone_tree(cached_ext, ext_install_dir) unless Dir.exist?(ext_install_dir)
-        sync_extension_artifacts_into_gem(ext_install_dir, ruby_dir, spec)
+        gem_dir = File.join(ruby_dir, "gems", spec_full_name(spec))
+        sync_extensions_into_gem(cached_ext, gem_dir)
       end
 
-      def sync_extension_artifacts_into_gem(ext_install_dir, ruby_dir, spec)
-        gem_dir = File.join(ruby_dir, "gems", spec_full_name(spec))
+      # Sync compiled extension artifacts into a gem's lib directory.
+      # source_dir should contain the compiled artifacts (from build output
+      # or a cached gem tree).
+      def sync_extensions_into_gem(cached_ext, gem_dir)
         lib_dir = File.join(gem_dir, "lib")
-        return unless Dir.exist?(lib_dir)
+        FS.mkdir_p(lib_dir)
 
-        Dir.glob(File.join(ext_install_dir, "**", "*.{so,bundle,dll,dylib}")).each do |artifact|
-          rel = artifact.delete_prefix("#{ext_install_dir}/")
+        Dir.glob(File.join(cached_ext, "**", "*.{so,bundle,dll,dylib}")).each do |artifact|
+          rel = artifact.delete_prefix("#{cached_ext}/")
           dest = File.join(lib_dir, rel)
           FS.mkdir_p(File.dirname(dest))
           FS.clonefile(artifact, dest)
         end
       end
 
+      def build_marker_path(gem_dir)
+        File.join(gem_dir, BUILD_MARKER)
+      end
+
       def build_env(gem_dir, build_ruby_dir, make_jobs)
         ruby_bin = File.join(build_ruby_dir, "bin")
         path = [ruby_bin, ENV["PATH"]].compact.reject(&:empty?).join(File::PATH_SEPARATOR)
@@ -292,6 +286,7 @@ module Scint
 
         Open3.popen2e(env, *cmd, **opts) do |stdin, out_err, wait_thr|
           stdin.close
+          out_err.set_encoding("ASCII-8BIT")
 
           out_err.each_line do |line|
             stripped = line.rstrip
@@ -322,7 +317,7 @@ module Scint
 
       private_class_method :find_extension_dirs, :compile_extension,
                            :compile_extconf, :compile_cmake, :compile_rake,
-                           :find_rake_executable, :link_extensions, :sync_extension_artifacts_into_gem,
+                           :find_rake_executable, :link_extensions,
                            :build_env, :run_cmd, :prebuilt_missing_for_ruby?
     end
   end

data/lib/scint/installer/linker.rb

@@ -3,6 +3,8 @@
 require_relative "../fs"
 require_relative "../platform"
 require_relative "../spec_utils"
+require_relative "../cache/layout"
+require_relative "../cache/validity"
 require "pathname"
 
 module Scint
@@ -34,7 +36,7 @@ module Scint
         # 1. Link gem files into gems/{full_name}/
         gem_dest = File.join(ruby_dir, "gems", full_name)
         unless Dir.exist?(gem_dest)
-          FS.clone_tree(prepared_gem.extracted_path, gem_dest)
+          materialize_gem_dir(prepared_gem, gem_dest)
         end
 
         # 2. Write gemspec into specifications/
@@ -60,6 +62,44 @@ module Scint
 
       # --- private helpers ---
 
+      def materialize_gem_dir(prepared_gem, gem_dest)
+        manifest = cached_manifest_for(prepared_gem)
+        if manifest && manifest["files"].is_a?(Array)
+          FS.materialize_from_manifest(prepared_gem.extracted_path, gem_dest, manifest["files"])
+        else
+          FS.clone_tree(prepared_gem.extracted_path, gem_dest)
+        end
+      end
+
+      def cached_manifest_for(prepared_gem)
+        return nil unless prepared_gem.from_cache
+
+        layout = cache_layout_for(prepared_gem)
+        cached_path = layout.cached_path(prepared_gem.spec)
+        return nil unless File.expand_path(prepared_gem.extracted_path) == File.expand_path(cached_path)
+
+        manifest = Cache::Validity.read_manifest(layout.cached_manifest_path(prepared_gem.spec))
+        return nil unless manifest
+        return nil unless Cache::Validity.manifest_matches?(manifest, prepared_gem.spec, Platform.abi_key, layout)
+
+        manifest
+      rescue StandardError
+        nil
+      end
+
+      def cache_layout_for(prepared_gem)
+        extracted = File.expand_path(prepared_gem.extracted_path)
+        abi_dir = File.dirname(extracted)
+        cached_dir = File.dirname(abi_dir)
+        root = File.dirname(cached_dir)
+
+        if File.basename(abi_dir) == Platform.abi_key && File.basename(cached_dir) == "cached"
+          Cache::Layout.new(root: root)
+        else
+          Cache::Layout.new
+        end
+      end
+
       def write_gemspec(prepared_gem, ruby_dir, full_name)
         spec_dir = File.join(ruby_dir, "specifications")
         FS.mkdir_p(spec_dir)
@@ -201,7 +241,8 @@ module Scint
         RUBY
       end
 
-      private_class_method :write_gemspec, :write_binstubs_impl, :write_ruby_bin_stub,
+      private_class_method :materialize_gem_dir, :cached_manifest_for, :cache_layout_for,
+                           :write_gemspec, :write_binstubs_impl, :write_ruby_bin_stub,
                            :write_bundle_bin_wrapper, :extract_executables,
                            :detect_executables_from_files, :augment_executable_metadata, :infer_bindir,
                            :minimal_gemspec

data/lib/scint/installer/planner.rb

@@ -2,6 +2,7 @@
 
 require_relative "extension_builder"
 require_relative "../platform"
+require_relative "../cache/validity"
 
 module Scint
   module Installer
@@ -12,16 +13,16 @@ module Scint
       # Compare resolved specs against what's already installed.
       # Returns an Array of PlanEntry with action set to one of:
       #   :skip      — already installed in bundle_path
-      #   :link      — extracted in global cache, just needs linking
+      #   :link      — cached in global cache, just needs linking
       #   :download  — needs downloading from remote
       #   :build_ext — has native extensions that need compiling
       #
       # Download entries are sorted largest-first so big gems start early,
       # keeping the pipeline saturated while small gems fill in gaps.
-      def plan(resolved_specs, bundle_path, cache_layout)
+      def plan(resolved_specs, bundle_path, cache_layout, telemetry: nil)
         ruby_dir = Platform.ruby_install_dir(bundle_path)
         entries = resolved_specs.map do |spec|
-          plan_one(spec, ruby_dir, cache_layout)
+          plan_one(spec, ruby_dir, cache_layout, telemetry: telemetry)
         end
 
         # Keep built-ins first, then downloads (big->small), then the rest.
@@ -32,7 +33,7 @@ module Scint
         builtins + downloads + rest
       end
 
-      def plan_one(spec, ruby_dir, cache_layout)
+      def plan_one(spec, ruby_dir, cache_layout, telemetry: nil)
         full = cache_layout.full_name(spec)
         gem_path = File.join(ruby_dir, "gems", full)
         spec_path = File.join(ruby_dir, "specifications", "#{full}.gemspec")
@@ -48,10 +49,12 @@ module Scint
 
         # Already installed? Require both gem files and specification.
         if Dir.exist?(gem_path) && File.exist?(spec_path)
-          if extension_link_missing?(spec, ruby_dir, cache_layout)
-            extracted = cache_layout.extracted_path(spec)
+          cache_source = Cache::Validity.source_path_for(spec, cache_layout, telemetry: telemetry)
+          if extension_link_missing?(spec, ruby_dir, cache_layout, cache_source)
             action = ExtensionBuilder.cached_build_available?(spec, cache_layout) ? :link : :build_ext
-            return PlanEntry.new(spec: spec, action: action, cached_path: extracted, gem_path: gem_path)
+            return PlanEntry.new(spec: spec, action: action, cached_path: cache_source, gem_path: gem_path) if cache_source
+
+            return PlanEntry.new(spec: spec, action: :download, cached_path: nil, gem_path: gem_path)
           end
 
           return PlanEntry.new(spec: spec, action: :skip, cached_path: nil, gem_path: gem_path)
@@ -64,39 +67,32 @@ module Scint
           return PlanEntry.new(spec: spec, action: action, cached_path: local_source, gem_path: gem_path)
         end
 
-        # Extracted in global cache?
-        extracted = cache_layout.extracted_path(spec)
-        if Dir.exist?(extracted)
-          action = needs_ext_build?(spec, cache_layout) ? :build_ext : :link
-          return PlanEntry.new(spec: spec, action: action, cached_path: extracted, gem_path: gem_path)
+        cache_source = Cache::Validity.source_path_for(spec, cache_layout, telemetry: telemetry)
+        if cache_source
+          action = needs_ext_build?(spec, cache_layout, cache_source) ? :build_ext : :link
+          return PlanEntry.new(spec: spec, action: action, cached_path: cache_source, gem_path: gem_path)
         end
 
         # Needs downloading
         PlanEntry.new(spec: spec, action: :download, cached_path: nil, gem_path: gem_path)
       end
 
-      def needs_ext_build?(spec, cache_layout)
-        extracted = cache_layout.extracted_path(spec)
-        return false unless ExtensionBuilder.needs_build?(spec, extracted)
+      def needs_ext_build?(spec, cache_layout, source_dir)
+        return false unless source_dir
+        return false unless ExtensionBuilder.needs_build?(spec, source_dir)
 
         !ExtensionBuilder.cached_build_available?(spec, cache_layout)
       end
 
-      def extension_link_missing?(spec, ruby_dir, cache_layout)
-        extracted = cache_layout.extracted_path(spec)
-        return false unless Dir.exist?(extracted)
-        return false unless ExtensionBuilder.needs_build?(spec, extracted)
+      def extension_link_missing?(spec, ruby_dir, cache_layout, source_dir)
+        return false unless source_dir
+        return false unless ExtensionBuilder.needs_build?(spec, source_dir)
 
         full = cache_layout.full_name(spec)
-        ext_install_dir = File.join(
-          ruby_dir,
-          "extensions",
-          Platform.gem_arch,
-          Platform.extension_api_version,
-          full,
-        )
-
-        !Dir.exist?(ext_install_dir)
+        gem_dir = File.join(ruby_dir, "gems", full)
+        marker = File.join(gem_dir, ExtensionBuilder::BUILD_MARKER)
+
+        !File.exist?(marker)
       end
 
       # Rough size estimate for download ordering.