proscenium 0.26.1-x86_64-linux-gnu → 0.27.0-x86_64-linux-gnu

data/lib/proscenium/cli/install.rb

@@ -3,10 +3,10 @@
 require 'fileutils'
 require 'bundler'
 require_relative '../bundled_gems'
-require_relative '../dependency_context'
-require_relative '../stale_contexts'
+require_relative '../contexts/projection'
+require_relative '../contexts/stale'
 require_relative 'collisions'
-require_relative 'contexts'
+require_relative '../contexts/plan'
 require_relative 'diff'
 require_relative 'manager'
 require_relative 'platform_variants'
@@ -54,10 +54,11 @@ module Proscenium
 
         contexts.flat_map do |gem, json|
           context = JSON.parse(json)
-          Rules::DEPENDENCY_FIELDS.flat_map { (context[it] || {}).keys }
-                                  .reject { it.start_with?('@rubygems/') }
-                                  .select { output.match?(named(it)) }
-                                  .map { [gem, it] }
+          fields = Contexts::Rules::DEPENDENCY_FIELDS
+          fields.flat_map { (context[it] || {}).keys }
+                .reject { it.start_with?('@rubygems/') }
+                .select { output.match?(named(it)) }
+                .map { [gem, it] }
         end
       end
 
@@ -86,9 +87,9 @@ module Proscenium
         specs = timed(:bundle) { BundledGems.installed_specs }
         @excluded = BundledGems.excluded_names(specs)
         @contexts = timed(:projection) do
-          Contexts.new(@root, BundledGems.participating(specs, overrides:))
+          Contexts::Plan.new(@root, BundledGems.participating(specs, overrides:))
         end
-        @committed = Contexts.committed(@root)
+        @committed = Contexts::Plan.committed(@root)
         check_owned_directory
         report_problems
         check_platform_variants(specs, overrides)
@@ -107,7 +108,7 @@ module Proscenium
         @contexts.problems.each do |code, args|
           @reporter.error(Error.new(code, **args), phase: 'validate', manager: @manager.name)
         end
-        raise Error.new('PSM-E-PROBLEMS', count: @contexts.problems.size)
+        raise Error, 'PSM-E-PROBLEMS'
       end
 
       # `.proscenium/packages/` is Proscenium's: every entry is a generated context. A package.json
@@ -121,7 +122,7 @@ module Proscenium
           # macOS's .DS_Store is ours to remove; anything else, a .git included, is the user's.
           next (Dir.children(File.dirname(path)) - OURS).any? unless File.exist?(path)
 
-          !generated?(gem, ContextMap.read_json(path))
+          !generated?(gem, Contexts::Map.read_json(path))
         rescue JSON::ParserError
           true
         end
@@ -135,7 +136,7 @@ module Proscenium
       # `proscenium` block naming a projection. A `proscenium` key alone is not enough, or install
       # would remove someone else's package as an orphan.
       def generated?(gem, package)
-        package.is_a?(Hash) && package['name'] == DependencyContext.name_for(gem) &&
+        package.is_a?(Hash) && package['name'] == Contexts::Projection.name_for(gem) &&
           package.dig('proscenium', 'projection').is_a?(String)
       rescue TypeError
         false
@@ -143,7 +144,7 @@ module Proscenium
 
       # A file, or a link leading nowhere, where only context directories belong.
       def strays
-        dir = File.join(@root, Contexts::DIR)
+        dir = File.join(@root, Contexts::Map::CONTEXTS)
         return [] unless Dir.exist?(dir)
 
         Dir.children(dir).reject { File.directory?(File.join(dir, it)) } - OURS
@@ -152,8 +153,8 @@ module Proscenium
       # Everything install writes is under .proscenium/ (C29). A link anywhere on the way, or in
       # place of a context, would send those writes outside the app.
       def check_owned_links
-        owned = ['.proscenium', Contexts::DIR] + @committed.flat_map do |gem, path|
-          [File.join(Contexts::DIR, gem), relative(path)]
+        owned = ['.proscenium', Contexts::Map::CONTEXTS] + @committed.flat_map do |gem, path|
+          [File.join(Contexts::Map::CONTEXTS, gem), relative(path)]
         end
         links = owned.select { File.symlink?(File.join(@root, it)) }
         raise Error.new('PSM-E-OWNED-LINK', paths: links.join(', ')) if links.any?
@@ -170,9 +171,9 @@ module Proscenium
       def check_trusted_sources
         manifests = @contexts.contexts.transform_values { JSON.parse(it.json) }
         # Bun's trust is read only when a gem reaches some package another way.
-        return if Rules.substitutions(manifests).empty?
+        return if Contexts::Rules.substitutions(manifests).empty?
 
-        found = Rules.trusted_substitutions(@manager.trusted_names, manifests)
+        found = Contexts::Rules.trusted_substitutions(@manager.trusted_names, manifests)
         return if found.empty?
 
         raise Error.new('PSM-E-TRUSTED-SOURCE', list: found.map { "  - #{it}" }.join("\n"))
@@ -182,8 +183,7 @@ module Proscenium
         found = Collisions.find(@root, @manager.name, @contexts.contexts.keys)
         return if found.empty?
 
-        raise Error.new('PSM-E-COLLISION', count: found.size,
-                                           list: found.map { "  - #{it}" }.join("\n"))
+        raise Error.new('PSM-E-COLLISION', list: found.map { "  - #{it}" }.join("\n"))
       end
 
       # Committed contexts no participating gem owns. A locked gem that is not installed (another
@@ -213,17 +213,17 @@ module Proscenium
       end
 
       def check_drift
-        @committed = Contexts.committed(@root)
+        @committed = Contexts::Plan.committed(@root)
         drift = []
         registered = Registration.registered?(@root, @manager.name)
         drift << 'the gem contexts are not registered' unless registered
         drift << "#{lockfile} is missing" unless File.exist?(File.join(@root, lockfile))
         changed.each { drift << describe_change(it) }
-        orphans.each { drift << format(StaleContexts::ORPHAN, gem: it) }
+        orphans.each { drift << format(Contexts::Stale::ORPHAN, gem: it) }
         return if drift.empty?
 
         list = drift.map { "  - #{it}" }.join("\n")
-        raise Error.new('PSM-E-DRIFT', count: drift.size, list:)
+        raise Error.new('PSM-E-DRIFT', list:)
       end
 
       # A line for each committed context kept for a gem that is not installed.
@@ -233,26 +233,15 @@ module Proscenium
         end
       end
 
+      # Why a context whose bytes differ from what install writes is drift, with the diff. Frozen
+      # compares bytes, so one the engine still builds with, only reformatted, is a hand edit.
       def describe_change(context)
         path = @committed[context.gem]
-        unless path && File.exist?(path)
-          return "#{context.gem}: its dependency context hasn't been written yet"
-        end
+        drift = Contexts::Stale.drift(context, path) || :edited
+        cause = "#{context.gem}: #{Contexts::Stale::REASONS[drift]}"
+        return cause if drift == :missing
 
-        before = File.read(path)
-        diff = Diff.unified(relative(path), before, context.json)
-        committed = JSON.parse(before)['proscenium'] || {}
-        current = JSON.parse(context.json)['proscenium']
-        cause = if committed['projection'] != current['projection']
-                  'its dependency context was written by a different version of Proscenium'
-                elsif committed['projectionSha256'] == current['projectionSha256']
-                  'its dependency context was edited by hand'
-                else
-                  'its NPM dependencies changed since its dependency context was written'
-                end
-        "#{context.gem}: #{cause}\n#{diff}"
-      rescue JSON::ParserError
-        "#{context.gem}: its dependency context is not valid JSON"
+        "#{cause}\n#{Diff.unified(relative(path), File.read(path), context.json)}"
       end
 
       def install
@@ -291,7 +280,7 @@ module Proscenium
       # links survive.
       def write_contexts
         changed.map do |context|
-          dir = File.join(@root, Contexts::DIR, context.gem)
+          dir = File.join(@root, Contexts::Map::CONTEXTS, context.gem)
           FileUtils.mkdir_p(dir)
           path = File.join(dir, 'package.json')
           ProjectLock.write("#{path}.tmp", context.json)
@@ -302,18 +291,18 @@ module Proscenium
 
       def remove_orphans
         orphans.map do |gem|
-          FileUtils.rm_rf(File.join(@root, Contexts::DIR, gem))
-          "#{Contexts::DIR}/#{gem} (removed)"
+          FileUtils.rm_rf(File.join(@root, Contexts::Map::CONTEXTS, gem))
+          "#{Contexts::Map::CONTEXTS}/#{gem} (removed)"
         end
       end
 
-      def run_manager(lock = nil)
+      def run_manager(lock)
         unless @reporter.json?
           @reporter.info(@reporter.paint("Running #{@manager.name} #{manager_args.join(' ')}...",
                                          :dim))
         end
         Runner.run(@manager.executable, manager_args, root: @root,
-                                                      on_spawn: lock&.method(:manager_started),
+                                                      on_spawn: lock.method(:manager_started),
                                                       manager: @manager.name)
       rescue Error => e
         raise unless e.code == 'PSM-E-NATIVE'
@@ -327,7 +316,7 @@ module Proscenium
                                           escape: "It involves #{involved}.")
         raise error
       ensure
-        lock&.manager_finished
+        lock.manager_finished
       end
 
       def manager_args
@@ -339,7 +328,7 @@ module Proscenium
         # dependencies left out of a production install.
         if @options[:production]
           (@excluded & @committed.keys).each do |gem|
-            args << "--filter=!#{DependencyContext.name_for(gem)}"
+            args << "--filter=!#{Contexts::Projection.name_for(gem)}"
           end
         end
         args + Array(@options[:js_args])

data/lib/proscenium/cli/manager.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'json'
-require_relative '../context_map'
+require_relative '../contexts/map'
 require_relative '../yaml_tree'
 require_relative 'pnpm_approvals'
 require 'open3'
@@ -53,7 +53,7 @@ module Proscenium
         path = File.join(root, 'package.json')
         return nil unless File.exist?(path)
 
-        field = ContextMap.read_json(path)['packageManager']
+        field = Contexts::Map.read_json(path)['packageManager']
         field.is_a?(String) ? field.split('@').first : nil
       rescue JSON::ParserError
         nil
@@ -129,7 +129,7 @@ module Proscenium
       # probing would change the project before install could refuse anything.
       def pinned_version
         path = File.join(@root, 'package.json')
-        field = File.exist?(path) && ContextMap.read_json(path)['packageManager']
+        field = File.exist?(path) && Contexts::Map.read_json(path)['packageManager']
         return unless field.is_a?(String)
 
         name, version = field.split('+').first.split('@', 2)
@@ -151,7 +151,7 @@ module Proscenium
         path = File.join(@root, 'pnpm-workspace.yaml')
         return unless File.exist?(path)
 
-        text = ContextMap.utf8(File.read(path)).delete_prefix(ContextMap::BOM)
+        text = Contexts::Map.utf8(File.read(path)).delete_prefix(Contexts::Map::BOM)
         value, = YamlTree.value(text, key)
         value.value if value.is_a?(Psych::Nodes::Scalar)
       rescue Psych::SyntaxError
@@ -190,7 +190,7 @@ module Proscenium
       # registration, so a file that is not strict JSON is refused here, before any write.
       def package_json
         path = File.join(@root, 'package.json')
-        File.exist?(path) ? ContextMap.read_json(path) : nil
+        File.exist?(path) ? Contexts::Map.read_json(path) : nil
       rescue JSON::ParserError
         raise Error.new('PSM-E-REGISTRATION', file: 'package.json')
       end
@@ -280,7 +280,7 @@ module Proscenium
       # here, so at worst an app that is not a member is refused.
       def member?(dir, root)
         path = File.join(dir, 'package.json')
-        package = File.exist?(path) && ContextMap.read_json(path)
+        package = File.exist?(path) && Contexts::Map.read_json(path)
         return false unless package.is_a?(Hash)
 
         workspaces = package['workspaces']

data/lib/proscenium/cli/platform_variants.rb

@@ -2,10 +2,10 @@
 
 require 'json'
 require_relative '../bundled_gems'
-require_relative '../context_map'
-require_relative '../dependency_context'
+require_relative '../contexts/map'
+require_relative '../contexts/projection'
 require_relative 'gem_archive'
-require_relative 'rules'
+require_relative '../contexts/rules'
 
 module Proscenium
   module CLI
@@ -50,14 +50,14 @@ module Proscenium
       # Whether the author contract refuses the variant, as it would on the host that installs it:
       # the projection drops scripts and workspaces, so equal projections do not show it.
       def refused?(gem, variant, text)
-        manifest = ContextMap.parse_json(text)
+        manifest = Contexts::Map.parse_json(text)
         return true unless manifest.is_a?(Hash)
 
         # A host that installs it refuses a frontend root outside the gem.
         root = BundledGems.frontend_root(variant) or return true
         gyp = root.empty? ? 'binding.gyp' : File.join(root, 'binding.gyp')
-        Rules.check(gem, manifest, binding_gyp: variant.files.include?(gyp))
-             .any? { !Rules::WARNINGS.include?(it.first) }
+        Contexts::Rules.check(gem, manifest, binding_gyp: variant.files.include?(gyp))
+                       .any? { !Contexts::Rules::WARNINGS.include?(it.first) }
       rescue JSON::ParserError
         true
       end
@@ -70,10 +70,10 @@ module Proscenium
 
       # The projection hash of a manifest's text, or nil for none that can be read.
       def projection(gem, text)
-        manifest = text && ContextMap.parse_json(text)
+        manifest = text && Contexts::Map.parse_json(text)
         return nil unless manifest.is_a?(Hash)
 
-        DependencyContext.project(gem, manifest).dig('proscenium', 'projectionSha256')
+        Contexts::Projection.project(gem, manifest).dig('proscenium', 'projectionSha256')
       rescue JSON::ParserError
         nil
       end

data/lib/proscenium/cli/pnpm_approvals.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../context_map'
+require_relative '../contexts/map'
 require_relative '../yaml_tree'
 
 module Proscenium
@@ -47,7 +47,7 @@ module Proscenium
       def setting?(path, key)
         return false unless File.exist?(path)
 
-        text = ContextMap.utf8(File.read(path)).delete_prefix(ContextMap::BOM)
+        text = Contexts::Map.utf8(File.read(path)).delete_prefix(Contexts::Map::BOM)
         value, anchors = YamlTree.value(text, key)
         true?(YamlTree.node(value, anchors))
       rescue Psych::SyntaxError
@@ -58,7 +58,7 @@ module Proscenium
         path = File.join(root, 'pnpm-workspace.yaml')
         return [] unless File.exist?(path)
 
-        text = ContextMap.utf8(File.read(path)).delete_prefix(ContextMap::BOM)
+        text = Contexts::Map.utf8(File.read(path)).delete_prefix(Contexts::Map::BOM)
         allowed, anchors = YamlTree.value(text, 'allowBuilds')
         listed, = YamlTree.value(text, 'onlyBuiltDependencies')
         node = ->(given) { YamlTree.node(given, anchors) }

data/lib/proscenium/cli/pnpm_workspace.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'yaml'
-require_relative '../context_map'
+require_relative '../contexts/map'
 require_relative 'brackets'
 
 module Proscenium
@@ -22,14 +22,14 @@ module Proscenium
       # whatever indentation its items use. The result is parsed back; anything but the old list
       # plus the pattern, with every other key unchanged, is refused rather than written.
       def splice(text)
-        return text if ContextMap.registered_in?('pnpm-workspace.yaml', text, strict: true)
+        return text if Contexts::Map.registered_in?('pnpm-workspace.yaml', text, strict: true)
 
-        text = ContextMap.utf8(text)
-        bom = text.start_with?(ContextMap::BOM) ? ContextMap::BOM : ''
+        text = Contexts::Map.utf8(text)
+        bom = text.start_with?(Contexts::Map::BOM) ? Contexts::Map::BOM : ''
         body = text.delete_prefix(bom)
         spliced = splice_body(body)
         verify(body, spliced)
-        if ContextMap.excludes?(ContextMap.yaml_packages(spliced))
+        if Contexts::Map.excludes?(Contexts::Map.yaml_packages(spliced))
           raise Error.new('PSM-E-REGISTRATION-EXCLUDED', file: 'pnpm-workspace.yaml')
         end
 
@@ -51,12 +51,12 @@ module Proscenium
           insert_into_flow(text, flow.end(0), text[flow.end(0)...close], eol)
         elsif (key = text.match(BLOCK, at))
           indent = text[key.end(0)..][/\A(?:[ \t]*(?:#.*)?\r?\n)*([ \t]*)- /, 1] || '  '
-          text.dup.insert(key.end(0), "#{indent}- #{ContextMap::REGISTRATION}#{eol}")
+          text.dup.insert(key.end(0), "#{indent}- #{Contexts::Map::REGISTRATION}#{eol}")
         else
           # A new key would override a list inherited through a merge key (`<<: *defaults`).
           raise refused if merges?(text)
 
-          "packages:#{eol}  - #{ContextMap::REGISTRATION}#{eol}#{eol unless text.empty?}#{text}"
+          "packages:#{eol}  - #{Contexts::Map::REGISTRATION}#{eol}#{eol unless text.empty?}#{text}"
         end
       end
 
@@ -69,7 +69,7 @@ module Proscenium
       end
 
       # The root mapping's `packages` key and its value, at any indentation, or nil. The last pair,
-      # as pnpm and ContextMap read it; another mapping's `packages` key is not it.
+      # as pnpm and Contexts::Map read it; another mapping's `packages` key is not it.
       def root_pair(text)
         root = Psych.parse_stream(text).children.first&.root
         return unless root.is_a?(Psych::Nodes::Mapping)
@@ -89,10 +89,11 @@ module Proscenium
       # `packages: *list` as a flow list of the entries it names plus the pattern, so the anchored
       # list stays as it is for anything else that uses it.
       def spell_out(text, node)
-        entries = ContextMap.yaml_packages(text)
+        entries = Contexts::Map.yaml_packages(text)
         raise refused unless entries&.all?(String)
 
-        list = (entries + [ContextMap::REGISTRATION]).map { "'#{it.gsub("'", "''")}'" }.join(', ')
+        list = (entries + [Contexts::Map::REGISTRATION]).map { "'#{it.gsub("'", "''")}'" }
+        list = list.join(', ')
         start = offset(text, node)
         "#{text[0...start]}[#{list}]#{text[(start + node.end_column - node.start_column)..]}"
       end
@@ -107,16 +108,16 @@ module Proscenium
                     elsif indent then "#{',' unless comma}#{eol}#{indent}"
                     else comma ? ' ' : ', '
                     end
-        item = "'#{ContextMap::REGISTRATION}'#{',' if comma}"
+        item = "'#{Contexts::Map::REGISTRATION}'#{',' if comma}"
         text.dup.insert(start + list.length, "#{separator}#{item}")
       end
 
-      # The `packages` list of a document that is empty or a mapping, as ContextMap reads it.
+      # The `packages` list of a document that is empty or a mapping, as Contexts::Map reads it.
       def packages(text)
         root = Psych.parse_stream(text).children.first&.root
         raise refused unless root.nil? || root.is_a?(Psych::Nodes::Mapping)
 
-        ContextMap.yaml_packages(text)
+        Contexts::Map.yaml_packages(text)
       rescue Psych::SyntaxError
         raise refused
       end
@@ -125,7 +126,7 @@ module Proscenium
       def verify(text, spliced)
         before = packages(text)
         after = packages(spliced)
-        expected = Array(before) + [ContextMap::REGISTRATION]
+        expected = Array(before) + [Contexts::Map::REGISTRATION]
         same = after.is_a?(Array) && after.tally == expected.tally
         raise refused unless same && others(spliced) == others(text)
       end

data/lib/proscenium/cli/project_lock.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'fileutils'
-require_relative '../context_map'
+require_relative '../contexts/map'
 
 module Proscenium
   module CLI
@@ -41,8 +41,8 @@ module Proscenium
       end
 
       # The engine probes these two to refuse builds during an install, so both sides share them.
-      def lock_path = File.join(@root, ContextMap::LOCK)
-      def marker_path = File.join(@root, ContextMap::INSTALLING)
+      def lock_path = File.join(@root, Contexts::Map::LOCK)
+      def marker_path = File.join(@root, Contexts::Map::INSTALLING)
       def holder_path = File.join(@dir, 'holder')
       def manager_path = File.join(@dir, 'manager')
 

data/lib/proscenium/cli/registration.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'json'
-require_relative '../context_map'
+require_relative '../contexts/map'
 require_relative 'bun_linker'
 require_relative 'brackets'
 require_relative 'gitignore'
@@ -15,7 +15,7 @@ module Proscenium
     # splice, so the file's other settings, order and comments survive; each is computed without
     # writing, so `install` can print it as a diff first.
     module Registration
-      PATTERN = ContextMap::REGISTRATION
+      PATTERN = Contexts::Map::REGISTRATION
 
       module_function
 
@@ -47,7 +47,7 @@ module Proscenium
       # Whether the app has adopted RubyGem NPM dependencies: its committed registration names the
       # contexts.
       def registered?(root, manager)
-        ContextMap.registers?(root, manager == 'bun' ? 'package.json' : 'pnpm-workspace.yaml')
+        Contexts::Map.registers?(root, manager == 'bun' ? 'package.json' : 'pnpm-workspace.yaml')
       end
 
       def refused(file) = Error.new('PSM-E-REGISTRATION', file:)
@@ -56,11 +56,11 @@ module Proscenium
       # or adds the key. Refuses rather than guess at JSON it cannot splice. A byte order mark is
       # kept.
       def splice_package_json(text)
-        return text if ContextMap.registered_in?('package.json', text, strict: true)
+        return text if Contexts::Map.registered_in?('package.json', text, strict: true)
 
         bom = text.start_with?("\uFEFF") ? "\uFEFF" : ''
         spliced = splice_json(text.delete_prefix(bom))
-        if ContextMap.excludes?(ContextMap.json_workspaces(spliced))
+        if Contexts::Map.excludes?(Contexts::Map.json_workspaces(spliced))
           raise Error.new('PSM-E-REGISTRATION-EXCLUDED', file: 'package.json')
         end
 

data/lib/proscenium/cli/reporter.rb

@@ -37,9 +37,9 @@ module Proscenium
       end
 
       # A line of the human summary, or an event in JSON mode.
-      def info(message, event: 'info', phase: nil, **details)
+      def info(message, event: 'info', **details)
         if @json
-          emit(event:, phase:, status: 'ok', message:, details:)
+          emit(event:, phase: nil, status: 'ok', message:, details:)
         elsif !@quiet
           @out.puts message
         end

data/lib/proscenium/cli/verify.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'json'
-require_relative '../context_map'
+require_relative '../contexts/map'
+require_relative '../contexts/stale'
 require_relative 'manager'
 
 module Proscenium
@@ -12,7 +12,8 @@ module Proscenium
     class Verify
       # A `packages:` key in pnpm-lock.yaml, and a `packages` entry in bun.lock, for a
       # `@rubygems/*` package that is not a link to its context. A pnpm key starting with `@` is
-      # always quoted, and a Git one holds colons: `'@rubygems/hue@git+ssh://git@github.com/...':`.
+      # always quoted, and a Git one holds colons:
+      # `'@rubygems/ui-gem@git+ssh://git@github.com/...':`.
       PNPM_REGISTRY = %r{^\s{2}'(@rubygems/[^@'\s]+)@(?!link:|workspace:)[^']*':\s*$}
       BUN_REGISTRY = %r{"(@rubygems/[^"]+)":\s*\["@rubygems/[^@"]+@(?!workspace:)}
 
@@ -40,7 +41,7 @@ module Proscenium
 
       def check_workspaces(lock)
         missing = @gems.reject do |gem|
-          path = ".proscenium/packages/#{gem}"
+          path = "#{Contexts::Map::CONTEXTS}/#{gem}"
           if @manager.name == 'pnpm'
             # An importer with no dependencies is written on one line: `  <path>: {}`.
             lock.match?(/^  #{Regexp.escape(path)}:(?: \{\})?$/)
@@ -54,53 +55,11 @@ module Proscenium
       end
 
       # Each peer a context declares that the app also depends on must resolve, from the context
-      # and from the app, to one real directory. A context that is missing or not valid JSON has
-      # no peers to check; StaleContexts and `install --frozen` report it themselves.
+      # and from the app, to one real directory. The rule is the engine's too, so it lives with
+      # Contexts::Stale.
       def check_peers
-        app = app_dependencies
-        @gems.each do |gem|
-          dir = File.join(@root, '.proscenium', 'packages', gem)
-          (peers(dir).keys & app).each do |name|
-            from_gem = resolve(dir, name)
-            from_app = resolve(@root, name)
-            next if from_gem.nil? || from_app.nil? || from_gem == from_app
-
-            raise Error.new('PSM-E-PEER-SPLIT', gem:, package: name, manager: @manager.name)
-          end
-        end
-      end
-
-      def peers(dir)
-        context = ContextMap.read_json(File.join(dir, 'package.json'))
-        peers = context['peerDependencies'] if context.is_a?(Hash)
-        peers.is_a?(Hash) ? peers : {}
-      rescue Errno::ENOENT, JSON::ParserError
-        {}
-      end
-
-      def app_dependencies
-        package = ContextMap.read_json(File.join(@root, 'package.json'))
-        return [] unless package.is_a?(Hash)
-
-        # Peers too: pnpm installs the app's own peers at the root.
-        %w[dependencies devDependencies optionalDependencies peerDependencies].flat_map do |field|
-          package[field].is_a?(Hash) ? package[field].keys : []
-        end
-      rescue Errno::ENOENT, JSON::ParserError
-        []
-      end
-
-      # The real directory `name` resolves to from `dir`, walking up node_modules as Node does,
-      # but no higher than the app.
-      def resolve(dir, name)
-        current = dir
-        loop do
-          candidate = File.join(current, 'node_modules', name)
-          return File.realpath(candidate) if File.exist?(candidate)
-          return nil if current == @root || current == File.dirname(current)
-
-          current = File.dirname(current)
-        end
+        gem, package = Contexts::Stale.peer_split(@root, @gems)
+        raise Error.new('PSM-E-PEER-SPLIT', gem:, package:) if gem
       end
     end
   end

data/lib/proscenium/cli.rb

@@ -13,10 +13,11 @@ module Proscenium
   # The `proscenium` command (#154): installs participating gems' JavaScript dependencies through
   # the app's own package manager. It runs under `bundle exec` and reads the bundle in process.
   #
-  # Load isolation is a contract, tested in test/cli/load_isolation_test.rb: nothing under
-  # lib/proscenium/cli/ may require `proscenium` itself, ActiveSupport, Rails, FFI or the engine
-  # library. Only Proscenium's plain-Ruby modules the engine shares with it (bundled_gems,
-  # dependency_context, context_map, stale_contexts) and these files.
+  # Load isolation is a contract in both directions, tested in test/cli/load_isolation_test.rb.
+  # Nothing under lib/proscenium/cli/ may require `proscenium` itself, ActiveSupport, Rails, FFI or
+  # the engine library: only the plain-Ruby model the engine shares with it (bundled_gems and
+  # contexts/) and these files. And that model loads nothing of cli/, so a change to the package
+  # manager, install or verify cannot break the engine.
   module CLI
     USAGE = <<~TEXT
       Usage: bundle exec proscenium <command> [options]