scint 0.1.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2dfc2e1d04a71bb75faa5638b47b53c72449a3ebc857da9c83286ff4d5811ba2
-  data.tar.gz: c0e0375479b2dc2522289685583b13a5dd2637b94e5999557f1a32e31943ef7f
+  metadata.gz: d1c0c2f09127da28473aad491848c5b3e7b976fa41405a94ce542859fa1aabf8
+  data.tar.gz: 2e7b1801b9a3004bc0d9709de9502bfff5a8b475178aa102ebb730a6cb1b6344
 SHA512:
-  metadata.gz: 54ede6af6c782642dee0fe66607830ddd78a7bda1e669e6d429188da2f0d0e97733cd014ddd80ce43c97cc9987296f699c9e274adfcef88ac7aa133369b42075
-  data.tar.gz: fb5bd293409889ddf8ce7ff16b61f51752528dc204340412f3aefca9f334221740be236fe3ba281c4325778645da03dd15a563aae101fbcaa5cbf07c91cca7a2
+  metadata.gz: 3d95e5006966b2025c5e21951bc918849081c330a2872e7e665cafa6d73ab522871f7e41aa2ed4c61bbed37e73363f19650dce16bbc1e472b3e4fe54c0177d97
+  data.tar.gz: 40fba5802be2359b85d201c2c732f8edac15f1e1be7ee17b2d59a39de9ac2f1ca6befd14d527fcacb4a5e763408c1296abe35301f8224a4b1138a5a4a1706096

data/VERSION

@@ -0,0 +1 @@
+0.6.0

data/lib/scint/cli/install.rb

@@ -52,10 +52,13 @@ module Scint
 
         cache = Scint::Cache::Layout.new
         bundle_path = @path || ENV["BUNDLER_PATH"] || ".bundle"
+        bundle_display = display_bundle_path(bundle_path)
         bundle_path = File.expand_path(bundle_path)
         worker_count = @jobs || [Platform.cpu_count * 2, 50].min
         compile_slots = compile_slots_for(worker_count)
         per_type_limits = install_task_limits(worker_count, compile_slots)
+        $stdout.puts "#{GREEN}💎#{RESET} Scintellating Gemfile into #{BOLD}#{bundle_display}#{RESET} #{DIM}(scint #{VERSION}, ruby #{RUBY_VERSION})#{RESET}"
+        $stdout.puts
 
         # 0. Build credential store from config files (~/.bundle/config, XDG scint/credentials)
         @credentials = Credentials.new
@@ -116,8 +119,9 @@ module Scint
 
           if to_install.empty?
             elapsed_ms = elapsed_ms_since(start_time)
+            worker_count = scheduler.stats[:workers]
             warn_missing_bundle_gitignore_entry
-            $stdout.puts "\n#{GREEN}#{total_gems}#{RESET} gems installed total#{install_breakdown(cached: cached_gems, updated: updated_gems)}. #{DIM}(#{format_elapsed(elapsed_ms)})#{RESET}"
+            $stdout.puts "\n#{GREEN}#{total_gems}#{RESET} gems installed total#{install_breakdown(cached: cached_gems, updated: updated_gems)}. #{DIM}(#{format_run_footer(elapsed_ms, worker_count)})#{RESET}"
             return 0
           end
 
@@ -151,6 +155,7 @@ module Scint
           end
 
           elapsed_ms = elapsed_ms_since(start_time)
+          worker_count = stats[:workers]
           failed = errors.filter_map { |e| e[:name] }.uniq
           failed_count = failed.size
           failed_count = 1 if failed_count.zero? && stats[:failed] > 0
@@ -159,14 +164,14 @@ module Scint
 
           if has_failures
             warn_missing_bundle_gitignore_entry
-            $stdout.puts "\n#{RED}Bundle failed!#{RESET} #{installed_total}/#{total_gems} gems installed total#{install_breakdown(cached: cached_gems, updated: updated_gems, compiled: compiled_gems, failed: failed_count)}. #{DIM}(#{format_elapsed(elapsed_ms)})#{RESET}"
+            $stdout.puts "\n#{RED}Bundle failed!#{RESET} #{installed_total}/#{total_gems} gems installed total#{install_breakdown(cached: cached_gems, updated: updated_gems, compiled: compiled_gems, failed: failed_count)}. #{DIM}(#{format_run_footer(elapsed_ms, worker_count)})#{RESET}"
             1
           else
             # 10. Write lockfile + runtime config only for successful installs
             write_lockfile(resolved, gemfile)
             write_runtime_config(resolved, bundle_path)
             warn_missing_bundle_gitignore_entry
-            $stdout.puts "\n#{GREEN}#{total_gems}#{RESET} gems installed total#{install_breakdown(cached: cached_gems, updated: updated_gems, compiled: compiled_gems)}. #{DIM}(#{format_elapsed(elapsed_ms)})#{RESET}"
+            $stdout.puts "\n#{GREEN}#{total_gems}#{RESET} gems installed total#{install_breakdown(cached: cached_gems, updated: updated_gems, compiled: compiled_gems)}. #{DIM}(#{format_run_footer(elapsed_ms, worker_count)})#{RESET}"
             0
           end
         ensure
@@ -194,7 +199,7 @@ module Scint
           remote_uri: nil,
           checksum: nil,
         )
-        resolved << scint_spec
+        resolved.unshift(scint_spec)
 
         resolved
       end
@@ -221,7 +226,7 @@ module Scint
         lib_dest = File.join(gem_dest, "lib")
         unless Dir.exist?(lib_dest)
           FS.mkdir_p(lib_dest)
-          FS.hardlink_tree(scint_root, lib_dest)
+          FS.clone_tree(scint_root, lib_dest)
         end
 
         # Write gemspec
@@ -255,11 +260,12 @@ module Scint
       def clone_git_source(source, cache)
         return unless source.respond_to?(:uri)
         git_dir = cache.git_path(source.uri)
-        return if Dir.exist?(git_dir)
+        if Dir.exist?(git_dir)
+          fetch_git_repo(git_dir)
+          return
+        end
 
-        FS.mkdir_p(File.dirname(git_dir))
-        system("git", "clone", "--bare", source.uri.to_s, git_dir,
-               [:out, :err] => File::NULL)
+        clone_git_repo(source.uri, git_dir)
       end
 
       def resolve(gemfile, lockfile, cache)
@@ -376,8 +382,16 @@ module Scint
       end
 
       def lockfile_to_resolved(lockfile)
-        lockfile.specs.map do |ls|
-          source = ls[:source]
+        local_plat = Platform.local_platform
+
+        # Pick one best platform variant per gem+version from lockfile specs.
+        by_gem = Hash.new { |h, k| h[k] = [] }
+        lockfile.specs.each { |ls| by_gem[[ls[:name], ls[:version]]] << ls }
+
+        resolved = by_gem.map do |(_name, _version), specs|
+          best = pick_best_platform_spec(specs, local_plat)
+
+          source = best[:source]
           source_value =
             if source.is_a?(Source::Rubygems)
               source.uri.to_s
@@ -386,16 +400,96 @@ module Scint
             end
 
           ResolvedSpec.new(
-            name: ls[:name],
-            version: ls[:version],
-            platform: ls[:platform],
-            dependencies: ls[:dependencies],
+            name: best[:name],
+            version: best[:version],
+            platform: best[:platform],
+            dependencies: best[:dependencies],
             source: source_value,
             has_extensions: false,
             remote_uri: nil,
-            checksum: ls[:checksum],
+            checksum: best[:checksum],
           )
         end
+
+        apply_locked_platform_preferences(resolved)
+      end
+
+      # Preference: exact platform match > compatible match > ruby > first.
+      def pick_best_platform_spec(specs, local_plat)
+        return specs.first if specs.size == 1
+
+        best = nil
+        best_score = -2
+
+        specs.each do |ls|
+          platform = ls[:platform] || "ruby"
+          if platform == "ruby"
+            score = 0
+          else
+            spec_plat = Gem::Platform.new(platform)
+            if spec_plat === local_plat
+              score = spec_plat.to_s == local_plat.to_s ? 2 : 1
+            else
+              score = -1
+            end
+          end
+
+          if score > best_score
+            best = ls
+            best_score = score
+          end
+        end
+
+        best
+      end
+
+      # Lockfiles can carry only the ruby variant for a gem version.
+      # Re-check compact index for the same locked version and upgrade to the
+      # best local platform variant when available.
+      def apply_locked_platform_preferences(resolved_specs)
+        preferred = preferred_platforms_for_locked_specs(resolved_specs)
+        return resolved_specs if preferred.empty?
+
+        resolved_specs.each do |spec|
+          key = "#{spec.name}-#{spec.version}"
+          platform = preferred[key]
+          next if platform.nil? || platform.empty?
+
+          spec.platform = platform
+        end
+
+        resolved_specs
+      end
+
+      def preferred_platforms_for_locked_specs(resolved_specs)
+        out = {}
+        by_source = resolved_specs
+          .select { |spec| rubygems_source_uri?(spec.source) }
+          .group_by { |spec| spec.source.to_s.chomp("/") }
+
+        by_source.each do |source_uri, specs|
+          begin
+            client = Index::Client.new(source_uri, credentials: @credentials)
+            provider = Resolver::Provider.new(client)
+            provider.prefetch(specs.map(&:name).uniq)
+
+            specs.each do |spec|
+              preferred = provider.preferred_platform_for(spec.name, Gem::Version.new(spec.version.to_s))
+              preferred = preferred.to_s
+              next if preferred.empty? || preferred == spec.platform.to_s
+
+              out["#{spec.name}-#{spec.version}"] = preferred
+            end
+          rescue StandardError
+            next
+          end
+        end
+
+        out
+      end
+
+      def rubygems_source_uri?(source)
+        source.is_a?(String) && source.match?(%r{\Ahttps?://})
       end
 
       def download_gem(entry, cache)
@@ -463,22 +557,37 @@ module Scint
         # and can't handle concurrent checkouts from the same repo.
         git_mutex_for(bare_repo).synchronize do
           clone_git_repo(uri, bare_repo) unless Dir.exist?(bare_repo)
+          fetch_git_repo(bare_repo)
+
+          resolved_revision = resolve_git_revision(bare_repo, revision)
 
           extracted = cache.extracted_path(spec)
-          return if Dir.exist?(extracted)
+          marker = git_checkout_marker_path(extracted)
+          if Dir.exist?(extracted) && File.exist?(marker)
+            return if File.read(marker).strip == resolved_revision
+          end
 
           tmp = "#{extracted}.#{Process.pid}.#{Thread.current.object_id}.tmp"
           begin
             FileUtils.rm_rf(tmp)
-            FS.mkdir_p(tmp)
-
-            cmd = ["git", "--git-dir", bare_repo, "--work-tree", tmp, "checkout", "-f", revision, "--", "."]
-            _out, err, status = Open3.capture3(*cmd)
+            FileUtils.mkdir_p(tmp)
+
+            _out, err, status = git_capture3(
+              "--git-dir", bare_repo,
+              "--work-tree", tmp,
+              "checkout",
+              "-f",
+              resolved_revision,
+              "--",
+              ".",
+            )
             unless status.success?
-              raise InstallError, "Git checkout failed for #{spec.name} (#{uri}@#{revision}): #{err.to_s.strip}"
+              raise InstallError, "Git checkout failed for #{spec.name} (#{uri}@#{resolved_revision}): #{err.to_s.strip}"
             end
 
+            FileUtils.rm_rf(extracted)
             FS.atomic_move(tmp, extracted)
+            FS.atomic_write(marker, "#{resolved_revision}\n")
           ensure
             FileUtils.rm_rf(tmp) if tmp && File.exist?(tmp)
           end
@@ -504,18 +613,47 @@ module Scint
 
       def clone_git_repo(uri, bare_repo)
         FS.mkdir_p(File.dirname(bare_repo))
-        _out, err, status = Open3.capture3("git", "clone", "--bare", uri.to_s, bare_repo)
+        _out, err, status = git_capture3("clone", "--bare", uri.to_s, bare_repo)
         unless status.success?
           raise InstallError, "Git clone failed for #{uri}: #{err.to_s.strip}"
         end
       end
 
+      def fetch_git_repo(bare_repo)
+        _out, err, status = git_capture3(
+          "--git-dir", bare_repo,
+          "fetch",
+          "--prune",
+          "origin",
+          "+refs/heads/*:refs/heads/*",
+          "+refs/tags/*:refs/tags/*",
+        )
+        unless status.success?
+          raise InstallError, "Git fetch failed for #{bare_repo}: #{err.to_s.strip}"
+        end
+      end
+
+      def resolve_git_revision(bare_repo, revision)
+        out, err, status = git_capture3("--git-dir", bare_repo, "rev-parse", "#{revision}^{commit}")
+        unless status.success?
+          raise InstallError, "Unable to resolve git revision #{revision.inspect} in #{bare_repo}: #{err.to_s.strip}"
+        end
+        out.strip
+      end
+
+      def git_capture3(*args)
+        Open3.capture3("git", "-c", "core.fsmonitor=false", *args)
+      end
+
+      def git_checkout_marker_path(dir)
+        "#{dir}.scint_git_revision"
+      end
+
       def compile_slots_for(worker_count)
-        # Keep one worker lane available for non-compile tasks and cap native
-        # compiles at two concurrent jobs.
-        max_compile = [2, Platform.cpu_count].min
-        available = [worker_count - 1, 1].max
-        [max_compile, available].min
+        # Keep native builds serialized to avoid build-env races and reduce
+        # memory/CPU spikes from concurrent extension compiles.
+        _ = worker_count
+        1
       end
 
       def install_task_limits(worker_count, compile_slots)
@@ -531,6 +669,12 @@ module Scint
         }
       end
 
+      def display_bundle_path(path)
+        return path if path.start_with?("/", "./", "../")
+
+        "./#{path}"
+      end
+
       # Enqueue dependency-aware install tasks so compile/binstub can run
       # concurrently with link/download once prerequisites are satisfied.
       def enqueue_install_dag(scheduler, plan, cache, bundle_path, progress = nil, compile_slots: 1)
@@ -545,8 +689,8 @@ module Scint
           when :skip
             next
           when :builtin
-            install_builtin_gem(entry, bundle_path)
-            next
+            link_id = scheduler.enqueue(:link, entry.spec.name,
+                                        -> { install_builtin_gem(entry, bundle_path) })
           when :download
             key = spec_key(entry.spec)
             download_id = scheduler.enqueue(:download, entry.spec.name,
@@ -563,7 +707,7 @@ module Scint
                                              build_depends = (depends_on + dep_links).uniq
 
                                              extracted = extracted_path_for_entry(entry, cache)
-                                             if Installer::ExtensionBuilder.buildable_source_dir?(extracted)
+                                             if Installer::ExtensionBuilder.needs_build?(entry.spec, extracted)
                                                build_id = scheduler.enqueue(:build_ext, entry.spec.name,
                                                                             -> { build_extensions(entry, cache, bundle_path, progress, compile_slots: compile_slots) },
                                                                             depends_on: build_depends)
@@ -649,7 +793,7 @@ module Scint
         enqueued = 0
         entries.each do |entry|
           extracted = extracted_path_for_entry(entry, cache)
-          next unless Installer::ExtensionBuilder.buildable_source_dir?(extracted)
+          next unless Installer::ExtensionBuilder.needs_build?(entry.spec, extracted)
 
           scheduler.enqueue(:build_ext, entry.spec.name,
                             -> { build_extensions(entry, cache, bundle_path, nil, compile_slots: compile_slots) })
@@ -663,10 +807,29 @@ module Scint
         if source_str.start_with?("/") && Dir.exist?(source_str)
           source_str
         else
-          entry.cached_path || cache.extracted_path(entry.spec)
+          base = entry.cached_path || cache.extracted_path(entry.spec)
+          if git_source?(entry.spec.source) && Dir.exist?(base)
+            resolve_git_gem_subdir(base, entry.spec)
+          else
+            base
+          end
         end
       end
 
+      # For git monorepo sources, map gem name to its gemspec subdirectory.
+      def resolve_git_gem_subdir(repo_root, spec)
+        name = spec.name
+        return repo_root if File.exist?(File.join(repo_root, "#{name}.gemspec"))
+
+        source = spec.source
+        glob = source.respond_to?(:glob) ? source.glob : Source::Git::DEFAULT_GLOB
+        Dir.glob(File.join(repo_root, glob)).each do |path|
+          return File.dirname(path) if File.basename(path, ".gemspec") == name
+        end
+
+        repo_root
+      end
+
       def link_gem_files(entry, cache, bundle_path)
         spec = entry.spec
         extracted = extracted_path_for_entry(entry, cache)
@@ -680,14 +843,13 @@ module Scint
           from_cache: true,
         )
         Installer::Linker.link_files(prepared, bundle_path)
-        Installer::Linker.link_files_to_ruby_dir(prepared, cache.install_ruby_dir)
         # If this gem has a cached native build, materialize it during link.
         # This lets reinstalling into a fresh .bundle skip build_ext entirely.
         Installer::ExtensionBuilder.link_cached_build(prepared, bundle_path, cache)
       end
 
       def build_extensions(entry, cache, bundle_path, progress = nil, compile_slots: 1)
-        extracted = entry.cached_path || cache.extracted_path(entry.spec)
+        extracted = extracted_path_for_entry(entry, cache)
         gemspec = load_gemspec(extracted, entry.spec, cache)
 
         sync_build_env_dependencies(entry.spec, bundle_path, cache)
@@ -716,6 +878,8 @@ module Scint
             dep.name
           end
         end
+        dep_names << "rake"
+        dep_names.uniq!
         return if dep_names.empty?
 
         source_ruby_dir = File.join(bundle_path, "ruby", RUBY_VERSION.split(".")[0, 2].join(".") + ".0")
@@ -734,7 +898,7 @@ module Scint
           next unless Dir.exist?(source_gem_dir)
 
           target_gem_dir = File.join(target_ruby_dir, "gems", full_name)
-          FS.hardlink_tree(source_gem_dir, target_gem_dir) unless Dir.exist?(target_gem_dir)
+          FS.clone_tree(source_gem_dir, target_gem_dir) unless Dir.exist?(target_gem_dir)
 
           target_spec_dir = File.join(target_ruby_dir, "specifications")
           target_spec_path = File.join(target_spec_dir, "#{full_name}.gemspec")
@@ -990,6 +1154,12 @@ module Scint
         "#{(elapsed_ms / 1000.0).round(2)}s"
       end
 
+      def format_run_footer(elapsed_ms, worker_count)
+        workers = worker_count.to_i
+        noun = workers == 1 ? "worker" : "workers"
+        "#{format_elapsed(elapsed_ms)}, #{workers} #{noun} used"
+      end
+
       def warn_missing_bundle_gitignore_entry
         path = ".gitignore"
         return unless File.file?(path)

data/lib/scint/fs.rb

@@ -32,6 +32,11 @@ module Scint
         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)
@@ -44,6 +49,30 @@ module Scint
       FileUtils.cp(src, dst)
     end
 
+    # Recursively clone directory tree from src_dir into dst_dir.
+    # On macOS/APFS, prefers CoW clones via `cp -cR`.
+    # Falls back to hardlink_tree, then regular copy per-file if needed.
+    def clone_tree(src_dir, dst_dir)
+      src_dir = src_dir.to_s
+      dst_dir = dst_dir.to_s
+      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
+
+      # Fast path on Linux filesystems with reflink support.
+      if Platform.linux?
+        src_contents = File.join(src_dir, ".")
+        return if system("cp", "--reflink=always", "-R", src_contents, dst_dir, [:out, :err] => File::NULL)
+      end
+
+      hardlink_tree(src_dir, dst_dir)
+    end
+
     # Recursively hardlink all files from src_dir into dst_dir.
     # Directory structure is recreated; files are hardlinked.
     def hardlink_tree(src_dir, dst_dir)
@@ -68,10 +97,26 @@ module Scint
           end
 
           mkdir_p(File.dirname(dst_path))
+          # Another worker may have already materialized this file.
+          next if File.exist?(dst_path)
+
           begin
             File.link(src_path, dst_path)
+          rescue Errno::EEXIST
+            # Lost a race to another concurrent linker; destination is valid.
+            next
           rescue SystemCallError
-            FileUtils.cp(src_path, dst_path)
+            # TOCTOU guard: destination may have appeared after File.link failed.
+            next if File.exist?(dst_path)
+
+            begin
+              clonefile(src_path, dst_path)
+            rescue StandardError
+              # If a concurrent worker created destination in the meantime,
+              # treat this as success; otherwise bubble up.
+              next if File.exist?(dst_path)
+              raise
+            end
           end
         end
       end

data/lib/scint/index/client.rb

@@ -12,7 +12,7 @@ module Scint
     # Thread-safe. Uses ETag/Range for efficient updates.
     class Client
       ACCEPT_ENCODING = "gzip"
-      USER_AGENT = "scint/0.1.0"
+      USER_AGENT = "scint/#{Scint::VERSION}"
       DEFAULT_TIMEOUT = 15
 
       attr_reader :source_uri

data/lib/scint/installer/extension_builder.rb

@@ -71,6 +71,41 @@ module Scint
         true
       end
 
+      # True when a gem has native extension sources that need compiling.
+      # Platform-specific gems usually ship precompiled binaries and should
+      # not be compiled from ext/ unless they lack support for this Ruby.
+      def needs_build?(spec, gem_dir)
+        platform = spec.respond_to?(:platform) ? spec.platform : nil
+        if platform && !platform.to_s.empty? && platform.to_s != "ruby"
+          return prebuilt_missing_for_ruby?(gem_dir) && buildable_source_dir?(gem_dir)
+        end
+
+        buildable_source_dir?(gem_dir)
+      end
+
+      # Detect versioned prebuilt extension folders like:
+      #   lib/sqlite3/3.1, lib/sqlite3/3.2 ...
+      # If present, the current Ruby minor must exist or we need a build.
+      def prebuilt_missing_for_ruby?(gem_dir)
+        ruby_minor = RUBY_VERSION[/\d+\.\d+/]
+        lib_dir = File.join(gem_dir, "lib")
+        return false unless Dir.exist?(lib_dir)
+
+        Dir.children(lib_dir).each do |child|
+          child_path = File.join(lib_dir, child)
+          next unless File.directory?(child_path)
+
+          version_dirs = Dir.children(child_path).select do |entry|
+            File.directory?(File.join(child_path, entry)) && entry.match?(/\A\d+\.\d+\z/)
+          end
+          next if version_dirs.empty?
+
+          return true unless version_dirs.include?(ruby_minor)
+        end
+
+        false
+      end
+
       # --- private ---
 
       def buildable_source_dir?(gem_dir)
@@ -175,7 +210,7 @@ module Scint
                                     spec_full_name(spec))
         return if Dir.exist?(ext_install_dir)
 
-        FS.hardlink_tree(cached_ext, ext_install_dir)
+        FS.clone_tree(cached_ext, ext_install_dir)
       end
 
       def build_env(gem_dir, build_ruby_dir, make_jobs)
@@ -258,7 +293,7 @@ module Scint
       private_class_method :find_extension_dirs, :compile_extension,
                            :compile_extconf, :compile_cmake, :compile_rake,
                            :find_rake_executable, :link_extensions, :build_env, :run_cmd,
-                           :spec_full_name, :ruby_install_dir
+                           :spec_full_name, :ruby_install_dir, :prebuilt_missing_for_ruby?
     end
   end
 end

data/lib/scint/installer/linker.rb

@@ -33,7 +33,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.hardlink_tree(prepared_gem.extracted_path, gem_dest)
+          FS.clone_tree(prepared_gem.extracted_path, gem_dest)
         end
 
         # 2. Write gemspec into specifications/

data/lib/scint/installer/planner.rb

@@ -23,11 +23,12 @@ module Scint
           plan_one(spec, ruby_dir, cache_layout)
         end
 
-        # Stable partition: downloads first (big→small), then everything else
-        downloads, rest = entries.partition { |e| e.action == :download }
+        # Keep built-ins first, then downloads (big->small), then the rest.
+        builtins, non_builtins = entries.partition { |e| e.action == :builtin }
+        downloads, rest = non_builtins.partition { |e| e.action == :download }
         downloads.sort_by! { |e| -(estimated_size(e.spec)) }
 
-        downloads + rest
+        builtins + downloads + rest
       end
 
       def plan_one(spec, ruby_dir, cache_layout)
@@ -58,7 +59,7 @@ module Scint
         # Local path sources are linked directly from their source tree.
         local_source = local_source_path(spec)
         if local_source
-          action = ExtensionBuilder.buildable_source_dir?(local_source) ? :build_ext : :link
+          action = ExtensionBuilder.needs_build?(spec, local_source) ? :build_ext : :link
           return PlanEntry.new(spec: spec, action: action, cached_path: local_source, gem_path: gem_path)
         end
 
@@ -75,7 +76,7 @@ module Scint
 
       def needs_ext_build?(spec, cache_layout)
         extracted = cache_layout.extracted_path(spec)
-        return false unless ExtensionBuilder.buildable_source_dir?(extracted)
+        return false unless ExtensionBuilder.needs_build?(spec, extracted)
 
         !ExtensionBuilder.cached_build_available?(spec, cache_layout)
       end
@@ -83,7 +84,7 @@ module Scint
       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.buildable_source_dir?(extracted)
+        return false unless ExtensionBuilder.needs_build?(spec, extracted)
 
         full = cache_layout.full_name(spec)
         ext_install_dir = File.join(

data/lib/scint/lockfile/writer.rb

@@ -6,7 +6,7 @@ module Scint
     # Produces output compatible with stock bundler.
     #
     # Sections in order: source blocks (GEM/GIT/PATH), PLATFORMS,
-    # DEPENDENCIES, CHECKSUMS (if present), RUBY VERSION, BUNDLED WITH.
+    # DEPENDENCIES, CHECKSUMS (if present), RUBY VERSION.
     class Writer
       def self.write(lockfile_data)
         new(lockfile_data).generate
@@ -24,7 +24,6 @@ module Scint
         add_dependencies(out)
         add_checksums(out)
         add_ruby_version(out)
-        add_bundled_with(out)
 
         out
       end
@@ -168,11 +167,6 @@ module Scint
         out << "  #{@data.ruby_version}\n"
       end
 
-      def add_bundled_with(out)
-        return unless @data.bundler_version
-        out << "\nBUNDLED WITH\n"
-        out << "   #{@data.bundler_version}\n"
-      end
     end
   end
 end