ryac 0.2.0

data/sig/ryac/pipeline/control_flow_simplify.rbs

@@ -0,0 +1,34 @@
+module Ryac
+  module Pipeline
+    class ControlFlowSimplify < Stage
+
+      COLLECTION_CONTEXT_BYTES: Array[Integer]
+      OPERATOR_START_BYTES: Array[Integer]
+
+      def fixpoint?: () -> bool
+      def collect: (StageContext ctx, Array[patch_entry] patches) -> void
+
+      private
+
+      def walk: (Prism::Node node, String source, Array[patch_entry] patches, ?bool statement_position) -> void
+      def try_if: (Prism::IfNode node, String source, bool statement_position) -> String?
+      def try_sole_nested_if: (Prism::IfNode node, Prism::Node inner, String source) -> String?
+      def logic_operand_text: (Prism::Node pred, String text) -> String
+      def else_text_for_ternary: (Prism::Node? subsequent, String source) -> String?
+      def build_ternary: (Prism::Node cond_node, String cond, Prism::Node? then_node, String? then_expr, String? else_expr) -> String
+      def try_tail_return: (Prism::DefNode node, Array[patch_entry] patches) -> void
+      def collect_tail_returns: (Prism::Node? node, Array[patch_entry] patches) -> void
+      def contains_tail_return_patch?: (Prism::Node node) -> bool
+      def try_unless: (Prism::UnlessNode node, String source, bool statement_position) -> String?
+      def try_loop: (Prism::WhileNode | Prism::UntilNode node, String source, bool statement_position, String keyword) -> String?
+      def too_complex_for_ternary?: (String? text) -> bool?
+      def in_collection_context?: (Prism::Node node, String source) -> bool
+      LOCAL_BINDING_NODES: Array[Class]
+      def condition_assigns_var_used_in_body?: (Prism::Node predicate, Prism::Node? body) -> bool
+      def collect_assigned_vars: (Prism::Node node) -> Set[Symbol]
+      def collect_read_vars: (Prism::Node? node) -> Set[Symbol]
+      def traverse: (Prism::Node? node) { (Prism::Node) -> void } -> void
+      def if_end_followed_by_operator?: (Prism::IfNode node, String source) -> bool
+    end
+  end
+end

data/sig/ryac/pipeline/data_types.rbs

@@ -0,0 +1,151 @@
+module Ryac
+  module Pipeline
+    class FileEntry
+      attr_reader path: String
+      attr_reader content: String
+      attr_reader dependencies: Array[String]
+      attr_reader require_nodes: Array[require_node_info]
+      attr_reader in_class_dependencies: Array[String]
+
+      def self.new: (path: String, content: String, dependencies: Array[String], require_nodes: Array[require_node_info], ?in_class_dependencies: Array[String]) -> FileEntry
+      def initialize: (path: String, content: String, dependencies: Array[String], require_nodes: Array[require_node_info], ?in_class_dependencies: Array[String]) -> void
+    end
+
+    class DependencyGraph
+      attr_reader files: Hash[String, FileEntry]
+      attr_reader adjacency: Hash[String, Array[String]]
+      attr_reader in_degrees: Hash[String, Integer]
+      attr_reader rbs_files: Hash[String, String]
+
+      def initialize: () -> void
+      def add_file: (FileEntry entry) -> void
+      def paths: () -> Array[String]
+      def []: (String path) -> FileEntry?
+      def size: () -> Integer
+      def empty?: () -> bool
+    end
+
+    class FileBoundary
+      attr_reader path: String
+      attr_reader start_line: Integer
+      attr_reader end_line: Integer
+
+      def self.new: (path: String, start_line: Integer, end_line: Integer) -> FileBoundary
+    end
+
+    class ConcatenatedSource
+      attr_reader content: String
+      attr_reader file_boundaries: Array[FileBoundary]
+      attr_reader original_size: Integer
+      attr_reader stdlib_requires: Array[String]
+      attr_reader rbs_files: Hash[String, String]
+
+      def self.new: (content: String, ?file_boundaries: Array[FileBoundary], ?original_size: Integer?, ?stdlib_requires: Array[String], ?rbs_files: Hash[String, String]) -> ConcatenatedSource
+      def initialize: (content: String, ?file_boundaries: Array[FileBoundary], ?original_size: Integer?, ?stdlib_requires: Array[String], ?rbs_files: Hash[String, String]) -> void
+      def with: (?content: String, ?file_boundaries: Array[FileBoundary], ?original_size: Integer, ?stdlib_requires: Array[String], ?rbs_files: Hash[String, String]) -> ConcatenatedSource
+    end
+
+    class AnalysisResult
+      attr_reader prism_ast: Prism::ProgramNode
+      attr_reader scope_mappings: scope_mapping_table
+      attr_reader constant_mapping: ConstantRenameMapping?
+      attr_reader rename_map: Hash[location_key, String]
+      attr_reader method_alias_map: Hash[location_key, Symbol]
+      attr_reader method_transform_map: Hash[location_key, String]
+      attr_reader source: ConcatenatedSource
+      attr_reader attr_rename_map: Hash[location_key, Hash[Symbol, String]]
+      attr_reader block_param_names_map: Hash[location_key, Hash[Symbol, String]]
+      attr_reader syntax_data: Hash[[Integer, Integer], Hash[Symbol, syntax_value]]
+      attr_reader const_resolution_map: Hash[location_key, Array[Symbol]]
+      attr_reader const_full_path_map: Hash[location_key, Array[Symbol]]
+      attr_reader const_write_cpath_map: Hash[location_key, Array[Symbol]]
+      attr_reader class_cpath_map: Hash[location_key, Array[Symbol]]
+      attr_reader superclass_resolution_map: Hash[location_key, Array[Symbol]]
+      attr_reader meta_node_map: Hash[location_key, meta_node_entry]
+      attr_reader local_rename_entries: Hash[location_key, String]
+      attr_reader keyword_rename_entries: Hash[location_key, String]
+      attr_reader ivar_rename_entries: Hash[location_key, String]
+      attr_reader attr_ivar_entries: Hash[location_key, String]
+      attr_reader cvar_rename_entries: Hash[location_key, String]
+      attr_reader gvar_rename_entries: Hash[location_key, String]
+
+      def self.new: (
+        prism_ast: Prism::ProgramNode,
+        scope_mappings: scope_mapping_table,
+        constant_mapping: ConstantRenameMapping?,
+        rename_map: Hash[location_key, String],
+        method_alias_map: Hash[location_key, Symbol],
+        method_transform_map: Hash[location_key, String],
+        source: ConcatenatedSource,
+        attr_rename_map: Hash[location_key, Hash[Symbol, String]],
+        block_param_names_map: Hash[location_key, Hash[Symbol, String]],
+        syntax_data: Hash[[Integer, Integer], Hash[Symbol, syntax_value]],
+        const_resolution_map: Hash[location_key, Array[Symbol]],
+        const_full_path_map: Hash[location_key, Array[Symbol]],
+        const_write_cpath_map: Hash[location_key, Array[Symbol]],
+        class_cpath_map: Hash[location_key, Array[Symbol]],
+        superclass_resolution_map: Hash[location_key, Array[Symbol]],
+        meta_node_map: Hash[location_key, meta_node_entry],
+        ?local_rename_entries: Hash[location_key, String],
+        ?keyword_rename_entries: Hash[location_key, String],
+        ?ivar_rename_entries: Hash[location_key, String],
+        ?attr_ivar_entries: Hash[location_key, String],
+        ?cvar_rename_entries: Hash[location_key, String],
+        ?gvar_rename_entries: Hash[location_key, String]
+      ) -> AnalysisResult
+      def initialize: (
+        prism_ast: Prism::ProgramNode,
+        scope_mappings: scope_mapping_table,
+        constant_mapping: ConstantRenameMapping?,
+        rename_map: Hash[location_key, String],
+        method_alias_map: Hash[location_key, Symbol],
+        method_transform_map: Hash[location_key, String],
+        source: ConcatenatedSource,
+        attr_rename_map: Hash[location_key, Hash[Symbol, String]],
+        block_param_names_map: Hash[location_key, Hash[Symbol, String]],
+        syntax_data: Hash[[Integer, Integer], Hash[Symbol, syntax_value]],
+        const_resolution_map: Hash[location_key, Array[Symbol]],
+        const_full_path_map: Hash[location_key, Array[Symbol]],
+        const_write_cpath_map: Hash[location_key, Array[Symbol]],
+        class_cpath_map: Hash[location_key, Array[Symbol]],
+        superclass_resolution_map: Hash[location_key, Array[Symbol]],
+        meta_node_map: Hash[location_key, meta_node_entry],
+        ?local_rename_entries: Hash[location_key, String],
+        ?keyword_rename_entries: Hash[location_key, String],
+        ?ivar_rename_entries: Hash[location_key, String],
+        ?attr_ivar_entries: Hash[location_key, String],
+        ?cvar_rename_entries: Hash[location_key, String],
+        ?gvar_rename_entries: Hash[location_key, String]
+      ) -> void
+    end
+
+    class CompressionStats
+      attr_reader original_size: Integer
+      attr_reader minified_size: Integer
+      attr_reader compression_ratio: Float
+      attr_reader file_count: Integer
+
+      def self.new: (original_size: Integer, minified_size: Integer, compression_ratio: Float, file_count: Integer) -> CompressionStats
+    end
+
+    class RenameResult
+      attr_reader code: String
+      attr_reader aliases: String
+      attr_reader preamble: String
+
+      def self.new: (code: String, ?aliases: String, ?preamble: String) -> RenameResult
+      def initialize: (code: String, ?aliases: String, ?preamble: String) -> void
+    end
+
+    class MinifiedResult
+      attr_reader content: String
+      attr_reader aliases: String
+      attr_reader preamble: String
+      attr_reader stats: CompressionStats
+
+      def self.new: (content: String, ?aliases: String, ?preamble: String, stats: CompressionStats) -> MinifiedResult
+      def initialize: (content: String, ?aliases: String, ?preamble: String, stats: CompressionStats) -> void
+      def full_content: () -> String
+    end
+  end
+end

data/sig/ryac/pipeline/endless_method.rbs

@@ -0,0 +1,14 @@
+module Ryac
+  module Pipeline
+    class EndlessMethod < Stage
+      def fixpoint?: () -> bool
+      def collect: (StageContext ctx, Array[patch_entry] patches) -> void
+
+      private
+
+      def walk: (Prism::Node node, String source, Array[patch_entry] patches) -> void
+      def try_def: (Prism::DefNode node, String source) -> String?
+      def keyword_logical?: (Prism::Node node, String source) -> bool
+    end
+  end
+end

data/sig/ryac/pipeline/errors.rbs

@@ -0,0 +1,46 @@
+module Ryac
+  module Pipeline
+    class StageError < Ryac::InputError
+    end
+
+    class FileNotFoundError < StageError
+      attr_reader path: String
+      attr_reader required_from: String?
+      attr_reader line: Integer?
+
+      def initialize: (String path, ?required_from: String?, ?line: Integer?) -> void
+    end
+
+    class DynamicRequireError < StageError
+      attr_reader path: String
+      attr_reader line: Integer
+      attr_reader expression: String
+
+      def initialize: (String path, line: Integer, expression: String) -> void
+    end
+
+    class CircularDependencyError < StageError
+      attr_reader cycle: Array[String]
+
+      def initialize: (Array[String] cycle) -> void
+    end
+
+    class NoFilesError < StageError
+      def initialize: () -> void
+    end
+
+    class GemNotFoundError < StageError
+      attr_reader gem_name: String
+
+      def initialize: (String gem_name) -> void
+    end
+
+    class InvalidOutputError < Ryac::InternalError
+      def initialize: (String label, Array[Prism::ParseError] errors) -> void
+    end
+
+    class RenameCollisionError < Ryac::InternalError
+      def initialize: (String scope, Array[[String, Array[Symbol]]] collisions) -> void
+    end
+  end
+end

data/sig/ryac/pipeline/file_collector.rbs

@@ -0,0 +1,34 @@
+module Ryac
+  module Pipeline
+    # resolved_path is absent for :require_stdlib nodes; every node records
+    # whether it sits inside a class/module body and/or a method body.
+    type require_node_info = { type: Symbol, path: String, line: Integer, start_offset: Integer, length: Integer, in_class: bool, in_method: bool, ?resolved_path: String }
+
+    class FileCollector
+      @graph: DependencyGraph
+      @visited: Set[String]
+      @gem_names: Array[String]
+      @project_roots: Array[String]
+
+      def call: (String | Array[String] entry_path, ?project_root: String | Array[String] | nil, ?gem_names: Array[String], ?gem_require_paths: Array[String]) -> DependencyGraph
+
+      private
+
+      def collect_file: (String file_path, ?required_from: String?, ?line: Integer?) -> void
+      def extract_require_nodes: (String file_path, String content) -> Array[require_node_info]
+      def traverse_for_requires: (Prism::Node? node, Array[require_node_info] nodes, String file_path, ?in_method: bool, ?in_class: bool) -> void
+      def handle_call_node: (Prism::CallNode node, Array[require_node_info] nodes, String file_path, ?in_method: bool, ?in_class: bool) -> void
+      def handle_require_relative: (Prism::CallNode node, Array[require_node_info] nodes, String file_path, ?in_method: bool, ?in_class: bool) -> void
+      def handle_require: (Prism::CallNode node, Array[require_node_info] nodes, String file_path, ?in_method: bool, ?in_class: bool) -> void
+      def handle_autoload: (Prism::CallNode node, Array[require_node_info] nodes, String file_path, ?in_method: bool, ?in_class: bool) -> void
+      def dir_interpolated_path: (Prism::Node path_arg) -> String?
+      def ensure_load_paths: (Array[String] require_paths) -> void
+      def collect_rbs_files: (Array[String] entry_paths) -> void
+      def collect_rbs_stdlib_files: () -> void
+      def load_rbs_from: (String dir) -> void
+      def find_project_root: (Array[String] entry_paths) -> String?
+      def resolve_relative_path: (String path, String from_file) -> String
+      def resolve_bare_require: (String path) -> String?
+    end
+  end
+end

data/sig/ryac/pipeline/method_renamer.rbs

@@ -0,0 +1,25 @@
+module Ryac
+  module Pipeline
+    class MethodRenamer < Stage
+      include RenamePatcher
+
+      @negated_transforms: Hash[location_key, bool]
+      @source_bytes: String
+
+      def needs_analysis?: () -> bool
+      def collect: (StageContext ctx, Array[patch_entry] patches) -> void
+
+      private
+
+      def collect_patches: (Prism::Node node, Array[patch_entry] patches, AnalysisResult analysis, Hash[location_key, String] rename_map, Hash[location_key, Symbol] method_alias_map) -> void
+      def handle_node: (Prism::Node subnode, Array[patch_entry] patches, AnalysisResult analysis, Hash[location_key, String] rename_map, Hash[location_key, Symbol] method_alias_map) -> void
+      def patch_def_name: (Prism::DefNode node, Array[patch_entry] patches, Hash[location_key, String] rename_map) -> void
+      def patch_call_node: (Prism::CallNode node, Array[patch_entry] patches, Hash[location_key, String] rename_map, Hash[location_key, Symbol] method_alias_map, AnalysisResult analysis) -> void
+
+      SEND_METHODS: Array[Symbol]
+
+      def patch_send_symbol: (Prism::CallNode node, Array[patch_entry] patches, String short_name) -> void
+      def patch_call_operator_write: (Prism::CallOperatorWriteNode | Prism::CallOrWriteNode | Prism::CallAndWriteNode node, Array[patch_entry] patches, Hash[location_key, String] rename_map, Hash[location_key, Symbol] method_alias_map) -> void
+    end
+  end
+end

data/sig/ryac/pipeline/paren_optimizer.rbs

@@ -0,0 +1,16 @@
+module Ryac
+  module Pipeline
+    class ParenOptimizer < Stage
+      def collect: (StageContext ctx, Array[patch_entry] patches) -> void
+
+      private
+
+      def walk: (Prism::Node node, String source, Array[patch_entry] patches, statement_level: bool) -> void
+      def walk_if: (Prism::IfNode node, String source, Array[patch_entry] patches) -> void
+      def walk_call_children: (Prism::CallNode node, String source, Array[patch_entry] patches) -> void
+      def try_remove_call_parens: (Prism::CallNode node, String source, Array[patch_entry] patches) -> void
+      def try_remove_yield_parens: (Prism::YieldNode node, Array[patch_entry] patches) -> void
+      def add_paren_removal_patches: (Prism::Location open_loc, Prism::Location close_loc, Array[patch_entry] patches) -> void
+    end
+  end
+end

data/sig/ryac/pipeline/rename_patcher.rbs

@@ -0,0 +1,38 @@
+module Ryac
+  module Pipeline
+    type patch_entry = { start: Integer, end: Integer, replacement: String }
+
+    module RenamePatcher
+      # Prism nodes whose name_loc is always present (variable write /
+      # operator-write nodes and similar). Prism types name_loc as nullable
+      # only on bare rest/block parameters, which never reach these helpers.
+      interface _NodeWithNameLoc
+        def name_loc: () -> Prism::Location
+      end
+
+      private
+
+      def walk_prism: (Prism::Node? node) { (Prism::Node) -> untyped } -> void
+      def prism_location_key: (Prism::Node node) -> location_key
+      def patch_variable: (Prism::Node node, Array[patch_entry] patches, Hash[location_key, String] rename_map) -> void
+      def patch_variable_name_only: (Prism::Node & _NodeWithNameLoc node, Array[patch_entry] patches, Hash[location_key, String] rename_map) -> void
+      def patch_def_params: (Prism::DefNode node, Array[patch_entry] patches, AnalysisResult analysis, Symbol param_names_key) -> void
+      def patch_required_params: (Array[Prism::Node]? requireds, Hash[Symbol, String] param_names, Array[patch_entry] patches) -> void
+      def patch_multi_target_params: (Prism::MultiTargetNode node, Hash[Symbol, String] param_names, Array[patch_entry] patches) -> void
+      def patch_optional_params: (Array[Prism::OptionalParameterNode]? optionals, Hash[Symbol, String] param_names, Array[patch_entry] patches) -> void
+      def patch_named_param: (Symbol name, Prism::Location? name_loc, Hash[Symbol, String] param_names, Array[patch_entry] patches) -> void
+      def patch_rest_param: (Prism::Node? rest, Hash[Symbol, String] param_names, Array[patch_entry] patches) -> void
+      def patch_post_params: (Array[Prism::Node]? posts, Hash[Symbol, String] param_names, Array[patch_entry] patches) -> void
+      def patch_keyword_params: (Array[Prism::RequiredKeywordParameterNode | Prism::OptionalKeywordParameterNode]? keywords, Hash[Symbol, String] param_names, Array[patch_entry] patches) -> void
+      def patch_keyword_rest: (Prism::Node? keyword_rest, Hash[Symbol, String] param_names, Array[patch_entry] patches) -> void
+      def patch_block_param_node: (Prism::Node? block, Hash[Symbol, String] param_names, Array[patch_entry] patches) -> void
+      def patch_block_params: (Prism::CallNode node, Array[patch_entry] patches, Hash[location_key, Hash[Symbol, String]] block_param_names_map) -> void
+      def patch_for_node: (Prism::ForNode node, Array[patch_entry] patches, AnalysisResult analysis, Symbol mangled_key) -> void
+      # The return value is only ever compared against :skip_children; a
+      # record-alias union here sends typeprof's solver into unbounded
+      # re-propagation during self-hosting, so it stays untyped.
+      def patch_assoc: (Prism::AssocNode node, Array[patch_entry] patches, Hash[location_key, String] rename_map, ?keyword_arg: bool) -> untyped
+      def patch_keyword_hash: (Prism::KeywordHashNode node, Array[patch_entry] patches, Hash[location_key, String] rename_map) { (Prism::Node) -> untyped } -> void
+    end
+  end
+end

data/sig/ryac/pipeline/source_patcher.rbs

@@ -0,0 +1,12 @@
+module Ryac
+  module Pipeline
+    module SourcePatcher
+      private
+
+      def mk: (Prism::Node node, String replacement) -> { start: Integer, end: Integer, replacement: String }
+      def apply_patches: (String source, Array[{ start: Integer, end: Integer, replacement: String }] patches) -> String
+      def src: (String source, Prism::Node node) -> String
+      def verify_parses: (String text, String label) -> void
+    end
+  end
+end

data/sig/ryac/pipeline/spelling_shorten.rbs

@@ -0,0 +1,14 @@
+module Ryac
+  module Pipeline
+    class SpellingShorten < Stage
+      SAFE_WORD: Regexp
+
+      def collect: (StageContext ctx, Array[patch_entry] patches) -> void
+
+      private
+
+      def try_percent_array: (Prism::ArrayNode node, Array[patch_entry] patches) -> void
+      def plain?: (Prism::Node node, Class klass) -> bool
+    end
+  end
+end

data/sig/ryac/pipeline/stage.rbs

@@ -0,0 +1,28 @@
+module Ryac
+  module Pipeline
+    class StageContext < Struct[untyped]
+      attr_accessor source: String
+      attr_accessor ast: Prism::ProgramNode
+      attr_accessor analysis: AnalysisResult?
+      attr_accessor aliases: String
+      attr_accessor preamble: String
+
+      def self.new: (String source, Prism::ProgramNode ast, AnalysisResult? analysis, String aliases, String preamble) -> StageContext
+    end
+
+    class Stage
+      include SourcePatcher
+
+      def self.new: (**untyped) -> Stage
+      def needs_analysis?: () -> bool
+      def fixpoint?: () -> bool
+      def collect: (StageContext ctx, Array[patch_entry] patches) -> void
+      def finish: (StageContext ctx) -> void
+      def call: (String input) -> String
+
+      private
+
+      def analysis: (StageContext ctx) -> AnalysisResult
+    end
+  end
+end

data/sig/ryac/pipeline/stage_runner.rbs

@@ -0,0 +1,18 @@
+module Ryac
+  module Pipeline
+    class StageRunner
+      include SourcePatcher
+
+      @stdlib_requires: Array[String]
+      @rbs_files: Hash[String, String]
+
+      def initialize: (?stdlib_requires: Array[String], ?rbs_files: Hash[String, String]) -> void
+      def call: (String code, Array[Minifier::stage_entry] stage_defs) -> RenameResult
+
+      private
+
+      def instantiate: (Minifier::stage_entry entry) -> Stage
+      def run_analysis_batch: (String code, Array[Stage] batch) -> [String, String, String]
+    end
+  end
+end

data/sig/ryac/pipeline/variable_renamer.rbs

@@ -0,0 +1,21 @@
+module Ryac
+  module Pipeline
+    class VariableRenamer < Stage
+      include RenamePatcher
+
+      FEATURES: Hash[Symbol, bool]
+
+      @features: Hash[Symbol, bool]
+
+      def needs_analysis?: () -> bool
+      def initialize: (?features: Hash[Symbol, bool]) -> void
+      def collect: (StageContext ctx, Array[patch_entry] patches) -> void
+
+      private
+
+      def build_rename_map: (AnalysisResult analysis) -> Hash[location_key, String]
+      def collect_patches: (Prism::Node node, Array[patch_entry] patches, AnalysisResult analysis, Hash[location_key, String] rename_map, Hash[location_key, Hash[Symbol, String]] block_param_names_map) -> void
+      def handle_node: (Prism::Node subnode, Array[patch_entry] patches, AnalysisResult analysis, Hash[location_key, String] rename_map, Hash[location_key, Hash[Symbol, String]] block_param_names_map) -> void
+    end
+  end
+end

data/sig/ryac/union_find.rbs

@@ -0,0 +1,17 @@
+module Ryac
+  # Union-Find over arbitrary hashable keys; each includer picks its key type
+  # (both current includers use method_key).
+  module UnionFind[K < Object]
+    @parent: Hash[K, K]
+    @rank: Hash[K, Integer]
+
+    def uf_init: () -> void
+    def uf_root: (K key) -> K
+    def merge_groups: (K key1, K key2) -> void
+
+    private
+
+    def uf_add: (K key) -> Integer
+    def uf_remove: (K key) -> void
+  end
+end

data/sig/ryac.rbs

@@ -0,0 +1,13 @@
+module Ryac
+  VERSION: String
+
+  type location_key = [Integer, Integer]
+  # Line/column coordinates — a separate space from byte-offset location_key;
+  # build with AstUtils.line_col_key, never by hand.
+  type line_col_key = [Integer, Integer]
+  type scope_id = location_key
+  type scope_mapping_table = Hash[scope_id, Hash[Symbol, String]]
+  type syntax_value = String | Integer | Symbol | bool | Hash[Symbol, String] | nil
+  type syntax_data_map = Hash[line_col_key, Hash[Symbol, syntax_value]]
+  type meta_node_entry = { type: Symbol, ?args: Array[Symbol] }
+end

data/sig/shims/env.rbs

@@ -0,0 +1,19 @@
+# Environment patches: methods missing from rbs core and from the
+# Bundler shim shipped inside the rbs gem — needed by the
+# BootConstants probe.
+
+module Bundler
+  def self.with_unbundled_env: [X] () { () -> X } -> X
+end
+
+module Process
+  def self.last_status: () -> ::Process::Status?
+end
+
+class IO
+  # `IO.popen([env_hash, cmd, *args])` — the env-hash-inside-the-array form
+  # the boot probe uses; rbs core only types env as a separate leading
+  # argument.
+  def self.popen: [X] (Array[Hash[String, String?] | String] env_and_cmd, ?String mode) { (instance) -> X } -> X
+                | ...
+end